Shady.Language.Exp

Expressions.

Variables

type Id = String

Variable name

data V a

Typed variables

Constructors

V

Fields

varName :: Id

varType :: Type a

Instances

HasExprU V

SynEq V

Show (V a)

HasExpr a => Pretty (V a)

HasExpr a => PrettyPrec (V a)

HasExpr a => HasExpr (V a)

ToE (Pat a)

var :: HasType a => Id -> V a

Make a variable, inferring the type from context.

genVar :: HasType a => NameM (V a)

Patterns

type Pat = Glom V

Variable patterns

patT :: Pat a -> Type a

The type of a pattern

pat :: HasType a => String -> Pat a

Make a variable pattern, inferring the type from context.

Type paths

data TPath

Type path

emptyP :: TPath

Empty type path

fstP :: TPath -> TPath

sndP :: TPath -> TPath

Extend a type path

namePath :: String -> TPath -> String

Augment a variable name with a type path

Expressions

data E where

Simple expressions (no Let). Statically typed. Constructors for operator/constant (Op), variable (Var), application ('(:^)'), and abstraction (Lam).

Constructors

Op :: Op a -> E a

Var :: V a -> E a

:^ :: HasType a => E (a -> b) -> E a -> E b

Lam :: HasType a => V a -> E b -> E (a -> b)

Instances

UnitF E

PairF E

SynEq E

(IsNat n, IsScalar a, Show a) => IfB BoolE (VecE n a)

Enum a => Enum (E a)

Eq (E a)

(IsNat n, IsScalar b, Floating b) => Floating (E (Vec n b))

(IsNat n, IsScalar b, Fractional b) => Fractional (E (Vec n b))

(IsNat n, IsScalar b, Integral b) => Integral (E (Vec n b))

(IsNat n, IsScalar a, Num a) => Num (E (Vec n a))

(IsNat n, IsScalar a, Ord a, Show a) => Ord (E (Vec n a))

(IsNat n, IsScalar a, Ord a, Num a) => Real (E (Vec n a))

(IsNat n, IsScalar b, RealFrac b) => RealFrac (E (Vec n b))

Show (E a)

(IsNat n, IsScalar a, Num a) => VectorSpace (E (Vec n a))

IsNat n => InnerSpace (E (Vec n R))

(IsNat n, IsScalar a, Num a) => AdditiveGroup (E (Vec n a))

Pretty (E a)

(IsNat n, IsScalar a, FMod a) => FMod (E (Vec n a))

(IsNat n, IsScalar a, FMod a, RealFrac a) => Frac (E (Vec n a))

PrettyPrec (E a)

HasExpr (E a)

(Show a, IsScalar a) => FromE (ComplexE a)

FromE (E a)

(Show a, IsScalar a) => ToE (ComplexE a)

ToE (E a)

IsNat n => Boolean (VecE n Bool)

(IsNat n, IsScalar a, Eq a, Show a) => EqB (VecE n Bool) (VecE n a)

(IsNat n, IsScalar a, Ord a, Show a) => OrdB (VecE n Bool) (VecE n a)

type :=> a b = E a -> b

Function from expressions. Nestable.

type :=>* a b = a :=> E b

Expression to expression. Ends a chain of '(:=>)'

n-ary operator application

op1 :: (HasType a, HasType b) => Op (a -> b) -> a :=>* b

Convenient operator application

op2 :: (HasType a, HasType b, HasType c) => Op (a -> b -> c) -> a :=> (b :=>* c)

Convenient operator application

op3 :: (HasType a, HasType b, HasType c, HasType d) => Op (a -> b -> c -> d) -> a :=> (b :=> (c :=>* d))

Convenient operator application

op4 :: (HasType a, HasType b, HasType c, HasType d, HasType e) => Op (a -> b -> c -> d -> e) -> a :=> (b :=> (c :=> (d :=>* e)))

Convenient operator application

Optimizing expression-builders

pureE :: Show a => a -> E a

Literal expression

fmapE :: (HasType a, HasType b) => Op (a -> b) -> a :=>* b

Apply a unary operator, with constant-folding and simplifications

liftE2 :: (HasType a, HasType b, HasType c) => Op (a -> b -> c) -> a :=> (b :=>* c)

Apply a binary operator, with constant-folding and simplifications

liftE3 :: (HasType a, HasType b, HasType c, HasType d) => Op (a -> b -> c -> d) -> a :=> (b :=> (c :=>* d))

Apply a ternary operator, with constant-folding and simplifications

liftE4 :: (HasType a, HasType b, HasType c, HasType d, HasType e) => Op (a -> b -> c -> d -> e) -> a :=> (b :=> (c :=> (d :=>* e)))

Apply an quaternary operator, with constant-folding and simplifications

Operations

notE :: IsNat n => Vec n Bool :=>* Vec n Bool

Transitional synonym for notB

(==^) :: (IsNat n, IsScalar a, Eq a, Show a) => Vec n a :=> (Vec n a :=>* B1)

Vector equality, resulting in a single Bool. See also '(==*)'.

(/=^) :: (IsNat n, IsScalar a, Eq a, Show a) => Vec n a :=> (Vec n a :=>* B1)

Vector inequality, resulting in a single Bool. See also '(/=*)'.

truncateE :: IsNat n => Vec n R :=>* Vec n R

roundE :: IsNat n => Vec n R :=>* Vec n R

ceilingE :: IsNat n => Vec n R :=>* Vec n R

floorE :: IsNat n => Vec n R :=>* Vec n R

allV :: IsNat n => Vec n Bool :=>* B1

Are all of the Bools true?

anyV :: IsNat n => Vec n Bool :=>* B1

Is all of the Bools true?

type SamplerE n = E (Sampler n)

texture :: IsNat n => Sampler n :=> (Vec n R :=>* R4)

Texturing

lit :: Show a => a -> E a

Literal value

type BoolE = E B1

Bool

type FloatE = E R1

Float expression

type R1E = E R1

type R2E = E R2

type R3E = E R3

type R4E = E R4

type VecE n a = E (Vec n a)

Expression vector

vec2 :: (IsScalar a, Show a) => One a :=> (One a :=>* Two a)

vec3 :: (IsScalar a, Show a) => One a :=> (One a :=> (One a :=>* Three a))

vec4 :: (IsScalar a, Show a) => One a :=> (One a :=> (One a :=> (One a :=>* Four a)))

un2 :: IsScalar a => Two a :=> (E (One a), E (One a))

un3 :: IsScalar a => Three a :=> (E (One a), E (One a), E (One a))

un4 :: IsScalar a => Four a :=> (E (One a), E (One a), E (One a), E (One a))

getX :: (IsNat n, IsScalar a, Show a) => Vec (S n) a :=>* One a

Extract X component

getY :: (IsNat n, IsScalar a, Show a) => Vec (S (S n)) a :=>* One a

Extract Y component

getZ :: (IsNat n, IsScalar a, Show a) => Vec (S (S (S n))) a :=>* One a

Extract Z component

getW :: (IsNat n, IsScalar a, Show a) => Vec (S (S (S (S n)))) a :=>* One a

Extract W component

get :: (IsNat n, IsScalar a, Show a) => Index n -> Vec n a :=>* One a

Extract vector component

(<+>) :: (IsNat m, IsNat n, IsNat (m :+: n), IsScalar a, Show a) => Vec m a :=> (Vec n a :=>* Vec (m :+: n) a)

Concatenation of vectors

unitE :: E ()

Expression-lifted '()'

pairE :: (HasType a, HasType b) => E a -> E b -> E (a, b)

Expression-lifted '(,)'

fstE :: (HasType a, HasType b) => Show a => E (a, b) -> E a

Expression-lifted fst

sndE :: (HasType a, HasType b) => Show b => E (a, b) -> E b

Expression-lifted snd

unPairE :: (HasType a, HasType b) => E (a, b) -> (E a, E b)

Unpack a pair

uniform :: (IsNat n, IsScalar a, Show a) => (E (Vec n a) -> b) -> E (One a) -> b

Uniform version of a function on vectors

uniformV :: (IsNat n, IsScalar a, Show a) => One a :=>* Vec n a

Uniform vector

type ComplexE a = Complex (E (One a))

Complex-valued expressions

Conversion to expressions

class ToE w where

Value convertible to an expression

Associated Types

type ExpT w

Methods

toEN :: w -> NameM (E (ExpT w))

Instances

ToE ()

(Show a, IsScalar a) => ToE (ComplexE a)

ToE (E a)

ToE (Pat a)

(FromE u, ToE v, HasType (ExpT u)) => ToE (u -> v)

(ToE u, Show (ExpT u), HasType (ExpT u), ToE v, Show (ExpT v), HasType (ExpT v)) => ToE (u, v)

(ToE u, HasType (ExpT u), ToE v, HasType (ExpT v), ToE w, HasType (ExpT w)) => ToE (u, v, w)

toE :: ToE w => w -> E (ExpT w)

Convert to an expression, using fresh name supply

class ToE w => FromE w where

Value convertible from an expression

Methods

fromE :: E (ExpT w) -> w

Instances

FromE ()

(Show a, IsScalar a) => FromE (ComplexE a)

FromE (E a)

(FromE u, HasType (ExpT u), FromE v, HasType (ExpT v)) => FromE (u, v)

(FromE u, HasType (ExpT u), FromE v, HasType (ExpT v), FromE w, HasType (ExpT w)) => FromE (u, v, w)

toFromE :: (FromE v, FromE w) => (v -> w) -> E (ExpT v) -> E (ExpT w)

Construct an E transformer from an ExpT transformer

patE :: Pat a -> E a

Turn a pattern into an expression.

module Shady.Language.Type

Temporary

letE :: (HasType a, HasType b) => V a -> E a -> E b -> E b

Short-hand for beta-redex