Data.Semimodule.Index

Documentation

type (+) = Either

rgt :: (a -> b) -> (a + b) -> b

rgt' :: (Void + b) -> b

lft :: (b -> a) -> (a + b) -> a

lft' :: (a + Void) -> a

eswap :: (a1 + a2) -> a2 + a1

fork :: a -> (a, a)

join :: (a + a) -> a

eval :: (a, a -> b) -> b

apply :: (b -> a, b) -> a

type Index b c = forall a. Trans a b c

A binary relation between two basis indices.

Index b c relations correspond to permutations, projections, and embedding transformations, as well as combinations thereof.

See also https://en.wikipedia.org/wiki/Logical_matrix.

type Endo a b = Trans a b b

An endomorphism over a free semimodule.

newtype Trans a b c

A general linear transformation between free semimodules indexed with bases b and c.

Constructors

Trans

Fields

• runTrans :: (c -> a) -> b -> a

Instances

Profunctor (Trans a)

Defined in Data.Semimodule.Index

Methods

dimap :: (a0 -> b) -> (c -> d) -> Trans a b c -> Trans a a0 d

lmap :: (a0 -> b) -> Trans a b c -> Trans a a0 c

rmap :: (b -> c) -> Trans a a0 b -> Trans a a0 c

(#.) :: Coercible c b => q b c -> Trans a a0 b -> Trans a a0 c

(.#) :: Coercible b a0 => Trans a b c -> q a0 b -> Trans a a0 c

Category (Trans a :: Type -> Type -> Type)

Defined in Data.Semimodule.Index

Methods

id :: Trans a a0 a0

(.) :: Trans a b c -> Trans a a0 b -> Trans a a0 c

Functor (Trans a b)

Defined in Data.Semimodule.Index

Methods

fmap :: (a0 -> b0) -> Trans a b a0 -> Trans a b b0

(<$) :: a0 -> Trans a b b0 -> Trans a b a0

arr :: (b -> c) -> Index b c

app :: Basis b f => Basis c g => Trans a b c -> g a -> f a

in1 :: Index (a, b) b

in2 :: Index (a, b) a

exl :: Index a (a + b)

exr :: Index b (a + b)

braid :: Index (a, b) (b, a)

ebraid :: Index (a + b) (b + a)

first :: Index b c -> Index (b, d) (c, d)

second :: Index b c -> Index (d, b) (d, c)

left :: Index b c -> Index (b + d) (c + d)

right :: Index b c -> Index (d + b) (d + c)

(***) :: Index a1 b1 -> Index a2 b2 -> Index (a1, a2) (b1, b2) infixr 3

(+++) :: Index a1 b1 -> Index a2 b2 -> Index (a1 + a2) (b1 + b2) infixr 2

(&&&) :: Index a b1 -> Index a b2 -> Index a (b1, b2) infixr 3

(|||) :: Index a1 b -> Index a2 b -> Index (a1 + a2) b infixr 2

($$$) :: Index a (b -> c) -> Index a b -> Index a c infixr 0

adivide :: (a -> (a1, a2)) -> Index a1 b -> Index a2 b -> Index a b

adivide' :: Index a b -> Index a b -> Index a b

adivided :: Index a1 b -> Index a2 b -> Index (a1, a2) b

aselect :: ((b1 + b2) -> b) -> Index a b1 -> Index a b2 -> Index a b

aselect' :: Index a b -> Index a b -> Index a b

aselected :: Index a b1 -> Index a b2 -> Index a (b1 + b2)