Safe Haskell | None |
---|---|

Language | Haskell2010 |

KansasLava is designed for generating hardware circuits. This module
provides a `Rep`

class that allows us to model, in the shallow embedding of
KL, two important features of hardware signals. First, all signals must have
some static width, as they will be synthsized to a collection of hardware
wires. Second, a value represented by a signal may be unknown, in part or in
whole.

- allOkayRep :: Size w => Matrix w (X Bool) -> Maybe (Matrix w Bool)
- data IntegerWidth = IntegerWidth
- log2 :: Integral a => a -> a
- sizedFromRepToIntegral :: forall w. (Rep w, Integral w, Size w) => RepValue -> X w
- repIntegral :: Name -> Type -> Q [Dec]
- repBitRep :: Name -> Int -> Q [Dec]
- class Rep w where
- class (Size (W a), Eq a, Rep a) => BitRep a where
- allReps :: Rep w => Witness w -> [RepValue]
- repWidth :: Rep w => Witness w -> Int
- unknownRepValue :: Rep w => Witness w -> RepValue
- pureX :: Rep w => w -> X w
- unknownX :: forall w. Rep w => X w
- liftX :: (Rep a, Rep b) => (a -> b) -> X a -> X b
- showRepDefault :: forall w. (Show w, Rep w) => X w -> String
- toRepFromIntegral :: forall v. (Rep v, Integral v) => X v -> RepValue
- fromRepToIntegral :: forall v. (Rep v, Integral v) => RepValue -> X v
- fromRepToInteger :: RepValue -> Integer
- cmpRep :: Rep a => X a -> X a -> Bool
- bitRepEnum :: (Rep a, Enum a, Bounded a, Size (W a)) => [(a, BitPat (W a))]
- bitRepToRep :: forall w. (BitRep w, Ord w) => X w -> RepValue
- bitRepToRep' :: forall w. (BitRep w, Ord w) => Map w RepValue -> X w -> RepValue
- bitRepFromRep :: forall w. (Ord w, BitRep w) => RepValue -> X w
- bitRepFromRep' :: forall w. (Ord w, BitRep w) => Map RepValue w -> RepValue -> X w
- bitRepMap :: forall w. (BitRep w, Ord w) => Map RepValue w
- expandBitRep :: RepValue -> [RepValue]

# Documentation

allOkayRep :: Size w => Matrix w (X Bool) -> Maybe (Matrix w Bool) Source

Check to see if all bits in a bitvector (represented as a Matrix) are valid. Returns Nothing if any of the bits are unknown.

data IntegerWidth Source

Integers are unbounded in size. We use the type `IntegerWidth`

as the
associated type representing this size in the instance of Rep for Integers.

sizedFromRepToIntegral :: forall w. (Rep w, Integral w, Size w) => RepValue -> X w Source

This is a version of fromRepToIntegral that check to see if the result is inside the size bounds.

A 'Rep a' is an `a`

value that we `Rep`

resent, aka we can push it over a
wire. The general idea is that instances of Rep should have a width (for the
corresponding bitvector representation) and that Rep instances should be able
to represent the "unknown" -- X -- value. For example, Bools can be
represented with one bit, and the inclusion of the unknown X value
corresponds to three-valued logic.

the width of the represented value, as a type-level number.

X are lifted inputs to this wire.

check for bad things.

and, put the good or bad things back.

toRep :: X w -> RepValue Source

convert to binary (rep) format

fromRep :: RepValue -> X w Source

convert from binary (rep) format

repType :: Witness w -> Type Source

Each wire has a known type.

Rep Bool | |

Rep Int | |

Rep Integer | |

Rep Word8 | |

Rep Word32 | |

Rep () | |

Rep X0 | |

Rep Ready | |

Rep Ack | |

Rep a => Rep (Maybe a) | |

Size ix => Rep (Unsigned ix) | |

Size ix => Rep (Signed ix) | |

(Integral x, Size x) => Rep (X0_ x) | |

(Integral x, Size x) => Rep (X1_ x) | |

(Size ix, Rep a, Rep ix) => Rep (ix -> a) | |

(Rep a, Rep b) => Rep (a, b) | |

(Enum ix, Size m, Size ix) => Rep (Sampled m ix) | |

(Size ix, Rep a) => Rep (Matrix ix a) | |

(Rep a, Rep b) => Rep ((:>) a b) | |

(Rep a, Rep b, Rep c) => Rep (a, b, c) |

class (Size (W a), Eq a, Rep a) => BitRep a where Source

`Bitrep`

is list of values, and their bitwise representation.
It is used to derive (via Template Haskell) the Rep for user Haskell datatypes.

allReps :: Rep w => Witness w -> [RepValue] Source

Given a witness of a representable type, generate all (2^n) possible values of that type.

unknownRepValue :: Rep w => Witness w -> RepValue Source

unknownRepValue returns a RepValue that is completely filled with `X`

.

liftX :: (Rep a, Rep b) => (a -> b) -> X a -> X b Source

liftX converts a function over values to a function over possibly unknown values.

showRepDefault :: forall w. (Show w, Rep w) => X w -> String Source

showRepDefault will print a Representable value, with "?" for unknown.
This is not wired into the class because of the extra `Show`

requirement.

toRepFromIntegral :: forall v. (Rep v, Integral v) => X v -> RepValue Source

Convert an integral value to a RepValue -- its bitvector representation.

fromRepToIntegral :: forall v. (Rep v, Integral v) => RepValue -> X v Source

Convert a RepValue representing an integral value to a representable value of that integral type.

fromRepToInteger :: RepValue -> Integer Source

fromRepToInteger always a positve number, unknowns defin

bitRepEnum :: (Rep a, Enum a, Bounded a, Size (W a)) => [(a, BitPat (W a))] Source

Helper for generating the bit pattern mappings.

expandBitRep :: RepValue -> [RepValue] Source