Control.Functor.Linear

The control functor hierarchy

The functors in this module are called control functors, which are different from the data functors in Data.Functor.Linear.

This distinction and the use-cases of each group of functors is explained in this blog post.

Control functor hierarchy

class Functor f => Functor f where

Control linear functors. The functor of type f a holds only one value of type a and represents a computation producing an a with an effect. All control functors are data functors, but not all data functors are control functors.

Methods

fmap :: (a %1 -> b) %1 -> f a %1 -> f b

Map a linear function g over a control functor f a. Note that g is used linearly over the single a in f a.

Instances

Functor Identity

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> Identity a %1 -> Identity b

Functor Par1

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> Par1 a %1 -> Par1 b

Functor IO

Defined in System.IO.Linear

Methods

fmap :: (a %1 -> b) %1 -> IO a %1 -> IO b

Functor RIO

Defined in System.IO.Resource.Linear.Internal

Methods

fmap :: (a %1 -> b) %1 -> RIO a %1 -> RIO b

(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> Generically1 f a %1 -> Generically1 f b

Functor (Of a)

Defined in Streaming.Linear.Internal.Type

Methods

fmap :: (a0 %1 -> b) %1 -> Of a a0 %1 -> Of a b

Functor ((,) a)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a0 %1 -> b) %1 -> (a, a0) %1 -> (a, b)

Functor m => Functor (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

fmap :: (a %1 -> b) %1 -> ReaderT r m a %1 -> ReaderT r m b

Functor m => Functor (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

fmap :: (a %1 -> b) %1 -> StateT s m a %1 -> StateT s m b

(Functor m, Functor f) => Functor (Stream f m)

Defined in Streaming.Linear.Internal.Type

Methods

fmap :: (a %1 -> b) %1 -> Stream f m a %1 -> Stream f m b

Functor m => Functor (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

fmap :: (a %1 -> b) %1 -> ReaderT r m a %1 -> ReaderT r m b

Functor m => Functor (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

fmap :: (a %1 -> b) %1 -> StateT s m a %1 -> StateT s m b

Functor ((,,) a b)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a0 %1 -> b0) %1 -> (a, b, a0) %1 -> (a, b, b0)

(Functor f, Functor g) => Functor (Sum f g)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> Sum f g a %1 -> Sum f g b

(Functor l, Functor r, EitherNoPar1 b1 b2 l r) => Functor (l :*: r)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> (l :*: r) a %1 -> (l :*: r) b

(Functor l, Functor r) => Functor (l :+: r)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> (l :+: r) a %1 -> (l :+: r) b

Functor ((,,,) a b c)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a0 %1 -> b0) %1 -> (a, b, c, a0) %1 -> (a, b, c, b0)

(Functor f, Functor g) => Functor (Compose f g)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> Compose f g a %1 -> Compose f g b

Functor f => Functor (M1 j c f)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> M1 j c f a %1 -> M1 j c f b

(Functor f, Functor g) => Functor (f :.: g)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a %1 -> b) %1 -> (f :.: g) a %1 -> (f :.: g) b

Functor (FUN 'One a :: TYPE LiftedRep -> Type)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a0 %1 -> b) %1 -> FUN 'One a a0 %1 -> FUN 'One a b

Functor ((,,,,) a b c d)

Defined in Control.Functor.Linear.Internal.Class

Methods

fmap :: (a0 %1 -> b0) %1 -> (a, b, c, d, a0) %1 -> (a, b, c, d, b0)

(<$>) :: Functor f => (a %1 -> b) %1 -> f a %1 -> f b infixl 4

(<&>) :: Functor f => f a %1 -> (a %1 -> b) %1 -> f b infixl 1

   (<&>) = flip fmap
   

(<$) :: (Functor f, Consumable b) => a %1 -> f b %1 -> f a infixl 4

Linearly typed replacement for the standard (<$) function.

void :: (Functor f, Consumable a) => f a %1 -> f ()

Discard a consumable value stored in a control functor.

dataFmapDefault :: Functor f => (a %1 -> b) -> f a %1 -> f b

Apply the control fmap over a data functor.

class (Applicative f, Functor f) => Applicative f where

Control linear applicative functors. These represent effectful computations that could produce continuations that can be applied with <*>.

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a %1 -> f a

Inject (and consume) a value into an applicative control functor.

(<*>) :: f (a %1 -> b) %1 -> f a %1 -> f b infixl 4

Apply the linear function in a control applicative functor to the value of type a in another functor. This is essentialy composing two effectful computations, one that produces a function f :: a %1-> b and one that produces a value of type a into a single effectful computation that produces a value of type b.

liftA2 :: (a %1 -> b %1 -> c) %1 -> f a %1 -> f b %1 -> f c

liftA2 g consumes g linearly as it lifts it over two functors: liftA2 g :: f a %1-> f b %1-> f c.

Instances

Applicative Identity

Defined in Control.Functor.Linear.Internal.Class

Methods

pure :: a %1 -> Identity a

(<*>) :: Identity (a %1 -> b) %1 -> Identity a %1 -> Identity b

liftA2 :: (a %1 -> b %1 -> c) %1 -> Identity a %1 -> Identity b %1 -> Identity c

Applicative IO

Defined in System.IO.Linear

Methods

pure :: a %1 -> IO a

(<*>) :: IO (a %1 -> b) %1 -> IO a %1 -> IO b

liftA2 :: (a %1 -> b %1 -> c) %1 -> IO a %1 -> IO b %1 -> IO c

Applicative RIO

Defined in System.IO.Resource.Linear.Internal

Methods

pure :: a %1 -> RIO a

(<*>) :: RIO (a %1 -> b) %1 -> RIO a %1 -> RIO b

liftA2 :: (a %1 -> b %1 -> c) %1 -> RIO a %1 -> RIO b %1 -> RIO c

Monoid a => Applicative ((,) a)

Defined in Control.Functor.Linear.Internal.Class

Methods

pure :: a0 %1 -> (a, a0)

(<*>) :: (a, a0 %1 -> b) %1 -> (a, a0) %1 -> (a, b)

liftA2 :: (a0 %1 -> b %1 -> c) %1 -> (a, a0) %1 -> (a, b) %1 -> (a, c)

(Applicative m, Dupable r) => Applicative (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

pure :: a %1 -> ReaderT r m a

(<*>) :: ReaderT r m (a %1 -> b) %1 -> ReaderT r m a %1 -> ReaderT r m b

liftA2 :: (a %1 -> b %1 -> c) %1 -> ReaderT r m a %1 -> ReaderT r m b %1 -> ReaderT r m c

Monad m => Applicative (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

pure :: a %1 -> StateT s m a

(<*>) :: StateT s m (a %1 -> b) %1 -> StateT s m a %1 -> StateT s m b

liftA2 :: (a %1 -> b %1 -> c) %1 -> StateT s m a %1 -> StateT s m b %1 -> StateT s m c

(Functor m, Functor f) => Applicative (Stream f m)

Defined in Streaming.Linear.Internal.Type

Methods

pure :: a %1 -> Stream f m a

(<*>) :: Stream f m (a %1 -> b) %1 -> Stream f m a %1 -> Stream f m b

liftA2 :: (a %1 -> b %1 -> c) %1 -> Stream f m a %1 -> Stream f m b %1 -> Stream f m c

Applicative m => Applicative (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

pure :: a %1 -> ReaderT r m a

(<*>) :: ReaderT r m (a %1 -> b) %1 -> ReaderT r m a %1 -> ReaderT r m b

liftA2 :: (a %1 -> b %1 -> c) %1 -> ReaderT r m a %1 -> ReaderT r m b %1 -> ReaderT r m c

(Monoid a, Monoid b) => Applicative ((,,) a b)

Defined in Control.Functor.Linear.Internal.Class

Methods

pure :: a0 %1 -> (a, b, a0)

(<*>) :: (a, b, a0 %1 -> b0) %1 -> (a, b, a0) %1 -> (a, b, b0)

liftA2 :: (a0 %1 -> b0 %1 -> c) %1 -> (a, b, a0) %1 -> (a, b, b0) %1 -> (a, b, c)

(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)

Defined in Control.Functor.Linear.Internal.Class

Methods

pure :: a0 %1 -> (a, b, c, a0)

(<*>) :: (a, b, c, a0 %1 -> b0) %1 -> (a, b, c, a0) %1 -> (a, b, c, b0)

liftA2 :: (a0 %1 -> b0 %1 -> c0) %1 -> (a, b, c, a0) %1 -> (a, b, c, b0) %1 -> (a, b, c, c0)

dataPureDefault :: Applicative f => a -> f a

Apply the control pure over a data applicative.

class Applicative m => Monad m where

Control linear monads. A linear monad is one in which you sequence linear functions in a context, i.e., you sequence functions of the form a %1-> m b.

Minimal complete definition

(>>=)

Methods

(>>=) :: m a %1 -> (a %1 -> m b) %1 -> m b infixl 1

x >>= g applies a linear function g linearly (i.e., using it exactly once) on the value of type a inside the value of type m a

(>>) :: m () %1 -> m a %1 -> m a infixl 1

Instances

Monad Identity

Defined in Control.Functor.Linear.Internal.Class

Methods

(>>=) :: Identity a %1 -> (a %1 -> Identity b) %1 -> Identity b

(>>) :: Identity () %1 -> Identity a %1 -> Identity a

Monad IO

Defined in System.IO.Linear

Methods

(>>=) :: IO a %1 -> (a %1 -> IO b) %1 -> IO b

(>>) :: IO () %1 -> IO a %1 -> IO a

Monad RIO

Defined in System.IO.Resource.Linear.Internal

Methods

(>>=) :: RIO a %1 -> (a %1 -> RIO b) %1 -> RIO b

(>>) :: RIO () %1 -> RIO a %1 -> RIO a

Monoid a => Monad ((,) a)

Defined in Control.Functor.Linear.Internal.Class

Methods

(>>=) :: (a, a0) %1 -> (a0 %1 -> (a, b)) %1 -> (a, b)

(>>) :: (a, ()) %1 -> (a, a0) %1 -> (a, a0)

(Monad m, Dupable r) => Monad (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

(>>=) :: ReaderT r m a %1 -> (a %1 -> ReaderT r m b) %1 -> ReaderT r m b

(>>) :: ReaderT r m () %1 -> ReaderT r m a %1 -> ReaderT r m a

Monad m => Monad (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

(>>=) :: StateT s m a %1 -> (a %1 -> StateT s m b) %1 -> StateT s m b

(>>) :: StateT s m () %1 -> StateT s m a %1 -> StateT s m a

(Functor m, Functor f) => Monad (Stream f m)

Defined in Streaming.Linear.Internal.Type

Methods

(>>=) :: Stream f m a %1 -> (a %1 -> Stream f m b) %1 -> Stream f m b

(>>) :: Stream f m () %1 -> Stream f m a %1 -> Stream f m a

Monad m => Monad (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

(>>=) :: ReaderT r m a %1 -> (a %1 -> ReaderT r m b) %1 -> ReaderT r m b

(>>) :: ReaderT r m () %1 -> ReaderT r m a %1 -> ReaderT r m a

return :: Monad m => a %1 -> m a

join :: Monad m => m (m a) %1 -> m a

Given an effect-producing computation that produces an effect-producing computation that produces an a, simplify it to an effect-producing computation that produces an a.

ap :: Monad m => m (a %1 -> b) %1 -> m a %1 -> m b

Use this operator to define Applicative instances in terms of Monad instances.

foldM :: forall m a b. Monad m => (b %1 -> a %1 -> m b) -> b %1 -> [a] %1 -> m b

Fold from left to right with a linear monad. This is a linear version of foldM.

class Monad m => MonadFail m where

This class handles pattern-matching failure in do-notation. See Control.Monad.Fail for details.

Methods

fail :: String -> m a

newtype Data f a

This is a newtype for deriving Data.XXX classes from Control.XXX classes.

Constructors

Data (f a)

Instances

Applicative f => Applicative (Data f)

Defined in Control.Functor.Linear.Internal.Instances

Methods

pure :: a -> Data f a

(<*>) :: Data f (a %1 -> b) %1 -> Data f a %1 -> Data f b

liftA2 :: (a %1 -> b %1 -> c) -> Data f a %1 -> Data f b %1 -> Data f c

Functor f => Functor (Data f)

Defined in Control.Functor.Linear.Internal.Instances

Methods

fmap :: (a %1 -> b) -> Data f a %1 -> Data f b

Monad transformers

ReaderT monad transformer

See here to learn about the basics of reader monads. To know about the standard reader monad functions, see the documentation of the standard reader monad here.

type Reader r = ReaderT r Identity

reader :: Monad m => (r %1 -> a) %1 -> ReaderT r m a

runReader :: Reader r a %1 -> r %1 -> a

mapReader :: (a %1 -> b) %1 -> Reader r a %1 -> Reader r b

withReader :: (r' %1 -> r) %1 -> Reader r a %1 -> Reader r' a

newtype ReaderT r m a

A linear reader monad transformer. This reader monad requires that use of the read-only state is explict.

The monad instance requires that r be Dupable. This means that you should use the linear reader monad just like the non-linear monad, except that the type system ensures that you explicity use or discard the read-only state (with the Consumable instance).

Constructors

ReaderT (r %1 -> m a)

Instances

Dupable r => MonadTrans (ReaderT r)

Defined in Control.Functor.Linear.Internal.Reader

Methods

lift :: Monad m => m a %1 -> ReaderT r m a

(Applicative m, Dupable r) => Applicative (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

pure :: a %1 -> ReaderT r m a

(<*>) :: ReaderT r m (a %1 -> b) %1 -> ReaderT r m a %1 -> ReaderT r m b

liftA2 :: (a %1 -> b %1 -> c) %1 -> ReaderT r m a %1 -> ReaderT r m b %1 -> ReaderT r m c

Functor m => Functor (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

fmap :: (a %1 -> b) %1 -> ReaderT r m a %1 -> ReaderT r m b

(Monad m, Dupable r) => Monad (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

(>>=) :: ReaderT r m a %1 -> (a %1 -> ReaderT r m b) %1 -> ReaderT r m b

(>>) :: ReaderT r m () %1 -> ReaderT r m a %1 -> ReaderT r m a

(Applicative m, Dupable r) => Applicative (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

pure :: a -> ReaderT r m a

(<*>) :: ReaderT r m (a %1 -> b) %1 -> ReaderT r m a %1 -> ReaderT r m b

liftA2 :: (a %1 -> b %1 -> c) -> ReaderT r m a %1 -> ReaderT r m b %1 -> ReaderT r m c

Functor m => Functor (ReaderT r m)

Defined in Control.Functor.Linear.Internal.Reader

Methods

fmap :: (a %1 -> b) -> ReaderT r m a %1 -> ReaderT r m b

runReaderT :: ReaderT r m a %1 -> r %1 -> m a

Provide an intial read-only state and run the monadic computation in a reader monad transformer

mapReaderT :: (m a %1 -> n b) %1 -> ReaderT r m a %1 -> ReaderT r n b

withReaderT :: (r' %1 -> r) %1 -> ReaderT r m a %1 -> ReaderT r' m a

ask :: Applicative m => ReaderT r m r

local :: (r %1 -> r) %1 -> ReaderT r m a %1 -> ReaderT r m a

asks :: Monad m => (r %1 -> a) %1 -> ReaderT r m a

StateT monad

This is a linear version of the standard state monad. The linear arrows ensure that the state is threaded linearly through functions of the form a %1-> StateT s m a. That is, when sequencing f :: a %1-> StateT s m b and g :: b %1-> StateT s m c, the type system enforces that state produced by $f$ is fed into g.

For this reason, there is only one way to define (>>=):

instance Monad m => Applicative (StateT s m) where
StateT mx >>= f = StateT $ \s -> do
  (x, s') <- mx s
  runStateT (f x) s'

To see examples and learn about all the standard state monad functions, see here. To learn the basics of the state monad, see here.

type State s = StateT s Identity

state :: Applicative m => (s %1 -> (a, s)) %1 -> StateT s m a

runState :: State s a %1 -> s %1 -> (a, s)

evalState :: Consumable s => State s a %1 -> s %1 -> a

Use with care! This consumes the final state, so might be costly at runtime.

execState :: State s () %1 -> s %1 -> s

mapState :: ((a, s) %1 -> (b, s)) %1 -> State s a %1 -> State s b

withState :: (s %1 -> s) %1 -> State s a %1 -> State s a

newtype StateT s m a

A (strict) linear state monad transformer.

Constructors

StateT (s %1 -> m (a, s))

Instances

MonadTrans (StateT s)

Defined in Control.Functor.Linear.Internal.State

Methods

lift :: Monad m => m a %1 -> StateT s m a

Monad m => Applicative (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

pure :: a %1 -> StateT s m a

(<*>) :: StateT s m (a %1 -> b) %1 -> StateT s m a %1 -> StateT s m b

liftA2 :: (a %1 -> b %1 -> c) %1 -> StateT s m a %1 -> StateT s m b %1 -> StateT s m c

Functor m => Functor (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

fmap :: (a %1 -> b) %1 -> StateT s m a %1 -> StateT s m b

Monad m => Monad (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

(>>=) :: StateT s m a %1 -> (a %1 -> StateT s m b) %1 -> StateT s m b

(>>) :: StateT s m () %1 -> StateT s m a %1 -> StateT s m a

Monad m => Applicative (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a %1 -> b) %1 -> StateT s m a %1 -> StateT s m b

liftA2 :: (a %1 -> b %1 -> c) -> StateT s m a %1 -> StateT s m b %1 -> StateT s m c

Functor m => Functor (StateT s m)

Defined in Control.Functor.Linear.Internal.State

Methods

fmap :: (a %1 -> b) -> StateT s m a %1 -> StateT s m b

runStateT :: StateT s m a %1 -> s %1 -> m (a, s)

evalStateT :: (Functor m, Consumable s) => StateT s m a %1 -> s %1 -> m a

Use with care! This consumes the final state, so might be costly at runtime.

execStateT :: Functor m => StateT s m () %1 -> s %1 -> m s

mapStateT :: (m (a, s) %1 -> n (b, s)) %1 -> StateT s m a %1 -> StateT s n b

withStateT :: (s %1 -> s) %1 -> StateT s m a %1 -> StateT s m a

get :: (Applicative m, Dupable s) => StateT s m s

put :: (Applicative m, Consumable s) => s %1 -> StateT s m ()

modify :: Applicative m => (s %1 -> s) %1 -> StateT s m ()

gets :: (Applicative m, Dupable s) => (s %1 -> a) %1 -> StateT s m a

class (forall m. Monad m => Monad (t m)) => MonadTrans t where

Methods

lift :: Monad m => m a %1 -> t m a

Instances

Dupable r => MonadTrans (ReaderT r)

Defined in Control.Functor.Linear.Internal.Reader

Methods

lift :: Monad m => m a %1 -> ReaderT r m a

MonadTrans (StateT s)

Defined in Control.Functor.Linear.Internal.State

Methods

lift :: Monad m => m a %1 -> StateT s m a

Functor f => MonadTrans (Stream f)

Defined in Streaming.Linear.Internal.Type

Methods

lift :: Monad m => m a %1 -> Stream f m a

MonadTrans (ReaderT r)

Defined in Control.Functor.Linear.Internal.Reader

Methods

lift :: Monad m => m a %1 -> ReaderT r m a

newtype Data f a

This is a newtype for deriving Data.XXX classes from Control.XXX classes.

Constructors

Data (f a)

Instances

Applicative f => Applicative (Data f)

Defined in Control.Functor.Linear.Internal.Instances

Methods

pure :: a -> Data f a

(<*>) :: Data f (a %1 -> b) %1 -> Data f a %1 -> Data f b

liftA2 :: (a %1 -> b %1 -> c) -> Data f a %1 -> Data f b %1 -> Data f c

Functor f => Functor (Data f)

Defined in Control.Functor.Linear.Internal.Instances

Methods

fmap :: (a %1 -> b) -> Data f a %1 -> Data f b