DDF.Lang

Documentation

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

Minimal complete definition

fix, left, right, sumMatch, unit, 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)

unit :: r h ()

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 Eval

Methods

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

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

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

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

unit :: Eval h ()

exfalso :: Eval h (Void -> a)

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

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

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

nil :: Eval h [a]

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

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

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

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

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

float2Double :: Eval h (Float -> Double)

double2Float :: Eval h (Double -> Float)

undefined :: Eval h a

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

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

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

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)

unit :: Show h ()

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)

unit :: Size h ()

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 r => Lang (GWDiff r)

Methods

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

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

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

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

unit :: GWDiff r h ()

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

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

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

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

nil :: GWDiff r h [a]

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

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

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

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

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

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

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

undefined :: GWDiff r h a

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

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

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

Lang r => Lang (ImpW r)

Methods

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

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

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

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

unit :: ImpW r h ()

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

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

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

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

nil :: ImpW r h [a]

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

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

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

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

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

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

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

undefined :: ImpW r h a

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

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

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

Lang r => Lang (UnHOAS r)

Methods

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

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

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

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

unit :: UnHOAS r h ()

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

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

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

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

nil :: UnHOAS r h [a]

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

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

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

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

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

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

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

undefined :: UnHOAS r h a

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

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

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

(Lang l, Lang r) => Lang (Combine l r)

Methods

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

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

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

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

unit :: Combine l r h ()

exfalso :: Combine l r h (Void -> a)

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

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

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

nil :: Combine l r h [a]

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

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

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

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

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

float2Double :: Combine l r h (Float -> Double)

double2Float :: Combine l r h (Double -> Float)

undefined :: Combine l r h a

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

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

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

(Vector r v, Lang r) => Lang (WDiff r v)

Methods

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

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

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

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

unit :: WDiff r v h ()

exfalso :: WDiff r v h (Void -> a)

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

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

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

nil :: WDiff r v h [a]

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

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

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

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

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

float2Double :: WDiff r v h (Float -> Double)

double2Float :: WDiff r v h (Double -> Float)

undefined :: WDiff r v h a

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

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

putStrLn :: WDiff r v 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 :: x -> Double h x

Lang r => Reify * r ()

Methods

reify :: x -> () h x

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

Methods

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

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

Methods

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

class Monoid r g => Group r g where

Minimal complete definition

invert | minus

Methods

invert :: r h (g -> g)

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

invert :: DBI r => r h (g -> g)

minus :: DBI r => r h (g -> g -> g)

Instances

Float r => Group r Float

Methods

invert :: r h (Float -> Float)

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

Double r => Group r Double

Methods

invert :: r h (Double -> Double)

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

Lang r => Group r ()

Methods

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

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

(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))

class Group r v => Vector r v where

Minimal complete definition

mult | divide

Methods

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

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

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

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

Instances

Lang r => Vector r Float

Methods

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

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

Double r => Vector r Double

Methods

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

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

Lang r => Vector r ()

Methods

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

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

(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 repr => ProdCon (Vector repr) l r

Methods

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

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

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

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

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

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

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

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

mult1 :: (Vector repr v, DBI repr) => repr h Double -> repr h (v -> v)

mult2 :: (Vector repr b, DBI repr) => repr h Double -> repr h b -> repr h b

divide2 :: (Vector repr b, DBI repr) => repr h b -> repr h Double -> repr h b

invert1 :: (Group repr b, DBI repr) => repr h b -> repr h b

minus1 :: (Group repr a, DBI repr) => repr h a -> repr h (a -> a)

divide1 :: (Vector repr a, DBI repr) => repr h a -> repr h (Double -> a)

recip :: Double repr => repr h (Double -> Double)

recip1 :: Double repr => repr h Double -> repr h Double

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

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

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

minus2 :: (Group repr b, DBI repr) => repr h b -> repr h b -> repr h b

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

doubleExp1 :: Double repr => repr h Double -> repr h Double

floatExp1 :: Float repr => repr h Float -> repr h Float

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

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

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

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

module DDF.Bool

module DDF.Char

module DDF.Double

module DDF.Float

module DDF.Map

module DDF.Dual

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)

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)

Double r => Monoid * r Double

Methods

zero :: Double h m

plus :: Double 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 repr => ProdCon (Monoid * repr) l r

Methods

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