DDF.Lang

Documentation

class Bool repr => Lang repr where

Minimal complete definition

mkProd, zro, fst, double, doublePlus, doubleMinus, doubleMult, doubleDivide, doubleExp, float, floatPlus, floatMinus, floatMult, floatDivide, floatExp, fix, left, right, sumMatch, unit, exfalso, nothing, just, optionMatch, ioRet, ioBind, ioMap, nil, cons, listMatch, writer, runWriter, float2Double, double2Float, state, runState

Methods

mkProd :: repr h (a -> b -> (a, b))

zro :: repr h ((a, b) -> a)

fst :: repr h ((a, b) -> b)

double :: Double -> repr h Double

doubleZero :: repr h Double

doubleOne :: repr h Double

doublePlus :: repr h (Double -> Double -> Double)

doubleMinus :: repr h (Double -> Double -> Double)

doubleMult :: repr h (Double -> Double -> Double)

doubleDivide :: repr h (Double -> Double -> Double)

doubleExp :: repr h (Double -> Double)

float :: Float -> repr h Float

floatZero :: repr h Float

floatOne :: repr h Float

floatPlus :: repr h (Float -> Float -> Float)

floatMinus :: repr h (Float -> Float -> Float)

floatMult :: repr h (Float -> Float -> Float)

floatDivide :: repr h (Float -> Float -> Float)

floatExp :: repr h (Float -> Float)

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

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

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

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

unit :: repr h ()

exfalso :: repr h (Void -> a)

nothing :: repr h (Maybe a)

just :: repr h (a -> Maybe a)

optionMatch :: repr h (b -> (a -> b) -> Maybe a -> b)

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

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

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

nil :: repr h [a]

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

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

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

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

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

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

curry :: repr h (((a, b) -> c) -> a -> b -> c)

uncurry :: repr h ((a -> b -> c) -> (a, b) -> c)

float2Double :: repr h (Float -> Double)

double2Float :: repr h (Double -> Float)

undefined :: repr h a

state :: repr h ((l -> (r, l)) -> State l r)

runState :: repr h (State l r -> l -> (r, l))

Instances

Lang Eval

Methods

mkProd :: Eval h (a -> b -> (a, b))

zro :: Eval h ((a, b) -> a)

fst :: Eval h ((a, b) -> b)

double :: Double -> Eval h Double

doubleZero :: Eval h Double

doubleOne :: Eval h Double

doublePlus :: Eval h (Double -> Double -> Double)

doubleMinus :: Eval h (Double -> Double -> Double)

doubleMult :: Eval h (Double -> Double -> Double)

doubleDivide :: Eval h (Double -> Double -> Double)

doubleExp :: Eval h (Double -> Double)

float :: Float -> Eval h Float

floatZero :: Eval h Float

floatOne :: Eval h Float

floatPlus :: Eval h (Float -> Float -> Float)

floatMinus :: Eval h (Float -> Float -> Float)

floatMult :: Eval h (Float -> Float -> Float)

floatDivide :: Eval h (Float -> Float -> Float)

floatExp :: Eval h (Float -> Float)

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)

nothing :: Eval h (Maybe a)

just :: Eval h (a -> Maybe a)

optionMatch :: Eval h (b -> (a -> b) -> Maybe a -> b)

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

swap :: Eval h ((l, r) -> (r, l))

curry :: Eval h (((a, b) -> c) -> a -> b -> c)

uncurry :: Eval h ((a -> b -> c) -> (a, b) -> c)

float2Double :: Eval h (Float -> Double)

double2Float :: Eval h (Double -> Float)

undefined :: Eval h a

state :: Eval h ((l -> (r, l)) -> State l r)

runState :: Eval h (State l r -> l -> (r, l))

Lang Show

Methods

mkProd :: Show h (a -> b -> (a, b))

zro :: Show h ((a, b) -> a)

fst :: Show h ((a, b) -> b)

double :: Double -> Show h Double

doubleZero :: Show h Double

doubleOne :: Show h Double

doublePlus :: Show h (Double -> Double -> Double)

doubleMinus :: Show h (Double -> Double -> Double)

doubleMult :: Show h (Double -> Double -> Double)

doubleDivide :: Show h (Double -> Double -> Double)

doubleExp :: Show h (Double -> Double)

float :: Float -> Show h Float

floatZero :: Show h Float

floatOne :: Show h Float

floatPlus :: Show h (Float -> Float -> Float)

floatMinus :: Show h (Float -> Float -> Float)

floatMult :: Show h (Float -> Float -> Float)

floatDivide :: Show h (Float -> Float -> Float)

floatExp :: Show h (Float -> Float)

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)

nothing :: Show h (Maybe a)

just :: Show h (a -> Maybe a)

optionMatch :: Show h (b -> (a -> b) -> Maybe a -> b)

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

swap :: Show h ((l, r) -> (r, l))

curry :: Show h (((a, b) -> c) -> a -> b -> c)

uncurry :: Show h ((a -> b -> c) -> (a, b) -> c)

float2Double :: Show h (Float -> Double)

double2Float :: Show h (Double -> Float)

undefined :: Show h a

state :: Show h ((l -> (r, l)) -> State l r)

runState :: Show h (State l r -> l -> (r, l))

Lang repr => Lang (GWDiff repr)

Methods

mkProd :: GWDiff repr h (a -> b -> (a, b))

zro :: GWDiff repr h ((a, b) -> a)

fst :: GWDiff repr h ((a, b) -> b)

double :: Double -> GWDiff repr h Double

doubleZero :: GWDiff repr h Double

doubleOne :: GWDiff repr h Double

doublePlus :: GWDiff repr h (Double -> Double -> Double)

doubleMinus :: GWDiff repr h (Double -> Double -> Double)

doubleMult :: GWDiff repr h (Double -> Double -> Double)

doubleDivide :: GWDiff repr h (Double -> Double -> Double)

doubleExp :: GWDiff repr h (Double -> Double)

float :: Float -> GWDiff repr h Float

floatZero :: GWDiff repr h Float

floatOne :: GWDiff repr h Float

floatPlus :: GWDiff repr h (Float -> Float -> Float)

floatMinus :: GWDiff repr h (Float -> Float -> Float)

floatMult :: GWDiff repr h (Float -> Float -> Float)

floatDivide :: GWDiff repr h (Float -> Float -> Float)

floatExp :: GWDiff repr h (Float -> Float)

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

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

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

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

unit :: GWDiff repr h ()

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

nothing :: GWDiff repr h (Maybe a)

just :: GWDiff repr h (a -> Maybe a)

optionMatch :: GWDiff repr h (b -> (a -> b) -> Maybe a -> b)

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

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

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

nil :: GWDiff repr h [a]

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

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

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

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

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

swap :: GWDiff repr h ((l, r) -> (r, l))

curry :: GWDiff repr h (((a, b) -> c) -> a -> b -> c)

uncurry :: GWDiff repr h ((a -> b -> c) -> (a, b) -> c)

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

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

undefined :: GWDiff repr h a

state :: GWDiff repr h ((l -> (r, l)) -> State l r)

runState :: GWDiff repr h (State l r -> l -> (r, l))

Lang repr => Lang (UnHOAS repr)

Methods

mkProd :: UnHOAS repr h (a -> b -> (a, b))

zro :: UnHOAS repr h ((a, b) -> a)

fst :: UnHOAS repr h ((a, b) -> b)

double :: Double -> UnHOAS repr h Double

doubleZero :: UnHOAS repr h Double

doubleOne :: UnHOAS repr h Double

doublePlus :: UnHOAS repr h (Double -> Double -> Double)

doubleMinus :: UnHOAS repr h (Double -> Double -> Double)

doubleMult :: UnHOAS repr h (Double -> Double -> Double)

doubleDivide :: UnHOAS repr h (Double -> Double -> Double)

doubleExp :: UnHOAS repr h (Double -> Double)

float :: Float -> UnHOAS repr h Float

floatZero :: UnHOAS repr h Float

floatOne :: UnHOAS repr h Float

floatPlus :: UnHOAS repr h (Float -> Float -> Float)

floatMinus :: UnHOAS repr h (Float -> Float -> Float)

floatMult :: UnHOAS repr h (Float -> Float -> Float)

floatDivide :: UnHOAS repr h (Float -> Float -> Float)

floatExp :: UnHOAS repr h (Float -> Float)

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

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

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

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

unit :: UnHOAS repr h ()

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

nothing :: UnHOAS repr h (Maybe a)

just :: UnHOAS repr h (a -> Maybe a)

optionMatch :: UnHOAS repr h (b -> (a -> b) -> Maybe a -> b)

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

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

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

nil :: UnHOAS repr h [a]

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

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

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

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

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

swap :: UnHOAS repr h ((l, r) -> (r, l))

curry :: UnHOAS repr h (((a, b) -> c) -> a -> b -> c)

uncurry :: UnHOAS repr h ((a -> b -> c) -> (a, b) -> c)

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

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

undefined :: UnHOAS repr h a

state :: UnHOAS repr h ((l -> (r, l)) -> State l r)

runState :: UnHOAS repr h (State l r -> l -> (r, l))

Lang repr => Lang (ImpW * repr)

Methods

mkProd :: ImpW * repr h (a -> b -> (a, b))

zro :: ImpW * repr h ((a, b) -> a)

fst :: ImpW * repr h ((a, b) -> b)

double :: Double -> ImpW * repr h Double

doubleZero :: ImpW * repr h Double

doubleOne :: ImpW * repr h Double

doublePlus :: ImpW * repr h (Double -> Double -> Double)

doubleMinus :: ImpW * repr h (Double -> Double -> Double)

doubleMult :: ImpW * repr h (Double -> Double -> Double)

doubleDivide :: ImpW * repr h (Double -> Double -> Double)

doubleExp :: ImpW * repr h (Double -> Double)

float :: Float -> ImpW * repr h Float

floatZero :: ImpW * repr h Float

floatOne :: ImpW * repr h Float

floatPlus :: ImpW * repr h (Float -> Float -> Float)

floatMinus :: ImpW * repr h (Float -> Float -> Float)

floatMult :: ImpW * repr h (Float -> Float -> Float)

floatDivide :: ImpW * repr h (Float -> Float -> Float)

floatExp :: ImpW * repr h (Float -> Float)

fix :: ImpW * repr h ((a -> a) -> a)

left :: ImpW * repr h (a -> Either a b)

right :: ImpW * repr h (b -> Either a b)

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

unit :: ImpW * repr h ()

exfalso :: ImpW * repr h (Void -> a)

nothing :: ImpW * repr h (Maybe a)

just :: ImpW * repr h (a -> Maybe a)

optionMatch :: ImpW * repr h (b -> (a -> b) -> Maybe a -> b)

ioRet :: ImpW * repr h (a -> IO a)

ioBind :: ImpW * repr h (IO a -> (a -> IO b) -> IO b)

ioMap :: ImpW * repr h ((a -> b) -> IO a -> IO b)

nil :: ImpW * repr h [a]

cons :: ImpW * repr h (a -> [a] -> [a])

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

listAppend :: ImpW * repr h ([a] -> [a] -> [a])

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

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

swap :: ImpW * repr h ((l, r) -> (r, l))

curry :: ImpW * repr h (((a, b) -> c) -> a -> b -> c)

uncurry :: ImpW * repr h ((a -> b -> c) -> (a, b) -> c)

float2Double :: ImpW * repr h (Float -> Double)

double2Float :: ImpW * repr h (Double -> Float)

undefined :: ImpW * repr h a

state :: ImpW * repr h ((l -> (r, l)) -> State l r)

runState :: ImpW * repr h (State l r -> l -> (r, l))

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

Methods

mkProd :: WDiff repr v h (a -> b -> (a, b))

zro :: WDiff repr v h ((a, b) -> a)

fst :: WDiff repr v h ((a, b) -> b)

double :: Double -> WDiff repr v h Double

doubleZero :: WDiff repr v h Double

doubleOne :: WDiff repr v h Double

doublePlus :: WDiff repr v h (Double -> Double -> Double)

doubleMinus :: WDiff repr v h (Double -> Double -> Double)

doubleMult :: WDiff repr v h (Double -> Double -> Double)

doubleDivide :: WDiff repr v h (Double -> Double -> Double)

doubleExp :: WDiff repr v h (Double -> Double)

float :: Float -> WDiff repr v h Float

floatZero :: WDiff repr v h Float

floatOne :: WDiff repr v h Float

floatPlus :: WDiff repr v h (Float -> Float -> Float)

floatMinus :: WDiff repr v h (Float -> Float -> Float)

floatMult :: WDiff repr v h (Float -> Float -> Float)

floatDivide :: WDiff repr v h (Float -> Float -> Float)

floatExp :: WDiff repr v h (Float -> Float)

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

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

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

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

unit :: WDiff repr v h ()

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

nothing :: WDiff repr v h (Maybe a)

just :: WDiff repr v h (a -> Maybe a)

optionMatch :: WDiff repr v h (b -> (a -> b) -> Maybe a -> b)

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

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

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

nil :: WDiff repr v h [a]

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

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

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

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

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

swap :: WDiff repr v h ((l, r) -> (r, l))

curry :: WDiff repr v h (((a, b) -> c) -> a -> b -> c)

uncurry :: WDiff repr v h ((a -> b -> c) -> (a, b) -> c)

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

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

undefined :: WDiff repr v h a

state :: WDiff repr v h ((l -> (r, l)) -> State l r)

runState :: WDiff repr v h (State l r -> l -> (r, l))

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

Methods

mkProd :: Combine l r h (a -> b -> (a, b))

zro :: Combine l r h ((a, b) -> a)

fst :: Combine l r h ((a, b) -> b)

double :: Double -> Combine l r h Double

doubleZero :: Combine l r h Double

doubleOne :: Combine l r h Double

doublePlus :: Combine l r h (Double -> Double -> Double)

doubleMinus :: Combine l r h (Double -> Double -> Double)

doubleMult :: Combine l r h (Double -> Double -> Double)

doubleDivide :: Combine l r h (Double -> Double -> Double)

doubleExp :: Combine l r h (Double -> Double)

float :: Float -> Combine l r h Float

floatZero :: Combine l r h Float

floatOne :: Combine l r h Float

floatPlus :: Combine l r h (Float -> Float -> Float)

floatMinus :: Combine l r h (Float -> Float -> Float)

floatMult :: Combine l r h (Float -> Float -> Float)

floatDivide :: Combine l r h (Float -> Float -> Float)

floatExp :: Combine l r h (Float -> Float)

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)

nothing :: Combine l r h (Maybe a)

just :: Combine l r h (a -> Maybe a)

optionMatch :: Combine l r h (b -> (a -> b) -> Maybe a -> b)

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

swap :: Combine l r h ((l, r) -> (r, l))

curry :: Combine l r h (((a, b) -> c) -> a -> b -> c)

uncurry :: Combine l r h ((a -> b -> c) -> (a, b) -> c)

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 ((l -> (r, l)) -> State l r)

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

class Reify repr x where

Minimal complete definition

reify

Methods

reify :: x -> repr h x

Instances

Lang repr => Reify * repr Double

Methods

reify :: x -> Double h x

Lang repr => Reify * repr ()

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 :: Lang r => r h (g -> g)

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

Instances

Lang r => Group r Float

Methods

invert :: r h (Float -> Float)

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

Lang 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 repr, Group repr v) => Group repr (Double -> v)

Methods

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

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

(Lang 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 :: Lang r => r h (Double -> v -> v)

divide :: Lang 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)

Lang 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 repr, Vector repr v) => Vector repr (Double -> v)

Methods

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

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

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

runImpW :: forall repr h x. Lang repr => ImpW repr h x -> RunImpW repr h x

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 :: Lang repr => repr h (a -> b -> c) -> repr h ((a, b) -> c)

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

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

zro1 :: Lang repr => repr h (b1, b) -> repr h b1

fst1 :: Lang repr => repr h (a, b) -> 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

mkProd1 :: Lang repr => repr h a -> repr h (b -> (a, b))

mkProd2 :: Lang repr => repr h a1 -> repr h a -> repr h (a1, a)

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 :: Lang repr => repr h (Double -> Double)

recip1 :: Lang 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 :: Lang repr => repr h Double -> repr h Double

floatExp1 :: Lang 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 (l -> (r, l)) -> repr h (State l r)

runState1 :: Lang repr => repr h (State l r) -> repr h (l -> (r, l))

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

module DDF.Bool

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 repr => ConvDiff repr Float

Methods

toDiff :: Monoid * repr x => Proxy * x -> repr h (Float -> Diff x Float)

toDiffBy :: repr h (x -> Float -> Diff x Float)

fromDiff :: Monoid * repr x => Proxy * x -> repr h (Diff x Float -> Float)

fromDiffBy :: repr h (x -> Diff x Float -> Float)

Lang repr => ConvDiff repr Double

Methods

toDiff :: Monoid * repr x => Proxy * x -> repr h (Double -> Diff x Double)

toDiffBy :: repr h (x -> Double -> Diff x Double)

fromDiff :: Monoid * repr x => Proxy * x -> repr h (Diff x Double -> Double)

fromDiffBy :: repr h (x -> Diff x Double -> Double)

Lang repr => ConvDiff repr ()

Methods

toDiff :: Monoid * repr x => Proxy * x -> repr h (() -> Diff x ())

toDiffBy :: repr h (x -> () -> Diff x ())

fromDiff :: Monoid * repr x => Proxy * x -> repr h (Diff x () -> ())

fromDiffBy :: repr h (x -> Diff x () -> ())

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

Lang repr => WithDiff * repr Float

Methods

withDiff :: Float h ((w -> x) -> w -> Diff x w)

Lang repr => WithDiff * repr Double

Methods

withDiff :: Double h ((w -> x) -> w -> Diff x w)

Lang repr => WithDiff * repr ()

Methods

withDiff :: () h ((w -> x) -> w -> Diff x w)

Lang r => Monoid * r Float

Methods

zero :: Float h m

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

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

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

Methods

withDiff :: (l, r) h ((w -> x) -> w -> Diff x w)

(Lang repr, Monoid * repr v) => Monoid * repr (Double -> v)

Methods

zero :: (Double -> v) h m

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

(Lang 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, ConvDiff repr l) => ConvDiff repr [l]

Methods

toDiff :: Monoid * repr x => Proxy * x -> repr h ([l] -> Diff x [l])

toDiffBy :: repr h (x -> [l] -> Diff x [l])

fromDiff :: Monoid * repr x => Proxy * x -> repr h (Diff x [l] -> [l])

fromDiffBy :: repr h (x -> Diff x [l] -> [l])

(Lang repr, ConvDiff repr l, ConvDiff repr r) => ConvDiff repr (l -> r)

Methods

toDiff :: Monoid * repr x => Proxy * x -> repr h ((l -> r) -> Diff x (l -> r))

toDiffBy :: repr h (x -> (l -> r) -> Diff x (l -> r))

fromDiff :: Monoid * repr x => Proxy * x -> repr h (Diff x (l -> r) -> l -> r)

fromDiffBy :: repr h (x -> Diff x (l -> r) -> l -> r)

(Lang repr, ConvDiff repr l, ConvDiff repr r) => ConvDiff repr (Either l r)

Methods

toDiff :: Monoid * repr x => Proxy * x -> repr h (Either l r -> Diff x (Either l r))

toDiffBy :: repr h (x -> Either l r -> Diff x (Either l r))

fromDiff :: Monoid * repr x => Proxy * x -> repr h (Diff x (Either l r) -> Either l r)

fromDiffBy :: repr h (x -> Diff x (Either l r) -> Either l r)

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

Methods

toDiff :: Monoid * repr x => Proxy * x -> repr h ((l, r) -> Diff x (l, r))

toDiffBy :: repr h (x -> (l, r) -> Diff x (l, r))

fromDiff :: Monoid * repr x => Proxy * x -> repr h (Diff x (l, r) -> (l, r))

fromDiffBy :: repr h (x -> Diff x (l, r) -> (l, r))

Lang repr => DBI (ImpW * repr)

Methods

z :: ImpW * repr (a, h) a

s :: ImpW * repr h b -> ImpW * repr (a, h) b

abs :: ImpW * repr (a, h) b -> ImpW * repr h (a -> b)

app :: ImpW * repr h (a -> b) -> ImpW * repr h a -> ImpW * repr h b

hoas :: (ImpW * repr (a, h) a -> ImpW * repr (a, h) b) -> ImpW * repr h (a -> b)

com :: ImpW * repr h ((b -> c) -> (a -> b) -> a -> c)

flip :: ImpW * repr h ((a -> b -> c) -> b -> a -> c)

id :: ImpW * repr h (a -> a)

const :: ImpW * repr h (a -> b -> a)

scomb :: ImpW * repr h ((a -> b -> c) -> (a -> b) -> a -> c)

dup :: ImpW * repr h ((a -> a -> b) -> a -> b)

let_ :: ImpW * repr h (a -> (a -> b) -> b)

Lang r => Bool (ImpW * r)

Methods

bool :: Bool -> ImpW * r h Bool

ite :: ImpW * r h (a -> a -> Bool -> a)

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

Methods

bool :: Bool -> WDiff r v h Bool

ite :: WDiff r v h (a -> a -> Bool -> a)

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

Methods

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

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

Methods

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