Language.Expression.Choice

Documentation

data OpChoice ops (t :: * -> *) a where

Form the union of a list of operators. This creates an operator which is a choice from one of its constituents.

For example, OpChoice '[NumOp, EqOp] is an operator that can either represent an arithmetic operation or an equality comparison.

Constructors

OpThis :: op t a -> OpChoice (op ': ops) t a

OpThat :: OpChoice ops t a -> OpChoice (op ': ops) t a

Instances

(HFoldableAt * k op, HFoldableAt * k (OpChoice ops)) => HFoldableAt * k (OpChoice ((:) ((* -> *) -> * -> *) op ops))

Methods

hfoldMap :: (forall (b :: k). t b -> OpChoice ((((* -> *) -> * -> *) ': op) ops) b) -> h t a -> OpChoice ((((* -> *) -> * -> *) ': op) ops) a

HFoldableAt * k (OpChoice ([] ((* -> *) -> * -> *)))

Methods

hfoldMap :: (forall (b :: k). t b -> OpChoice [(* -> *) -> * -> *] b) -> h t a -> OpChoice [(* -> *) -> * -> *] a

(HTraversable * op, HTraversable * (OpChoice ops)) => HTraversable * (OpChoice ((:) ((* -> *) -> * -> *) op ops))

Methods

htraverse :: Applicative f => (forall (b :: OpChoice ((((* -> *) -> * -> *) ': op) ops)). t b -> f (t' b)) -> h t a -> f (h t' a)

hsequence :: Applicative f => h (Compose * (OpChoice ((((* -> *) -> * -> *) ': op) ops)) f t) a -> f (h t a)

HTraversable * (OpChoice ([] ((* -> *) -> * -> *)))

Methods

htraverse :: Applicative f => (forall (b :: OpChoice [(* -> *) -> * -> *]). t b -> f (t' b)) -> h t a -> f (h t' a)

hsequence :: Applicative f => h (Compose * (OpChoice [(* -> *) -> * -> *]) f t) a -> f (h t a)

(HFunctor * op, HFunctor * (OpChoice ops)) => HFunctor * (OpChoice ((:) ((* -> *) -> * -> *) op ops))

Methods

hmap :: (forall (b :: OpChoice ((((* -> *) -> * -> *) ': op) ops)). t b -> t' b) -> h t a -> h t' a

HFunctor * (OpChoice ([] ((* -> *) -> * -> *)))

Methods

hmap :: (forall (b :: OpChoice [(* -> *) -> * -> *]). t b -> t' b) -> h t a -> h t' a

(Pretty2 * * op, Pretty2 * * (OpChoice ops)) => Pretty2 * * (OpChoice ((:) ((* -> *) -> * -> *) op ops))

Methods

pretty2 :: Pretty1 (OpChoice ((((* -> *) -> * -> *) ': op) ops)) t => op t a -> String

prettys2Prec :: Pretty1 (OpChoice ((((* -> *) -> * -> *) ': op) ops)) t => Int -> op t a -> ShowS

Pretty2 * * (OpChoice ([] ((* -> *) -> * -> *)))

Methods

pretty2 :: Pretty1 (OpChoice [(* -> *) -> * -> *]) t => op t a -> String

prettys2Prec :: Pretty1 (OpChoice [(* -> *) -> * -> *]) t => Int -> op t a -> ShowS

_OpThis :: Prism' (OpChoice (op ': ops) t a) (op t a)

_OpThat :: Prism' (OpChoice (op ': ops) t a) (OpChoice ops t a)

noOps :: OpChoice '[] t a -> x

newtype AsOp (t :: * -> *) a op

Constructors

AsOp (op t a)

Instances

Wrapped (AsOp t a op)

Associated Types

type Unwrapped (AsOp t a op) :: *

Methods

_Wrapped' :: Iso' (AsOp t a op) (Unwrapped (AsOp t a op))

(~) * (AsOp t1 a1 op1) t2 => Rewrapped (AsOp t3 a2 op2) t2

type Unwrapped (AsOp t a op)

type Unwrapped (AsOp t a op) = op t a

choiceToUnion :: OpChoice ops t a -> Union (AsOp t a) ops

unionToChoice :: Union (AsOp t a) ops -> OpChoice ops t a

_OpChoice :: Iso (OpChoice ops t a) (OpChoice ops' t' a') (Union (AsOp t a) ops) (Union (AsOp t' a') ops')

class ChooseOp op ops where

This class provides a low-boilerplate way of lifting individual operators into a union, and extracting operators from a union.

Minimal complete definition

chooseOp

Methods

chooseOp :: Prism' (OpChoice ops t a) (op t a)

Project a single operator from a union which contains it.

Instances

UElem ((* -> *) -> * -> *) op ops i => ChooseOp op ops

Methods

chooseOp :: (Choice p, Applicative f) => p (op t a) (f (op t a)) -> p (OpChoice ops t a) (f (OpChoice ops t a))

class SubsetOp ops1 ops2 where

Minimal complete definition

subsetOp

Methods

subsetOp :: Prism' (OpChoice ops2 t a) (OpChoice ops1 t a)

Instances

USubset ((* -> *) -> * -> *) ops1 ops2 is => SubsetOp ops1 ops2

Methods

subsetOp :: (Choice p, Applicative f) => p (OpChoice ops1 t a) (f (OpChoice ops1 t a)) -> p (OpChoice ops2 t a) (f (OpChoice ops2 t a))

newtype HFree' ops v a

HFree' ops v a is a higher-order free monad over the list of operators ops with variables in the type v and it represents a value of type a.

Intuitively, it represents an expression which may contain operations from any of the operators in the list ops.

Constructors

HFree'

Fields

• getHFree' :: HFree (OpChoice ops) v a

Instances

(HFoldableAt * k (OpChoice ops), HFunctor * (OpChoice ops)) => HFoldableAt * k (HFree' ops)

Methods

hfoldMap :: (forall (b :: k). t b -> HFree' ops b) -> h t a -> HFree' ops a

Pretty2 * * (OpChoice ops) => Pretty2 * * (HFree' ops)

Methods

pretty2 :: Pretty1 (HFree' ops) t => op t a -> String

prettys2Prec :: Pretty1 (HFree' ops) t => Int -> op t a -> ShowS

HTraversable * (OpChoice ops) => HTraversable * (HFree' ops)

Methods

htraverse :: Applicative f => (forall (b :: HFree' ops). t b -> f (t' b)) -> h t a -> f (h t' a)

hsequence :: Applicative f => h (Compose * (HFree' ops) f t) a -> f (h t a)

HFunctor * (OpChoice ops) => HMonad * (HFree' ops)

HFunctor * (OpChoice ops) => HBind * (HFree' ops)

Methods

(^>>=) :: h t a -> (forall (b :: HFree' ops). t b -> h t' b) -> h t' a

HPointed * (HFree' ops)

Methods

hpure :: t a -> h t a

HFunctor * (OpChoice ops) => HFunctor * (HFree' ops)

Methods

hmap :: (forall (b :: HFree' ops). t b -> t' b) -> h t a -> h t' a

(Data (HFree * (OpChoice ops) v a), Typeable * (HFree' ops v a)) => Data (HFree' ops v a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HFree' ops v a -> c (HFree' ops v a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HFree' ops v a)

toConstr :: HFree' ops v a -> Constr

dataTypeOf :: HFree' ops v a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HFree' ops v a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HFree' ops v a))

gmapT :: (forall b. Data b => b -> b) -> HFree' ops v a -> HFree' ops v a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HFree' ops v a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HFree' ops v a -> r

gmapQ :: (forall d. Data d => d -> u) -> HFree' ops v a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HFree' ops v a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HFree' ops v a -> m (HFree' ops v a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HFree' ops v a -> m (HFree' ops v a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HFree' ops v a -> m (HFree' ops v a)

Wrapped (HFree' ops v a)

Associated Types

type Unwrapped (HFree' ops v a) :: *

Methods

_Wrapped' :: Iso' (HFree' ops v a) (Unwrapped (HFree' ops v a))

(~) * (HFree' ops1 v1 a1) t => Rewrapped (HFree' ops2 v2 a2) t

type Unwrapped (HFree' ops v a)

type Unwrapped (HFree' ops v a) = HFree * (OpChoice ops) v a

squashExpression :: (HFunctor op1, HFunctor op2, HFunctor (OpChoice ops), ChooseOp op1 ops, ChooseOp op2 ops) => HFree op1 (HFree op2 v) a -> HFree' ops v a

Squash a composition of expressions over different operators into a single-layered expression over a choice of the two operators.

hwrap' :: (HFunctor op, HFunctor (OpChoice ops), ChooseOp op ops) => op (HFree' ops v) a -> HFree' ops v a