Safe Haskell | None |
---|---|
Language | Haskell2010 |
The Signal module serves as a representation for the combined shallow and
deep embeddings of sequential circuits. The shallow portion is reprented as a
stream, the deep portion as a (typed) entity. To allow for multiple clock
domains, the Signal type includes an extra type parameter. The type alias Seq
is for sequential logic in some implicit global clock domain.
- data Signal c a = Signal (Stream (X a)) (D a)
- type Seq a = Signal CLK a
- shallowS :: Signal c a -> Stream (X a)
- deepS :: Signal c a -> D a
- deepMapS :: (D a -> D a) -> Signal c a -> Signal c a
- shallowMapS :: (Stream (X a) -> Stream (X a)) -> Signal c a -> Signal c a
- pureS :: Rep a => a -> Signal i a
- witnessS :: Rep a => Witness a -> Signal i a -> Signal i a
- mkDeepS :: D a -> Signal c a
- mkShallowS :: Clock c => Stream (X a) -> Signal c a
- undefinedS :: forall a sig clk. (Rep a, sig ~ Signal clk) => sig a
- commentS :: forall a sig clk. (Rep a, sig ~ Signal clk) => String -> sig a -> sig a
- idS :: forall a sig clk. (Rep a, sig ~ Signal clk) => Id -> sig a -> sig a
- primXS :: Rep a => X a -> String -> Signal i a
- primXS1 :: forall a b i. (Rep a, Rep b) => (X a -> X b) -> String -> Signal i a -> Signal i b
- primXS2 :: forall a b c i. (Rep a, Rep b, Rep c) => (X a -> X b -> X c) -> String -> Signal i a -> Signal i b -> Signal i c
- primXS3 :: forall a b c d i. (Rep a, Rep b, Rep c, Rep d) => (X a -> X b -> X c -> X d) -> String -> Signal i a -> Signal i b -> Signal i c -> Signal i d
- primS :: Rep a => a -> String -> Signal i a
- primS1 :: (Rep a, Rep b) => (a -> b) -> String -> Signal i a -> Signal i b
- primS2 :: (Rep a, Rep b, Rep c) => (a -> b -> c) -> String -> Signal i a -> Signal i b -> Signal i c
- primS3 :: (Rep a, Rep b, Rep c, Rep d) => (a -> b -> c -> d) -> String -> Signal i a -> Signal i b -> Signal i c -> Signal i d
- toS :: (Clock c, Rep a) => [a] -> Signal c a
- toS' :: (Clock c, Rep a) => [Maybe a] -> Signal c a
- toSX :: forall a c. (Clock c, Rep a) => [X a] -> Signal c a
- fromS :: Rep a => Signal c a -> [Maybe a]
- fromSX :: Rep a => Signal c a -> [X a]
- takeS :: (Rep a, Clock c) => Int -> Signal c a -> Signal c a
- cmpSignalRep :: forall a c. Rep a => Int -> Signal c a -> Signal c a -> Bool
- typeOfS :: forall w clk sig. (Rep w, sig ~ Signal clk) => sig w -> Type
- class Pack clk a where
- mapPacked :: (Pack i a, Pack i b, sig ~ Signal i) => (Unpacked i a -> Unpacked i b) -> sig a -> sig b
- zipPacked :: (Pack i a, Pack i b, Pack i c, sig ~ Signal i) => (Unpacked i a -> Unpacked i b -> Unpacked i c) -> sig a -> sig b -> sig c
- unpackMatrix :: (Rep a, Size x, sig ~ Signal clk) => sig (Matrix x a) -> Matrix x (sig a)
- packMatrix :: (Rep a, Size x, sig ~ Signal clk) => Matrix x (sig a) -> sig (Matrix x a)
- delay :: forall a clk. (Rep a, Clock clk) => Signal clk a -> Signal clk a
- delays :: forall a clk. (Rep a, Clock clk) => Int -> Signal clk a -> Signal clk a
- register :: forall a clk. (Rep a, Clock clk) => a -> Signal clk a -> Signal clk a
- registers :: forall a clk. (Rep a, Clock clk) => Int -> a -> Signal clk a -> Signal clk a
- entityD :: forall a. Rep a => String -> D a
- entityD1 :: forall a1 a. (Rep a, Rep a1) => String -> D a1 -> D a
- entityD2 :: forall a1 a2 a. (Rep a, Rep a1, Rep a2) => String -> D a1 -> D a2 -> D a
- entityD3 :: forall a1 a2 a3 a. (Rep a, Rep a1, Rep a2, Rep a3) => String -> D a1 -> D a2 -> D a3 -> D a
- pureD :: Rep a => a -> D a
- pureXD :: Rep a => X a -> D a
Documentation
These are sequences of values over time. We assume edge triggered logic (checked at (typically) rising edge of clock) This clock is assumed known, based on who is consuming the list. Right now, it is global, but we think we can support multiple clocks with a bit of work.
(Bounded a, Rep a) => Bounded (Signal i a) | |
(Rep a, Enum a) => Enum (Signal i a) | |
(Rep a, Eq a) => Eq (Signal c a) | |
(Eq a, Show a, Fractional a, Rep a) => Fractional (Signal i a) | |
(Rep a, Integral a) => Integral (Signal i a) | |
(Num a, Rep a) => Num (Signal i a) | |
(Ord a, Rep a) => Ord (Signal i a) | |
(Rep a, Real a) => Real (Signal i a) | |
Rep a => Show (Signal c a) | |
(Show a, Bits a, Rep a) => Bits (Signal i a) | |
Dual (Signal c a) |
witnessS :: Rep a => Witness a -> Signal i a -> Signal i a Source
A Signal
witness identity function. Useful when typing things.
mkDeepS :: D a -> Signal c a Source
Inject a deep value into a Signal. The shallow portion of the Signal will be an error, if it is every used.
mkShallowS :: Clock c => Stream (X a) -> Signal c a Source
Inject a shallow value into a Signal. The deep portion of the Signal will be an Error if it is ever used.
undefinedS :: forall a sig clk. (Rep a, sig ~ Signal clk) => sig a Source
Create a Signal with undefined for both the deep and shallow elements.
commentS :: forall a sig clk. (Rep a, sig ~ Signal clk) => String -> sig a -> sig a Source
Attach a comment to a Signal
.
primXS :: Rep a => X a -> String -> Signal i a Source
create a zero-arity Signal value from an X
value.
primXS1 :: forall a b i. (Rep a, Rep b) => (X a -> X b) -> String -> Signal i a -> Signal i b Source
create an arity-1 Signal function from an X
function.
primXS2 :: forall a b c i. (Rep a, Rep b, Rep c) => (X a -> X b -> X c) -> String -> Signal i a -> Signal i b -> Signal i c Source
create an arity-2 Signal function from an X
function.
primXS3 :: forall a b c d i. (Rep a, Rep b, Rep c, Rep d) => (X a -> X b -> X c -> X d) -> String -> Signal i a -> Signal i b -> Signal i c -> Signal i d Source
create an arity-3 Signal function from an X
function.
primS1 :: (Rep a, Rep b) => (a -> b) -> String -> Signal i a -> Signal i b Source
create an arity-1 Signal function from a function.
primS2 :: (Rep a, Rep b, Rep c) => (a -> b -> c) -> String -> Signal i a -> Signal i b -> Signal i c Source
create an arity-2 Signal function from a function.
primS3 :: (Rep a, Rep b, Rep c, Rep d) => (a -> b -> c -> d) -> String -> Signal i a -> Signal i b -> Signal i c -> Signal i d Source
create an arity-3 Signal function from a function.
toS :: (Clock c, Rep a) => [a] -> Signal c a Source
Convert a list of values into a Signal. The shallow portion of the resulting Signal will begin with the input list, then an infinite stream of X unknowns.
toS' :: (Clock c, Rep a) => [Maybe a] -> Signal c a Source
Convert a list of values into a Signal. The input list is wrapped with a Maybe, and any Nothing elements are mapped to X's unknowns.
toSX :: forall a c. (Clock c, Rep a) => [X a] -> Signal c a Source
Convert a list of X values to a Signal. Pad the end with an infinite list of X unknowns.
fromS :: Rep a => Signal c a -> [Maybe a] Source
Convert a Signal of values into a list of Maybe values.
fromSX :: Rep a => Signal c a -> [X a] Source
Convret a Signal of values into a list of representable values.
takeS :: (Rep a, Clock c) => Int -> Signal c a -> Signal c a Source
take the first n elements of a Signal
; the rest is undefined.
cmpSignalRep :: forall a c. Rep a => Int -> Signal c a -> Signal c a -> Bool Source
Compare the first depth elements of two Signals.
typeOfS :: forall w clk sig. (Rep w, sig ~ Signal clk) => sig w -> Type Source
Return the Lava type of a representable signal.
The Pack class allows us to move between signals containing compound data and signals containing the elements of the compound data. This is done by commuting the signal type constructor with the type constructor representing the compound data. For example, if we have a value x :: Signal sig => sig (a,b), then 'unpack x' converts this to a (sig a, sig b). Dually, pack takes (sig a,sig b) to sig (a,b).
mapPacked :: (Pack i a, Pack i b, sig ~ Signal i) => (Unpacked i a -> Unpacked i b) -> sig a -> sig b Source
Given a function over unpacked (composite) signals, turn it into a function over packed signals.
zipPacked :: (Pack i a, Pack i b, Pack i c, sig ~ Signal i) => (Unpacked i a -> Unpacked i b -> Unpacked i c) -> sig a -> sig b -> sig c Source
Lift a binary function operating over unpacked signals into a function over a pair of packed signals.
delay :: forall a clk. (Rep a, Clock clk) => Signal clk a -> Signal clk a Source
a delay is a register with no defined default / initial value.
delays :: forall a clk. (Rep a, Clock clk) => Int -> Signal clk a -> Signal clk a Source
delays generates a serial sequence of n delays.
register :: forall a clk. (Rep a, Clock clk) => a -> Signal clk a -> Signal clk a Source
A register is a state element with a reset. The reset is supplied by the clock domain in the Signal.
registers :: forall a clk. (Rep a, Clock clk) => Int -> a -> Signal clk a -> Signal clk a Source
registers generates a serial sequence of n registers, all with the same initial value.