Modulemachines-0.7.4Haskell2010

Data.Machine.Type

3 types
1 class
19 values

Packagemachines-0.7.4
Exports23
LanguageHaskell2010
LicenceBSD-3-Clause
SourceType.hs

Machines

8 declarations

newtypenewtype MachineT (m :: Type -> Type) (k :: Type -> Type) o

A MachineT reads from a number of inputs and may yield results before stopping with monadic side-effects.

Constructors

MachineT
- runMachineT :: m (Step k o (MachineT m k o))

Instances6Functor, Applicative, Foldable, Pointed, Semigroup, Monoid

Monad m => Functor (MachineT m k)Defined in machines-0.7.4 · Data.Machine.Type
(Monad m, Appliance k) => Applicative (MachineT m k)Defined in machines-0.7.4 · Data.Machine.Type
m ~ Identity => Foldable (MachineT m k)Defined in machines-0.7.4 · Data.Machine.Type
This permits toList to be used on a Machine.
Monad m => Pointed (MachineT m k)Defined in machines-0.7.4 · Data.Machine.Type
Monad m => Semigroup (MachineT m k o)Defined in machines-0.7.4 · Data.Machine.Type
Monad m => Monoid (MachineT m k o)Defined in machines-0.7.4 · Data.Machine.Type

datadata Step (k :: Type -> Type) o r

This is the base functor for a Machine or MachineT.

Note: A Machine is usually constructed from Plan, so it does not need to be CPS'd.

Constructors

Stop
Yield o r
forall t. Await (t -> r) (k t) r

Instances1Functor

Functor (Step k o)Defined in machines-0.7.4 · Data.Machine.Type

typetype Machine (k :: Type -> Type) o = forall (m :: Type -> Type). Monad m => MachineT m k o

A Machine reads from a number of inputs and may yield results before stopping.

A Machine can be used as a MachineT m for any Monad m.

valuerunT_ :: Monad m => MachineT m k b -> m ()

Stop feeding input into model, taking only the effects.

valuerunT :: Monad m => MachineT m k b -> m [b]

Stop feeding input into model and extract an answer

valuerun :: MachineT Identity k b -> [b]

Run a pure machine and extract an answer.

valuerunMachine :: MachineT Identity k o -> Step k o (MachineT Identity k o)

runMachine = runIdentity . runMachineT

valueencased :: Monad m => Step k o (MachineT m k o) -> MachineT m k o

Pack a Step of a Machine into a Machine.

Building machines from plans

valueconstruct :: Monad m => PlanT k o m a -> MachineT m k o

Compile a machine to a model.

valuerepeatedly :: Monad m => PlanT k o m a -> MachineT m k o

Generates a model that runs a machine until it stops, then start it up again.

repeatedly m = construct (forever m)

valueunfoldPlan :: Monad m => s -> (s -> PlanT k o m s) -> MachineT m k o

Unfold a stateful PlanT into a MachineT.

valuebefore :: Monad m => MachineT m k o -> PlanT k o m a -> MachineT m k o

Evaluate a machine until it stops, and then yield answers according to the supplied model.

valuepreplan :: Monad m => PlanT k o m (MachineT m k o) -> MachineT m k o

Incorporate a Plan into the resulting machine.

Deconstructing machines back into plans

valuedeconstruct :: Monad m => MachineT m k (Either a o) -> PlanT k o m a

valuetagDone

:: Monad m
=> o -> Bool
-> MachineT m k o
-> MachineT m k (Either o o)

Use a predicate to mark a yielded value as the terminal value of this Machine. This is useful in combination with deconstruct to combine Plans.

valuefinishWith

:: Monad m
=> o -> Maybe r
-> MachineT m k o
-> MachineT m k (Either r o)

Use a function to produce and mark a yielded value as the terminal value of a Machine. All yielded values for which the given function returns Nothing are yielded down the pipeline, but the first value for which the function returns a Just value will be returned by a Plan created via deconstruct.

Reshaping machines

6 declarations

valuefit

:: Monad m
=> forall a. k a -> k' a
-> MachineT m k o
-> MachineT m k' o

Connect different kinds of machines.

fit id = id

valuefitM

:: (Monad m, Monad m')
=> forall a. m a -> m' a
-> MachineT m k o
-> MachineT m' k o

valuepass :: k o -> Machine k o

Given a handle, ignore all other inputs and just stream input from that handle.

pass id :: Process a a
pass L  :: Tee a b a
pass R  :: Tee a b b
pass X  :: Wye a b a
pass Y  :: Wye a b b
pass Z  :: Wye a b (Either a b)

valuestarve :: Monad m => MachineT m k0 b -> MachineT m k b -> MachineT m k b

Run a machine with no input until it stops, then behave as another machine.

valuestopped :: Monad m => MachineT m k b

This is a stopped Machine

valuestepMachine

:: Monad m
=> MachineT m k o
-> Step k o (MachineT m k o) -> MachineT m k' o'
-> MachineT m k' o'

Transform a Machine by looking at a single step of that machine.

Applicative Machines

1 declaration

classclass Appliance (k :: Type -> Type) where

An input type that supports merging requests from multiple machines.

Methods

applied :: Monad m => MachineT m k (a -> b) -> MachineT m k a -> MachineT m k b