CLasH.HardwareTypes

Documentation

module Types

data NaturalT s => Vector s a

Instances

NaturalT s => Functor (Vector s)

NaturalT s => Foldable (Vector s)

NaturalT s => Traversable (Vector s)

Eq a => Eq (Vector s a)

(Read a, NaturalT nT) => Read (Vector nT a)

Show a => Show (Vector s a)

(Lift a, NaturalT nT) => Lift (Vector nT a)

empty :: Vector D0 a

(+>) :: a -> Vector s a -> Vector (Succ s) a

singleton :: a -> Vector D1 a

vectorTH :: Lift a => [a] -> ExpQ

unsafeVector :: NaturalT s => s -> [a] -> Vector s a

readVector :: (Read a, NaturalT s) => String -> Vector s a

length :: forall s a. NaturalT s => Vector s a -> Int

lengthT :: NaturalT s => Vector s a -> s

fromVector :: NaturalT s => Vector s a -> [a]

null :: Vector D0 a -> Bool

(!) :: (PositiveT s, NaturalT u, s :>: u ~ True) => Vector s a -> Index u -> a

replace :: (PositiveT s, NaturalT u, s :>: u ~ True) => Vector s a -> Index u -> a -> Vector s a

head :: PositiveT s => Vector s a -> a

last :: PositiveT s => Vector s a -> a

init :: PositiveT s => Vector s a -> Vector (Pred s) a

tail :: PositiveT s => Vector s a -> Vector (Pred s) a

take :: NaturalT i => i -> Vector s a -> Vector (Min s i) a

drop :: NaturalT i => i -> Vector s a -> Vector (s :-: Min s i) a

select :: (NaturalT f, NaturalT s, NaturalT n, f :<: i ~ True, ((s :*: n) :+: f) :<=: i ~ True) => f -> s -> n -> Vector i a -> Vector n a

(<+) :: Vector s a -> a -> Vector (Succ s) a

(++) :: Vector s a -> Vector s2 a -> Vector (s :+: s2) a

map :: (a -> b) -> Vector s a -> Vector s b

zipWith :: (a -> b -> c) -> Vector s a -> Vector s b -> Vector s c

foldl :: (a -> b -> a) -> a -> Vector s b -> a

foldr :: (b -> a -> a) -> a -> Vector s b -> a

zip :: Vector s a -> Vector s b -> Vector s (a, b)

unzip :: Vector s (a, b) -> (Vector s a, Vector s b)

shiftl :: (PositiveT s, NaturalT n, n ~ Pred s, s ~ Succ n) => Vector s a -> a -> Vector s a

shiftr :: (PositiveT s, NaturalT n, n ~ Pred s, s ~ Succ n) => Vector s a -> a -> Vector s a

rotl :: forall s a. NaturalT s => Vector s a -> Vector s a

rotr :: NaturalT s => Vector s a -> Vector s a

concat :: Vector s1 (Vector s2 a) -> Vector (s1 :*: s2) a

reverse :: Vector s a -> Vector s a

iterate :: NaturalT s => (a -> a) -> a -> Vector s a

iteraten :: NaturalT s => s -> (a -> a) -> a -> Vector s a

generate :: NaturalT s => (a -> a) -> a -> Vector s a

generaten :: NaturalT s => s -> (a -> a) -> a -> Vector s a

copy :: NaturalT s => a -> Vector s a

copyn :: NaturalT s => s -> a -> Vector s a

split :: NaturalT s => Vector s a -> (Vector (Div2 s) a, Vector (Div2 s) a)

data NaturalT upper => Index upper

Instances

NaturalT nT => Bounded (Index nT)

NaturalT nT => Enum (Index nT)

NaturalT nT => Eq (Index nT)

NaturalT nT => Integral (Index nT)

NaturalT nT => Num (Index nT)

NaturalT nT => Ord (Index nT)

NaturalT nT => Real (Index nT)

NaturalT nT => Show (Index nT)

NaturalT nT => Lift (Index nT)

fromNaturalT :: (NaturalT n, NaturalT upper, n :<=: upper ~ True) => n -> Index upper

fromUnsigned :: (NaturalT nT, Integral (Unsigned nT)) => Unsigned nT -> Index (Pow2 nT :-: D1)

rangeT :: Index nT -> nT

data NaturalT nT => Signed nT

Instances

NaturalT nT => Bounded (Signed nT)

NaturalT nT => Enum (Signed nT)

NaturalT nT => Eq (Signed nT)

NaturalT nT => Integral (Signed nT)

NaturalT nT => Num (Signed nT)

NaturalT nT => Ord (Signed nT)

NaturalT nT => Read (Signed nT)

NaturalT nT => Real (Signed nT)

NaturalT nT => Show (Signed nT)

NaturalT nT => Bits (Signed nT)

NaturalT nT => Lift (Signed nT)

resize :: (NaturalT nT, NaturalT nT') => Signed nT -> Signed nT'

data NaturalT nT => Unsigned nT

Instances

NaturalT nT => Bounded (Unsigned nT)

NaturalT nT => Enum (Unsigned nT)

NaturalT nT => Eq (Unsigned nT)

NaturalT nT => Integral (Unsigned nT)

NaturalT nT => Num (Unsigned nT)

NaturalT nT => Ord (Unsigned nT)

NaturalT nT => Read (Unsigned nT)

NaturalT nT => Real (Unsigned nT)

NaturalT nT => Show (Unsigned nT)

NaturalT nT => Bits (Unsigned nT)

NaturalT nT => Lift (Unsigned nT)

resize :: (NaturalT nT, NaturalT nT') => Unsigned nT -> Unsigned nT'

fromIndex :: (NaturalT nT, NaturalT nT', Pow2 nT' :>: nT ~ True, Integral (Index nT)) => Index nT -> Unsigned nT'

module Prelude

data Bit

Constructors

High

Low

Instances

Eq Bit

Read Bit

Show Bit

Typeable Bit

Lift Bit

newtype State s

Constructors

State s

Instances

Show s => Show (State s)

resizeInt :: (NaturalT nT, NaturalT nT') => Signed nT -> Signed nT'

resizeWord :: (NaturalT nT, NaturalT nT') => Unsigned nT -> Unsigned nT'

hwand :: Bit -> Bit -> Bit

hwor :: Bit -> Bit -> Bit

hwxor :: Bit -> Bit -> Bit

hwnot :: Bit -> Bit

type RAM s a = Vector (s :+: D1) a

type MemState s a = State (RAM s a)

blockRAM :: (NaturalT s, PositiveT (s :+: D1), (s :+: D1) :>: s ~ True) => MemState s a -> a -> Index s -> Index s -> Bool -> (MemState s a, a)