Lang

Documentation

class DBI 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

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)

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)

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)

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)

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

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)

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

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 l, Group repr r) => Group repr (l -> r)

Methods

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

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

(Lang repr, 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 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, 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

newtype GWDiff repr h x

Constructors

GWDiff

Fields

• runGWDiff :: forall v. Vector repr v => Proxy v -> repr (Diff v h) (Diff v x)

Instances

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)

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)

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

Orphan instances

Lang r => Monad r Maybe

Methods

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

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

Lang r => Monad r IO

Methods

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

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

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

Methods

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

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

Lang r => BiFunctor * r (,)

Methods

bimap :: (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 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, 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 (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 l, Monoid * repr r) => Monoid * repr (l -> r)

Methods

zero :: (l -> r) h m

plus :: (l -> r) 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 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)

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)