| Safe Haskell | None |
|---|
Feldspar.Core.Types
Contents
- data a :> b = a :> b
- newtype WordN = WordN Word32
- newtype IntN = IntN Int32
- data N8
- data N16
- data N32
- data N64
- data NNative
- data BitWidth n where
- bitWidth :: BitWidth n -> String
- data U
- data S
- data Signedness s where
- U :: Signedness U
- S :: Signedness S
- signedness :: Signedness s -> String
- type family GenericInt s n
- 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
- data TargetArr n a = TargetArr (GenericInt U n) [a]
- class MonadType m where
- voidTypeRep :: TypeRep (m ())
- type Mut = IO
- type MArr a = IOArray Index a
- type Par = Par
- type IV = IVar
- newtype FVal a = FVal {
- unFVal :: a
- data TypeRep a where
- 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
- 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)
- argType :: TypeRep (a -> b) -> TypeRep a
- resType :: TypeRep (a -> b) -> TypeRep b
- data TypeEq a b where
- defaultSize :: TypeRep a -> Size a
- signEq :: Signedness s1 -> Signedness s2 -> Maybe (TypeEq s1 s2)
- widthEq :: BitWidth n1 -> BitWidth n2 -> Maybe (TypeEq n1 n2)
- typeEq :: TypeRep a -> TypeRep b -> Maybe (TypeEq a b)
- showTup :: [String] -> String
- type family TargetType n a
- class (Eq a, Show a, Typeable a, Show (Size a), Lattice (Size a)) => Type a where
- typeRepByProxy :: Type a => Proxy a -> TypeRep a
- data AnySize = AnySize
- anySizeFun :: AnySize -> AnySize
- anySizeFun2 :: AnySize -> AnySize -> AnySize
- type family Size a
- data RangeSet a where
- sizeToRange :: forall a. Type a => Size a -> RangeSet a
- tIntN :: Patch IntN IntN
- tWordN :: Patch WordN WordN
- tIndex :: Patch Index Index
- tLength :: Patch Length Length
- tArr :: Patch a a -> Patch [a] [a]
Heterogenous lists
Heterogeneous list
Constructors
| a :> b |
Integers
Target-dependent unsigned integers
Instances
| Bounded WordN | |
| Enum WordN | |
| Eq WordN | |
| Integral WordN | |
| Num WordN | |
| Ord WordN | |
| Real WordN | |
| Show WordN | |
| Ix WordN | |
| Typeable WordN | |
| Arbitrary WordN | |
| Bits WordN | |
| Type WordN | |
| Numeric WordN | |
| Eq WordN | |
| Ord WordN | |
| Integral WordN | |
| Bits WordN | |
| Show (MArr a) | |
| (Eq (MArr a), Show (MArr a), Typeable (MArr a), Show (Size (MArr a)), Lattice (Size (MArr a)), Type a) => Type (MArr a) | |
| Slice sl => Slice (:. sl (Data Length)) | |
| Shape sh => Shape (:. sh (Data Length)) |
Target-dependent signed integers
signedness :: Signedness s -> StringSource
type family GenericInt s n Source
A generalization of unsigned and signed integers. The first parameter represents the signedness and the sectond parameter the number of bits.
genericLen :: BitWidth n -> [a] -> GenericInt U nSource
Arrays
Array whose length is represented by an n-bit word
Constructors
| TargetArr (GenericInt U n) [a] |
Monadic Types
This class is used to allow constructs to be abstract in the monad
Methods
voidTypeRep :: TypeRep (m ())Source
Mutable data
Par Monad
Future values
Type representation
Representation of supported types
Constructors
defaultSize :: TypeRep a -> Size aSource
signEq :: Signedness s1 -> Signedness s2 -> Maybe (TypeEq s1 s2)Source
Type equality on Signedness
type family TargetType n a Source
class (Eq a, Show a, Typeable a, Show (Size a), Lattice (Size a)) => Type a whereSource
The set of supported types
Instances
| Type Bool | |
| Type Float | |
| Type Int8 | |
| Type Int16 | |
| Type Int32 | |
| Type Int64 | |
| Type Word8 | |
| Type Word16 | |
| Type Word32 | |
| Type Word64 | |
| Type () | |
| Type IntN | |
| Type WordN | |
| (Eq [a], Show [a], Typeable [a], Show (Size [a]), Lattice (Size [a]), Type a) => Type [a] | |
| (Eq (Complex a), Show (Complex a), Typeable (Complex a), Show (Size (Complex a)), Lattice (Size (Complex a)), Type a, RealFloat a) => Type (Complex a) | |
| (Eq (IORef a), Typeable (IORef a), Show (Size (IORef a)), Lattice (Size (IORef a)), Type a, Show (IORef a)) => Type (IORef a) | |
| (Eq (FVal a), Show (FVal a), Typeable (FVal a), Show (Size (FVal a)), Lattice (Size (FVal a)), Type a) => Type (FVal a) | |
| (Eq (IV a), Show (IV a), Typeable (IV a), Show (Size (IV a)), Lattice (Size (IV a)), Type a) => Type (IV a) | |
| (Eq (MArr a), Show (MArr a), Typeable (MArr a), Show (Size (MArr a)), Lattice (Size (MArr a)), Type a) => Type (MArr a) | |
| (Eq (a, b), Show (a, b), Typeable (a, b), Show (Size (a, b)), Lattice (Size (a, b)), Type a, Type b) => Type (a, b) | |
| (Eq (a, b, c), Show (a, b, c), Typeable (a, b, c), Show (Size (a, b, c)), Lattice (Size (a, b, c)), Type a, Type b, Type c) => Type (a, b, c) | |
| (Eq (a, b, c, d), Show (a, b, c, d), Typeable (a, b, c, d), Show (Size (a, b, c, d)), Lattice (Size (a, b, c, d)), Type a, Type b, Type c, Type d) => Type (a, b, c, d) | |
| (Eq (a, b, c, d, e), Show (a, b, c, d, e), Typeable (a, b, c, d, e), Show (Size (a, b, c, d, e)), Lattice (Size (a, b, c, d, e)), Type a, Type b, Type c, Type d, Type e) => Type (a, b, c, d, e) | |
| (Eq (a, b, c, d, e, f), Show (a, b, c, d, e, f), Typeable (a, b, c, d, e, f), Show (Size (a, b, c, d, e, f)), Lattice (Size (a, b, c, d, e, f)), Type a, Type b, Type c, Type d, Type e, Type f) => Type (a, b, c, d, e, f) | |
| (Eq (a, b, c, d, e, f, g), Show (a, b, c, d, e, f, g), Typeable (a, b, c, d, e, f, g), Show (Size (a, b, c, d, e, f, g)), Lattice (Size (a, b, c, d, e, f, g)), 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 aSource
Sized types
Constructors
| AnySize |
anySizeFun :: AnySize -> AnySizeSource
anySizeFun2 :: AnySize -> AnySize -> AnySizeSource
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.