Feldspar.Core.Types

Heterogenous lists

data a :> b

Heterogeneous list

Constructors

a :> b

Instances

(Eq a, Eq b) => Eq (:> a b)

(Ord a, Ord b) => Ord (:> a b)

(Show a, Show b) => Show (:> a b)

(Lattice a, Lattice b) => Lattice (:> a b)

Integers

newtype WordN

Target-dependent unsigned integers

Constructors

WordN Word32

Instances

Bounded WordN

Enum WordN

Eq WordN

Integral WordN

Num WordN

Ord WordN

Real WordN

Show WordN

Ix WordN

Typeable WordN

Arbitrary WordN

NFData WordN

Storable WordN

Bits WordN

Default WordN

Random WordN

Type WordN

Numeric WordN

Eq WordN

Ord WordN

Integral WordN

Bits WordN

Show (MArr a)

Type a => Type (MArr a)

Slice sl => Slice (:. sl (Data Length))

Shape sh => Shape (:. sh (Data Length))

newtype IntN

Target-dependent signed integers

Constructors

IntN Int32

Instances

Bounded IntN

Enum IntN

Eq IntN

Integral IntN

Num IntN

Ord IntN

Real IntN

Show IntN

Ix IntN

Typeable IntN

Arbitrary IntN

NFData IntN

Storable IntN

Bits IntN

Default IntN

Random IntN

Type IntN

Numeric IntN

Eq IntN

Ord IntN

Integral IntN

Bits IntN

data N8

Type representation of 8 bits

data N16

Type representation of 16 bits

data N32

Type representation of 32 bits

data N64

Type representation of 64 bits

data NNative

Type representation of the native number of bits on the target

data BitWidth n where

Witness for N8, N16, N32, N64 or NNative

Constructors

N8 :: BitWidth N8

N16 :: BitWidth N16

N32 :: BitWidth N32

N64 :: BitWidth N64

NNative :: BitWidth NNative

bitWidth :: BitWidth n -> String

data U

Type representation of "unsigned"

data S

Type representation of "signed"

data Signedness s where

Witness for U or S

Constructors

U :: Signedness U

S :: Signedness S

signedness :: Signedness s -> String

type family GenericInt s n

A generalization of unsigned and signed integers. The first parameter represents the signedness and the sectond parameter the number of bits.

type family WidthOf a

type family SignOf a

fromWordN :: BitWidth n -> WordN -> GenericInt U n

fromIntN :: BitWidth n -> IntN -> GenericInt S n

genericLen :: BitWidth n -> [a] -> GenericInt U n

type Length = WordN

type Index = WordN

Arrays

data TargetArr n a

Array whose length is represented by an n-bit word

Constructors

TargetArr (GenericInt U n) [a]

Monadic Types

class MonadType m where

This class is used to allow constructs to be abstract in the monad

Methods

voidTypeRep :: TypeRep (m ())

Instances

MonadType Par

MonadType Mut

Mutable data

type Mut = IO

Monad for manipulation of mutable data

type MArr a = IOArray Index a

Mutable arrays

Par Monad

type Par = Par

Monad for parallel constructs

type IV = IVar

Immutable references

Future values

newtype FVal a

Constructors

FVal

Fields

unFVal :: a

Instances

Typeable1 FVal

Eq a => Eq (FVal a)

Show (FVal a)

Type a => Type (FVal a)

Type representation

data TypeRep a where

Representation of supported types

Constructors

UnitType :: TypeRep ()

BoolType :: TypeRep Bool

IntType :: (BoundedInt (GenericInt s n), Size (GenericInt s n) ~ Range (GenericInt s n)) => Signedness s -> BitWidth n -> TypeRep (GenericInt s n)

FloatType :: TypeRep Float

DoubleType :: TypeRep Double

ComplexType :: RealFloat a => TypeRep a -> TypeRep (Complex a)

ArrayType :: TypeRep a -> TypeRep [a]

TargetArrType :: BitWidth n -> TypeRep a -> TypeRep (TargetArr n a)

Tup2Type :: TypeRep a -> TypeRep b -> TypeRep (a, b)

Tup3Type :: TypeRep a -> TypeRep b -> TypeRep c -> TypeRep (a, b, c)

Tup4Type :: TypeRep a -> TypeRep b -> TypeRep c -> TypeRep d -> TypeRep (a, b, c, d)

Tup5Type :: TypeRep a -> TypeRep b -> TypeRep c -> TypeRep d -> TypeRep e -> TypeRep (a, b, c, d, e)

Tup6Type :: TypeRep a -> TypeRep b -> TypeRep c -> TypeRep d -> TypeRep e -> TypeRep f -> TypeRep (a, b, c, d, e, f)

Tup7Type :: TypeRep a -> TypeRep b -> TypeRep c -> TypeRep d -> TypeRep e -> TypeRep f -> TypeRep g -> TypeRep (a, b, c, d, e, f, g)

FunType :: TypeRep a -> TypeRep b -> TypeRep (a -> b)

MutType :: TypeRep a -> TypeRep (Mut a)

RefType :: TypeRep a -> TypeRep (IORef a)

MArrType :: TypeRep a -> TypeRep (MArr a)

ParType :: TypeRep a -> TypeRep (Par a)

IVarType :: TypeRep a -> TypeRep (IV a)

FValType :: TypeRep a -> TypeRep (FVal a)

Instances

Show (TypeRep a)

argType :: TypeRep (a -> b) -> TypeRep a

resType :: TypeRep (a -> b) -> TypeRep b

data TypeEq a b where

Type equality witness

Constructors

TypeEq :: TypeEq a a

defaultSize :: TypeRep a -> Size a

signEq :: Signedness s1 -> Signedness s2 -> Maybe (TypeEq s1 s2)

Type equality on Signedness

widthEq :: BitWidth n1 -> BitWidth n2 -> Maybe (TypeEq n1 n2)

Type equality on BitWidth

typeEq :: TypeRep a -> TypeRep b -> Maybe (TypeEq a b)

Type equality on TypeRep

showTup :: [String] -> String

type family TargetType n a

class (Eq a, Show a, Typeable a, Show (Size a), Lattice (Size a)) => Type a where

The set of supported types

Methods

typeRep :: TypeRep a

Gives the type representation a value.

sizeOf :: a -> Size a

toTarget :: BitWidth n -> a -> TargetType n a

Instances

Type Bool

Type Double

Type Float

Type Int8

Type Int16

Type Int32

Type Int64

Type Word8

Type Word16

Type Word32

Type Word64

Type ()

Type IntN

Type WordN

Type a => Type [a]

(Type a, RealFloat a) => Type (Complex a)

(Type a, Show (IORef a)) => Type (IORef a)

Type a => Type (FVal a)

Type a => Type (IV a)

Type a => Type (MArr a)

(Type a, Type b) => Type (a, b)

(Type a, Type b, Type c) => Type (a, b, c)

(Type a, Type b, Type c, Type d) => Type (a, b, c, d)

(Type a, Type b, Type c, Type d, Type e) => Type (a, b, c, d, e)

(Type a, Type b, Type c, Type d, Type e, Type f) => Type (a, b, c, d, e, f)

(Type a, Type b, Type c, Type d, Type e, Type f, Type g) => Type (a, b, c, d, e, f, g)

typeRepByProxy :: Type a => Proxy a -> TypeRep a

Sized types

data AnySize

Constructors

AnySize

Instances

Eq AnySize

Num AnySize

Ord AnySize

Show AnySize

Lattice AnySize

anySizeFun :: AnySize -> AnySize

anySizeFun2 :: AnySize -> AnySize -> AnySize

type family Size a

data RangeSet a where

A generalization of Range that serves two purposes: (1) Adding an extra Universal constructor to support unbounded types (Range can only represent bounded ranges), and (2) pack a BoundedInt constraint with the RangeSet constructor. This is what allows sizeToRange to be defined as a total function with Type as the only constraint.

Constructors

RangeSet :: BoundedInt a => Range a -> RangeSet a

Universal :: RangeSet a

Instances

Show a => Show (RangeSet a)

sizeToRange :: forall a. Type a => Size a -> RangeSet a

Cast a Size to a RangeSet

tIntN :: Patch IntN IntN

tWordN :: Patch WordN WordN

tIndex :: Patch Index Index

tLength :: Patch Length Length

tArr :: Patch a a -> Patch [a] [a]