Control.SessionTypes.Indexed

This module provides a set of indexed type classes (IxFunctor, IxApplicative, IxMonad, etc..) that correspond to existing type classes (Functor, Applicative, Monad, etc..)

The intent of this module is to replace the use of non-indexed type classes with indexed type class.

For that reason the indexed type classes expose functions that are named the same as the functions exposed by a corresponding non-indexed type class.

There are two ways to use this module:

import           SessionTypes
import qualified SessionTypes.Indexed as I

prog = send 5 I.>> eps0

{-# LANGUAGE RebindableSyntax #-}
import SessionTypes
import SessionTypes.Indexed

prog = do
 send 5
 eps0

With RebindableSyntax we construct a custom do notation by rebinding (>>=) with (>>=) of IxMonad. Rebinding is not limited to only (>>=), but also all other functions in Prelude.

We do not want to force importing Prelude if you use RebindableSyntax. Therefore this module also exports Prelude that hides functions already defined by the indexed type classes.

Classes

class IxFunctor (f :: p -> p -> Type -> Type) where

Minimal complete definition

fmap

Methods

fmap :: (a -> b) -> f j k a -> f j k b

Instances

IxFunctor (Cap *) (IxC m)

Methods

fmap :: (a -> b) -> f j k a -> f j k b

Monad m => IxFunctor (Cap a) (STTerm a m)

Methods

fmap :: (a -> b) -> f j k a -> f j k b

class IxFunctor f => IxApplicative (f :: p -> p -> Type -> Type) where

Minimal complete definition

pure, (<*>)

Methods

pure :: a -> f i i a

(<*>) :: f s r (a -> b) -> f r k a -> f s k b

Instances

IxApplicative (Cap *) (IxC m)

Methods

pure :: a -> f i i a

(<*>) :: f s r (a -> b) -> f r k a -> f s k b

Monad m => IxApplicative (Cap a) (STTerm a m)

Methods

pure :: a -> f i i a

(<*>) :: f s r (a -> b) -> f r k a -> f s k b

class IxApplicative m => IxMonad (m :: p -> p -> Type -> Type) where

Minimal complete definition

(>>=), return

Methods

(>>=) :: m s t a -> (a -> m t k b) -> m s k b infixl 1

(>>) :: m s t a -> m t k b -> m s k b infixl 1

return :: a -> m i i a

fail :: String -> m i i a

Instances

IxMonad (Cap *) (IxC m)

Methods

(>>=) :: m s t a -> (a -> m t k b) -> m s k b

(>>) :: m s t a -> m t k b -> m s k b

return :: a -> m i i a

fail :: String -> m i i a

Monad m => IxMonad (Cap a) (STTerm a m)

Methods

(>>=) :: m s t a -> (a -> m t k b) -> m s k b

(>>) :: m s t a -> m t k b -> m s k b

return :: a -> m i i a

fail :: String -> m i i a

Transformers

class IxMonad (t m) => IxMonadT t m where

Type class for lifting monadic computations

Minimal complete definition

lift

Methods

lift :: m a -> t m s s a

Instances

Monad m => IxMonadT (Cap a) (STTerm a) m

Methods

lift :: m a -> m m s s a

class IxMonad (t m) => IxMonadIxT t m where

Type class for lifting indexed monadic computations

Minimal complete definition

ilift

Methods

ilift :: m s r a -> t m s r a

Mtl

class IxMonad m => IxMonadReader r m | m -> r where

Type class representing the indexed monad reader

Minimal complete definition

ask, local, reader

Methods

ask :: m s s r

local :: (r -> r) -> m s t a -> m s t a

reader :: (r -> a) -> m i i a

Exception

class IxMonad m => IxMonadThrow m s where

Type class for indexed monads in which exceptions may be thrown.

Minimal complete definition

throwM

Methods

throwM :: Exception e => e -> m s s a

Provide an Exception to be thrown

class IxMonadThrow m s => IxMonadCatch m s where

Type class for indexed monads to allow catching of exceptions.

Minimal complete definition

catch

Methods

catch :: Exception e => m s s a -> (e -> m s s a) -> m s s a

Provide a handler to catch exceptions.

class IxMonadCatch m s => IxMonadMask m s where

Type class for indexed monads that may mask asynchronous exceptions.

Minimal complete definition

mask, uninterruptibleMask

Methods

mask :: ((m s s b -> m s s b) -> m s s b) -> m s s b

run an action that disables asynchronous exceptions. The provided function can be used to restore the occurrence of asynchronous exceptions.

uninterruptibleMask :: ((m s s b -> m s s b) -> m s s b) -> m s s b

Ensures that even interruptible functions may not raise asynchronous exceptions.

MonadIO

class IxMonadIO m where

Type class for indexed monads that may lift IO computations.

Minimal complete definition

liftIO

Methods

liftIO :: IO a -> m s s a

Instances

MonadIO m => IxMonadIO (Cap a) (STTerm a m)

Methods

liftIO :: IO a -> m s s a

Combinators

ap :: IxMonad m => m s r (a -> b) -> m r k a -> m s k b

Rebind

ifThenElse :: Bool -> t -> t -> t