DBI

Documentation

class Monoid r m where

Minimal complete definition

zero, plus

Methods

zero :: r h m

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

class Monoid repr w => WithDiff repr w where

Minimal complete definition

withDiff

Methods

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

withDiff1 :: (WithDiff * repr w, DBI repr) => repr h (w -> x) -> repr h (w -> Diff x w)

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

class DBI repr where

Minimal complete definition

z, s, abs, app

Methods

z :: repr (a, h) a

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

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

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

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

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

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)

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

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

Instances

DBI Eval

Methods

z :: Eval (a, h) a

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

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

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

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

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

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)

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

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

DBI repr => DBI (GWDiff repr)

Methods

z :: GWDiff repr (a, h) a

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

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

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

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

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

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

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

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

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

dup :: GWDiff repr h ((a -> a -> b) -> a -> b)

let_ :: GWDiff repr h (a -> (a -> b) -> b)

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

abs :: 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

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

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

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)

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

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

DBI (Show * *)

Methods

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

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

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

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

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

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

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)

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

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

DBI repr => DBI (UnHOAS * * repr)

Methods

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

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

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

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

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

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

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

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

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

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

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

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

(DBI l, DBI r) => DBI (Combine * * l r)

Methods

z :: Combine * * l r (a, h) a

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

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

app :: Combine * * l r h (a -> b) -> Combine * * l r h a -> Combine * * l r h b

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

com :: Combine * * l r h ((b -> c) -> (a -> b) -> a -> c)

flip :: Combine * * l r h ((a -> b -> c) -> b -> a -> c)

id :: Combine * * l r h (a -> a)

const :: Combine * * l r h (a -> b -> a)

scomb :: Combine * * l r h ((a -> b -> c) -> (a -> b) -> a -> c)

dup :: Combine * * l r h ((a -> a -> b) -> a -> b)

let_ :: Combine * * l r h (a -> (a -> b) -> b)

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

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

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

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, DBI repr) => 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 Functor r f where

Minimal complete definition

map

Methods

map :: r h ((a -> b) -> f a -> 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)

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)

class BiFunctor r p where

Minimal complete definition

bimap

Methods

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

app3 :: DBI repr => repr h (a2 -> a1 -> a -> b) -> repr h a2 -> repr h a1 -> repr h 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

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

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

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

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

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)

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

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

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)

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

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

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

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

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

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)

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

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

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)

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

NTS k k1 repr l r => NT k k1 repr l r

Methods

conv :: r l t -> r r t

class NTS repr l r where

Minimal complete definition

convS

Methods

convS :: repr l t -> repr r t

Instances

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

Methods

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

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

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

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

type Diff v () = ()

type Diff v Float

type Diff v Float = (Float, v)

type Diff v Double

type Diff v Double = (Double, v)

type Diff v Void

type Diff v Void = Void

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

type Diff v (Either a b)

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

type Diff v (Writer w a)

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

newtype WDiff repr v h x

Constructors

WDiff

Fields

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

Instances

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

abs :: 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

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

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

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)

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

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

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

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

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

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

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

ProdCon RandRange l r

Methods

prodCon :: (RandRange l, RandRange r) :- RandRange (l, r)

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

Methods

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

class ProdCon con l r where

Minimal complete definition

prodCon

Methods

prodCon :: (con l, con r) :- con (l, r)

Instances

ProdCon Show l r

Methods

prodCon :: (Show l, Show r) :- Show (l, r)

ProdCon Random l r

Methods

prodCon :: (Random l, Random r) :- Random (l, r)

ProdCon RandRange l r

Methods

prodCon :: (RandRange l, RandRange r) :- RandRange (l, r)

Lang repr => ProdCon (Vector repr) l r

Methods

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

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

Methods

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

class Weight w where

Minimal complete definition

weightCon

Methods

weightCon :: (con (), con Double, ForallV (ProdCon con)) :- con w

Instances

Weight Double

Methods

weightCon :: (con (), con Double, ForallV (* -> * -> Constraint) (ProdCon con)) :- con Double

Weight ()

Methods

weightCon :: (con (), con Double, ForallV (* -> * -> Constraint) (ProdCon con)) :- con ()

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

Methods

weightCon :: (con (), con Double, ForallV (* -> * -> Constraint) (ProdCon con)) :- con (l, r)

data RunImpW repr h x

Constructors

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

data ImpW repr h x

Constructors

NoImpW (repr h x)

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

Instances

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)

type RunImpWR repr h x = forall r. (forall w. Weight w => repr h (w -> x) -> r) -> r

runImpW2RunImpWR :: RunImpW repr h x -> RunImpWR repr h x

runImpWR2RunImpW :: RunImpWR repr h x -> RunImpW repr h x

data Combine l r h x

Constructors

Combine (l h x) (r h x)

Instances

(DBI l, DBI r) => DBI (Combine * * l r)

Methods

z :: Combine * * l r (a, h) a

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

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

app :: Combine * * l r h (a -> b) -> Combine * * l r h a -> Combine * * l r h b

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

com :: Combine * * l r h ((b -> c) -> (a -> b) -> a -> c)

flip :: Combine * * l r h ((a -> b -> c) -> b -> a -> c)

id :: Combine * * l r h (a -> a)

const :: Combine * * l r h (a -> b -> a)

scomb :: Combine * * l r h ((a -> b -> c) -> (a -> b) -> a -> c)

dup :: Combine * * l r h ((a -> a -> b) -> a -> b)

let_ :: Combine * * l r h (a -> (a -> b) -> b)

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

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)