TypedFlow.Types

Documentation

data Sat a b where

Constructors

Sat :: a b => Sat a b

type DOC = Doc ()

type (<) i j = CmpNat i j ~ LT

type family Product xs where ...

Equations

Product '[] = 1

Product (x ': xs) = x * Product xs

type family Sum xs where ...

Equations

Sum '[] = 0

Sum (x ': xs) = x + Sum xs

type family xs ++ ys where ...

Equations

'[] ++ xs = xs

(x ': xs) ++ ys = x ': (xs ++ ys)

type family Tail xs where ...

Equations

Tail (x ': xs) = xs

type family Last xs where ...

Equations

Last '[x] = x

Last (x ': xs) = Last xs

type family Init xs where ...

Equations

Init '[x] = '[]

Init (x ': xs) = x ': Init xs

plusAssoc' :: forall x y z. ((x + y) + z) :~: (x + (y + z))

plusAssoc :: forall x y z k. (((x + y) + z) ~ (x + (y + z)) => k) -> k

prodAssoc' :: forall x y z. ((x * y) * z) :~: (x * (y * z))

prodAssoc :: forall x y z k. (((x * y) * z) ~ (x * (y * z)) => k) -> k

prodHomo' :: forall x y. Product (x ++ y) :~: (Product x * Product y)

prodHomo :: forall x y k. (Product (x ++ y) ~ (Product x * Product y) => k) -> k

knownProduct' :: forall s k. All KnownNat s => SList s -> (KnownNat (Product s) => k) -> k

knownProduct :: forall s k. KnownShape s => (KnownNat (Product s) => k) -> k

initLast' :: forall s k. SList s -> ((Init s ++ '[Last s]) ~ s => k) -> k

initLast :: forall s k. KnownShape s => ((Init s ++ '[Last s]) ~ s => k) -> k

knownLast' :: All KnownNat s => SList s -> (KnownNat (Last s) => k) -> k

knownLast :: forall s k. KnownShape s => (KnownNat (Last s) => k) -> k

splitApp' :: forall ys xs k. SList xs -> ((Take (PeanoLength xs) (xs ++ ys) ~ xs, Drop (PeanoLength xs) (xs ++ ys) ~ ys) => k) -> k

splitApp :: forall xs ys k. KnownLen xs => ((Take (PeanoLength xs) (xs ++ ys) ~ xs, Drop (PeanoLength xs) (xs ++ ys) ~ ys) => k) -> k

knownAppend' :: forall t s k. (All KnownNat s, KnownShape t) => SList s -> (KnownShape (s ++ t) => k) -> k

knownAppend :: forall s t k. (KnownShape s, KnownShape t) => (KnownShape (s ++ t) => k) -> k

type family Length xs where ...

Equations

Length '[] = 0

Length (x ': xs) = 1 + Length xs

type family Reverse' xs ys where ...

Equations

Reverse' '[] ys = ys

Reverse' (x ': xs) ys = Reverse' xs (x ': ys)

type family Reverse xs where ...

Equations

Reverse xs = Reverse' xs '[]

newtype V n a

Constructors

V [a]

Instances

Functor (V n)

Methods

fmap :: (a -> b) -> V n a -> V n b

(<$) :: a -> V n b -> V n a

KnownNat n => Applicative (V n)

Methods

pure :: a -> V n a

(<*>) :: V n (a -> b) -> V n a -> V n b

(*>) :: V n a -> V n b -> V n b

(<*) :: V n a -> V n b -> V n a

Foldable (V n)

Methods

fold :: Monoid m => V n m -> m

foldMap :: Monoid m => (a -> m) -> V n a -> m

foldr :: (a -> b -> b) -> b -> V n a -> b

foldr' :: (a -> b -> b) -> b -> V n a -> b

foldl :: (b -> a -> b) -> b -> V n a -> b

foldl' :: (b -> a -> b) -> b -> V n a -> b

foldr1 :: (a -> a -> a) -> V n a -> a

foldl1 :: (a -> a -> a) -> V n a -> a

toList :: V n a -> [a]

null :: V n a -> Bool

length :: V n a -> Int

elem :: Eq a => a -> V n a -> Bool

maximum :: Ord a => V n a -> a

minimum :: Ord a => V n a -> a

sum :: Num a => V n a -> a

product :: Num a => V n a -> a

Traversable (V n)

Methods

traverse :: Applicative f => (a -> f b) -> V n a -> f (V n b)

sequenceA :: Applicative f => V n (f a) -> f (V n a)

mapM :: Monad m => (a -> m b) -> V n a -> m (V n b)

sequence :: Monad m => V n (m a) -> m (V n a)

data NP f xs where

Constructors

Unit :: NP f '[]

(:*) :: f x -> NP f xs -> NP f (x ': xs) infixr 5

Instances

(KnownTyp Typ t, All [Nat] KnownShape ys) => KnownTensors (HTV t ys)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> HTV t ys -> Gen (HTV t ys)

newtype I a

Constructors

I a

newtype K a x

Constructors

K a

type HList = NP I

pattern HSingle :: forall k f a. f a -> NP k f ((:) k a ([] k))

pattern VecSing :: forall s t. Tensor s t -> HTV t ((:) Shape s ([] Shape))

pattern VecPair :: forall s t s'. Tensor s t -> Tensor s' t -> HTV t ((:) Shape s ((:) Shape s' ([] Shape)))

pattern VecTriple :: forall s t s' s3. Tensor s t -> Tensor s' t -> Tensor s3 t -> HTV t ((:) Shape s ((:) Shape s' ((:) Shape s3 ([] Shape))))

type family All (c :: k -> Constraint) (xs :: [k]) :: Constraint where ...

Equations

All c '[] = ()

All c (x ': xs) = (c x, All c xs)

class Fun c

Associated Types

type Ap c (t :: k) :: l

Instances

Fun k c => Fun [k] (FMap k c)

Associated Types

type Ap l (FMap k c) (c :: FMap k c -> Constraint) (t :: FMap k c) :: l

Fun [k] (Snoc k x)

Associated Types

type Ap l (Snoc k x) (c :: Snoc k x -> Constraint) (t :: Snoc k x) :: l

Fun [k] (Cons k x)

Associated Types

type Ap l (Cons k x) (c :: Cons k x -> Constraint) (t :: Cons k x) :: l

class Cons x xs

Instances

Fun [k] (Cons k x)

Associated Types

type Ap l (Cons k x) (c :: Cons k x -> Constraint) (t :: Cons k x) :: l

type Ap [k] [k] (Cons k x) xs

type Ap [k] [k] (Cons k x) xs = (:) k x xs

class Snoc x xs

Instances

Fun [k] (Snoc k x)

Associated Types

type Ap l (Snoc k x) (c :: Snoc k x -> Constraint) (t :: Snoc k x) :: l

type Ap [k] [k] (Snoc k x) ([] k)

type Ap [k] [k] (Snoc k x) ([] k) = (:) k x ([] k)

type Ap [k] [k] (Snoc k x) ((:) k y ys)

type Ap [k] [k] (Snoc k x) ((:) k y ys) = (:) k y (Ap [k] [k] (Snoc k x) ys)

class FMap c xs

Instances

Fun k c => Fun [k] (FMap k c)

Associated Types

type Ap l (FMap k c) (c :: FMap k c -> Constraint) (t :: FMap k c) :: l

type Ap [k1] [k] (FMap k c) ([] k)

type Ap [k1] [k] (FMap k c) ([] k) = [] k1

type Ap [a] [k] (FMap k c) ((:) k x xs)

type Ap [a] [k] (FMap k c) ((:) k x xs) = (:) a (Ap a k c x) (Ap [a] [k] (FMap k c) xs)

newtype F g t s

Flip at type level

Constructors

F

Fields

• fromF :: g s t

Instances

(KnownTyp Typ t, All [Nat] KnownShape ys) => KnownTensors (HTV t ys)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> HTV t ys -> Gen (HTV t ys)

type HTV t = NP (F T t)

Heterogeneous tensor vector with the same kind of elements

data Pair a b

Constructors

a :& b

type family Fst (x :: Pair a b) where ...

Equations

Fst (x :& y) = x

type family Snd (x :: Pair a b) where ...

Equations

Snd (x :& y) = y

newtype Uncurry g s

Constructors

Uncurry

Fields

• fromUncurry :: g (Fst s) (Snd s)

type HHTV = NP (Uncurry T)

hhead :: NP f (x ': xs) -> f x

htail :: NP f (x ': xs) -> NP f xs

htmap :: forall f ss t u. (forall s. Tensor s t -> Tensor (Ap f s) u) -> HTV t ss -> HTV u (Ap (FMap f) ss)

hmap :: (forall x. f x -> g x) -> NP f xs -> NP g xs

hendo :: NP Endo xs -> HList xs -> HList xs

happ :: NP f xs -> NP f ys -> NP f (xs ++ ys)

data Both f g x

Constructors

Both (f x) (g x)

hzip :: NP f xs -> NP g xs -> NP (Both f g) xs

hzipWith :: (forall x. f x -> g x -> h x) -> NP f xs -> NP g xs -> NP h xs

hfor_ :: Monad m => NP f xs -> (forall x. f x -> m a) -> m ()

htoList :: NP (K a) xs -> [a]

hsplit' :: SPeano n -> NP f xs -> (NP f (Take n xs), NP f (Drop n xs))

hsplit :: forall xs ys f. KnownLen xs => NP f (xs ++ ys) -> (NP f xs, NP f ys)

hsnoc :: NP f xs -> f x -> NP f (xs ++ '[x])

data Peano

Constructors

Zero

Succ Peano

Instances

KnownPeano Peano Zero

Methods

peanoInt :: Integer

KnownPeano Peano n => KnownPeano Peano (Succ n)

Methods

peanoInt :: Integer

type Dim0 = Zero

type Dim1 = Succ Dim0

type Dim2 = Succ Dim1

type Dim3 = Succ Dim2

type Axis0 = Zero

type Axis1 = Succ Dim0

type Axis2 = Succ Dim1

type Axis3 = Succ Dim2

class KnownPeano n where

Minimal complete definition

peanoInt

Methods

peanoInt :: Integer

Instances

KnownPeano Peano Zero

Methods

peanoInt :: Integer

KnownPeano Peano n => KnownPeano Peano (Succ n)

Methods

peanoInt :: Integer

data SPeano n where

Constructors

SZero :: SPeano Zero

SSucc :: SPeano n -> SPeano (Succ n)

data Vec n a where

Constructors

VNil :: Vec Zero a

VCons :: a -> Vec n a -> Vec (Succ n) a

vecToList :: Vec n a -> [a]

type family Take n xs where ...

Equations

Take Zero xs = '[]

Take (Succ n) '[] = '[]

Take (Succ n) (x ': xs) = x ': Take n xs

type family Drop n xs where ...

Equations

Drop Zero xs = xs

Drop (Succ n) '[] = '[]

Drop (Succ n) (x ': xs) = Drop n xs

type family At n xs where ...

Equations

At Zero (x ': xs) = x

At (Succ n) (x ': xs) = At n xs

data Kind

Constructors

Float

Int

Bool

Instances

Show Kind

Methods

showsPrec :: Int -> Kind -> ShowS

show :: Kind -> String

showList :: [Kind] -> ShowS

KnownKind Kind Float

Methods

kindVal :: Kind

KnownKind Kind Int

Methods

kindVal :: Kind

KnownKind Kind Bool

Methods

kindVal :: Kind

data NBits

Constructors

B32

B64

B1

Instances

Show NBits

Methods

showsPrec :: Int -> NBits -> ShowS

show :: NBits -> String

showList :: [NBits] -> ShowS

KnownBits NBits B32

Methods

bitsVal :: NBits

KnownBits NBits B64

Methods

bitsVal :: NBits

KnownBits NBits B1

Methods

bitsVal :: NBits

data Typ

Constructors

Typ Kind NBits

Instances

Show Typ

Methods

showsPrec :: Int -> Typ -> ShowS

show :: Typ -> String

showList :: [Typ] -> ShowS

(KnownBits NBits l, KnownKind Kind k) => KnownTyp Typ (Typ k l)

Methods

typVal :: Typ

(KnownTyp Typ t, All [Nat] KnownShape ys) => KnownTensors (HTV t ys)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> HTV t ys -> Gen (HTV t ys)

type Flt t = Typ Float t

type Float32 = Typ Float B32

type Int32 = Typ Int B32

type Int64 = Typ Int B64

type TFBool = Typ Bool B1

type Scalar t = T '[] t

showTyp :: forall t. KnownTyp t => DOC

type Shape = [Nat]

type UntypedExpression = DOC

data T shape t

Constructors

T

Fields

• fromTensor :: UntypedExpression

Instances

(KnownTyp Typ t, KnownShape shape) => KnownTensors (T shape t)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> T shape t -> Gen (T shape t)

(KnownTyp Typ t, All [Nat] KnownShape ys) => KnownTensors (HTV t ys)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> HTV t ys -> Gen (HTV t ys)

data SNat n where

Constructors

SNat :: KnownNat n => Proxy n -> SNat n

class (KnownLen s, All KnownNat s) => KnownShape s

Instances

KnownShape ([] Nat)

(KnownNat x, KnownShape xs) => KnownShape ((:) Nat x xs)

class KnownTyp t where

Minimal complete definition

typVal

Methods

typVal :: Typ

Instances

(KnownBits NBits l, KnownKind Kind k) => KnownTyp Typ (Typ k l)

Methods

typVal :: Typ

class KnownBits t where

Minimal complete definition

bitsVal

Methods

bitsVal :: NBits

Instances

KnownBits NBits B32

Methods

bitsVal :: NBits

KnownBits NBits B64

Methods

bitsVal :: NBits

KnownBits NBits B1

Methods

bitsVal :: NBits

class KnownKind t where

Minimal complete definition

kindVal

Methods

kindVal :: Kind

Instances

KnownKind Kind Float

Methods

kindVal :: Kind

KnownKind Kind Int

Methods

kindVal :: Kind

KnownKind Kind Bool

Methods

kindVal :: Kind

type SList = SList' Proxy

data SList' f s where

Constructors

LZ :: SList' f '[]

LS :: forall x xs f. f x -> SList' f xs -> SList' f (x ': xs)

type family PeanoLength xs :: Peano where ...

Equations

PeanoLength '[] = Zero

PeanoLength (x ': xs) = Succ (PeanoLength xs)

withKnownNat :: forall k. Int -> (forall n. KnownNat n => Proxy n -> k) -> k

class KnownLen s where

Minimal complete definition

listLen, shapePeano, shapeSList

Methods

listLen :: Integer

shapePeano :: SPeano (PeanoLength s)

shapeSList :: SList s

Instances

KnownLen a ([] a)

Methods

listLen :: Integer

shapePeano :: SPeano (PeanoLength [a] s)

shapeSList :: SList [a] s

KnownLen a xs => KnownLen a ((:) a x xs)

Methods

listLen :: Integer

shapePeano :: SPeano (PeanoLength ((a ': x) xs) s)

shapeSList :: SList ((a ': x) xs) s

shapeSListProxy :: KnownLen xs => proxy xs -> SList xs

shapeToList' :: All KnownNat s => SList s -> [Integer]

shapeToList :: forall s. KnownShape s => [Integer]

showShape' :: [Integer] -> DOC

showShape :: forall s. KnownShape s => DOC

showShapeMinus :: forall s. KnownShape s => DOC

Show a shape, but None is replaced by "-1"

showShapeLen :: forall s. KnownLen s => DOC

rememberNat :: SNat n -> (KnownNat n => r) -> r

type None = 514229

showDim' :: String -> Integer -> DOC

showDimM :: forall n. KnownNat n => DOC

showDim :: forall n. KnownNat n => DOC

str :: Show a => a -> DOC

data ParamInfo

Constructors

ParamInfo

Fields

• paramName :: String
• paramShape :: [Integer]
• paramDType :: Typ
• paramVar :: forall s t. (KnownShape s, KnownTyp t) => Tensor s t

data GState

Constructors

GState

Fields

• nextVar :: Integer

  next free variable

• genText :: DOC
• genParams :: [ParamInfo]

  optimizable parameters

• genTrainingPlaceholder :: Scalar TFBool

  flag which is true when training

• genPeeks :: [(String, UntypedExpression)]

Instances

MonadState GState Gen

Methods

get :: Gen GState

put :: GState -> Gen ()

state :: (GState -> (a, GState)) -> Gen a

newtype Gen x

Constructors

Gen

Fields

• fromGen :: State GState x

Instances

Monad Gen

Methods

(>>=) :: Gen a -> (a -> Gen b) -> Gen b

(>>) :: Gen a -> Gen b -> Gen b

return :: a -> Gen a

fail :: String -> Gen a

Functor Gen

Methods

fmap :: (a -> b) -> Gen a -> Gen b

(<$) :: a -> Gen b -> Gen a

Applicative Gen

Methods

pure :: a -> Gen a

(<*>) :: Gen (a -> b) -> Gen a -> Gen b

(*>) :: Gen a -> Gen b -> Gen b

(<*) :: Gen a -> Gen b -> Gen a

MonadState GState Gen

Methods

get :: Gen GState

put :: GState -> Gen ()

state :: (GState -> (a, GState)) -> Gen a

newParameter :: MonadState GState m => ParamInfo -> m ()

peekAtAny :: String -> UntypedExpression -> Gen ()

Name an expression so that it is made available for session.run.

newVar :: Gen DOC

gen :: DOC -> Gen ()

setGen :: DOC -> Gen ()

withDOC :: forall a. (DOC -> DOC) -> Gen a -> Gen a

type Tensor shape = T shape

(<--) :: DOC -> UntypedExpression -> Gen ()

tuple :: [DOC] -> DOC

dict :: [(String, DOC)] -> DOC

funcall :: String -> [DOC] -> DOC

funcall' :: DOC -> [DOC] -> DOC

binOp :: forall s1 s2 s3 t1 t2 t3. String -> Tensor s1 t1 -> Tensor s2 t2 -> Tensor s3 t3

unOp :: forall s1 s2 t1 t2. String -> Tensor s1 t1 -> Tensor s2 t2

assign :: forall s t. T s t -> Gen (T s t)

genFun :: forall b. String -> [DOC] -> Gen b -> Gen b

lambda :: (T s t -> T s' t') -> Gen UntypedExpression

generate :: Gen () -> (String, [ParamInfo])

generateFile :: String -> Gen () -> IO ()

named :: String -> DOC -> DOC