Shady.Language.Type

Contents

• Type values
• Generating type values
• Type equality
• Vector operations
• Convenient type synonyms
• Notions of equality
• Pairing and unit
• Re-export

Description

Synopsis

• data ScalarT where
  • Bool :: ScalarT Bool
  • Int :: ScalarT Int
  • Float :: ScalarT Float
• data VectorT n a = VectorT (Nat n) (ScalarT a)
• data Type where
  • VecT :: (IsNat n, IsScalar a) => VectorT n a -> Type (Vec n a)
  • SamplerT :: IsNat n => Nat n -> Type (Sampler n)
  • UnitT :: Type ()
  • :*: :: (HasType a, HasType b) => Type a -> Type b -> Type (a, b)
  • :->: :: (HasType a, HasType b) => Type a -> Type b -> Type (a -> b)
• type TextureId = Int
• data Sampler n = Sampler {
  • samplerDim :: Nat n
  • samplerTexture :: TextureId
  }
• sampler1 :: TextureId -> Sampler1
• sampler2 :: TextureId -> Sampler2
• sampler3 :: TextureId -> Sampler3
• type Sampler1 = Sampler OneT
• type Sampler2 = Sampler TwoT
• type Sampler3 = Sampler ThreeT
• class (Storable a, Typeable a, Show a) => IsScalar a where
  • scalarT :: ScalarT a
• vectorT :: (IsNat n, IsScalar a) => VectorT n a
• class Show t => HasType t where
  • typeT :: Type t
• typeOf :: HasType a => a -> Type a
• typeOf1 :: HasType a => f a -> Type a
• typeOf2 :: HasType a => g (f a) -> Type a
• compatible :: (HasType a, HasType b) => a -> b -> Maybe (a :=: b)
• compatible1 :: (HasType a, HasType b) => f a -> g b -> Maybe (a :=: b)
• data IsVec where
  • IsVec :: (IsNat n, IsScalar a) => IsVec (Vec n a)
• checkVec :: forall t. HasType t => Maybe (IsVec t)
• checkVec' :: forall f t. HasType t => f t -> Maybe (IsVec t)
• data ($a) :=: ($b) where
  • Refl :: :=: a a
• ptyEq :: ScalarT a -> ScalarT b -> Maybe (a :=: b)
• vtyEq :: VectorT m a -> VectorT n b -> Maybe (Vec m a :=: Vec n b)
• tyEq :: Type c -> Type c' -> Maybe (c :=: c')
• (=:=) :: forall f a b. (HasType a, HasType b, SynEq f) => f a -> f b -> Maybe (a :=: b)
• (===) :: forall f a b. (HasType a, HasType b, SynEq f) => f a -> f b -> Bool
• type R = Float
• type R1 = One R
• type R2 = Two R
• type R3 = Three R
• type R4 = Four R
• type B1 = One Bool
• type Pred1 a = a -> B1
• type Pred2 a = a -> Pred1 a
• class SynEq f where
  • (=-=) :: HasType c => f c -> f c -> Bool
• class SynEq2 f where
  • (=--=) :: (SynEq v, HasType c) => f v c -> f v c -> Bool
• class PairF f where
  • (#) :: (HasType a, HasType b) => f a -> f b -> f (a :# b)
• type :# a b = (a, b)
• class UnitF f where
  • unit :: f ()
• module Shady.Vec

Type values

Generating type values

Type equality

Vector operations

Convenient type synonyms

Notions of equality

Pairing and unit

Re-export