Clash.Class.Counter

Utilities for wrapping counters consisting of multiple individual counters

Documentation

class Counter a where

Counter is a class that composes multiple counters into a single one. It is similar to odometers found in olds cars, once all counters reach their maximum they reset to zero - i.e. odometer rollover. See countSucc and countPred for API usage examples.

Example use case: when driving a monitor through VGA you would like to keep track at least two counters: one counting a horizontal position, and one vertical. Perhaps a fancy VGA driver would also like to keep track of the number of drawn frames. To do so, the three counters are setup with different types. On each round of the horizontal counter the vertical counter should be increased. On each round of the vertical counter the frame counter should be increased. With this class you could simply use the type:

(FrameCount, VerticalCount, HorizontalCount)

and have countSucc work as described.

Minimal complete definition

Nothing

Methods

countMin :: a

Value counter wraps around to on a countSuccOverflow overflow

default countMin :: Bounded a => a

countMax :: a

Value counter wraps around to on a countPredOverflow overflow

default countMax :: Bounded a => a

countSuccOverflow :: a -> (Bool, a)

Gets the successor of a. If it overflows, the first part of the tuple will be set to True and the second part wraps around to countMin.

default countSuccOverflow :: (Eq a, Enum a, Bounded a) => a -> (Bool, a)

countPredOverflow :: a -> (Bool, a)

Gets the predecessor of a. If it underflows, the first part of the tuple will be set to True and the second part wraps around to countMax.

default countPredOverflow :: (Eq a, Enum a, Bounded a) => a -> (Bool, a)

Instances

Counter Bool

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Bool

countMax :: Bool

countSuccOverflow :: Bool -> (Bool, Bool)

countPredOverflow :: Bool -> (Bool, Bool)

Counter Int

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Int

countMax :: Int

countSuccOverflow :: Int -> (Bool, Int)

countPredOverflow :: Int -> (Bool, Int)

Counter Int8

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Int8

countMax :: Int8

countSuccOverflow :: Int8 -> (Bool, Int8)

countPredOverflow :: Int8 -> (Bool, Int8)

Counter Int16

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Int16

countMax :: Int16

countSuccOverflow :: Int16 -> (Bool, Int16)

countPredOverflow :: Int16 -> (Bool, Int16)

Counter Int32

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Int32

countMax :: Int32

countSuccOverflow :: Int32 -> (Bool, Int32)

countPredOverflow :: Int32 -> (Bool, Int32)

Counter Int64

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Int64

countMax :: Int64

countSuccOverflow :: Int64 -> (Bool, Int64)

countPredOverflow :: Int64 -> (Bool, Int64)

Counter Word

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Word

countMax :: Word

countSuccOverflow :: Word -> (Bool, Word)

countPredOverflow :: Word -> (Bool, Word)

Counter Word8

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Word8

countMax :: Word8

countSuccOverflow :: Word8 -> (Bool, Word8)

countPredOverflow :: Word8 -> (Bool, Word8)

Counter Word16

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Word16

countMax :: Word16

countSuccOverflow :: Word16 -> (Bool, Word16)

countPredOverflow :: Word16 -> (Bool, Word16)

Counter Word32

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Word32

countMax :: Word32

countSuccOverflow :: Word32 -> (Bool, Word32)

countPredOverflow :: Word32 -> (Bool, Word32)

Counter Word64

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Word64

countMax :: Word64

countSuccOverflow :: Word64 -> (Bool, Word64)

countPredOverflow :: Word64 -> (Bool, Word64)

Counter Bit

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Bit

countMax :: Bit

countSuccOverflow :: Bit -> (Bool, Bit)

countPredOverflow :: Bit -> (Bool, Bit)

Counter a => Counter (Maybe a)

Nothing is considered the minimum value, while Just countMax is considered the maximum value.

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Maybe a

countMax :: Maybe a

countSuccOverflow :: Maybe a -> (Bool, Maybe a)

countPredOverflow :: Maybe a -> (Bool, Maybe a)

Counter a => Counter (Identity a)

Since: 1.8.2

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Identity a

countMax :: Identity a

countSuccOverflow :: Identity a -> (Bool, Identity a)

countPredOverflow :: Identity a -> (Bool, Identity a)

KnownNat n => Counter (BitVector n)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: BitVector n

countMax :: BitVector n

countSuccOverflow :: BitVector n -> (Bool, BitVector n)

countPredOverflow :: BitVector n -> (Bool, BitVector n)

(1 <= n, KnownNat n) => Counter (Index n)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Index n

countMax :: Index n

countSuccOverflow :: Index n -> (Bool, Index n)

countPredOverflow :: Index n -> (Bool, Index n)

KnownNat n => Counter (Unsigned n)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Unsigned n

countMax :: Unsigned n

countSuccOverflow :: Unsigned n -> (Bool, Unsigned n)

countPredOverflow :: Unsigned n -> (Bool, Unsigned n)

KnownNat n => Counter (Signed n)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Signed n

countMax :: Signed n

countSuccOverflow :: Signed n -> (Bool, Signed n)

countPredOverflow :: Signed n -> (Bool, Signed n)

(Counter a, Counter b) => Counter (Either a b)

Counter instance that flip-flops between Left and Right. Examples:

>>> type T = Either (Index 2) (Unsigned 2)
>>> countSucc @T (Left 0)
Left 1
>>> countSucc @T (Left 1)
Right 0
>>> countSucc @T (Right 0)
Right 1

Defined in Clash.Class.Counter.Internal

Methods

countMin :: Either a b

countMax :: Either a b

countSuccOverflow :: Either a b -> (Bool, Either a b)

countPredOverflow :: Either a b -> (Bool, Either a b)

(Counter a0, Counter a1) => Counter (a0, a1)

Counters on tuples increment from right-to-left. This makes sense from the perspective of LSB/MSB; MSB is on the left-hand-side and LSB is on the right-hand-side in other Clash types.

>>> type T = (Unsigned 2, Index 2, Index 2)
>>> countSucc @T (0, 0, 0)
(0,0,1)
>>> countSucc @T (0, 0, 1)
(0,1,0)
>>> countSucc @T (0, 1, 0)
(0,1,1)
>>> countSucc @T (0, 1, 1)
(1,0,0)

NB: The documentation only shows the instances up to 3-tuples. By default, instances up to and including 12-tuples will exist. If the flag large-tuples is set instances up to the GHC imposed limit will exist. The GHC imposed limit is either 62 or 64 depending on the GHC version.

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1)

countMax :: (a0, a1)

countSuccOverflow :: (a0, a1) -> (Bool, (a0, a1))

countPredOverflow :: (a0, a1) -> (Bool, (a0, a1))

(Counter a0, Counter a1, Counter a2) => Counter (a0, a1, a2)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2)

countMax :: (a0, a1, a2)

countSuccOverflow :: (a0, a1, a2) -> (Bool, (a0, a1, a2))

countPredOverflow :: (a0, a1, a2) -> (Bool, (a0, a1, a2))

(Counter a0, Counter a1, Counter a2, Counter a3) => Counter (a0, a1, a2, a3)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3)

countMax :: (a0, a1, a2, a3)

countSuccOverflow :: (a0, a1, a2, a3) -> (Bool, (a0, a1, a2, a3))

countPredOverflow :: (a0, a1, a2, a3) -> (Bool, (a0, a1, a2, a3))

(Counter a0, Counter a1, Counter a2, Counter a3, Counter a4) => Counter (a0, a1, a2, a3, a4)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3, a4)

countMax :: (a0, a1, a2, a3, a4)

countSuccOverflow :: (a0, a1, a2, a3, a4) -> (Bool, (a0, a1, a2, a3, a4))

countPredOverflow :: (a0, a1, a2, a3, a4) -> (Bool, (a0, a1, a2, a3, a4))

(Counter a0, Counter a1, Counter a2, Counter a3, Counter a4, Counter a5) => Counter (a0, a1, a2, a3, a4, a5)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3, a4, a5)

countMax :: (a0, a1, a2, a3, a4, a5)

countSuccOverflow :: (a0, a1, a2, a3, a4, a5) -> (Bool, (a0, a1, a2, a3, a4, a5))

countPredOverflow :: (a0, a1, a2, a3, a4, a5) -> (Bool, (a0, a1, a2, a3, a4, a5))

(Counter a0, Counter a1, Counter a2, Counter a3, Counter a4, Counter a5, Counter a6) => Counter (a0, a1, a2, a3, a4, a5, a6)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3, a4, a5, a6)

countMax :: (a0, a1, a2, a3, a4, a5, a6)

countSuccOverflow :: (a0, a1, a2, a3, a4, a5, a6) -> (Bool, (a0, a1, a2, a3, a4, a5, a6))

countPredOverflow :: (a0, a1, a2, a3, a4, a5, a6) -> (Bool, (a0, a1, a2, a3, a4, a5, a6))

(Counter a0, Counter a1, Counter a2, Counter a3, Counter a4, Counter a5, Counter a6, Counter a7) => Counter (a0, a1, a2, a3, a4, a5, a6, a7)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3, a4, a5, a6, a7)

countMax :: (a0, a1, a2, a3, a4, a5, a6, a7)

countSuccOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7))

countPredOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7))

(Counter a0, Counter a1, Counter a2, Counter a3, Counter a4, Counter a5, Counter a6, Counter a7, Counter a8) => Counter (a0, a1, a2, a3, a4, a5, a6, a7, a8)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3, a4, a5, a6, a7, a8)

countMax :: (a0, a1, a2, a3, a4, a5, a6, a7, a8)

countSuccOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7, a8))

countPredOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7, a8))

(Counter a0, Counter a1, Counter a2, Counter a3, Counter a4, Counter a5, Counter a6, Counter a7, Counter a8, Counter a9) => Counter (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)

countMax :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)

countSuccOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9))

countPredOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9))

(Counter a0, Counter a1, Counter a2, Counter a3, Counter a4, Counter a5, Counter a6, Counter a7, Counter a8, Counter a9, Counter a10) => Counter (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

countMax :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

countSuccOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10))

countPredOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10))

(Counter a0, Counter a1, Counter a2, Counter a3, Counter a4, Counter a5, Counter a6, Counter a7, Counter a8, Counter a9, Counter a10, Counter a11) => Counter (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

countMax :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

countSuccOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11))

countPredOverflow :: (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> (Bool, (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11))

countSucc :: Counter a => a -> a

Successor of a counter.

Examples:

>>> type T = (Unsigned 2, Unsigned 2)
>>> countSucc @T (1, 1)
(1,2)
>>> countSucc @T (1, 2)
(1,3)
>>> countSucc @T (1, 3)
(2,0)
>>> countSucc @T (3, 3)
(0,0)
>>> countSucc @(Index 9, Index 2) (0, 1)
(1,0)
>>> countSucc @(Either (Index 9) (Index 9)) (Left 8)
Right 0

countPred :: Counter a => a -> a

Predecessor of a counter

Examples:

>>> type T = (Unsigned 2, Unsigned 2)
>>> countPred @T (1, 2)
(1,1)
>>> countPred @T (1, 3)
(1,2)
>>> countPred @T (2, 0)
(1,3)
>>> countPred @T (0, 0)
(3,3)
>>> countPred @(Index 9, Index 2) (1, 0)
(0,1)
>>> countPred @(Either (Index 9) (Index 9)) (Right 0)
Left 8