DDF.Lang

Documentation

class (Bool r, Char r, Double r, Float r, Bimap r, Dual r, Unit r) => Lang r where

Minimal complete definition

fix, left, right, sumMatch, exfalso, ioRet, ioBind, ioMap, nil, cons, listMatch, writer, runWriter, float2Double, double2Float, state, runState, putStrLn

Methods

fix :: r h ((a -> a) -> a)

left :: r h (a -> Either a b)

right :: r h (b -> Either a b)

sumMatch :: r h ((a -> c) -> (b -> c) -> Either a b -> c)

exfalso :: r h (Void -> a)

ioRet :: r h (a -> IO a)

ioBind :: r h (IO a -> (a -> IO b) -> IO b)

ioMap :: r h ((a -> b) -> IO a -> IO b)

nil :: r h [a]

cons :: r h (a -> [a] -> [a])

listMatch :: r h (b -> (a -> [a] -> b) -> [a] -> b)

listAppend :: r h ([a] -> [a] -> [a])

writer :: r h ((a, w) -> Writer w a)

runWriter :: r h (Writer w a -> (a, w))

float2Double :: r h (Float -> Double)

double2Float :: r h (Double -> Float)

undefined :: r h a

state :: r h ((x -> (y, x)) -> State x y)

runState :: r h (State x y -> x -> (y, x))

putStrLn :: r h (String -> IO ())

Instances

Lang Show

Methods

fix :: Show h ((a -> a) -> a)

left :: Show h (a -> Either a b)

right :: Show h (b -> Either a b)

sumMatch :: Show h ((a -> c) -> (b -> c) -> Either a b -> c)

exfalso :: Show h (Void -> a)

ioRet :: Show h (a -> IO a)

ioBind :: Show h (IO a -> (a -> IO b) -> IO b)

ioMap :: Show h ((a -> b) -> IO a -> IO b)

nil :: Show h [a]

cons :: Show h (a -> [a] -> [a])

listMatch :: Show h (b -> (a -> [a] -> b) -> [a] -> b)

listAppend :: Show h ([a] -> [a] -> [a])

writer :: Show h ((a, w) -> Writer w a)

runWriter :: Show h (Writer w a -> (a, w))

float2Double :: Show h (Float -> Double)

double2Float :: Show h (Double -> Float)

undefined :: Show h a

state :: Show h ((x -> (y, x)) -> State x y)

runState :: Show h (State x y -> x -> (y, x))

putStrLn :: Show h (String -> IO ())

Lang Size

Methods

fix :: Size h ((a -> a) -> a)

left :: Size h (a -> Either a b)

right :: Size h (b -> Either a b)

sumMatch :: Size h ((a -> c) -> (b -> c) -> Either a b -> c)

exfalso :: Size h (Void -> a)

ioRet :: Size h (a -> IO a)

ioBind :: Size h (IO a -> (a -> IO b) -> IO b)

ioMap :: Size h ((a -> b) -> IO a -> IO b)

nil :: Size h [a]

cons :: Size h (a -> [a] -> [a])

listMatch :: Size h (b -> (a -> [a] -> b) -> [a] -> b)

listAppend :: Size h ([a] -> [a] -> [a])

writer :: Size h ((a, w) -> Writer w a)

runWriter :: Size h (Writer w a -> (a, w))

float2Double :: Size h (Float -> Double)

double2Float :: Size h (Double -> Float)

undefined :: Size h a

state :: Size h ((x -> (y, x)) -> State x y)

runState :: Size h (State x y -> x -> (y, x))

putStrLn :: Size h (String -> IO ())

Lang UInt

Methods

fix :: UInt h ((a -> a) -> a)

left :: UInt h (a -> Either a b)

right :: UInt h (b -> Either a b)

sumMatch :: UInt h ((a -> c) -> (b -> c) -> Either a b -> c)

exfalso :: UInt h (Void -> a)

ioRet :: UInt h (a -> IO a)

ioBind :: UInt h (IO a -> (a -> IO b) -> IO b)

ioMap :: UInt h ((a -> b) -> IO a -> IO b)

nil :: UInt h [a]

cons :: UInt h (a -> [a] -> [a])

listMatch :: UInt h (b -> (a -> [a] -> b) -> [a] -> b)

listAppend :: UInt h ([a] -> [a] -> [a])

writer :: UInt h ((a, w) -> Writer w a)

runWriter :: UInt h (Writer w a -> (a, w))

float2Double :: UInt h (Float -> Double)

double2Float :: UInt h (Double -> Float)

undefined :: UInt h a

state :: UInt h ((x -> (y, x)) -> State x y)

runState :: UInt h (State x y -> x -> (y, x))

putStrLn :: UInt h (String -> IO ())

Lang r => Lang (UnLiftEnv r)

Methods

fix :: UnLiftEnv r h ((a -> a) -> a)

left :: UnLiftEnv r h (a -> Either a b)

right :: UnLiftEnv r h (b -> Either a b)

sumMatch :: UnLiftEnv r h ((a -> c) -> (b -> c) -> Either a b -> c)

exfalso :: UnLiftEnv r h (Void -> a)

ioRet :: UnLiftEnv r h (a -> IO a)

ioBind :: UnLiftEnv r h (IO a -> (a -> IO b) -> IO b)

ioMap :: UnLiftEnv r h ((a -> b) -> IO a -> IO b)

nil :: UnLiftEnv r h [a]

cons :: UnLiftEnv r h (a -> [a] -> [a])

listMatch :: UnLiftEnv r h (b -> (a -> [a] -> b) -> [a] -> b)

listAppend :: UnLiftEnv r h ([a] -> [a] -> [a])

writer :: UnLiftEnv r h ((a, w) -> Writer w a)

runWriter :: UnLiftEnv r h (Writer w a -> (a, w))

float2Double :: UnLiftEnv r h (Float -> Double)

double2Float :: UnLiftEnv r h (Double -> Float)

undefined :: UnLiftEnv r h a

state :: UnLiftEnv r h ((x -> (y, x)) -> State x y)

runState :: UnLiftEnv r h (State x y -> x -> (y, x))

putStrLn :: UnLiftEnv r h (String -> IO ())

class Reify r x where

Minimal complete definition

reify

Methods

reify :: x -> r h x

Instances

Lang r => Reify r Double

Methods

reify :: Double -> r h Double

Lang r => Reify r ()

Methods

reify :: () -> r h ()

(Lang repr, Reify repr l, Reify repr r) => Reify repr (l, r)

Methods

reify :: (l, r) -> repr h (l, r)

Lang repr => ProdCon (Reify repr) l r

Methods

prodCon :: (Reify repr l, Reify repr r) :- Reify repr (l, r)

cons2 :: Lang r => r h a1 -> r h [a1] -> r h [a1]

listMatch2 :: Lang r => r h a1 -> r h (a -> [a] -> a1) -> r h ([a] -> a1)

fix1 :: Lang r => r h (b -> b) -> r h b

fix2 :: Lang r => r h ((a -> b) -> a -> b) -> r h a -> r h b

uncurry1 :: Prod r => r h (a -> b -> c) -> r h ((a, b) -> c)

optionMatch2 :: Option r => r h a1 -> r h (a -> a1) -> r h (Maybe a -> a1)

optionMatch3 :: Option r => r h b -> r h (a -> b) -> r h (Maybe a) -> r h b

writer1 :: Lang r => r h (a, w) -> r h (Writer w a)

runWriter1 :: Lang r => r h (Writer w a) -> r h (a, w)

ioBind2 :: Lang r => r h (IO a) -> r h (a -> IO b) -> r h (IO b)

float2Double1 :: Lang r => r h Float -> r h Double

doubleExp1 :: Double r => r h Double -> r h Double

floatExp1 :: Float r => r h Float -> r h Float

sumMatch2 :: Lang r => r h (a -> c) -> r h (b -> c) -> r h (Either a b -> c)

state1 :: Lang r => r h (x -> (y, x)) -> r h (State x y)

runState1 :: Lang r => r h (State x y) -> r h (x -> (y, x))

runState2 :: Lang r => r h (State a y) -> r h a -> r h (y, a)

module DDF.Bool

module DDF.Char

module DDF.Double

module DDF.Float

module DDF.Bimap

module DDF.Dual

module DDF.Meta.Diff

module DDF.Unit

Orphan instances

Lang r => Monad r Maybe

Methods

bind :: r h (Maybe a -> (a -> Maybe b) -> Maybe b)

join :: r h (Maybe (Maybe a) -> Maybe a)

Lang r => Monad r IO

Methods

bind :: r h (IO a -> (a -> IO b) -> IO b)

join :: r h (IO (IO a) -> IO a)

Lang r => Vector r Float

Methods

mult :: r h (Double -> Float -> Float)

divide :: r h (Float -> Double -> Float)

Lang r => Vector r ()

Methods

mult :: r h (Double -> () -> ())

divide :: r h (() -> Double -> ())

Float r => Group r Float

Methods

invert :: r h (Float -> Float)

minus :: r h (Float -> Float -> Float)

Lang r => Group r ()

Methods

invert :: r h (() -> ())

minus :: r h (() -> () -> ())

Dual r => BiFunctor * r Dual

Methods

bimap :: Dual h ((a -> b) -> (c -> d) -> p a c -> p b d)

Prod r => BiFunctor * r (,)

Methods

bimap :: (h, (a -> b) -> (c -> d) -> p a c -> p b d)

Lang r => BiFunctor * r Either

Methods

bimap :: Either h ((a -> b) -> (c -> d) -> p a c -> p b d)

Lang r => Applicative * r Maybe

Methods

pure :: Maybe h (x -> a x)

ap :: Maybe h (a (x -> y) -> a x -> a y)

Lang r => Applicative * r IO

Methods

pure :: IO h (x -> a x)

ap :: IO h (a (x -> y) -> a x -> a y)

Lang r => Functor * r Maybe

Methods

map :: Maybe h ((a -> b) -> f a -> f b)

Lang r => Functor * r IO

Methods

map :: IO h ((a -> b) -> f a -> f b)

Lang r => Functor * r []

Methods

map :: [h] ((a -> b) -> f a -> f b)

Float r => Monoid * r Float

Methods

zero :: Float h m

plus :: Float h (m -> m -> m)

Lang r => Monoid * r ()

Methods

zero :: () h m

plus :: () h (m -> m -> m)

Lang r => Applicative * r (State l)

Methods

pure :: State l h (x -> a x)

ap :: State l h (a (x -> y) -> a x -> a y)

(Lang r, Monoid * r w) => Applicative * r (Writer w)

Methods

pure :: Writer w h (x -> a x)

ap :: Writer w h (a (x -> y) -> a x -> a y)

Lang r => Functor * r (State l)

Methods

map :: State l h ((a -> b) -> f a -> f b)

Lang r => Functor * r (Map k)

Methods

map :: Map k h ((a -> b) -> f a -> f b)

Lang r => Functor * r (Writer w)

Methods

map :: Writer w h ((a -> b) -> f a -> f b)

Lang r => Monoid * r [a]

Methods

zero :: [a] h m

plus :: [a] h (m -> m -> m)

(Double r, Monoid * r v) => Monoid * r (Double -> v)

Methods

zero :: (Double -> v) h m

plus :: (Double -> v) h (m -> m -> m)

(Prod repr, Monoid * repr l, Monoid * repr r) => Monoid * repr (l, r)

Methods

zero :: (l, r) h m

plus :: (l, r) h (m -> m -> m)

Lang r => Monad r (State l)

Methods

bind :: r h (State l a -> (a -> State l b) -> State l b)

join :: r h (State l (State l a) -> State l a)

(Lang r, Monoid * r w) => Monad r (Writer w)

Methods

bind :: r h (Writer w a -> (a -> Writer w b) -> Writer w b)

join :: r h (Writer w (Writer w a) -> Writer w a)

(Lang r, Vector r v) => Vector r (Double -> v)

Methods

mult :: r h (Double -> (Double -> v) -> Double -> v)

divide :: r h ((Double -> v) -> Double -> Double -> v)

(Prod repr, Double repr, Vector repr l, Vector repr r) => Vector repr (l, r)

Methods

mult :: repr h (Double -> (l, r) -> (l, r))

divide :: repr h ((l, r) -> Double -> (l, r))

(Lang r, Group r v) => Group r (Double -> v)

Methods

invert :: r h ((Double -> v) -> Double -> v)

minus :: r h ((Double -> v) -> (Double -> v) -> Double -> v)

(Prod repr, Group repr l, Group repr r) => Group repr (l, r)

Methods

invert :: repr h ((l, r) -> (l, r))

minus :: repr h ((l, r) -> (l, r) -> (l, r))

Lang repr => ProdCon (Vector repr) l r

Methods

prodCon :: (Vector repr l, Vector repr r) :- Vector repr (l, r)

Lang repr => ProdCon (Monoid * repr) l r

Methods

prodCon :: (Monoid * repr l, Monoid * repr r) :- Monoid * repr (l, r)