Rock

Documentation

data Writer w f a where

A query that returns a w alongside the ordinary a.

Constructors

Writer :: f a -> Writer w f (a, w)

Instances

GCompare f => GCompare (Writer w f :: Type -> Type)

Defined in Rock.Core

Methods

gcompare :: forall (a :: k) (b :: k). Writer w f a -> Writer w f b -> GOrdering a b

GEq f => GEq (Writer w f :: Type -> Type)

Defined in Rock.Core

Methods

geq :: forall (a :: k) (b :: k). Writer w f a -> Writer w f b -> Maybe (a :~: b)

type Rules f = GenRules f f

A function which, given an f query, returns a Task allowed to make f queries to compute its result.

type GenRules f g = forall a. f a -> Task g a

A function which, given an f query, returns a Task allowed to make g queries to compute its result.

newtype Task f a

An IO action that is allowed to make f queries using the fetch method from its MonadFetch instance.

Constructors

Task

Fields

• unTask :: ReaderT (Fetch f) IO a

Instances

MonadBaseControl IO (Task f)

Defined in Rock.Core

Associated Types

type StM (Task f) a

Methods

liftBaseWith :: (RunInBase (Task f) IO -> IO a) -> Task f a

restoreM :: StM (Task f) a -> Task f a

MonadFetch f (Task f)

Defined in Rock.Core

Methods

fetch :: f a -> Task f a

MonadBase IO (Task f)

Defined in Rock.Core

Methods

liftBase :: IO α -> Task f α

MonadFix (Task f)

Defined in Rock.Core

Methods

mfix :: (a -> Task f a) -> Task f a

MonadIO (Task f)

Defined in Rock.Core

Methods

liftIO :: IO a -> Task f a

Applicative (Task f)

Defined in Rock.Core

Methods

pure :: a -> Task f a

(<*>) :: Task f (a -> b) -> Task f a -> Task f b

liftA2 :: (a -> b -> c) -> Task f a -> Task f b -> Task f c

(*>) :: Task f a -> Task f b -> Task f b

(<*) :: Task f a -> Task f b -> Task f a

Functor (Task f)

Defined in Rock.Core

Methods

fmap :: (a -> b) -> Task f a -> Task f b

(<$) :: a -> Task f b -> Task f a

Monad (Task f)

Defined in Rock.Core

Methods

(>>=) :: Task f a -> (a -> Task f b) -> Task f b

(>>) :: Task f a -> Task f b -> Task f b

return :: a -> Task f a

type StM (Task f) a

Defined in Rock.Core

type StM (Task f) a = StM (ReaderT (Fetch f) IO) a

class Monad m => MonadFetch f m | m -> f where

Monads that can make f queries by fetching them.

Minimal complete definition

Nothing

Methods

fetch :: f a -> m a

default fetch :: (MonadTrans t, MonadFetch f m1, m ~ t m1) => f a -> m a

Instances

MonadFetch f (Task f)

Defined in Rock.Core

Methods

fetch :: f a -> Task f a

MonadFetch f m => MonadFetch f (MaybeT m)

Defined in Rock.Core

Methods

fetch :: f a -> MaybeT m a

MonadFetch f m => MonadFetch f (ExceptT e m)

Defined in Rock.Core

Methods

fetch :: f a -> ExceptT e m a

MonadFetch f m => MonadFetch f (IdentityT m)

Defined in Rock.Core

Methods

fetch :: f a -> IdentityT m a

MonadFetch f m => MonadFetch f (ReaderT r m)

Defined in Rock.Core

Methods

fetch :: f a -> ReaderT r m a

MonadFetch f m => MonadFetch f (StateT s m)

Defined in Rock.Core

Methods

fetch :: f a -> StateT s m a

MonadFetch f m => MonadFetch f (StateT s m)

Defined in Rock.Core

Methods

fetch :: f a -> StateT s m a

(Monoid w, MonadFetch f m) => MonadFetch f (WriterT w m)

Defined in Rock.Core

Methods

fetch :: f a -> WriterT w m a

(Monoid w, MonadFetch f m) => MonadFetch f (WriterT w m)

Defined in Rock.Core

Methods

fetch :: f a -> WriterT w m a

MonadFetch f m => MonadFetch f (ContT r m)

Defined in Rock.Core

Methods

fetch :: f a -> ContT r m a

(MonadFetch f m, Monoid w) => MonadFetch f (RWST r w s m)

Defined in Rock.Core

Methods

fetch :: f a -> RWST r w s m a

(MonadFetch f m, Monoid w) => MonadFetch f (RWST r w s m)

Defined in Rock.Core

Methods

fetch :: f a -> RWST r w s m a

newtype Cyclic f

Constructors

Cyclic (Some f)

Instances

(GShow f, Typeable f) => Exception (Cyclic f)

Defined in Rock.Core

Methods

toException :: Cyclic f -> SomeException

fromException :: SomeException -> Maybe (Cyclic f)

displayException :: Cyclic f -> String

GShow f => Show (Cyclic f)

Defined in Rock.Core

Methods

showsPrec :: Int -> Cyclic f -> ShowS

show :: Cyclic f -> String

showList :: [Cyclic f] -> ShowS

data MemoEntry a

Constructors

Started !ThreadId !(MVar (Maybe a)) !(MVar (Maybe [ThreadId]))

Done !a

data TaskKind

Constructors

Input

Used for tasks whose results can change independently of their fetched dependencies, i.e. inputs.

NonInput

Used for task whose results only depend on fetched dependencies.

type ReverseDependencies f = HashMap (Some f) (HashSet (Some f))

writer :: forall f w g. (forall a. f a -> w -> Task g ()) -> GenRules (Writer w f) g -> GenRules f g

writer write rules runs write w each time a w is returned from a rule in rules.

transFetch :: (forall b. f b -> Task f' b) -> Task f a -> Task f' a

Transform the type of queries that a Task performs.

runTask :: Rules f -> Task f a -> IO a

Perform a Task, fetching dependency queries from the given Rules function.

track :: forall f g a. (GEq f, Hashable (Some f)) => (forall a'. f a' -> a' -> g a') -> Task f a -> Task f (a, DHashMap f g)

Track the query dependencies of a Task in a DHashMap.

trackM :: forall f g a. (GEq f, Hashable (Some f)) => (forall a'. f a' -> a' -> Task f (g a')) -> Task f a -> Task f (a, DHashMap f g)

Track the query dependencies of a Task in a DHashMap. Monadic version.

memoise :: forall f g. (GEq f, Hashable (Some f)) => IORef (DHashMap f MVar) -> GenRules f g -> GenRules f g

Remember what f queries have already been performed and their results in a DHashMap, and reuse them if a query is performed again a second time.

The DHashMap should typically not be reused if there has been some change that might make a query return a different result.

memoiseWithCycleDetection :: forall f g. (Typeable f, GShow f, GEq f, Hashable (Some f)) => IORef (DHashMap f MemoEntry) -> IORef (HashMap ThreadId ThreadId) -> GenRules f g -> GenRules f g

Like memoise, but throw Cyclic f if a query depends on itself, directly or indirectly.

The HashMap represents dependencies between threads and should not be reused between invocations.

verifyTraces :: forall f dep. (Hashable (Some f), GEq f, Has' Eq f dep, Typeable f, GShow f) => IORef (Traces f dep) -> (forall a. f a -> a -> Task f (dep a)) -> GenRules (Writer TaskKind f) f -> Rules f

Remember the results of previous f queries and what their dependencies were then.

If all dependencies of a NonInput query are the same, reuse the old result. Input queries are not reused.

traceFetch :: (forall a. f a -> Task g ()) -> (forall a. f a -> a -> Task g ()) -> GenRules f g -> GenRules f g

traceFetch before after rules runs before q before a query is performed from rules, and after q result every time a query returns with result result.

trackReverseDependencies :: (GEq f, Hashable (Some f)) => IORef (ReverseDependencies f) -> Rules f -> Rules f

Write reverse dependencies to the 'IORef.

reachableReverseDependencies :: (GEq f, Hashable (Some f)) => f a -> ReverseDependencies f -> (DHashMap f (Const ()), ReverseDependencies f)

reachableReverseDependencies key returns all keys reachable, by reverse dependency, from key from the input DHashMap. It also returns the reverse dependency map with those same keys removed.

type Traces f dep = DHashMap f (ValueDeps f dep)