Control.Object.Object

Documentation

newtype Object f g

The type Object f g represents objects which can handle messages f, perform actions in the environment g. It can be thought of as an automaton that transforms effects. Objects can be composed just like functions using @>>@; the identity element is echo. Objects are morphisms of the category of actions.

Naturality

runObject obj . fmap f ≡ fmap f . runObject obj

Constructors

Object

Fields

runObject :: forall x. f x -> g (x, Object f g)

echo :: Functor f => Object f f

The trivial object

(@>>@) :: Functor h => Object f g -> Object g h -> Object f h infixr 1

The categorical composition of objects.

(@<<@) :: Functor h => Object g h -> Object f g -> Object f h infixl 1

Reversed '(>>)'

liftO :: Functor g => (forall x. f x -> g x) -> Object f g

Lift a natural transformation into an object.

(^>>@) :: Functor h => (forall x. f x -> g x) -> Object g h -> Object f h infixr 1

(@>>^) :: Functor h => Object f g -> (forall x. g x -> h x) -> Object f h infixr 1

(@||@) :: Functor h => Object f h -> Object g h -> Object (f `Sum` g) h

Combine objects so as to handle a Sum of interfaces.

Stateful construction

unfoldO :: Functor g => (forall a. r -> f a -> g (a, r)) -> r -> Object f g

An unwrapped analog of stateful id = unfoldO runObject iterative = unfoldO iterObject cascading = unfoldO cascadeObject

unfoldOM :: Monad m => (forall a. r -> f a -> m (a, r)) -> r -> Object f m

Same as unfoldO but requires Monad instead

stateful :: Monad m => (forall a. t a -> StateT s m a) -> s -> Object t m

Build a stateful object.

stateful t s = t ^>>@ variable s

(@~) :: Monad m => s -> (forall a. t a -> StateT s m a) -> Object t m infix 1

Flipped stateful. it is super convenient to use with the LambdaCase extension.

variable :: Monad m => s -> Object (StateT s m) m

A mutable variable.

variable = stateful id

Method cascading

(@-) :: Object f g -> f x -> g (x, Object f g) infixr 3

An infix alias for runObject

iterObject :: Monad m => Object f m -> Free f a -> m (a, Object f m)

Cascading

iterative :: Monad m => Object f m -> Object (Free f) m

Objects can consume free monads. cascading is more preferred.

cascadeObject :: Monad m => Object t m -> Skeleton t a -> m (a, Object t m)

Pass zero or more messages to an object.

cascading :: Monad m => Object t m -> Object (Skeleton t) m

Add capability to handle multiple messages at once.

Filtering

data Fallible t a where

Constructors

Fallible :: t a -> Fallible t (Maybe a)

filteredO :: Monad m => (forall x. t x -> Bool) -> Object t m -> Object (Fallible t) m

filterO :: (forall x. t x -> Bool) -> Object (Fallible t) (Skeleton t)

Manipulation on StateT

invokesOf :: Monad m => ((Object t m -> WriterT r m (Object t m)) -> s -> WriterT r m s) -> t a -> (a -> r) -> StateT s m r

Send a message to an object through a lens.

invokes :: (Traversable t, Monad m, Monoid r) => f a -> (a -> r) -> StateT (t (Object f m)) m r

(@!=) :: Monad m => ((Object t m -> WriterT a m (Object t m)) -> s -> WriterT a m s) -> t a -> StateT s m a

A method invocation operator on StateT.

announce :: (Traversable t, Monad m) => f a -> StateT (t (Object f m)) m [a]

Send a message to objects in a traversable container.

announce = withBuilder . invokesOf traverse

withBuilder :: Functor f => ((a -> Endo [a]) -> f (Endo [a])) -> f [a]