DBI

Documentation

class Reify repr x where

Minimal complete definition

reify

Methods

reify :: x -> repr h x

Instances

DBI repr => Reify * repr Double

Methods

reify :: x -> Double h x

DBI repr => Reify * repr ()

Methods

reify :: x -> () h x

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

Methods

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

class DBI repr where

Minimal complete definition

z, s, lam, app, mkProd, zro, fst, lit, doublePlus, doubleMinus, doubleMult, doubleDivide, fix, left, right, sumMatch, unit, exfalso, nothing, just, optionMatch, ioRet, ioBind, ioMap, nil, cons, listMatch, writer, runWriter, exp

Methods

z :: repr (a, h) a

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

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

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

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

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

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

lit :: Double -> repr h Double

litZero :: repr h Double

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

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

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)

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

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

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

id :: repr h (a -> a)

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

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

exp :: repr h (Double -> Double)

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

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

Instances

DBI Eval

Methods

z :: Eval (a, h) a

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

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

app :: Eval h (a -> b) -> Eval h a -> Eval h b

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

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

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

lit :: Double -> Eval h Double

litZero :: Eval h Double

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

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

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)

com :: Eval h ((b -> c) -> (a -> b) -> a -> c)

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

flip :: Eval h ((a -> b -> c) -> b -> a -> c)

id :: Eval h (a -> a)

const :: Eval h (a -> b -> a)

scomb :: Eval h ((a -> b -> c) -> (a -> b) -> a -> c)

exp :: Eval h (Double -> Double)

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

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

DBI repr => DBI (ImpW repr)

Methods

z :: ImpW repr (a, h) a

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

lam :: ImpW repr (a, h) b -> ImpW repr h (a -> b)

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

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

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

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

lit :: Double -> ImpW repr h Double

litZero :: ImpW repr h Double

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

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

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)

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

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

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)

exp :: ImpW repr h (Double -> Double)

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

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

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

Methods

z :: WDiff repr v (a, h) a

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

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

app :: WDiff repr v h (a -> b) -> WDiff repr v h a -> WDiff repr v h b

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)

lit :: Double -> WDiff repr v h Double

litZero :: WDiff repr v h Double

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

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

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)

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

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

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

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

const :: WDiff repr v h (a -> b -> a)

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

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

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

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

DBI (Show * *)

Methods

z :: Show * * (a, h) a

s :: Show * * h b -> Show * * (a, h) b

lam :: Show * * (a, h) b -> Show * * h (a -> b)

app :: Show * * h (a -> b) -> Show * * h a -> Show * * h b

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

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

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

lit :: Double -> Show * * h Double

litZero :: Show * * h Double

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

hoas :: (Show * * (a, h) a -> Show * * (a, h) b) -> Show * * h (a -> b)

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)

com :: Show * * h ((b -> c) -> (a -> b) -> a -> c)

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

flip :: Show * * h ((a -> b -> c) -> b -> a -> c)

id :: Show * * h (a -> a)

const :: Show * * h (a -> b -> a)

scomb :: Show * * h ((a -> b -> c) -> (a -> b) -> a -> c)

exp :: Show * * h (Double -> Double)

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

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

DBI (Term * * DBI)

Methods

z :: Term * * DBI (a, h) a

s :: Term * * DBI h b -> Term * * DBI (a, h) b

lam :: Term * * DBI (a, h) b -> Term * * DBI h (a -> b)

app :: Term * * DBI h (a -> b) -> Term * * DBI h a -> Term * * DBI h b

mkProd :: Term * * DBI h (a -> b -> (a, b))

zro :: Term * * DBI h ((a, b) -> a)

fst :: Term * * DBI h ((a, b) -> b)

lit :: Double -> Term * * DBI h Double

litZero :: Term * * DBI h Double

litOne :: Term * * DBI h Double

doublePlus :: Term * * DBI h (Double -> Double -> Double)

doubleMinus :: Term * * DBI h (Double -> Double -> Double)

doubleMult :: Term * * DBI h (Double -> Double -> Double)

doubleDivide :: Term * * DBI h (Double -> Double -> Double)

hoas :: (Term * * DBI (a, h) a -> Term * * DBI (a, h) b) -> Term * * DBI h (a -> b)

fix :: Term * * DBI h ((a -> a) -> a)

left :: Term * * DBI h (a -> Either a b)

right :: Term * * DBI h (b -> Either a b)

sumMatch :: Term * * DBI h ((a -> c) -> (b -> c) -> Either a b -> c)

unit :: Term * * DBI h ()

exfalso :: Term * * DBI h (Void -> a)

nothing :: Term * * DBI h (Maybe a)

just :: Term * * DBI h (a -> Maybe a)

optionMatch :: Term * * DBI h (b -> (a -> b) -> Maybe a -> b)

ioRet :: Term * * DBI h (a -> IO a)

ioBind :: Term * * DBI h (IO a -> (a -> IO b) -> IO b)

ioMap :: Term * * DBI h ((a -> b) -> IO a -> IO b)

nil :: Term * * DBI h [a]

cons :: Term * * DBI h (a -> [a] -> [a])

listMatch :: Term * * DBI h (b -> (a -> [a] -> b) -> [a] -> b)

com :: Term * * DBI h ((b -> c) -> (a -> b) -> a -> c)

listAppend :: Term * * DBI h ([a] -> [a] -> [a])

writer :: Term * * DBI h ((a, w) -> Writer w a)

runWriter :: Term * * DBI h (Writer w a -> (a, w))

swap :: Term * * DBI h ((l, r) -> (r, l))

flip :: Term * * DBI h ((a -> b -> c) -> b -> a -> c)

id :: Term * * DBI h (a -> a)

const :: Term * * DBI h (a -> b -> a)

scomb :: Term * * DBI h ((a -> b -> c) -> (a -> b) -> a -> c)

exp :: Term * * DBI h (Double -> Double)

curry :: Term * * DBI h (((a, b) -> c) -> a -> b -> c)

uncurry :: Term * * DBI h ((a -> b -> c) -> (a, b) -> c)

const1 :: DBI repr => repr h a -> repr h (b -> a)

cons2 :: DBI repr => repr h a -> repr h [a] -> repr h [a]

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

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

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

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

class Monoid r m where

Minimal complete definition

zero, plus

Methods

zero :: r h m

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

Instances

DBI r => Monoid * r Double

Methods

zero :: Double h m

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

DBI r => Monoid * r ()

Methods

zero :: () h m

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

DBI r => Monoid * r [a]

Methods

zero :: [a] h m

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

(DBI repr, Monoid * repr l, Monoid * repr r) => Monoid * repr (l -> r)

Methods

zero :: (l -> r) h m

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

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

Methods

zero :: (l, r) h m

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

class (DBI r, Monoid r g) => Group r g where

Minimal complete definition

invert | minus

Methods

invert :: r h (g -> g)

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

Instances

DBI r => Group r Double

Methods

invert :: r h (Double -> Double)

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

DBI r => Group r ()

Methods

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

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

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

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

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

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

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

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

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)

Instances

DBI r => Vector r Double

Methods

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

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

DBI r => Vector r ()

Methods

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

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

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

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

class Functor r f where

Minimal complete definition

map

Methods

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

Instances

DBI r => Functor * r Maybe

Methods

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

DBI r => Functor * r IO

Methods

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

DBI r => Functor * r []

Methods

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

DBI r => Functor * r (Writer w)

Methods

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

map2 :: (Functor * repr f, DBI repr) => repr h (a -> b) -> repr h (f a) -> repr h (f b)

class Functor r a => Applicative r a where

Minimal complete definition

pure, ap

Methods

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

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

Instances

DBI r => Applicative * r Maybe

Methods

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

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

DBI r => Applicative * r IO

Methods

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

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

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

return :: Applicative k r a => r h (x -> a x)

class (DBI r, Applicative r m) => Monad r m where

Minimal complete definition

join | bind

Methods

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

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

Instances

DBI r => Monad r Maybe

Methods

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

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

DBI r => Monad r IO

Methods

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

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

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

bind2 :: Monad repr m => repr h (m a) -> repr h (a -> m b) -> repr h (m b)

map1 :: (Functor * repr f, DBI repr) => repr h (a -> b) -> repr h (f a -> f b)

join1 :: Monad repr m => repr h (m (m a)) -> repr h (m a)

bimap2 :: BiFunctor repr p => repr h (a -> b) -> repr h (c -> d) -> repr h (p a c -> p b d)

flip1 :: DBI repr => repr h (a -> b -> c) -> repr h (b -> a -> c)

flip2 :: DBI repr => repr h (a1 -> a -> c) -> repr h a -> repr h (a1 -> c)

class DBI r => BiFunctor r p where

Minimal complete definition

bimap

Methods

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

Instances

DBI r => BiFunctor r (,)

Methods

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

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

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

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

app3 :: DBI repr => repr h (a2 -> a1 -> a -> b) -> repr h a2 -> repr h a1 -> repr h a -> repr h b

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

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

com2 :: DBI repr => repr h (b -> c) -> repr h (a -> b) -> repr h (a -> c)

newtype Eval h x

Constructors

Eval

Fields

• runEval :: h -> x

Instances

DBI Eval

Methods

z :: Eval (a, h) a

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

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

app :: Eval h (a -> b) -> Eval h a -> Eval h b

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

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

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

lit :: Double -> Eval h Double

litZero :: Eval h Double

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

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

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)

com :: Eval h ((b -> c) -> (a -> b) -> a -> c)

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

flip :: Eval h ((a -> b -> c) -> b -> a -> c)

id :: Eval h (a -> a)

const :: Eval h (a -> b -> a)

scomb :: Eval h ((a -> b -> c) -> (a -> b) -> a -> c)

exp :: Eval h (Double -> Double)

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

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

comb :: x -> Eval h x

data AST

Constructors

Leaf String

App String AST [AST]

Lam String [String] AST

Instances

Show AST

Methods

showsPrec :: Int -> AST -> ShowS

show :: AST -> String

showList :: [AST] -> ShowS

appAST :: AST -> AST -> AST

lamAST :: String -> AST -> AST

newtype Show h a

Constructors

Show

Fields

• runShow :: [String] -> Int -> AST

Instances

DBI (Show * *)

Methods

z :: Show * * (a, h) a

s :: Show * * h b -> Show * * (a, h) b

lam :: Show * * (a, h) b -> Show * * h (a -> b)

app :: Show * * h (a -> b) -> Show * * h a -> Show * * h b

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

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

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

lit :: Double -> Show * * h Double

litZero :: Show * * h Double

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

hoas :: (Show * * (a, h) a -> Show * * (a, h) b) -> Show * * h (a -> b)

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)

com :: Show * * h ((b -> c) -> (a -> b) -> a -> c)

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

flip :: Show * * h ((a -> b -> c) -> b -> a -> c)

id :: Show * * h (a -> a)

const :: Show * * h (a -> b -> a)

scomb :: Show * * h ((a -> b -> c) -> (a -> b) -> a -> c)

exp :: Show * * h (Double -> Double)

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

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

name :: String -> Show k k1 h a

class NT repr l r where

Minimal complete definition

conv

Methods

conv :: repr l t -> repr r t

Instances

NT k k1 repr x x

Methods

conv :: x l t -> x r t

(DBI repr, NT * * repr l r) => NT * * repr l (a, r)

Methods

conv :: (a, r) l t -> (a, r) r t

hlam :: forall repr a b h. DBI repr => ((forall k. NT repr (a, h) k => repr k a) -> repr (a, h) b) -> repr h (a -> b)

hlam2 :: forall repr a b c h. DBI repr => ((forall k. NT repr (a, h) k => repr k a) -> (forall k. NT repr (b, (a, h)) k => repr k b) -> repr (b, (a, h)) c) -> repr h (a -> b -> c)

hlam3 :: (NT * * repr (a, (b1, (a1, h))) k, NT * * repr (b1, (a1, h)) k1, NT * * repr (a1, h) k2, DBI repr) => (repr k2 a1 -> repr k1 b1 -> repr k a -> repr (a, (b1, (a1, h))) b) -> repr h (a1 -> b1 -> a -> b)

type family Diff v x

Instances

type Diff v Void

type Diff v Void = Void

type Diff v ()

type Diff v () = ()

type Diff v Double

type Diff v Double = (Double, v)

type Diff v [a]

type Diff v [a] = [Diff v a]

type Diff v (IO a)

type Diff v (IO a) = IO (Diff v a)

type Diff v (Maybe a)

type Diff v (Maybe a) = Maybe (Diff v a)

type Diff v (Writer w a)

type Diff v (Writer w a) = Writer (Diff v w) (Diff v a)

type Diff v (Either a b)

type Diff v (Either a b) = Either (Diff v a) (Diff v b)

type Diff v (a -> b)

type Diff v (a -> b) = Diff v a -> Diff v b

type Diff v (a, b)

type Diff v (a, b) = (Diff v a, Diff v b)

newtype WDiff repr v h x

Constructors

WDiff

Fields

• runWDiff :: repr (Diff v h) (Diff v x)

Instances

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

Methods

z :: WDiff repr v (a, h) a

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

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

app :: WDiff repr v h (a -> b) -> WDiff repr v h a -> WDiff repr v h b

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)

lit :: Double -> WDiff repr v h Double

litZero :: WDiff repr v h Double

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

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

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)

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

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

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

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

const :: WDiff repr v h (a -> b -> a)

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

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

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

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

app2 :: DBI repr => repr h (a1 -> a -> b) -> repr h a1 -> repr h a -> repr h b

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

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

plus2 :: (Monoid * repr b, DBI repr) => repr h b -> repr h b -> repr h b

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

fst1 :: DBI repr => repr h (a, b) -> repr h b

minus2 :: Group repr b => repr h b -> repr h b -> repr h b

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

mult2 :: Vector repr b => repr h Double -> repr h b -> repr h b

divide2 :: Vector repr b => repr h b -> repr h Double -> repr h b

invert1 :: Group repr b => repr h b -> repr h b

exp1 :: DBI repr => repr h Double -> repr h Double

noEnv :: repr () x -> repr () x

selfWithDiff :: (DBI repr, Weight repr w) => repr h (w -> Diff w w)

withDiff1 :: Weight repr w => repr h (w -> x) -> repr h (w -> Diff x w)

class RandRange w where

Minimal complete definition

randRange

Methods

randRange :: (Double, Double) -> (w, w)

Instances

RandRange Double

Methods

randRange :: (Double, Double) -> (Double, Double)

RandRange ()

Methods

randRange :: (Double, Double) -> ((), ())

(RandRange l, RandRange r) => RandRange (l, r)

Methods

randRange :: (Double, Double) -> ((l, r), (l, r))

class (Random w, RandRange w, Reify repr w, Show w, Vector repr w) => Weight repr w where

Minimal complete definition

withDiff, fromDiff

Methods

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

fromDiff :: Proxy x -> repr h (Diff x w -> w)

Instances

DBI repr => Weight repr Double

Methods

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

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

DBI repr => Weight repr ()

Methods

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

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

(DBI repr, Weight repr l, Weight repr r) => Weight repr (l, r)

Methods

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

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

data RunImpW repr h x

Constructors

Weight repr w => RunImpW (repr h (w -> x))

data ImpW repr h x

Constructors

NoImpW (repr h x)

Weight repr w => ImpW (repr h (w -> x))

Instances

DBI repr => DBI (ImpW repr)

Methods

z :: ImpW repr (a, h) a

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

lam :: ImpW repr (a, h) b -> ImpW repr h (a -> b)

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

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

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

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

lit :: Double -> ImpW repr h Double

litZero :: ImpW repr h Double

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

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

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)

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

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

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)

exp :: ImpW repr h (Double -> Double)

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

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

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

data Term con h x

Constructors

Term (forall r. con r => r h x)

Instances

DBI (Term * * DBI)

Methods

z :: Term * * DBI (a, h) a

s :: Term * * DBI h b -> Term * * DBI (a, h) b

lam :: Term * * DBI (a, h) b -> Term * * DBI h (a -> b)

app :: Term * * DBI h (a -> b) -> Term * * DBI h a -> Term * * DBI h b

mkProd :: Term * * DBI h (a -> b -> (a, b))

zro :: Term * * DBI h ((a, b) -> a)

fst :: Term * * DBI h ((a, b) -> b)

lit :: Double -> Term * * DBI h Double

litZero :: Term * * DBI h Double

litOne :: Term * * DBI h Double

doublePlus :: Term * * DBI h (Double -> Double -> Double)

doubleMinus :: Term * * DBI h (Double -> Double -> Double)

doubleMult :: Term * * DBI h (Double -> Double -> Double)

doubleDivide :: Term * * DBI h (Double -> Double -> Double)

hoas :: (Term * * DBI (a, h) a -> Term * * DBI (a, h) b) -> Term * * DBI h (a -> b)

fix :: Term * * DBI h ((a -> a) -> a)

left :: Term * * DBI h (a -> Either a b)

right :: Term * * DBI h (b -> Either a b)

sumMatch :: Term * * DBI h ((a -> c) -> (b -> c) -> Either a b -> c)

unit :: Term * * DBI h ()

exfalso :: Term * * DBI h (Void -> a)

nothing :: Term * * DBI h (Maybe a)

just :: Term * * DBI h (a -> Maybe a)

optionMatch :: Term * * DBI h (b -> (a -> b) -> Maybe a -> b)

ioRet :: Term * * DBI h (a -> IO a)

ioBind :: Term * * DBI h (IO a -> (a -> IO b) -> IO b)

ioMap :: Term * * DBI h ((a -> b) -> IO a -> IO b)

nil :: Term * * DBI h [a]

cons :: Term * * DBI h (a -> [a] -> [a])

listMatch :: Term * * DBI h (b -> (a -> [a] -> b) -> [a] -> b)

com :: Term * * DBI h ((b -> c) -> (a -> b) -> a -> c)

listAppend :: Term * * DBI h ([a] -> [a] -> [a])

writer :: Term * * DBI h ((a, w) -> Writer w a)

runWriter :: Term * * DBI h (Writer w a -> (a, w))

swap :: Term * * DBI h ((l, r) -> (r, l))

flip :: Term * * DBI h ((a -> b -> c) -> b -> a -> c)

id :: Term * * DBI h (a -> a)

const :: Term * * DBI h (a -> b -> a)

scomb :: Term * * DBI h ((a -> b -> c) -> (a -> b) -> a -> c)

exp :: Term * * DBI h (Double -> Double)

curry :: Term * * DBI h (((a, b) -> c) -> a -> b -> c)

uncurry :: Term * * DBI h ((a -> b -> c) -> (a, b) -> c)

Orphan instances

Random ()

Methods

randomR :: RandomGen g => ((), ()) -> g -> ((), g)

random :: RandomGen g => g -> ((), g)

randomRs :: RandomGen g => ((), ()) -> g -> [()]

randoms :: RandomGen g => g -> [()]

randomRIO :: ((), ()) -> IO ()

randomIO :: IO ()

(Random l, Random r) => Random (l, r)

Methods

randomR :: RandomGen g => ((l, r), (l, r)) -> g -> ((l, r), g)

random :: RandomGen g => g -> ((l, r), g)

randomRs :: RandomGen g => ((l, r), (l, r)) -> g -> [(l, r)]

randoms :: RandomGen g => g -> [(l, r)]

randomRIO :: ((l, r), (l, r)) -> IO (l, r)

randomIO :: IO (l, r)