| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Control.Monad.Trans.Fraxl
Synopsis
- type FreerT f = FreeT (Ap f)
- type Fraxl r = FreerT (Union r)
- type Fetch f m a = ASeq f a -> m (ASeq m a)
- runFraxl :: Monad m => (forall a'. Fetch f m a') -> FreerT f m a -> m a
- simpleAsyncFetch :: MonadIO m => (forall x. f x -> IO x) -> Fetch f m a
- fetchNil :: Applicative m => Fetch (Union '[]) m a
- (|:|) :: forall f r a m. Monad m => (forall a'. Fetch f m a') -> (forall a'. Fetch (Union r) m a') -> Fetch (Union (f ': r)) m a
- hoistFetch :: Functor m => (forall x. m x -> n x) -> Fetch f m a -> Fetch f n a
- transFetch :: (forall x. g x -> f x) -> Fetch f m a -> Fetch g m a
- data ASeq (f :: Type -> Type) a where
- reduceASeq :: Applicative f => ASeq f u -> f u
- hoistASeq :: (forall x. f x -> g x) -> ASeq f a -> ASeq g a
- traverseASeq :: Applicative h => (forall x. f x -> h (g x)) -> ASeq f a -> h (ASeq g a)
- rebaseASeq :: ASeq f u -> (forall x. (x -> y) -> ASeq f x -> z) -> (v -> u -> y) -> ASeq f v -> z
- newtype CachedFetch f a = CachedFetch (f a)
- fetchCached :: forall t m f a. (Monad m, MonadTrans t, MonadState (DMap f MVar) (t m), GCompare f, MonadIO (t m)) => (forall a'. Fetch f m a') -> Fetch (CachedFetch f) (t m) a
- runCachedFraxl :: forall m f a. (MonadIO m, GCompare f) => (forall a'. Fetch f m a') -> FreerT f m a -> DMap f MVar -> m (a, DMap f MVar)
- evalCachedFraxl :: forall m f a. (MonadIO m, GCompare f) => (forall a'. Fetch f m a') -> FreerT f m a -> m a
- module Data.GADT.Compare
- newtype Union ts f = Union (Sum ts f)
- unconsCoRec :: Sum (t ': ts) f -> Either (t f) (Sum ts f)
The Fraxl Monad
type FreerT f = FreeT (Ap f) Source #
Fraxl is based on a particular Freer monad. This Freer monad has applicative optimization, which is used to parallelize effects.
type Fetch f m a = ASeq f a -> m (ASeq m a) Source #
A data source is an effect f that operates in some monad m.
Given a sequence of effects,
a data source should use m to prepare a corresponding sequence of results.
fetchNil :: Applicative m => Fetch (Union '[]) m a Source #
Fetch empty union.
Only necessary to terminate a list of Fetch functions for Fetch (Union r)
(|:|) :: forall f r a m. Monad m => (forall a'. Fetch f m a') -> (forall a'. Fetch (Union r) m a') -> Fetch (Union (f ': r)) m a infixr 5 Source #
Like '(:)' for constructing Fetch (Union (f ': r))
hoistFetch :: Functor m => (forall x. m x -> n x) -> Fetch f m a -> Fetch f n a Source #
Hoist a Fetch function into a different result monad.
transFetch :: (forall x. g x -> f x) -> Fetch f m a -> Fetch g m a Source #
Translate a Fetch function from f requests, to g requests.
The Sequence of Effects
data ASeq (f :: Type -> Type) a where #
The free applicative is composed of a sequence of effects,
and a pure function to apply that sequence to.
The fast free applicative separates these from each other,
so that the sequence may be built up independently,
and so that fmap can run in constant time by having immediate access to the pure function.
reduceASeq :: Applicative f => ASeq f u -> f u #
hoistASeq :: (forall x. f x -> g x) -> ASeq f a -> ASeq g a #
Given a natural transformation from f to g this gives a natural transformation from ASeq f to ASeq g.
traverseASeq :: Applicative h => (forall x. f x -> h (g x)) -> ASeq f a -> h (ASeq g a) #
Traverse a sequence with resepect to its interpretation type f.
rebaseASeq :: ASeq f u -> (forall x. (x -> y) -> ASeq f x -> z) -> (v -> u -> y) -> ASeq f v -> z #
It may not be obvious, but this essentially acts like ++, traversing the first sequence and creating a new one by appending the second sequence. The difference is that this also has to modify the return functions and that the return type depends on the input types.
See the source of hoistAp as an example usage.
Caching
newtype CachedFetch f a Source #
Caching in Fraxl works by translating FreerT f into
FreerT (CachedFetch f), then running with CachedFetch's DataSource.
That instance requires f to to have a GCompare instance.
The CachedFetch instance uses a MonadState to track cached requests.
The state variable is a DMap from the 'dependent-map' package.
Keys are requests, and values are MVars of the results.
Constructors
| CachedFetch (f a) |
fetchCached :: forall t m f a. (Monad m, MonadTrans t, MonadState (DMap f MVar) (t m), GCompare f, MonadIO (t m)) => (forall a'. Fetch f m a') -> Fetch (CachedFetch f) (t m) a Source #
runCachedFraxl :: forall m f a. (MonadIO m, GCompare f) => (forall a'. Fetch f m a') -> FreerT f m a -> DMap f MVar -> m (a, DMap f MVar) Source #
Runs a Fraxl computation with caching using a given starting cache. Alongside the result, it returns the final cache.
evalCachedFraxl :: forall m f a. (MonadIO m, GCompare f) => (forall a'. Fetch f m a') -> FreerT f m a -> m a Source #
Like runCachedFraxl, except it starts with an empty cache
and discards the final cache.
module Data.GADT.Compare
Union
Union represents a value of any type constructor in r applied with a.
Instances
| (Monad m, KnownNat (ElemIndex f r)) => MonadFraxl f (Fraxl r m) Source # | |
Defined in Control.Monad.Fraxl.Class | |
| (GCompare f, GCompare (Union r)) => GCompare (Union (f ': r) :: Type -> Type) Source # | |
| GCompare (Union ([] :: [Type -> Type])) Source # | |
| (GEq f, GEq (Union r)) => GEq (Union (f ': r) :: Type -> Type) Source # | |
| GEq (Union ([] :: [Type -> Type])) Source # | |