Copyright	(C) 2013-2016 University of Twente 2017-2019 Myrtle Software Ltd 2017 Google Inc. 2021-2022 QBayLogic B.V.
License	BSD2 (see the file LICENSE)
Maintainer	QBayLogic B.V. <devops@qbaylogic.com>
Safe Haskell	Unsafe
Language	Haskell2010
Extensions	Cpp MonoLocalBinds ScopedTypeVariables BangPatterns ViewPatterns DataKinds InstanceSigs StandaloneDeriving DeriveDataTypeable DeriveFunctor DeriveTraversable DeriveFoldable DeriveGeneric DefaultSignatures DeriveLift DerivingStrategies FlexibleContexts MagicHash KindSignatures TupleSections TypeOperators ExplicitNamespaces ExplicitForAll BinaryLiterals TypeApplications

Clash.Prelude

Contents

Creating synchronous sequential circuits
Synchronizer circuits for safe clock domain crossings
ROMs
- ROMs defined by a MemBlob
- ROMs defined by a data file
RAM primitives with a combinational read port
BlockRAM primitives
Utility functions
Tracing
Exported modules

Description

Clash is a functional hardware description language that borrows both its syntax and semantics from the functional programming language Haskell. The merits of using a functional language to describe hardware comes from the fact that combinational circuits can be directly modeled as mathematical functions and that functional languages lend themselves very well at describing and (de-)composing mathematical functions.

This package provides:

Prelude library containing datatypes and functions for circuit design

To use the library:

Import Clash.Prelude; by default clock and reset lines are implicitly routed for all the components found in Clash.Prelude. You can read more about implicit clock and reset lines in Clash.Signal
Alternatively, if you want to explicitly route clock and reset ports, for more straightforward multi-clock designs, you can import the Clash.Explicit.Prelude module. Note that you should not import Clash.Prelude and Clash.Explicit.Prelude at the same time as they have overlapping definitions.

For now, Clash.Prelude is also the best starting point for exploring the library. A preliminary version of a tutorial can be found in Clash.Tutorial. Some circuit examples can be found in Clash.Examples.

Synopsis

mealy :: (HiddenClockResetEnable dom, NFDataX s) => (s -> i -> (s, o)) -> s -> Signal dom i -> Signal dom o
mealyB :: (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o) => (s -> i -> (s, o)) -> s -> Unbundled dom i -> Unbundled dom o
(<^>) :: (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o) => (s -> i -> (s, o)) -> s -> Unbundled dom i -> Unbundled dom o
moore :: (HiddenClockResetEnable dom, NFDataX s) => (s -> i -> s) -> (s -> o) -> s -> Signal dom i -> Signal dom o
mooreB :: (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o) => (s -> i -> s) -> (s -> o) -> s -> Unbundled dom i -> Unbundled dom o
registerB :: (HiddenClockResetEnable dom, NFDataX a, Bundle a) => a -> Unbundled dom a -> Unbundled dom a
dualFlipFlopSynchronizer :: (NFDataX a, HiddenClock dom1, HiddenClockResetEnable dom2) => a -> Signal dom1 a -> Signal dom2 a
asyncFIFOSynchronizer :: (HiddenClockResetEnable rdom, HiddenClockResetEnable wdom, 2 <= addrSize, NFDataX a) => SNat addrSize -> Signal rdom Bool -> Signal wdom (Maybe a) -> (Signal rdom a, Signal rdom Bool, Signal wdom Bool)
asyncRom :: (KnownNat n, Enum addr) => Vec n a -> addr -> a
asyncRomPow2 :: KnownNat n => Vec (2 ^ n) a -> Unsigned n -> a
rom :: forall dom n m a. (NFDataX a, KnownNat n, KnownNat m, HiddenClock dom, HiddenEnable dom) => Vec n a -> Signal dom (Unsigned m) -> Signal dom a
romPow2 :: forall dom n a. (KnownNat n, NFDataX a, HiddenClock dom, HiddenEnable dom) => Vec (2 ^ n) a -> Signal dom (Unsigned n) -> Signal dom a
asyncRomBlob :: Enum addr => MemBlob n m -> addr -> BitVector m
asyncRomBlobPow2 :: KnownNat n => MemBlob (2 ^ n) m -> Unsigned n -> BitVector m
romBlob :: forall dom addr m n. (HiddenClock dom, HiddenEnable dom, Enum addr) => MemBlob n m -> Signal dom addr -> Signal dom (BitVector m)
romBlobPow2 :: forall dom m n. (HiddenClock dom, HiddenEnable dom, KnownNat n) => MemBlob (2 ^ n) m -> Signal dom (Unsigned n) -> Signal dom (BitVector m)
asyncRomFile :: (KnownNat m, Enum addr) => SNat n -> FilePath -> addr -> BitVector m
asyncRomFilePow2 :: forall n m. (KnownNat m, KnownNat n) => FilePath -> Unsigned n -> BitVector m
romFile :: (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom, Enum addr) => SNat n -> FilePath -> Signal dom addr -> Signal dom (BitVector m)
romFilePow2 :: forall n m dom. (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom) => FilePath -> Signal dom (Unsigned n) -> Signal dom (BitVector m)
asyncRam :: (Enum addr, HiddenClock dom, HiddenEnable dom, HasCallStack, NFDataX a) => SNat n -> Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a
asyncRamPow2 :: (KnownNat n, HiddenClock dom, HiddenEnable dom, HasCallStack, NFDataX a) => Signal dom (Unsigned n) -> Signal dom (Maybe (Unsigned n, a)) -> Signal dom a
blockRam :: (HasCallStack, HiddenClock dom, HiddenEnable dom, NFDataX a, Enum addr) => Vec n a -> Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a
blockRamPow2 :: (HasCallStack, HiddenClock dom, HiddenEnable dom, NFDataX a, KnownNat n) => Vec (2 ^ n) a -> Signal dom (Unsigned n) -> Signal dom (Maybe (Unsigned n, a)) -> Signal dom a
blockRamU :: forall n dom a r addr. (HasCallStack, HiddenClockResetEnable dom, NFDataX a, Enum addr, 1 <= n) => ResetStrategy r -> SNat n -> (Index n -> a) -> Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a
blockRam1 :: forall n dom a r addr. (HasCallStack, HiddenClockResetEnable dom, NFDataX a, Enum addr, 1 <= n) => ResetStrategy r -> SNat n -> a -> Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a
data ResetStrategy (r :: Bool) where
- ClearOnReset :: ResetStrategy 'True
- NoClearOnReset :: ResetStrategy 'False
blockRamBlob :: forall dom addr m n. (HiddenClock dom, HiddenEnable dom, Enum addr) => MemBlob n m -> Signal dom addr -> Signal dom (Maybe (addr, BitVector m)) -> Signal dom (BitVector m)
blockRamBlobPow2 :: forall dom m n. (HiddenClock dom, HiddenEnable dom, KnownNat n) => MemBlob (2 ^ n) m -> Signal dom (Unsigned n) -> Signal dom (Maybe (Unsigned n, BitVector m)) -> Signal dom (BitVector m)
data MemBlob (n :: Nat) (m :: Nat)
createMemBlob :: forall a f. (Foldable f, BitPack a) => String -> Maybe Bit -> f a -> DecsQ
memBlobTH :: forall a f. (Foldable f, BitPack a) => Maybe Bit -> f a -> ExpQ
unpackMemBlob :: forall n m. MemBlob n m -> [BitVector m]
blockRamFile :: (KnownNat m, Enum addr, HiddenClock dom, HiddenEnable dom, HasCallStack) => SNat n -> FilePath -> Signal dom addr -> Signal dom (Maybe (addr, BitVector m)) -> Signal dom (BitVector m)
blockRamFilePow2 :: forall dom n m. (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom, HasCallStack) => FilePath -> Signal dom (Unsigned n) -> Signal dom (Maybe (Unsigned n, BitVector m)) -> Signal dom (BitVector m)
readNew :: (HiddenClockResetEnable dom, NFDataX a, Eq addr) => (Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a) -> Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a
trueDualPortBlockRam :: forall nAddrs dom1 dom2 a. (HasCallStack, KnownNat nAddrs, HiddenClock dom1, HiddenClock dom2, NFDataX a) => Signal dom1 (RamOp nAddrs a) -> Signal dom2 (RamOp nAddrs a) -> (Signal dom1 a, Signal dom2 a)
data RamOp n a
- = RamRead (Index n)
- | RamWrite (Index n) a
- | RamNoOp
window :: (HiddenClockResetEnable dom, KnownNat n, Default a, NFDataX a) => Signal dom a -> Vec (n + 1) (Signal dom a)
windowD :: (HiddenClockResetEnable dom, KnownNat n, Default a, NFDataX a) => Signal dom a -> Vec (n + 1) (Signal dom a)
isRising :: (HiddenClockResetEnable dom, NFDataX a, Bounded a, Eq a) => a -> Signal dom a -> Signal dom Bool
isFalling :: (HiddenClockResetEnable dom, NFDataX a, Bounded a, Eq a) => a -> Signal dom a -> Signal dom Bool
riseEvery :: HiddenClockResetEnable dom => SNat n -> Signal dom Bool
oscillate :: HiddenClockResetEnable dom => Bool -> SNat n -> Signal dom Bool
traceSignal1 :: (BitPack a, NFDataX a, Typeable a) => String -> Signal dom a -> Signal dom a
traceVecSignal1 :: (KnownNat n, BitPack a, NFDataX a, Typeable a) => String -> Signal dom (Vec (n + 1) a) -> Signal dom (Vec (n + 1) a)
traceSignal :: forall dom a. (KnownDomain dom, BitPack a, NFDataX a, Typeable a) => String -> Signal dom a -> Signal dom a
traceVecSignal :: forall dom a n. (KnownDomain dom, KnownNat n, BitPack a, NFDataX a, Typeable a) => String -> Signal dom (Vec (n + 1) a) -> Signal dom (Vec (n + 1) a)
dumpVCD :: NFDataX a => (Int, Int) -> Signal dom a -> [String] -> IO (Either String Text)
data Reset (dom :: Domain)
data Clock (dom :: Domain)
data Enable dom
data Signal (dom :: Domain) a
type Domain = Symbol
data VDomainConfiguration = VDomainConfiguration {
- vName :: String
- vPeriod :: Natural
- vActiveEdge :: ActiveEdge
- vResetKind :: ResetKind
- vInitBehavior :: InitBehavior
- vResetPolarity :: ResetPolarity
}
type XilinxSystem = "XilinxSystem" :: Domain
type IntelSystem = "IntelSystem" :: Domain
type System = "System" :: Domain
class KnownSymbol dom => KnownDomain (dom :: Domain) where
- type KnownConf dom :: DomainConfiguration
- knownDomain :: SDomainConfiguration dom (KnownConf dom)
type KnownConfiguration dom conf = (KnownDomain dom, KnownConf dom ~ conf)
data SDomainConfiguration (dom :: Domain) (conf :: DomainConfiguration) where
- SDomainConfiguration :: SSymbol dom -> SNat period -> SActiveEdge edge -> SResetKind reset -> SInitBehavior init -> SResetPolarity polarity -> SDomainConfiguration dom ('DomainConfiguration dom period edge reset init polarity)
type DomainResetPolarity (dom :: Domain) = DomainConfigurationResetPolarity (KnownConf dom)
type DomainInitBehavior (dom :: Domain) = DomainConfigurationInitBehavior (KnownConf dom)
type DomainResetKind (dom :: Domain) = DomainConfigurationResetKind (KnownConf dom)
type DomainActiveEdge (dom :: Domain) = DomainConfigurationActiveEdge (KnownConf dom)
type DomainPeriod (dom :: Domain) = DomainConfigurationPeriod (KnownConf dom)
data DomainConfiguration = DomainConfiguration {
- _name :: Domain
- _period :: Nat
- _activeEdge :: ActiveEdge
- _resetKind :: ResetKind
- _initBehavior :: InitBehavior
- _resetPolarity :: ResetPolarity
}
data SInitBehavior (init :: InitBehavior) where
- SUnknown :: SInitBehavior 'Unknown
- SDefined :: SInitBehavior 'Defined
data InitBehavior
- = Unknown
- | Defined
data SResetPolarity (polarity :: ResetPolarity) where
- SActiveHigh :: SResetPolarity 'ActiveHigh
- SActiveLow :: SResetPolarity 'ActiveLow
data ResetPolarity
- = ActiveHigh
- | ActiveLow
data SResetKind (resetKind :: ResetKind) where
- SAsynchronous :: SResetKind 'Asynchronous
- SSynchronous :: SResetKind 'Synchronous
data ResetKind
- = Asynchronous
- | Synchronous
data SActiveEdge (edge :: ActiveEdge) where
- SRising :: SActiveEdge 'Rising
- SFalling :: SActiveEdge 'Falling
data ActiveEdge
- = Rising
- | Falling
vSystem :: VDomainConfiguration
vIntelSystem :: VDomainConfiguration
vXilinxSystem :: VDomainConfiguration
vDomain :: SDomainConfiguration dom conf -> VDomainConfiguration
createDomain :: VDomainConfiguration -> Q [Dec]
sameDomain :: forall (domA :: Domain) (domB :: Domain). (KnownDomain domA, KnownDomain domB) => Maybe (domA :~: domB)
fromEnable :: Enable dom -> Signal dom Bool
toEnable :: Signal dom Bool -> Enable dom
enableGen :: Enable dom
clockGen :: KnownDomain dom => Clock dom
resetGen :: forall dom. KnownDomain dom => Reset dom
resetGenN :: forall dom n. (KnownDomain dom, 1 <= n) => SNat n -> Reset dom
unsafeToHighPolarity :: forall dom. KnownDomain dom => Reset dom -> Signal dom Bool
unsafeToLowPolarity :: forall dom. KnownDomain dom => Reset dom -> Signal dom Bool
unsafeFromReset :: Reset dom -> Signal dom Bool
unsafeToReset :: Signal dom Bool -> Reset dom
unsafeFromHighPolarity :: forall dom. KnownDomain dom => Signal dom Bool -> Reset dom
unsafeFromLowPolarity :: forall dom. KnownDomain dom => Signal dom Bool -> Reset dom
(.||.) :: Applicative f => f Bool -> f Bool -> f Bool
(.&&.) :: Applicative f => f Bool -> f Bool -> f Bool
mux :: Applicative f => f Bool -> f a -> f a -> f a
(.==.) :: (Eq a, Applicative f) => f a -> f a -> f Bool
(./=.) :: (Eq a, Applicative f) => f a -> f a -> f Bool
(.<.) :: (Ord a, Applicative f) => f a -> f a -> f Bool
(.<=.) :: (Ord a, Applicative f) => f a -> f a -> f Bool
(.>.) :: (Ord a, Applicative f) => f a -> f a -> f Bool
(.>=.) :: (Ord a, Applicative f) => f a -> f a -> f Bool
fromList :: NFDataX a => [a] -> Signal dom a
fromList_lazy :: [a] -> Signal dom a
hzToPeriod :: HasCallStack => Ratio Natural -> Natural
periodToHz :: Natural -> Ratio Natural
clockPeriod :: forall dom period. (KnownDomain dom, DomainPeriod dom ~ period) => SNat period
activeEdge :: forall dom edge. (KnownDomain dom, DomainActiveEdge dom ~ edge) => SActiveEdge edge
resetKind :: forall dom sync. (KnownDomain dom, DomainResetKind dom ~ sync) => SResetKind sync
initBehavior :: forall dom init. (KnownDomain dom, DomainInitBehavior dom ~ init) => SInitBehavior init
resetPolarity :: forall dom polarity. (KnownDomain dom, DomainResetPolarity dom ~ polarity) => SResetPolarity polarity
knownVDomain :: forall dom. KnownDomain dom => VDomainConfiguration
data BiSignalOut (ds :: BiSignalDefault) (dom :: Domain) (n :: Nat)
data BiSignalIn (ds :: BiSignalDefault) (dom :: Domain) (n :: Nat)
data BiSignalDefault
- = PullUp
- | PullDown
- | Floating
readFromBiSignal :: (HasCallStack, BitPack a) => BiSignalIn ds d (BitSize a) -> Signal d a
mergeBiSignalOuts :: (HasCallStack, KnownNat n) => Vec n (BiSignalOut defaultState dom m) -> BiSignalOut defaultState dom m
writeToBiSignal :: (HasCallStack, BitPack a) => BiSignalIn ds d (BitSize a) -> Signal d (Maybe a) -> BiSignalOut ds d (BitSize a)
veryUnsafeToBiSignalIn :: (HasCallStack, KnownNat n, Given (SBiSignalDefault ds)) => BiSignalOut ds d n -> BiSignalIn ds d n
class Bundle a where
- type Unbundled (dom :: Domain) a = res | res -> dom a
- bundle :: Unbundled dom a -> Signal dom a
- unbundle :: Signal dom a -> Unbundled dom a
data TaggedEmptyTuple (dom :: Domain) = TaggedEmptyTuple
data EmptyTuple = EmptyTuple
systemClockGen :: Clock System
systemResetGen :: Reset System
resetSynchronizer :: forall dom. KnownDomain dom => Clock dom -> Reset dom -> Reset dom
resetGlitchFilter :: forall dom glitchlessPeriod n. (KnownDomain dom, glitchlessPeriod ~ (n + 1)) => SNat glitchlessPeriod -> Clock dom -> Reset dom -> Reset dom
type SystemClockResetEnable = (Hidden (HiddenClockName System) (Clock System), Hidden (HiddenResetName System) (Reset System), Hidden (HiddenEnableName System) (Enable System))
type HiddenClockResetEnable dom = (HiddenClock dom, HiddenReset dom, HiddenEnable dom)
type HiddenEnable dom = (Hidden (HiddenEnableName dom) (Enable dom), KnownDomain dom)
type HiddenReset dom = (Hidden (HiddenResetName dom) (Reset dom), KnownDomain dom)
type HiddenClock dom = (Hidden (HiddenClockName dom) (Clock dom), KnownDomain dom)
exposeClock :: forall dom r. WithSingleDomain dom r => (HiddenClock dom => r) -> KnownDomain dom => Clock dom -> r
exposeSpecificClock :: forall dom r. WithSpecificDomain dom r => (HiddenClock dom => r) -> KnownDomain dom => Clock dom -> r
hideClock :: forall dom r. HiddenClock dom => (Clock dom -> r) -> r
withClock :: forall dom r. WithSingleDomain dom r => KnownDomain dom => Clock dom -> (HiddenClock dom => r) -> r
withSpecificClock :: forall dom r. (KnownDomain dom, WithSpecificDomain dom r) => Clock dom -> (HiddenClock dom => r) -> r
hasClock :: forall dom. HiddenClock dom => Clock dom
exposeReset :: forall dom r. WithSingleDomain dom r => (HiddenReset dom => r) -> KnownDomain dom => Reset dom -> r
exposeSpecificReset :: forall dom r. WithSpecificDomain dom r => (HiddenReset dom => r) -> KnownDomain dom => Reset dom -> r
hideReset :: forall dom r. HiddenReset dom => (Reset dom -> r) -> r
withReset :: forall dom r. WithSingleDomain dom r => KnownDomain dom => Reset dom -> (HiddenReset dom => r) -> r
withSpecificReset :: forall dom r. (KnownDomain dom, WithSpecificDomain dom r) => Reset dom -> (HiddenReset dom => r) -> r
hasReset :: forall dom. HiddenReset dom => Reset dom
exposeEnable :: forall dom r. WithSingleDomain dom r => (HiddenEnable dom => r) -> KnownDomain dom => Enable dom -> r
exposeSpecificEnable :: forall dom r. WithSpecificDomain dom r => (HiddenEnable dom => r) -> KnownDomain dom => Enable dom -> r
hideEnable :: forall dom r. HiddenEnable dom => (Enable dom -> r) -> r
withEnable :: forall dom r. KnownDomain dom => WithSingleDomain dom r => Enable dom -> (HiddenEnable dom => r) -> r
withSpecificEnable :: forall dom r. (KnownDomain dom, WithSpecificDomain dom r) => Enable dom -> (HiddenEnable dom => r) -> r
hasEnable :: forall dom. HiddenEnable dom => Enable dom
andEnable :: forall dom r. HiddenEnable dom => WithSingleDomain dom r => Signal dom Bool -> (HiddenEnable dom => r) -> r
andSpecificEnable :: forall dom r. (HiddenEnable dom, WithSpecificDomain dom r) => Signal dom Bool -> (HiddenEnable dom => r) -> r
exposeClockResetEnable :: forall dom r. WithSingleDomain dom r => (HiddenClockResetEnable dom => r) -> KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> r
exposeSpecificClockResetEnable :: forall dom r. WithSpecificDomain dom r => (HiddenClockResetEnable dom => r) -> KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> r
hideClockResetEnable :: forall dom r. HiddenClockResetEnable dom => (KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> r) -> r
withClockResetEnable :: forall dom r. KnownDomain dom => WithSingleDomain dom r => Clock dom -> Reset dom -> Enable dom -> (HiddenClockResetEnable dom => r) -> r
withSpecificClockResetEnable :: forall dom r. (KnownDomain dom, WithSpecificDomain dom r) => Clock dom -> Reset dom -> Enable dom -> (HiddenClockResetEnable dom => r) -> r
dflipflop :: forall dom a. (HiddenClock dom, NFDataX a) => Signal dom a -> Signal dom a
delay :: forall dom a. (NFDataX a, HiddenClock dom, HiddenEnable dom) => a -> Signal dom a -> Signal dom a
delayMaybe :: forall dom a. (NFDataX a, HiddenClock dom, HiddenEnable dom) => a -> Signal dom (Maybe a) -> Signal dom a
delayEn :: forall dom a. (NFDataX a, HiddenClock dom, HiddenEnable dom) => a -> Signal dom Bool -> Signal dom a -> Signal dom a
register :: forall dom a. (HiddenClockResetEnable dom, NFDataX a) => a -> Signal dom a -> Signal dom a
regMaybe :: forall dom a. (HiddenClockResetEnable dom, NFDataX a) => a -> Signal dom (Maybe a) -> Signal dom a
regEn :: forall dom a. (HiddenClockResetEnable dom, NFDataX a) => a -> Signal dom Bool -> Signal dom a -> Signal dom a
sample :: forall dom a. (KnownDomain dom, NFDataX a) => (HiddenClockResetEnable dom => Signal dom a) -> [a]
sampleN :: forall dom a. (KnownDomain dom, NFDataX a) => Int -> (HiddenClockResetEnable dom => Signal dom a) -> [a]
sampleWithReset :: forall dom a m. (KnownDomain dom, NFDataX a, 1 <= m) => SNat m -> (HiddenClockResetEnable dom => Signal dom a) -> [a]
sampleWithResetN :: forall dom a m. (KnownDomain dom, NFDataX a, 1 <= m) => SNat m -> Int -> (HiddenClockResetEnable dom => Signal dom a) -> [a]
sample_lazy :: forall dom a. KnownDomain dom => (HiddenClockResetEnable dom => Signal dom a) -> [a]
sampleN_lazy :: forall dom a. KnownDomain dom => Int -> (HiddenClockResetEnable dom => Signal dom a) -> [a]
simulate :: forall dom a b. (KnownDomain dom, NFDataX a, NFDataX b) => (HiddenClockResetEnable dom => Signal dom a -> Signal dom b) -> [a] -> [b]
simulateN :: forall dom a b. (KnownDomain dom, NFDataX a, NFDataX b) => Int -> (HiddenClockResetEnable dom => Signal dom a -> Signal dom b) -> [a] -> [b]
simulateWithReset :: forall dom a b m. (KnownDomain dom, NFDataX a, NFDataX b, 1 <= m) => SNat m -> a -> (HiddenClockResetEnable dom => Signal dom a -> Signal dom b) -> [a] -> [b]
simulateWithResetN :: forall dom a b m. (KnownDomain dom, NFDataX a, NFDataX b, 1 <= m) => SNat m -> a -> Int -> (HiddenClockResetEnable dom => Signal dom a -> Signal dom b) -> [a] -> [b]
simulate_lazy :: forall dom a b. KnownDomain dom => (HiddenClockResetEnable dom => Signal dom a -> Signal dom b) -> [a] -> [b]
simulateB :: forall dom a b. (KnownDomain dom, Bundle a, Bundle b, NFDataX a, NFDataX b) => (HiddenClockResetEnable dom => Unbundled dom a -> Unbundled dom b) -> [a] -> [b]
simulateB_lazy :: forall dom a b. (KnownDomain dom, Bundle a, Bundle b) => (HiddenClockResetEnable dom => Unbundled dom a -> Unbundled dom b) -> [a] -> [b]
runUntil :: forall dom a. (KnownDomain dom, NFDataX a, ShowX a) => (a -> Bool) -> (HiddenClockResetEnable dom => Signal dom a) -> IO ()
testFor :: KnownDomain dom => Int -> (HiddenClockResetEnable dom => Signal dom Bool) -> Property
unsafeSynchronizer :: forall dom1 dom2 a. (HiddenClock dom1, HiddenClock dom2) => Signal dom1 a -> Signal dom2 a
holdReset :: forall dom m. HiddenClockResetEnable dom => SNat m -> Reset dom
fromListWithReset :: forall dom a. (HiddenReset dom, NFDataX a) => a -> [a] -> Signal dom a
convertReset :: forall domA domB. (HiddenClock domA, HiddenClock domB) => Reset domA -> Reset domB
signalAutomaton :: forall dom a b. KnownDomain dom => (HiddenClockResetEnable dom => Signal dom a -> Signal dom b) -> Automaton (->) a b
module Clash.Signal.Delayed
module Clash.Sized.BitVector
module Clash.Sized.Signed
module Clash.Sized.Unsigned
module Clash.Sized.Index
module Clash.Sized.Fixed
data Vec :: Nat -> Type -> Type where
- Nil :: Vec 0 a
- Cons :: a -> Vec n a -> Vec (n + 1) a
- pattern (:<) :: Vec n a -> a -> Vec (n + 1) a
- pattern (:>) :: a -> Vec n a -> Vec (n + 1) a
foldl :: (b -> a -> b) -> b -> Vec n a -> b
foldr :: (a -> b -> b) -> b -> Vec n a -> b
map :: (a -> b) -> Vec n a -> Vec n b
bv2v :: KnownNat n => BitVector n -> Vec n Bit
data VCons (a :: Type) (f :: TyFun Nat Type) :: Type
traverse# :: forall a f b n. Applicative f => (a -> f b) -> Vec n a -> f (Vec n b)
singleton :: a -> Vec 1 a
head :: Vec (n + 1) a -> a
tail :: Vec (n + 1) a -> Vec n a
last :: Vec (n + 1) a -> a
init :: Vec (n + 1) a -> Vec n a
shiftInAt0 :: KnownNat n => Vec n a -> Vec m a -> (Vec n a, Vec m a)
shiftInAtN :: KnownNat m => Vec n a -> Vec m a -> (Vec n a, Vec m a)
(+>>) :: KnownNat n => a -> Vec n a -> Vec n a
(<<+) :: Vec n a -> a -> Vec n a
shiftOutFrom0 :: (Default a, KnownNat m) => SNat m -> Vec (m + n) a -> (Vec (m + n) a, Vec m a)
shiftOutFromN :: (Default a, KnownNat n) => SNat m -> Vec (m + n) a -> (Vec (m + n) a, Vec m a)
(++) :: Vec n a -> Vec m a -> Vec (n + m) a
splitAt :: SNat m -> Vec (m + n) a -> (Vec m a, Vec n a)
splitAtI :: KnownNat m => Vec (m + n) a -> (Vec m a, Vec n a)
concat :: Vec n (Vec m a) -> Vec (n * m) a
concatMap :: (a -> Vec m b) -> Vec n a -> Vec (n * m) b
unconcat :: KnownNat n => SNat m -> Vec (n * m) a -> Vec n (Vec m a)
unconcatI :: (KnownNat n, KnownNat m) => Vec (n * m) a -> Vec n (Vec m a)
merge :: KnownNat n => Vec n a -> Vec n a -> Vec (2 * n) a
reverse :: Vec n a -> Vec n a
imap :: forall n a b. KnownNat n => (Index n -> a -> b) -> Vec n a -> Vec n b
izipWith :: KnownNat n => (Index n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
ifoldr :: KnownNat n => (Index n -> a -> b -> b) -> b -> Vec n a -> b
ifoldl :: KnownNat n => (a -> Index n -> b -> a) -> a -> Vec n b -> a
indices :: KnownNat n => SNat n -> Vec n (Index n)
indicesI :: KnownNat n => Vec n (Index n)
findIndex :: KnownNat n => (a -> Bool) -> Vec n a -> Maybe (Index n)
elemIndex :: (KnownNat n, Eq a) => a -> Vec n a -> Maybe (Index n)
zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
zipWith3 :: (a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d
zipWith4 :: (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e
zipWith5 :: (a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g -> Vec n h
foldr1 :: (a -> a -> a) -> Vec (n + 1) a -> a
foldl1 :: (a -> a -> a) -> Vec (n + 1) a -> a
fold :: forall n a. (a -> a -> a) -> Vec (n + 1) a -> a
scanl :: (b -> a -> b) -> b -> Vec n a -> Vec (n + 1) b
postscanl :: (b -> a -> b) -> b -> Vec n a -> Vec n b
scanr :: (a -> b -> b) -> b -> Vec n a -> Vec (n + 1) b
postscanr :: (a -> b -> b) -> b -> Vec n a -> Vec n b
mapAccumL :: (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)
mapAccumR :: (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)
zip :: Vec n a -> Vec n b -> Vec n (a, b)
zip3 :: Vec n a -> Vec n b -> Vec n c -> Vec n (a, b, c)
zip4 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n (a, b, c, d)
zip5 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n (a, b, c, d, e)
zip6 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n (a, b, c, d, e, f)
zip7 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g -> Vec n (a, b, c, d, e, f, g)
unzip :: Vec n (a, b) -> (Vec n a, Vec n b)
unzip3 :: Vec n (a, b, c) -> (Vec n a, Vec n b, Vec n c)
unzip4 :: Vec n (a, b, c, d) -> (Vec n a, Vec n b, Vec n c, Vec n d)
unzip5 :: Vec n (a, b, c, d, e) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e)
unzip6 :: Vec n (a, b, c, d, e, f) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e, Vec n f)
unzip7 :: Vec n (a, b, c, d, e, f, g) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e, Vec n f, Vec n g)
(!!) :: (KnownNat n, Enum i) => Vec n a -> i -> a
length :: KnownNat n => Vec n a -> Int
replace :: (KnownNat n, Enum i) => i -> a -> Vec n a -> Vec n a
take :: SNat m -> Vec (m + n) a -> Vec m a
takeI :: KnownNat m => Vec (m + n) a -> Vec m a
drop :: SNat m -> Vec (m + n) a -> Vec n a
dropI :: KnownNat m => Vec (m + n) a -> Vec n a
at :: SNat m -> Vec (m + (n + 1)) a -> a
select :: CmpNat (i + s) (s * n) ~ 'GT => SNat f -> SNat s -> SNat n -> Vec (f + i) a -> Vec n a
selectI :: (CmpNat (i + s) (s * n) ~ 'GT, KnownNat n) => SNat f -> SNat s -> Vec (f + i) a -> Vec n a
replicate :: SNat n -> a -> Vec n a
repeat :: KnownNat n => a -> Vec n a
iterate :: SNat n -> (a -> a) -> a -> Vec n a
iterateI :: forall n a. KnownNat n => (a -> a) -> a -> Vec n a
unfoldr :: SNat n -> (s -> (a, s)) -> s -> Vec n a
unfoldrI :: KnownNat n => (s -> (a, s)) -> s -> Vec n a
generate :: SNat n -> (a -> a) -> a -> Vec n a
generateI :: KnownNat n => (a -> a) -> a -> Vec n a
transpose :: KnownNat n => Vec m (Vec n a) -> Vec n (Vec m a)
stencil1d :: KnownNat n => SNat (stX + 1) -> (Vec (stX + 1) a -> b) -> Vec ((stX + n) + 1) a -> Vec (n + 1) b
stencil2d :: (KnownNat n, KnownNat m) => SNat (stY + 1) -> SNat (stX + 1) -> (Vec (stY + 1) (Vec (stX + 1) a) -> b) -> Vec ((stY + m) + 1) (Vec ((stX + n) + 1) a) -> Vec (m + 1) (Vec (n + 1) b)
windows1d :: KnownNat n => SNat (stX + 1) -> Vec ((stX + n) + 1) a -> Vec (n + 1) (Vec (stX + 1) a)
windows2d :: (KnownNat n, KnownNat m) => SNat (stY + 1) -> SNat (stX + 1) -> Vec ((stY + m) + 1) (Vec ((stX + n) + 1) a) -> Vec (m + 1) (Vec (n + 1) (Vec (stY + 1) (Vec (stX + 1) a)))
permute :: (Enum i, KnownNat n, KnownNat m) => (a -> a -> a) -> Vec n a -> Vec m i -> Vec (m + k) a -> Vec n a
backpermute :: (Enum i, KnownNat n) => Vec n a -> Vec m i -> Vec m a
scatter :: (Enum i, KnownNat n, KnownNat m) => Vec n a -> Vec m i -> Vec (m + k) a -> Vec n a
gather :: (Enum i, KnownNat n) => Vec n a -> Vec m i -> Vec m a
interleave :: (KnownNat n, KnownNat d) => SNat d -> Vec (n * d) a -> Vec (d * n) a
rotateLeft :: (Enum i, KnownNat n) => Vec n a -> i -> Vec n a
rotateRight :: (Enum i, KnownNat n) => Vec n a -> i -> Vec n a
rotateLeftS :: KnownNat n => Vec n a -> SNat d -> Vec n a
rotateRightS :: KnownNat n => Vec n a -> SNat d -> Vec n a
toList :: Vec n a -> [a]
listToVecTH :: Lift a => [a] -> ExpQ
asNatProxy :: Vec n a -> Proxy n
lengthS :: KnownNat n => Vec n a -> SNat n
lazyV :: KnownNat n => Vec n a -> Vec n a
dfold :: forall p k a. KnownNat k => Proxy (p :: TyFun Nat Type -> Type) -> (forall l. SNat l -> a -> (p @@ l) -> p @@ (l + 1)) -> (p @@ 0) -> Vec k a -> p @@ k
dtfold :: forall p k a. KnownNat k => Proxy (p :: TyFun Nat Type -> Type) -> (a -> p @@ 0) -> (forall l. SNat l -> (p @@ l) -> (p @@ l) -> p @@ (l + 1)) -> Vec (2 ^ k) a -> p @@ k
vfold :: forall k a b. KnownNat k => (forall l. SNat l -> a -> Vec l b -> Vec (l + 1) b) -> Vec k a -> Vec k b
smap :: forall k a b. KnownNat k => (forall l. SNat l -> a -> b) -> Vec k a -> Vec k b
concatBitVector# :: forall n m. (KnownNat n, KnownNat m) => Vec n (BitVector m) -> BitVector (n * m)
unconcatBitVector# :: forall n m. (KnownNat n, KnownNat m) => BitVector (n * m) -> Vec n (BitVector m)
v2bv :: KnownNat n => Vec n Bit -> BitVector n
seqV :: KnownNat n => Vec n a -> b -> b
forceV :: KnownNat n => Vec n a -> Vec n a
seqVX :: KnownNat n => Vec n a -> b -> b
forceVX :: KnownNat n => Vec n a -> Vec n a
module Clash.Sized.RTree
module Clash.Annotations.TopEntity
class Generic a
class Generic1 (f :: k -> Type)
module GHC.TypeLits
module GHC.TypeLits.Extra
module Clash.Promoted.Nat
module Clash.Promoted.Nat.Literals
module Clash.Promoted.Nat.TH
module Clash.Promoted.Symbol
class Lift (t :: TYPE r) where
- lift :: t -> Q Exp
- liftTyped :: t -> Q (TExp t)
class NFDataX a => AutoReg a
autoReg :: (HasCallStack, HiddenClockResetEnable dom, AutoReg a) => a -> Signal dom a -> Signal dom a
deriveAutoReg :: Name -> DecsQ
module Clash.Class.BitPack
module Clash.Class.Exp
module Clash.Class.Num
module Clash.Class.Parity
module Clash.Class.Resize
module Control.Applicative
module Data.Bits
module Data.Default.Class
type Type = Type
data Constraint
module Clash.XException
module Clash.NamedTypes
module Clash.Hidden
module Clash.Magic
module Clash.HaskellPrelude

Creating synchronous sequential circuits

mealy Source #

Arguments

:: (HiddenClockResetEnable dom, NFDataX s)
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Signal dom i -> Signal dom o	Synchronous sequential function with input and output matching that of the mealy machine

Create a synchronous function from a combinational function describing a mealy machine

macT
  :: Int        -- Current state
  -> (Int,Int)  -- Input
  -> (Int,Int)  -- (Updated state, output)
macT s (x,y) = (s',s)
  where
    s' = x * y + s

mac :: HiddenClockResetEnable dom  => Signal dom (Int, Int) -> Signal dom Int
mac = mealy macT 0

>>> simulate @System mac [(0,0),(1,1),(2,2),(3,3),(4,4)]
[0,0,1,5,14...
...

Synchronous sequential functions can be composed just like their combinational counterpart:

dualMac
  :: HiddenClockResetEnable dom
  => (Signal dom Int, Signal dom Int)
  -> (Signal dom Int, Signal dom Int)
  -> Signal dom Int
dualMac (a,b) (x,y) = s1 + s2
  where
    s1 = mealy mac 0 (bundle (a,x))
    s2 = mealy mac 0 (bundle (b,y))

mealyB Source #

Arguments

:: (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o)
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Unbundled dom i -> Unbundled dom o	Synchronous sequential function with input and output matching that of the mealy machine

A version of mealy that does automatic Bundleing

Given a function f of type:

f :: Int -> (Bool, Int) -> (Int, (Int, Bool))

When we want to make compositions of f in g using mealy, we have to write:

g a b c = (b1,b2,i2)
  where
    (i1,b1) = unbundle (mealy f 0 (bundle (a,b)))
    (i2,b2) = unbundle (mealy f 3 (bundle (c,i1)))

Using mealyB however we can write:

g a b c = (b1,b2,i2)
  where
    (i1,b1) = mealyB f 0 (a,b)
    (i2,b2) = mealyB f 3 (c,i1)

(<^>) Source #

Arguments

:: (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o)
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Unbundled dom i -> Unbundled dom o	Synchronous sequential function with input and output matching that of the mealy machine

Infix version of mealyB

moore Source #

Arguments

:: (HiddenClockResetEnable dom, NFDataX s)
=> (s -> i -> s)	Transfer function in moore machine form: `state -> input -> newstate`
-> (s -> o)	Output function in moore machine form: `state -> output`
-> s	Initial state
-> Signal dom i -> Signal dom o	Synchronous sequential function with input and output matching that of the moore machine

Create a synchronous function from a combinational function describing a moore machine

macT
  :: Int        -- Current state
  -> (Int,Int)  -- Input
  -> Int        -- Updated state
macT s (x,y) = x * y + s

mac
  :: HiddenClockResetEnable dom
  => Signal dom (Int, Int)
  -> Signal dom Int
mac = moore mac id 0

>>> simulate @System mac [(0,0),(1,1),(2,2),(3,3),(4,4)]
[0,0,1,5,14,30,...
...

Synchronous sequential functions can be composed just like their combinational counterpart:

dualMac
  :: HiddenClockResetEnable dom
  => (Signal dom Int, Signal dom Int)
  -> (Signal dom Int, Signal dom Int)
  -> Signal dom Int
dualMac (a,b) (x,y) = s1 + s2
  where
    s1 = moore mac id 0 (bundle (a,x))
    s2 = moore mac id 0 (bundle (b,y))

mooreB Source #

Arguments

:: (HiddenClockResetEnable dom, NFDataX s, Bundle i, Bundle o)
=> (s -> i -> s)	Transfer function in moore machine form: `state -> input -> newstate`
-> (s -> o)	Output function in moore machine form: `state -> output`
-> s	Initial state
-> Unbundled dom i -> Unbundled dom o	Synchronous sequential function with input and output matching that of the moore machine

A version of moore that does automatic Bundleing

Given a functions t and o of types:

t :: Int -> (Bool, Int) -> Int
o :: Int -> (Int, Bool)

When we want to make compositions of t and o in g using moore, we have to write:

g a b c = (b1,b2,i2)
  where
    (i1,b1) = unbundle (moore t o 0 (bundle (a,b)))
    (i2,b2) = unbundle (moore t o 3 (bundle (c,i1)))

Using mooreB however we can write:

g a b c = (b1,b2,i2)
  where
    (i1,b1) = mooreB t o 0 (a,b)
    (i2,b2) = mooreB t o 3 (c,i1)

registerB :: (HiddenClockResetEnable dom, NFDataX a, Bundle a) => a -> Unbundled dom a -> Unbundled dom a infixr 3 Source #

Create a register function for product-type like signals (e.g. '(Signal a, Signal b)')

rP :: HiddenClockResetEnable dom
   => (Signal dom Int, Signal dom Int)
   -> (Signal dom Int, Signal dom Int)
rP = registerB (8,8)

>>> simulateB @System rP [(1,1),(2,2),(3,3)] :: [(Int,Int)]
[(8,8),(1,1),(2,2),(3,3)...
...

Synchronizer circuits for safe clock domain crossings

dualFlipFlopSynchronizer Source #

Arguments

:: (NFDataX a, HiddenClock dom1, HiddenClockResetEnable dom2)
=> a	Initial value of the two synchronization registers
-> Signal dom1 a	Incoming data
-> Signal dom2 a	Outgoing, synchronized, data

Synchronizer based on two sequentially connected flip-flops.

NB: This synchronizer can be used for bit-synchronization.
NB: Although this synchronizer does reduce metastability, it does not guarantee the proper synchronization of a whole word. For example, given that the output is sampled twice as fast as the input is running, and we have two samples in the input stream that look like:
```
[0111,1000]
```
But the circuit driving the input stream has a longer propagation delay on msb compared to the lsbs. What can happen is an output stream that looks like this:
```
[0111,0111,0000,1000]
```
Where the level-change of the msb was not captured, but the level change of the lsbs were.
If you want to have safe word-synchronization use asyncFIFOSynchronizer.

asyncFIFOSynchronizer Source #

Arguments

:: (HiddenClockResetEnable rdom, HiddenClockResetEnable wdom, 2 <= addrSize, NFDataX a)
=> SNat addrSize	Size of the internally used addresses, the FIFO contains `2^addrSize` elements.
-> Signal rdom Bool	Read request
-> Signal wdom (Maybe a)	Element to insert
-> (Signal rdom a, Signal rdom Bool, Signal wdom Bool)	(Oldest element in the FIFO, `empty` flag, `full` flag)

Synchronizer implemented as a FIFO around an asynchronous RAM. Based on the design described in Clash.Tutorial, which is itself based on the design described in http://www.sunburst-design.com/papers/CummingsSNUG2002SJ_FIFO1.pdf.

NB: This synchronizer can be used for word-synchronization.

ROMs

asyncRom Source #

Arguments

:: (KnownNat n, Enum addr)
=> Vec n a	ROM content, also determines the size, `n`, of the ROM NB: must be a constant
-> addr	Read address `rd`
-> a	The value of the ROM at address `rd`

An asynchronous/combinational ROM with space for n elements

Additional helpful information:

See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs
A large Vec for the content might be too inefficient, depending on how it is constructed. See asyncRomFile and asyncRomBlob for different approaches that scale well.

asyncRomPow2 Source #

Arguments

:: KnownNat n
=> Vec (2 ^ n) a	ROM content NB: must be a constant
-> Unsigned n	Read address `rd`
-> a	The value of the ROM at address `rd`

An asynchronous/combinational ROM with space for 2^n elements

Additional helpful information:

See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs
A large Vec for the content might be too inefficient, depending on how it is constructed. See asyncRomFilePow2 and asyncRomBlobPow2 for different approaches that scale well.

rom Source #

Arguments

:: forall dom n m a. (NFDataX a, KnownNat n, KnownNat m, HiddenClock dom, HiddenEnable dom)
=> Vec n a	ROM content, also determines the size, `n`, of the ROM NB: must be a constant
-> Signal dom (Unsigned m)	Read address `rd`
-> Signal dom a	The value of the ROM at address `rd`

A ROM with a synchronous read port, with space for n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

Additional helpful information:

See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs
A large Vec for the content might be too inefficient, depending on how it is constructed. See romFile and romBlob for different approaches that scale well.

romPow2 Source #

Arguments

:: forall dom n a. (KnownNat n, NFDataX a, HiddenClock dom, HiddenEnable dom)
=> Vec (2 ^ n) a	ROM content NB: must be a constant
-> Signal dom (Unsigned n)	Read address `rd`
-> Signal dom a	The value of the ROM at address `rd`

A ROM with a synchronous read port, with space for 2^n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

Additional helpful information:

See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs
A large Vec for the content might be too inefficient, depending on how it is constructed. See romFilePow2 and romBlobPow2 for different approaches that scale well.

ROMs defined by a `MemBlob`

asyncRomBlob Source #

Arguments

:: Enum addr
=> MemBlob n m	ROM content, also determines the size, `n`, of the ROM NB: MUST be a constant
-> addr	Read address `r`
-> BitVector m	The value of the ROM at address `r`

An asynchronous/combinational ROM with space for n elements

Additional helpful information:

See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs.

asyncRomBlobPow2 Source #

Arguments

:: KnownNat n
=> MemBlob (2 ^ n) m	ROM content, also determines the size, 2^`n`, of the ROM NB: MUST be a constant
-> Unsigned n	Read address `r`
-> BitVector m	The value of the ROM at address `r`

An asynchronous/combinational ROM with space for 2^n elements

Additional helpful information:

See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs.

romBlob Source #

Arguments

:: forall dom addr m n. (HiddenClock dom, HiddenEnable dom, Enum addr)
=> MemBlob n m	ROM content, also determines the size, `n`, of the ROM NB: MUST be a constant
-> Signal dom addr	Read address `r`
-> Signal dom (BitVector m)	The value of the ROM at address `r` from the previous clock cycle

A ROM with a synchronous read port, with space for n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

Additional helpful information:

See Clash.Sized.Fixed and Clash.Explicit.BlockRam for ideas on how to use ROMs and RAMs.

romBlobPow2 Source #

Arguments

:: forall dom m n. (HiddenClock dom, HiddenEnable dom, KnownNat n)
=> MemBlob (2 ^ n) m	ROM content, also determines the size, 2^`n`, of the ROM NB: MUST be a constant
-> Signal dom (Unsigned n)	Read address `r`
-> Signal dom (BitVector m)	The value of the ROM at address `r` from the previous clock cycle

A ROM with a synchronous read port, with space for 2^n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

Additional helpful information:

See Clash.Sized.Fixed and Clash.Explicit.BlockRam for ideas on how to use ROMs and RAMs.

ROMs defined by a data file

asyncRomFile Source #

Arguments

:: (KnownNat m, Enum addr)
=> SNat n	Size of the ROM
-> FilePath	File describing the content of the ROM
-> addr	Read address `rd`
-> BitVector m	The value of the ROM at address `rd`

An asynchronous/combinational ROM with space for n elements

NB: This function might not work for specific combinations of code-generation backends and hardware targets. Please check the support table below:

               | VHDL     | Verilog  | SystemVerilog |
===============+==========+==========+===============+
Altera/Quartus | Broken   | Works    | Works         |
Xilinx/ISE     | Works    | Works    | Works         |
ASIC           | Untested | Untested | Untested      |
===============+==========+==========+===============+

Additional helpful information:

See Clash.Prelude.ROM.File for more information on how to instantiate a ROM with the contents of a data file.
See Clash.Sized.Fixed for ideas on how to create your own data files.
When you notice that asyncRomFile is significantly slowing down your simulation, give it a monomorphic type signature. So instead of leaving the type to be inferred:
```
myRomData = asyncRomFile d512 "memory.bin"
```
or giving it a polymorphic type signature:
```
myRomData :: Enum addr => addr -> BitVector 16
myRomData = asyncRomFile d512 "memory.bin"
```
you should give it a monomorphic type signature:
```
myRomData :: Unsigned 9 -> BitVector 16
myRomData = asyncRomFile d512 "memory.bin"
```

asyncRomFilePow2 Source #

Arguments

:: forall n m. (KnownNat m, KnownNat n)
=> FilePath	File describing the content of the ROM
-> Unsigned n	Read address `rd`
-> BitVector m	The value of the ROM at address `rd`

An asynchronous/combinational ROM with space for 2^n elements

NB: This function might not work for specific combinations of code-generation backends and hardware targets. Please check the support table below:

               | VHDL     | Verilog  | SystemVerilog |
===============+==========+==========+===============+
Altera/Quartus | Broken   | Works    | Works         |
Xilinx/ISE     | Works    | Works    | Works         |
ASIC           | Untested | Untested | Untested      |
===============+==========+==========+===============+

Additional helpful information:

See Clash.Prelude.ROM.File for more information on how to instantiate a ROM with the contents of a data file.
See Clash.Sized.Fixed for ideas on how to create your own data files.
When you notice that asyncRomFilePow2 is significantly slowing down your simulation, give it a monomorphic type signature. So instead of leaving the type to be inferred:
```
myRomData = asyncRomFilePow2 "memory.bin"
```
you should give it a monomorphic type signature:
```
myRomData :: Unsigned 9 -> BitVector 16
myRomData = asyncRomFilePow2 "memory.bin"
```

romFile Source #

Arguments

:: (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom, Enum addr)
=> SNat n	Size of the ROM
-> FilePath	File describing the content of the ROM
-> Signal dom addr	Read address `rd`
-> Signal dom (BitVector m)	The value of the ROM at address `rd` from the previous clock cycle

A ROM with a synchronous read port, with space for n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

NB: This function might not work for specific combinations of code-generation backends and hardware targets. Please check the support table below:

               | VHDL     | Verilog  | SystemVerilog |
===============+==========+==========+===============+
Altera/Quartus | Broken   | Works    | Works         |
Xilinx/ISE     | Works    | Works    | Works         |
ASIC           | Untested | Untested | Untested      |
===============+==========+==========+===============+

Additional helpful information:

See Clash.Prelude.ROM.File for more information on how to instantiate a ROM with the contents of a data file.
See Clash.Sized.Fixed for ideas on how to create your own data files.

romFilePow2 Source #

Arguments

:: forall n m dom. (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom)
=> FilePath	File describing the content of the ROM
-> Signal dom (Unsigned n)	Read address `rd`
-> Signal dom (BitVector m)	The value of the ROM at address `rd` from the previous clock cycle

A ROM with a synchronous read port, with space for 2^n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

NB: This function might not work for specific combinations of code-generation backends and hardware targets. Please check the support table below:

               | VHDL     | Verilog  | SystemVerilog |
===============+==========+==========+===============+
Altera/Quartus | Broken   | Works    | Works         |
Xilinx/ISE     | Works    | Works    | Works         |
ASIC           | Untested | Untested | Untested      |
===============+==========+==========+===============+

Additional helpful information:

See Clash.Prelude.ROM.File for more information on how to instantiate a ROM with the contents of a data file.
See Clash.Sized.Fixed for ideas on how to create your own data files.

RAM primitives with a combinational read port

asyncRam Source #

Arguments

:: (Enum addr, HiddenClock dom, HiddenEnable dom, HasCallStack, NFDataX a)
=> SNat n	Size `n` of the RAM
-> Signal dom addr	Read address `r`
-> Signal dom (Maybe (addr, a))	(write address `w`, value to write)
-> Signal dom a	Value of the `RAM` at address `r`

Create a RAM with space for n elements.

NB: Initial content of the RAM is undefined, reading it will throw an XException

Additional helpful information:

See Clash.Prelude.BlockRam for more information on how to use a RAM.

asyncRamPow2 Source #

Arguments

:: (KnownNat n, HiddenClock dom, HiddenEnable dom, HasCallStack, NFDataX a)
=> Signal dom (Unsigned n)	Read address `r`
-> Signal dom (Maybe (Unsigned n, a))	(write address `w`, value to write)
-> Signal dom a	Value of the `RAM` at address `r`

Create a RAM with space for 2^n elements

NB: Initial content of the RAM is undefined, reading it will throw an XException

Additional helpful information:

See Clash.Prelude.BlockRam for more information on how to use a RAM.

BlockRAM primitives

blockRam Source #

Arguments

:: (HasCallStack, HiddenClock dom, HiddenEnable dom, NFDataX a, Enum addr)
=> Vec n a	Initial content of the BRAM, also determines the size, `n`, of the BRAM. NB: MUST be a constant.
-> Signal dom addr	Read address `r`
-> Signal dom (Maybe (addr, a))	(write address `w`, value to write)
-> Signal dom a	Value of the `blockRAM` at address `r` from the previous clock cycle

Create a blockRAM with space for n elements.

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

bram40
  :: HiddenClock dom
  => Signal dom (Unsigned 6)
  -> Signal dom (Maybe (Unsigned 6, Bit))
  -> Signal dom Bit
bram40 = blockRam (replicate d40 1)

Additional helpful information:

See Clash.Prelude.BlockRam for more information on how to use a Block RAM.
Use the adapter readNew for obtaining write-before-read semantics like this: readNew (blockRam inits) rd wrM.
A large Vec for the initial content might be too inefficient, depending on how it is constructed. See blockRamFile and blockRamBlob for different approaches that scale well.

blockRamPow2 Source #

Arguments

:: (HasCallStack, HiddenClock dom, HiddenEnable dom, NFDataX a, KnownNat n)
=> Vec (2 ^ n) a	Initial content of the BRAM NB: MUST be a constant.
-> Signal dom (Unsigned n)	Read address `r`
-> Signal dom (Maybe (Unsigned n, a))	(write address `w`, value to write)
-> Signal dom a	Value of the `blockRAM` at address `r` from the previous clock cycle

Create a blockRAM with space for 2^n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

bram32
  :: HiddenClock dom
  => Signal dom (Unsigned 5)
  -> Signal dom (Maybe (Unsigned 5, Bit))
  -> Signal dom Bit
bram32 = blockRamPow2 (replicate d32 1)

Additional helpful information:

See Clash.Prelude.BlockRam for more information on how to use a Block RAM.
Use the adapter readNew for obtaining write-before-read semantics like this: readNew (blockRamPow2 inits) rd wrM.
A large Vec for the initial content might be too inefficient, depending on how it is constructed. See blockRamFilePow2 and blockRamBlobPow2 for different approaches that scale well.

blockRamU Source #

Arguments

:: forall n dom a r addr. (HasCallStack, HiddenClockResetEnable dom, NFDataX a, Enum addr, 1 <= n)
=> ResetStrategy r	Whether to clear BRAM on asserted reset (`ClearOnReset`) or not (`NoClearOnReset`). Reset needs to be asserted at least n cycles to clear the BRAM.
-> SNat n	Number of elements in BRAM
-> (Index n -> a)	If applicable (see first argument), reset BRAM using this function.
-> Signal dom addr	Read address `r`
-> Signal dom (Maybe (addr, a))	(write address `w`, value to write)
-> Signal dom a	Value of the `blockRAM` at address `r` from the previous clock cycle

Version of blockram that has no default values set. May be cleared to a arbitrary state using a reset function.

blockRam1 Source #

Arguments

:: forall n dom a r addr. (HasCallStack, HiddenClockResetEnable dom, NFDataX a, Enum addr, 1 <= n)
=> ResetStrategy r	Whether to clear BRAM on asserted reset (`ClearOnReset`) or not (`NoClearOnReset`). Reset needs to be asserted at least n cycles to clear the BRAM.
-> SNat n	Number of elements in BRAM
-> a	Initial content of the BRAM (replicated n times)
-> Signal dom addr	Read address `r`
-> Signal dom (Maybe (addr, a))	(write address `w`, value to write)
-> Signal dom a	Value of the `blockRAM` at address `r` from the previous clock cycle

Version of blockram that is initialized with the same value on all memory positions.

data ResetStrategy (r :: Bool) where Source #

Constructors

ClearOnReset :: ResetStrategy 'True
NoClearOnReset :: ResetStrategy 'False

BlockRAM primitives initialized with a `MemBlob`

blockRamBlob Source #

Arguments

:: forall dom addr m n. (HiddenClock dom, HiddenEnable dom, Enum addr)
=> MemBlob n m	Initial content of the RAM, also determines the size, `n`, of the RAM NB: MUST be a constant
-> Signal dom addr	Read address `r`
-> Signal dom (Maybe (addr, BitVector m))	(write address `w`, value to write)
-> Signal dom (BitVector m)	Value of the blockRAM at address `r` from the previous clock cycle

Create a blockRAM with space for n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

Additional helpful information:

See Clash.Prelude.BlockRam for more information on how to use a Block RAM.
Use the adapter readNew for obtaining write-before-read semantics like this: readNew (blockRamBlob content) rd wrM.

blockRamBlobPow2 Source #

Arguments

:: forall dom m n. (HiddenClock dom, HiddenEnable dom, KnownNat n)
=> MemBlob (2 ^ n) m	Initial content of the RAM, also determines the size, 2^`n`, of the RAM NB: MUST be a constant
-> Signal dom (Unsigned n)	Read address `r`
-> Signal dom (Maybe (Unsigned n, BitVector m))	(write address `w`, value to write)
-> Signal dom (BitVector m)	Value of the blockRAM at address `r` from the previous clock cycle

Create a blockRAM with space for 2^n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

Additional helpful information:

See Clash.Prelude.BlockRam for more information on how to use a Block RAM.
Use the adapter readNew for obtaining write-before-read semantics like this: readNew (blockRamBlobPow2 content) rd wrM.

Creating and inspecting `MemBlob`

data MemBlob (n :: Nat) (m :: Nat) Source #

Efficient storage of memory content

It holds n words of BitVector m.

Instances

Instances details

Show (MemBlob n m) Source #
Instance details Defined in Clash.Explicit.BlockRam.Internal Methods showsPrec :: Int -> MemBlob n m -> ShowS # show :: MemBlob n m -> String # showList :: [MemBlob n m] -> ShowS #

createMemBlob Source #

Arguments

:: forall a f. (Foldable f, BitPack a)
=> String	Name of the binding to generate
-> Maybe Bit	Value to map don't care bits to. `Nothing` means throwing an error on don't care bits.
-> f a	The content for the `MemBlob`
-> DecsQ

Create a MemBlob binding from a list of values

Since this uses Template Haskell, nothing in the arguments given to createMemBlob can refer to something defined in the same module.

Example

Expand

createMemBlob "content" Nothing [15 :: Unsigned 8 .. 17]

ram clk en = blockRamBlob clk en content

The Maybe datatype has don't care bits, where the actual value does not matter. But the bits need a defined value in the memory. Either 0 or 1 can be used, and both are valid representations of the data.

>>> import qualified Prelude as P
>>> let es = [ Nothing, Just (7 :: Unsigned 8), Just 8 ]
>>> :{
createMemBlob "content0" (Just 0) es
createMemBlob "content1" (Just 1) es
x = 1
:}

>>> let pr = mapM_ (putStrLn . show)
>>> pr $ P.map pack es
0b0_...._....
0b1_0000_0111
0b1_0000_1000
>>> pr $ unpackMemBlob content0
0b0_0000_0000
0b1_0000_0111
0b1_0000_1000
>>> pr $ unpackMemBlob content1
0b0_1111_1111
0b1_0000_0111
0b1_0000_1000
>>> :{
createMemBlob "contentN" Nothing es
x = 1
:}

<interactive>:...: error:
    packBVs: cannot convert don't care values. Please specify a mapping to a definite value.

Note how we hinted to clashi that our multi-line command was a list of declarations by including a dummy declaration x = 1. Without this trick, clashi would expect an expression and the Template Haskell would not work.

memBlobTH Source #

Arguments

:: forall a f. (Foldable f, BitPack a)
=> Maybe Bit	Value to map don't care bits to. `Nothing` means throwing an error on don't care bits.
-> f a	The content for the `MemBlob`
-> ExpQ

Create a MemBlob from a list of values

Since this uses Template Haskell, nothing in the arguments given to memBlobTH can refer to something defined in the same module.

Example

Expand

ram clk en = blockRamBlob clk en $(memBlobTH Nothing [15 :: Unsigned 8 .. 17])

The Maybe datatype has don't care bits, where the actual value does not matter. But the bits need a defined value in the memory. Either 0 or 1 can be used, and both are valid representations of the data.

>>> import qualified Prelude as P
>>> let es = [ Nothing, Just (7 :: Unsigned 8), Just 8 ]
>>> content0 = $(memBlobTH (Just 0) es)
>>> content1 = $(memBlobTH (Just 1) es)
>>> let pr = mapM_ (putStrLn . show)
>>> pr $ P.map pack es
0b0_...._....
0b1_0000_0111
0b1_0000_1000
>>> pr $ unpackMemBlob content0
0b0_0000_0000
0b1_0000_0111
0b1_0000_1000
>>> pr $ unpackMemBlob content1
0b0_1111_1111
0b1_0000_0111
0b1_0000_1000
>>> $(memBlobTH Nothing es)

<interactive>:...: error:
    • packBVs: cannot convert don't care values. Please specify a mapping to a definite value.
    • In the untyped splice: $(memBlobTH Nothing es)

unpackMemBlob :: forall n m. MemBlob n m -> [BitVector m] Source #

Convert a MemBlob back to a list

NB: Not synthesizable

BlockRAM primitives initialized with a data file

blockRamFile Source #

Arguments

:: (KnownNat m, Enum addr, HiddenClock dom, HiddenEnable dom, HasCallStack)
=> SNat n	Size of the blockRAM
-> FilePath	File describing the initial content of the blockRAM
-> Signal dom addr	Read address `r`
-> Signal dom (Maybe (addr, BitVector m))	(write address `w`, value to write)
-> Signal dom (BitVector m)	Value of the `blockRAM` at address `r` from the previous clock cycle

Create a blockRAM with space for n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

NB: This function might not work for specific combinations of code-generation backends and hardware targets. Please check the support table below:

               | VHDL     | Verilog  | SystemVerilog |
===============+==========+==========+===============+
Altera/Quartus | Broken   | Works    | Works         |
Xilinx/ISE     | Works    | Works    | Works         |
ASIC           | Untested | Untested | Untested      |
===============+==========+==========+===============+

Additional helpful information:

See Clash.Prelude.BlockRam for more information on how to use a Block RAM.
Use the adapter readNew for obtaining write-before-read semantics like this: readNew (blockRamFile size file) rd wrM.
See Clash.Prelude.BlockRam.File for more information on how to instantiate a Block RAM with the contents of a data file.
See Clash.Sized.Fixed for ideas on how to create your own data files.

blockRamFilePow2 Source #

Arguments

:: forall dom n m. (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom, HasCallStack)
=> FilePath	File describing the initial content of the blockRAM
-> Signal dom (Unsigned n)	Read address `r`
-> Signal dom (Maybe (Unsigned n, BitVector m))	(write address `w`, value to write)
-> Signal dom (BitVector m)	Value of the `blockRAM` at address `r` from the previous clock cycle

Create a blockRAM with space for 2^n elements

NB: Read value is delayed by 1 cycle
NB: Initial output value is undefined, reading it will throw an XException

NB: This function might not work for specific combinations of code-generation backends and hardware targets. Please check the support table below:

               | VHDL     | Verilog  | SystemVerilog |
===============+==========+==========+===============+
Altera/Quartus | Broken   | Works    | Works         |
Xilinx/ISE     | Works    | Works    | Works         |
ASIC           | Untested | Untested | Untested      |
===============+==========+==========+===============+

Additional helpful information:

See Clash.Prelude.BlockRam for more information on how to use a Block RAM.
Use the adapter readNew for obtaining write-before-read semantics like this: readNew (blockRamFilePow2 file) rd wrM.
See Clash.Prelude.BlockRam.File for more information on how to instantiate a Block RAM with the contents of a data file.
See Clash.Sized.Fixed for ideas on how to create your own data files.

BlockRAM read/write conflict resolution

readNew Source #

Arguments

:: (HiddenClockResetEnable dom, NFDataX a, Eq addr)
=> (Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a)	The `ram` component
-> Signal dom addr	Read address `r`
-> Signal dom (Maybe (addr, a))	(Write address `w`, value to write)
-> Signal dom a	Value of the `ram` at address `r` from the previous clock cycle

Create read-after-write blockRAM from a read-before-write one (synchronized to system clock)

>>> import Clash.Prelude
>>> :t readNew (blockRam (0 :> 1 :> Nil))
readNew (blockRam (0 :> 1 :> Nil))
  :: ...
     ...
     ...
     ...
     ... =>
     Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a

True dual-port block RAM

trueDualPortBlockRam Source #

Arguments

:: forall nAddrs dom1 dom2 a. (HasCallStack, KnownNat nAddrs, HiddenClock dom1, HiddenClock dom2, NFDataX a)
=> Signal dom1 (RamOp nAddrs a)	RAM operation for port A
-> Signal dom2 (RamOp nAddrs a)	RAM operation for port B
-> (Signal dom1 a, Signal dom2 a)	Outputs data on next cycle. When writing, the data written will be echoed. When reading, the read data is returned.

Produces vendor-agnostic HDL that will be inferred as a true dual-port block RAM

Any value that is being written on a particular port is also the value that will be read on that port, i.e. the same-port read/write behavior is: WriteFirst. For mixed-port read/write, when port A writes to the address port B reads from, the output of port B is undefined, and vice versa.

data RamOp n a Source #

Port operation

Constructors

RamRead (Index n)	Read from address
RamWrite (Index n) a	Write data to address
RamNoOp	No operation

Instances

Instances details

Show a => Show (RamOp n a) Source #
Instance details Defined in Clash.Explicit.BlockRam Methods showsPrec :: Int -> RamOp n a -> ShowS # show :: RamOp n a -> String # showList :: [RamOp n a] -> ShowS #
Generic (RamOp n a) Source #
Instance details Defined in Clash.Explicit.BlockRam Associated Types type Rep (RamOp n a) :: Type -> Type # Methods from :: RamOp n a -> Rep (RamOp n a) x # to :: Rep (RamOp n a) x -> RamOp n a #
NFDataX a => NFDataX (RamOp n a) Source #
Instance details Defined in Clash.Explicit.BlockRam Methods deepErrorX :: String -> RamOp n a Source # hasUndefined :: RamOp n a -> Bool Source # ensureSpine :: RamOp n a -> RamOp n a Source # rnfX :: RamOp n a -> () Source #
type Rep (RamOp n a) Source #
Instance details Defined in Clash.Explicit.BlockRam type Rep (RamOp n a) = D1 ('MetaData "RamOp" "Clash.Explicit.BlockRam" "clash-prelude-1.5.0-inplace" 'False) (C1 ('MetaCons "RamRead" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Index n))) :+: (C1 ('MetaCons "RamWrite" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Index n)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "RamNoOp" 'PrefixI 'False) (U1 :: Type -> Type)))

Utility functions

window Source #

Arguments

:: (HiddenClockResetEnable dom, KnownNat n, Default a, NFDataX a)
=> Signal dom a	Signal to create a window over
-> Vec (n + 1) (Signal dom a)	Window of at least size 1

Give a window over a Signal

window4 :: HiddenClockResetEnable dom
        => Signal dom Int -> Vec 4 (Signal dom Int)
window4 = window

>>> simulateB @System window4 [1::Int,2,3,4,5] :: [Vec 4 Int]
[1 :> 0 :> 0 :> 0 :> Nil,2 :> 1 :> 0 :> 0 :> Nil,3 :> 2 :> 1 :> 0 :> Nil,4 :> 3 :> 2 :> 1 :> Nil,5 :> 4 :> 3 :> 2 :> Nil,...
...

windowD Source #

Arguments

:: (HiddenClockResetEnable dom, KnownNat n, Default a, NFDataX a)
=> Signal dom a	Signal to create a window over
-> Vec (n + 1) (Signal dom a)	Window of at least size 1

Give a delayed window over a Signal

windowD3
  :: HiddenClockResetEnable dom
  => Signal dom Int
  -> Vec 3 (Signal dom Int)
windowD3 = windowD

>>> simulateB @System windowD3 [1::Int,2,3,4] :: [Vec 3 Int]
[0 :> 0 :> 0 :> Nil,1 :> 0 :> 0 :> Nil,2 :> 1 :> 0 :> Nil,3 :> 2 :> 1 :> Nil,4 :> 3 :> 2 :> Nil,...
...

isRising Source #

Arguments

:: (HiddenClockResetEnable dom, NFDataX a, Bounded a, Eq a)
=> a	Starting value
-> Signal dom a
-> Signal dom Bool

Give a pulse when the Signal goes from minBound to maxBound

isFalling Source #

Arguments

:: (HiddenClockResetEnable dom, NFDataX a, Bounded a, Eq a)
=> a	Starting value
-> Signal dom a
-> Signal dom Bool

Give a pulse when the Signal goes from maxBound to minBound

riseEvery :: HiddenClockResetEnable dom => SNat n -> Signal dom Bool Source #

Give a pulse every n clock cycles. This is a useful helper function when combined with functions like regEn or mux, in order to delay a register by a known amount.

To be precise: the given signal will be False for the next n-1 cycles, followed by a single True value:

>>> Prelude.last (sampleN @System 1025 (riseEvery d1024)) == True
True
>>> Prelude.or (sampleN @System 1024 (riseEvery d1024)) == False
True

For example, to update a counter once every 10 million cycles:

counter = regEn 0 (riseEvery (SNat :: SNat 10000000)) (counter + 1)

oscillate :: HiddenClockResetEnable dom => Bool -> SNat n -> Signal dom Bool Source #

Oscillate a Bool for a given number of cycles. This is a convenient function when combined with something like regEn, as it allows you to easily hold a register value for a given number of cycles. The input Bool determines what the initial value is.

To oscillate on an interval of 5 cycles:

>>> sampleN @System 11 (oscillate False d5)
[False,False,False,False,False,False,True,True,True,True,True]

To oscillate between True and False:

>>> sampleN @System 11 (oscillate False d1)
[False,False,True,False,True,False,True,False,True,False,True]

An alternative definition for the above could be:

>>> let osc' = register False (not <$> osc')
>>> sampleN @System 200 (oscillate False d1) == sampleN @System 200 osc'
True

Tracing

Simple

traceSignal1 Source #

Arguments

:: (BitPack a, NFDataX a, Typeable a)
=> String	Name of signal in the VCD output
-> Signal dom a	Signal to trace
-> Signal dom a

Trace a single signal. Will emit an error if a signal with the same name was previously registered.

NB associates the traced signal with a clock period of 1, which results in incorrect VCD files when working with circuits that have multiple clocks. Use traceSignal when working with circuits that have multiple clocks.

traceVecSignal1 Source #

Arguments

:: (KnownNat n, BitPack a, NFDataX a, Typeable a)
=> String	Name of signal in debugging output. Will be appended by _0, _1, ..., _n.
-> Signal dom (Vec (n + 1) a)	Signal to trace
-> Signal dom (Vec (n + 1) a)

Trace a single vector signal: each element in the vector will show up as a different trace. If the trace name already exists, this function will emit an error.

NB associates the traced signal with a clock period of 1, which results in incorrect VCD files when working with circuits that have multiple clocks. Use traceSignal when working with circuits that have multiple clocks.

Tracing in a multi-clock environment

traceSignal Source #

Arguments

:: forall dom a. (KnownDomain dom, BitPack a, NFDataX a, Typeable a)
=> String	Name of signal in the VCD output
-> Signal dom a	Signal to trace
-> Signal dom a

Trace a single signal. Will emit an error if a signal with the same name was previously registered.

NB Works correctly when creating VCD files from traced signal in multi-clock circuits. However traceSignal1 might be more convenient to use when the domain of your circuit is polymorphic.

traceVecSignal Source #

Arguments

:: forall dom a n. (KnownDomain dom, KnownNat n, BitPack a, NFDataX a, Typeable a)
=> String	Name of signal in debugging output. Will be appended by _0, _1, ..., _n.
-> Signal dom (Vec (n + 1) a)	Signal to trace
-> Signal dom (Vec (n + 1) a)

Trace a single vector signal: each element in the vector will show up as a different trace. If the trace name already exists, this function will emit an error.

NB Works correctly when creating VCD files from traced signal in multi-clock circuits. However traceSignal1 might be more convinient to use when the domain of your circuit is polymorphic.

VCD dump functions

dumpVCD Source #

Arguments

:: NFDataX a
=> (Int, Int)	(offset, number of samples)
-> Signal dom a	(One of) the outputs of the circuit containing the traces
-> [String]	The names of the traces you definitely want to be dumped in the VCD file
-> IO (Either String Text)

Produce a four-state VCD (Value Change Dump) according to IEEE 1364-{1995,2001}. This function fails if a trace name contains either non-printable or non-VCD characters.

Due to lazy evaluation, the created VCD files might not contain all the traces you were expecting. You therefore have to provide a list of names you definately want to be dumped in the VCD file.

For example:

vcd <- dumpVCD (0, 100) cntrOut ["main", "sub"]

Evaluates cntrOut long enough in order for to guarantee that the main, and sub traces end up in the generated VCD file.

Exported modules

Synchronous signals

data Reset (dom :: Domain) Source #

A reset signal belonging to a domain called dom.

The underlying representation of resets is Bool.

Instances

Instances details

type HasDomain dom1 (Reset dom2) Source #
Instance details Defined in Clash.Class.HasDomain.HasSpecificDomain type HasDomain dom1 (Reset dom2) = DomEq dom1 dom2
type TryDomain t (Reset dom) Source #
Instance details Defined in Clash.Class.HasDomain.HasSingleDomain type TryDomain t (Reset dom) = 'Found dom

data Clock (dom :: Domain) Source #

A clock signal belonging to a domain named dom.

Instances

Instances details

Show (Clock dom) Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> Clock dom -> ShowS # show :: Clock dom -> String # showList :: [Clock dom] -> ShowS #
Clocks (Clock c1, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) Source #
type HasDomain dom1 (Clock dom2) Source #
Instance details Defined in Clash.Class.HasDomain.HasSpecificDomain type HasDomain dom1 (Clock dom2) = DomEq dom1 dom2
type TryDomain t (Clock dom) Source #
Instance details Defined in Clash.Class.HasDomain.HasSingleDomain type TryDomain t (Clock dom) = 'Found dom
type ClocksCxt (Clock c1, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Signal pllLock Bool) = KnownDomain c1
type ClocksCxt (Clock c1, Clock c2, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12, KnownDomain c13)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12, KnownDomain c13, KnownDomain c14)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12, KnownDomain c13, KnownDomain c14, KnownDomain c15)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12, KnownDomain c13, KnownDomain c14, KnownDomain c15, KnownDomain c16)

data Enable dom Source #

A signal of booleans, indicating whether a component is enabled. No special meaning is implied, it's up to the component itself to decide how to respond to its enable line. It is used throughout Clash as a global enable signal.

Instances

Instances details

type HasDomain dom1 (Enable dom2) Source #
Instance details Defined in Clash.Class.HasDomain.HasSpecificDomain type HasDomain dom1 (Enable dom2) = DomEq dom1 dom2
type TryDomain t (Enable dom) Source #
Instance details Defined in Clash.Class.HasDomain.HasSingleDomain type TryDomain t (Enable dom) = 'Found dom

data Signal (dom :: Domain) a Source #

Clash has synchronous Signals in the form of:

Signal (dom :: Domain) a

Where a is the type of the value of the Signal, for example Int or Bool, and dom is the clock- (and reset-) domain to which the memory elements manipulating these Signals belong.

The type-parameter, dom, is of the kind Domain - a simple string. That string refers to a single synthesis domain. A synthesis domain describes the behavior of certain aspects of memory elements in it.

NB: "Bad things"™ happen when you actually use a clock period of 0, so do not do that!
NB: You should be judicious using a clock with period of 1 as you can never create a clock that goes any faster!
NB: For the best compatibility make sure your period is divisible by 2, because some VHDL simulators don't support fractions of picoseconds.
NB: Whether System has good defaults depends on your target platform. Check out IntelSystem and XilinxSystem too!

Signals have the type role

>>> :i Signal
type role Signal nominal representational
...

as it is safe to coerce the underlying value of a signal, but not safe to coerce a signal between different synthesis domains.

See the module documentation of Clash.Signal for more information about domains.

Instances

Instances details

Lift a => Lift (Signal dom a :: Type) Source #
Instance details Defined in Clash.Signal.Internal Methods lift :: Signal dom a -> Q Exp # liftTyped :: Signal dom a -> Q (TExp (Signal dom a)) #
AssertionValue dom (Signal dom Bool) Source #	Stream of booleans, originating from a circuit
Instance details Defined in Clash.Verification.Internal Methods toAssertionValue :: Signal dom Bool -> Assertion dom Source #
Functor (Signal dom) Source #
Instance details Defined in Clash.Signal.Internal Methods fmap :: (a -> b) -> Signal dom a -> Signal dom b # (<$) :: a -> Signal dom b -> Signal dom a #
Applicative (Signal dom) Source #
Instance details Defined in Clash.Signal.Internal Methods pure :: a -> Signal dom a # (<>) :: Signal dom (a -> b) -> Signal dom a -> Signal dom b # liftA2 :: (a -> b -> c) -> Signal dom a -> Signal dom b -> Signal dom c # (>) :: Signal dom a -> Signal dom b -> Signal dom b # (<*) :: Signal dom a -> Signal dom b -> Signal dom a #
Foldable (Signal dom) Source #	NB: Not synthesizable NB: In "`foldr f z s`": The function `f` should be lazy in its second argument. The `z` element will never be used.
Instance details Defined in Clash.Signal.Internal Methods fold :: Monoid m => Signal dom m -> m # foldMap :: Monoid m => (a -> m) -> Signal dom a -> m # foldMap' :: Monoid m => (a -> m) -> Signal dom a -> m # foldr :: (a -> b -> b) -> b -> Signal dom a -> b # foldr' :: (a -> b -> b) -> b -> Signal dom a -> b # foldl :: (b -> a -> b) -> b -> Signal dom a -> b # foldl' :: (b -> a -> b) -> b -> Signal dom a -> b # foldr1 :: (a -> a -> a) -> Signal dom a -> a # foldl1 :: (a -> a -> a) -> Signal dom a -> a # toList :: Signal dom a -> [a] # null :: Signal dom a -> Bool # length :: Signal dom a -> Int # elem :: Eq a => a -> Signal dom a -> Bool # maximum :: Ord a => Signal dom a -> a # minimum :: Ord a => Signal dom a -> a # sum :: Num a => Signal dom a -> a # product :: Num a => Signal dom a -> a #
Traversable (Signal dom) Source #
Instance details Defined in Clash.Signal.Internal Methods traverse :: Applicative f => (a -> f b) -> Signal dom a -> f (Signal dom b) # sequenceA :: Applicative f => Signal dom (f a) -> f (Signal dom a) # mapM :: Monad m => (a -> m b) -> Signal dom a -> m (Signal dom b) # sequence :: Monad m => Signal dom (m a) -> m (Signal dom a) #
Fractional a => Fractional (Signal dom a) Source #
Instance details Defined in Clash.Signal.Internal Methods (/) :: Signal dom a -> Signal dom a -> Signal dom a # recip :: Signal dom a -> Signal dom a # fromRational :: Rational -> Signal dom a #
Num a => Num (Signal dom a) Source #
Instance details Defined in Clash.Signal.Internal Methods (+) :: Signal dom a -> Signal dom a -> Signal dom a # (-) :: Signal dom a -> Signal dom a -> Signal dom a # (*) :: Signal dom a -> Signal dom a -> Signal dom a # negate :: Signal dom a -> Signal dom a # abs :: Signal dom a -> Signal dom a # signum :: Signal dom a -> Signal dom a # fromInteger :: Integer -> Signal dom a #
Show a => Show (Signal dom a) Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> Signal dom a -> ShowS # show :: Signal dom a -> String # showList :: [Signal dom a] -> ShowS #
Arbitrary a => Arbitrary (Signal dom a) Source #
Instance details Defined in Clash.Signal.Internal Methods arbitrary :: Gen (Signal dom a) # shrink :: Signal dom a -> [Signal dom a] #
CoArbitrary a => CoArbitrary (Signal dom a) Source #
Instance details Defined in Clash.Signal.Internal Methods coarbitrary :: Signal dom a -> Gen b -> Gen b #
Default a => Default (Signal dom a) Source #
Instance details Defined in Clash.Signal.Internal Methods def :: Signal dom a #
NFDataX a => NFDataX (Signal domain a) Source #
Instance details Defined in Clash.Signal.Internal Methods deepErrorX :: String -> Signal domain a Source # hasUndefined :: Signal domain a -> Bool Source # ensureSpine :: Signal domain a -> Signal domain a Source # rnfX :: Signal domain a -> () Source #
Clocks (Clock c1, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) Source #
Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks Associated Types type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) Source # Methods clocks :: forall (domIn :: Domain). (KnownDomain domIn, ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool)) => Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) Source #
type HasDomain dom1 (Signal dom2 a) Source #
Instance details Defined in Clash.Class.HasDomain.HasSpecificDomain type HasDomain dom1 (Signal dom2 a) = DomEq dom1 dom2
type TryDomain t (Signal dom a) Source #
Instance details Defined in Clash.Class.HasDomain.HasSingleDomain type TryDomain t (Signal dom a) = 'Found dom
type ClocksCxt (Clock c1, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Signal pllLock Bool) = KnownDomain c1
type ClocksCxt (Clock c1, Clock c2, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12, KnownDomain c13)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12, KnownDomain c13, KnownDomain c14)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12, KnownDomain c13, KnownDomain c14, KnownDomain c15)
type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) Source #
Instance details Defined in Clash.Clocks type ClocksCxt (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Clock c11, Clock c12, Clock c13, Clock c14, Clock c15, Clock c16, Signal pllLock Bool) = (KnownDomain c1, KnownDomain c2, KnownDomain c3, KnownDomain c4, KnownDomain c5, KnownDomain c6, KnownDomain c7, KnownDomain c8, KnownDomain c9, KnownDomain c10, KnownDomain c11, KnownDomain c12, KnownDomain c13, KnownDomain c14, KnownDomain c15, KnownDomain c16)

type Domain = Symbol Source #

data VDomainConfiguration Source #

Same as SDomainConfiguration but allows for easy updates through record update syntax. Should be used in combination with vDomain and createDomain. Example:

createDomain (knownVDomain @System){vName="System10", vPeriod=10}

This duplicates the settings in the System domain, replaces the name and period, and creates an instance for it. As most users often want to update the system domain, a shortcut is available in the form:

createDomain vSystem{vName="System10", vPeriod=10}

Constructors

VDomainConfiguration

Fields

vName :: String
Corresponds to _name on DomainConfiguration
vPeriod :: Natural
Corresponds to _period on DomainConfiguration
vActiveEdge :: ActiveEdge
Corresponds to _activeEdge on DomainConfiguration
vResetKind :: ResetKind
Corresponds to _resetKind on DomainConfiguration
vInitBehavior :: InitBehavior
Corresponds to _initBehavior on DomainConfiguration
vResetPolarity :: ResetPolarity
Corresponds to _resetPolarity on DomainConfiguration

Instances

Instances details

Eq VDomainConfiguration Source #
Instance details Defined in Clash.Signal.Internal Methods (==) :: VDomainConfiguration -> VDomainConfiguration -> Bool # (/=) :: VDomainConfiguration -> VDomainConfiguration -> Bool #
Read VDomainConfiguration Source #
Instance details Defined in Clash.Signal.Internal Methods readsPrec :: Int -> ReadS VDomainConfiguration # readList :: ReadS [VDomainConfiguration] # readPrec :: ReadPrec VDomainConfiguration # readListPrec :: ReadPrec [VDomainConfiguration] #
Show VDomainConfiguration Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> VDomainConfiguration -> ShowS # show :: VDomainConfiguration -> String # showList :: [VDomainConfiguration] -> ShowS #
Generic VDomainConfiguration Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep VDomainConfiguration :: Type -> Type # Methods from :: VDomainConfiguration -> Rep VDomainConfiguration x # to :: Rep VDomainConfiguration x -> VDomainConfiguration #
NFData VDomainConfiguration Source #
Instance details Defined in Clash.Signal.Internal Methods rnf :: VDomainConfiguration -> () #
type Rep VDomainConfiguration Source #
Instance details Defined in Clash.Signal.Internal type Rep VDomainConfiguration = D1 ('MetaData "VDomainConfiguration" "Clash.Signal.Internal" "clash-prelude-1.5.0-inplace" 'False) (C1 ('MetaCons "VDomainConfiguration" 'PrefixI 'True) ((S1 ('MetaSel ('Just "vName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :: (S1 ('MetaSel ('Just "vPeriod") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Natural) :: S1 ('MetaSel ('Just "vActiveEdge") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ActiveEdge))) :: (S1 ('MetaSel ('Just "vResetKind") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ResetKind) :: (S1 ('MetaSel ('Just "vInitBehavior") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 InitBehavior) :*: S1 ('MetaSel ('Just "vResetPolarity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ResetPolarity)))))

type XilinxSystem = "XilinxSystem" :: Domain Source #

A clock (and reset) dom with clocks running at 100 MHz. Memory elements respond to the rising edge of the clock, and synchronously to changes in reset signals. It has defined initial values, and active-high resets.

See module documentation of Clash.Explicit.Signal for more information on how to create custom synthesis domains.

type IntelSystem = "IntelSystem" :: Domain Source #

A clock (and reset) dom with clocks running at 100 MHz. Memory elements respond to the rising edge of the clock, and asynchronously to changes in reset signals. It has defined initial values, and active-high resets.

See module documentation of Clash.Explicit.Signal for more information on how to create custom synthesis domains.

type System = "System" :: Domain Source #

A clock (and reset) dom with clocks running at 100 MHz. Memory elements respond to the rising edge of the clock, and asynchronously to changes in reset signals. It has defined initial values, and active-high resets.

See module documentation of Clash.Explicit.Signal for more information on how to create custom synthesis domains.

class KnownSymbol dom => KnownDomain (dom :: Domain) where Source #

A KnownDomain constraint indicates that a circuit's behavior depends on some properties of a domain. See DomainConfiguration for more information.

Associated Types

type KnownConf dom :: DomainConfiguration Source #

Methods

knownDomain :: SDomainConfiguration dom (KnownConf dom) Source #

Returns SDomainConfiguration corresponding to an instance's DomainConfiguration.

Example usage:

>>> knownDomain @System
SDomainConfiguration (SSymbol @"System") (SNat @10000) SRising SAsynchronous SDefined SActiveHigh

Instances

Instances details

KnownDomain XilinxSystem Source #	System instance with defaults set for Xilinx FPGAs
Instance details Defined in Clash.Signal.Internal Associated Types type KnownConf XilinxSystem :: DomainConfiguration Source # Methods knownDomain :: SDomainConfiguration XilinxSystem (KnownConf XilinxSystem) Source #
KnownDomain IntelSystem Source #	System instance with defaults set for Intel FPGAs
Instance details Defined in Clash.Signal.Internal Associated Types type KnownConf IntelSystem :: DomainConfiguration Source # Methods knownDomain :: SDomainConfiguration IntelSystem (KnownConf IntelSystem) Source #
KnownDomain System Source #	A clock (and reset) dom with clocks running at 100 MHz
Instance details Defined in Clash.Signal.Internal Associated Types type KnownConf System :: DomainConfiguration Source # Methods knownDomain :: SDomainConfiguration System (KnownConf System) Source #

type KnownConfiguration dom conf = (KnownDomain dom, KnownConf dom ~ conf) Source #

data SDomainConfiguration (dom :: Domain) (conf :: DomainConfiguration) where Source #

Singleton version of DomainConfiguration

Constructors

SDomainConfiguration :: SSymbol dom -> SNat period -> SActiveEdge edge -> SResetKind reset -> SInitBehavior init -> SResetPolarity polarity -> SDomainConfiguration dom ('DomainConfiguration dom period edge reset init polarity)

Instances

Instances details

Show (SDomainConfiguration dom conf) Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> SDomainConfiguration dom conf -> ShowS # show :: SDomainConfiguration dom conf -> String # showList :: [SDomainConfiguration dom conf] -> ShowS #

type DomainResetPolarity (dom :: Domain) = DomainConfigurationResetPolarity (KnownConf dom) Source #

Convenience type to help to extract the reset polarity from a domain. Example usage:

myFunc :: (KnownDomain dom, DomainResetPolarity dom ~ 'ActiveHigh) => ...

type DomainInitBehavior (dom :: Domain) = DomainConfigurationInitBehavior (KnownConf dom) Source #

Convenience type to help to extract the initial value behavior from a domain. Example usage:

myFunc :: (KnownDomain dom, DomainInitBehavior dom ~ 'Defined) => ...

type DomainResetKind (dom :: Domain) = DomainConfigurationResetKind (KnownConf dom) Source #

Convenience type to help to extract the reset synchronicity from a domain. Example usage:

myFunc :: (KnownDomain dom, DomainResetKind dom ~ 'Synchronous) => ...

type DomainActiveEdge (dom :: Domain) = DomainConfigurationActiveEdge (KnownConf dom) Source #

Convenience type to help to extract the active edge from a domain. Example usage:

myFunc :: (KnownDomain dom, DomainActiveEdge dom ~ 'Rising) => ...

type DomainPeriod (dom :: Domain) = DomainConfigurationPeriod (KnownConf dom) Source #

Convenience type to help to extract a period from a domain. Example usage:

myFunc :: (KnownDomain dom, DomainPeriod dom ~ 6000) => ...

data DomainConfiguration Source #

A domain with a name (Domain). Configures the behavior of various aspects of a circuits. See the documentation of this record's field types for more information on the options.

See module documentation of Clash.Explicit.Signal for more information on how to create custom synthesis domains.

Constructors

DomainConfiguration

Fields

_name :: Domain
Domain name
_period :: Nat
Period of clock in ps
_activeEdge :: ActiveEdge
Active edge of the clock
_resetKind :: ResetKind
Whether resets are synchronous (edge-sensitive) or asynchronous (level-sensitive)
_initBehavior :: InitBehavior
Whether the initial (or "power up") value of memory elements is unknown/undefined, or configurable to a specific value
_resetPolarity :: ResetPolarity
Whether resets are active high or active low

data SInitBehavior (init :: InitBehavior) where Source #

Constructors

SUnknown :: SInitBehavior 'Unknown
SDefined :: SInitBehavior 'Defined

Instances

Instances details

Show (SInitBehavior init) Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> SInitBehavior init -> ShowS # show :: SInitBehavior init -> String # showList :: [SInitBehavior init] -> ShowS #

data InitBehavior Source #

Constructors

Unknown	Power up value of memory elements is unknown.
Defined	If applicable, power up value of a memory element is defined. Applies to `register`s for example, but not to `blockRam`.

Instances

Instances details

Eq InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Methods (==) :: InitBehavior -> InitBehavior -> Bool # (/=) :: InitBehavior -> InitBehavior -> Bool #
Data InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InitBehavior -> c InitBehavior # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InitBehavior # toConstr :: InitBehavior -> Constr # dataTypeOf :: InitBehavior -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InitBehavior) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InitBehavior) # gmapT :: (forall b. Data b => b -> b) -> InitBehavior -> InitBehavior # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InitBehavior -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InitBehavior -> r # gmapQ :: (forall d. Data d => d -> u) -> InitBehavior -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InitBehavior -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InitBehavior -> m InitBehavior # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InitBehavior -> m InitBehavior # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InitBehavior -> m InitBehavior #
Ord InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Methods compare :: InitBehavior -> InitBehavior -> Ordering # (<) :: InitBehavior -> InitBehavior -> Bool # (<=) :: InitBehavior -> InitBehavior -> Bool # (>) :: InitBehavior -> InitBehavior -> Bool # (>=) :: InitBehavior -> InitBehavior -> Bool # max :: InitBehavior -> InitBehavior -> InitBehavior # min :: InitBehavior -> InitBehavior -> InitBehavior #
Read InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Methods readsPrec :: Int -> ReadS InitBehavior # readList :: ReadS [InitBehavior] # readPrec :: ReadPrec InitBehavior # readListPrec :: ReadPrec [InitBehavior] #
Show InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> InitBehavior -> ShowS # show :: InitBehavior -> String # showList :: [InitBehavior] -> ShowS #
Generic InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep InitBehavior :: Type -> Type # Methods from :: InitBehavior -> Rep InitBehavior x # to :: Rep InitBehavior x -> InitBehavior #
NFData InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Methods rnf :: InitBehavior -> () #
Hashable InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Methods hashWithSalt :: Int -> InitBehavior -> Int # hash :: InitBehavior -> Int #
type Rep InitBehavior Source #
Instance details Defined in Clash.Signal.Internal type Rep InitBehavior = D1 ('MetaData "InitBehavior" "Clash.Signal.Internal" "clash-prelude-1.5.0-inplace" 'False) (C1 ('MetaCons "Unknown" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Defined" 'PrefixI 'False) (U1 :: Type -> Type))

data SResetPolarity (polarity :: ResetPolarity) where Source #

Singleton version of ResetPolarity

Constructors

SActiveHigh :: SResetPolarity 'ActiveHigh
SActiveLow :: SResetPolarity 'ActiveLow

Instances

Instances details

Show (SResetPolarity polarity) Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> SResetPolarity polarity -> ShowS # show :: SResetPolarity polarity -> String # showList :: [SResetPolarity polarity] -> ShowS #

data ResetPolarity Source #

Determines the value for which a reset line is considered "active"

Constructors

ActiveHigh	Reset is considered active if underlying signal is `True`.
ActiveLow	Reset is considered active if underlying signal is `False`.

Instances

Instances details

Eq ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Methods (==) :: ResetPolarity -> ResetPolarity -> Bool # (/=) :: ResetPolarity -> ResetPolarity -> Bool #
Data ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ResetPolarity -> c ResetPolarity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ResetPolarity # toConstr :: ResetPolarity -> Constr # dataTypeOf :: ResetPolarity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ResetPolarity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ResetPolarity) # gmapT :: (forall b. Data b => b -> b) -> ResetPolarity -> ResetPolarity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ResetPolarity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ResetPolarity -> r # gmapQ :: (forall d. Data d => d -> u) -> ResetPolarity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ResetPolarity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ResetPolarity -> m ResetPolarity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ResetPolarity -> m ResetPolarity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ResetPolarity -> m ResetPolarity #
Ord ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Methods compare :: ResetPolarity -> ResetPolarity -> Ordering # (<) :: ResetPolarity -> ResetPolarity -> Bool # (<=) :: ResetPolarity -> ResetPolarity -> Bool # (>) :: ResetPolarity -> ResetPolarity -> Bool # (>=) :: ResetPolarity -> ResetPolarity -> Bool # max :: ResetPolarity -> ResetPolarity -> ResetPolarity # min :: ResetPolarity -> ResetPolarity -> ResetPolarity #
Read ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Methods readsPrec :: Int -> ReadS ResetPolarity # readList :: ReadS [ResetPolarity] # readPrec :: ReadPrec ResetPolarity # readListPrec :: ReadPrec [ResetPolarity] #
Show ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> ResetPolarity -> ShowS # show :: ResetPolarity -> String # showList :: [ResetPolarity] -> ShowS #
Generic ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep ResetPolarity :: Type -> Type # Methods from :: ResetPolarity -> Rep ResetPolarity x # to :: Rep ResetPolarity x -> ResetPolarity #
NFData ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Methods rnf :: ResetPolarity -> () #
Hashable ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Methods hashWithSalt :: Int -> ResetPolarity -> Int # hash :: ResetPolarity -> Int #
type Rep ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal type Rep ResetPolarity = D1 ('MetaData "ResetPolarity" "Clash.Signal.Internal" "clash-prelude-1.5.0-inplace" 'False) (C1 ('MetaCons "ActiveHigh" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ActiveLow" 'PrefixI 'False) (U1 :: Type -> Type))

data SResetKind (resetKind :: ResetKind) where Source #

Singleton version of ResetKind

Constructors

SAsynchronous :: SResetKind 'Asynchronous
SSynchronous :: SResetKind 'Synchronous

Instances

Instances details

Show (SResetKind reset) Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> SResetKind reset -> ShowS # show :: SResetKind reset -> String # showList :: [SResetKind reset] -> ShowS #

data ResetKind Source #

Constructors

Asynchronous	Elements respond asynchronously to changes in their reset input. This means that they do not wait for the next active clock edge, but respond immediately instead. Common on Intel FPGA platforms.
Synchronous	Elements respond synchronously to changes in their reset input. This means that changes in their reset input won't take effect until the next active clock edge. Common on Xilinx FPGA platforms.

Instances

Instances details

Eq ResetKind Source #
Instance details Defined in Clash.Signal.Internal Methods (==) :: ResetKind -> ResetKind -> Bool # (/=) :: ResetKind -> ResetKind -> Bool #
Data ResetKind Source #
Instance details Defined in Clash.Signal.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ResetKind -> c ResetKind # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ResetKind # toConstr :: ResetKind -> Constr # dataTypeOf :: ResetKind -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ResetKind) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ResetKind) # gmapT :: (forall b. Data b => b -> b) -> ResetKind -> ResetKind # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ResetKind -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ResetKind -> r # gmapQ :: (forall d. Data d => d -> u) -> ResetKind -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ResetKind -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ResetKind -> m ResetKind # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ResetKind -> m ResetKind # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ResetKind -> m ResetKind #
Ord ResetKind Source #
Instance details Defined in Clash.Signal.Internal Methods compare :: ResetKind -> ResetKind -> Ordering # (<) :: ResetKind -> ResetKind -> Bool # (<=) :: ResetKind -> ResetKind -> Bool # (>) :: ResetKind -> ResetKind -> Bool # (>=) :: ResetKind -> ResetKind -> Bool # max :: ResetKind -> ResetKind -> ResetKind # min :: ResetKind -> ResetKind -> ResetKind #
Read ResetKind Source #
Instance details Defined in Clash.Signal.Internal Methods readsPrec :: Int -> ReadS ResetKind # readList :: ReadS [ResetKind] # readPrec :: ReadPrec ResetKind # readListPrec :: ReadPrec [ResetKind] #
Show ResetKind Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> ResetKind -> ShowS # show :: ResetKind -> String # showList :: [ResetKind] -> ShowS #
Generic ResetKind Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep ResetKind :: Type -> Type # Methods from :: ResetKind -> Rep ResetKind x # to :: Rep ResetKind x -> ResetKind #
NFData ResetKind Source #
Instance details Defined in Clash.Signal.Internal Methods rnf :: ResetKind -> () #
Hashable ResetKind Source #
Instance details Defined in Clash.Signal.Internal Methods hashWithSalt :: Int -> ResetKind -> Int # hash :: ResetKind -> Int #
type Rep ResetKind Source #
Instance details Defined in Clash.Signal.Internal type Rep ResetKind = D1 ('MetaData "ResetKind" "Clash.Signal.Internal" "clash-prelude-1.5.0-inplace" 'False) (C1 ('MetaCons "Asynchronous" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Synchronous" 'PrefixI 'False) (U1 :: Type -> Type))

data SActiveEdge (edge :: ActiveEdge) where Source #

Singleton version of ActiveEdge

Constructors

SRising :: SActiveEdge 'Rising
SFalling :: SActiveEdge 'Falling

Instances

Instances details

Show (SActiveEdge edge) Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> SActiveEdge edge -> ShowS # show :: SActiveEdge edge -> String # showList :: [SActiveEdge edge] -> ShowS #

data ActiveEdge Source #

Determines clock edge memory elements are sensitive to. Not yet implemented.

Constructors

Rising	Elements are sensitive to the rising edge (low-to-high) of the clock.
Falling	Elements are sensitive to the falling edge (high-to-low) of the clock.

Instances

Instances details

Eq ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Methods (==) :: ActiveEdge -> ActiveEdge -> Bool # (/=) :: ActiveEdge -> ActiveEdge -> Bool #
Data ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ActiveEdge -> c ActiveEdge # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ActiveEdge # toConstr :: ActiveEdge -> Constr # dataTypeOf :: ActiveEdge -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ActiveEdge) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ActiveEdge) # gmapT :: (forall b. Data b => b -> b) -> ActiveEdge -> ActiveEdge # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ActiveEdge -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ActiveEdge -> r # gmapQ :: (forall d. Data d => d -> u) -> ActiveEdge -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ActiveEdge -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ActiveEdge -> m ActiveEdge # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ActiveEdge -> m ActiveEdge # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ActiveEdge -> m ActiveEdge #
Ord ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Methods compare :: ActiveEdge -> ActiveEdge -> Ordering # (<) :: ActiveEdge -> ActiveEdge -> Bool # (<=) :: ActiveEdge -> ActiveEdge -> Bool # (>) :: ActiveEdge -> ActiveEdge -> Bool # (>=) :: ActiveEdge -> ActiveEdge -> Bool # max :: ActiveEdge -> ActiveEdge -> ActiveEdge # min :: ActiveEdge -> ActiveEdge -> ActiveEdge #
Read ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Methods readsPrec :: Int -> ReadS ActiveEdge # readList :: ReadS [ActiveEdge] # readPrec :: ReadPrec ActiveEdge # readListPrec :: ReadPrec [ActiveEdge] #
Show ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Methods showsPrec :: Int -> ActiveEdge -> ShowS # show :: ActiveEdge -> String # showList :: [ActiveEdge] -> ShowS #
Generic ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep ActiveEdge :: Type -> Type # Methods from :: ActiveEdge -> Rep ActiveEdge x # to :: Rep ActiveEdge x -> ActiveEdge #
Binary ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Methods put :: ActiveEdge -> Put # get :: Get ActiveEdge # putList :: [ActiveEdge] -> Put #
NFData ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Methods rnf :: ActiveEdge -> () #
Hashable ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Methods hashWithSalt :: Int -> ActiveEdge -> Int # hash :: ActiveEdge -> Int #
type Rep ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal type Rep ActiveEdge = D1 ('MetaData "ActiveEdge" "Clash.Signal.Internal" "clash-prelude-1.5.0-inplace" 'False) (C1 ('MetaCons "Rising" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Falling" 'PrefixI 'False) (U1 :: Type -> Type))

vSystem :: VDomainConfiguration Source #

Convenience value to allow easy "subclassing" of System domain. Should be used in combination with createDomain. For example, if you just want to change the period but leave all other settings intact use:

createDomain vSystem{vName="System10", vPeriod=10}

vIntelSystem :: VDomainConfiguration Source #

Convenience value to allow easy "subclassing" of IntelSystem domain. Should be used in combination with createDomain. For example, if you just want to change the period but leave all other settings intact use:

createDomain vIntelSystem{vName="Intel10", vPeriod=10}

vXilinxSystem :: VDomainConfiguration Source #

Convenience value to allow easy "subclassing" of XilinxSystem domain. Should be used in combination with createDomain. For example, if you just want to change the period but leave all other settings intact use:

createDomain vXilinxSystem{vName="Xilinx10", vPeriod=10}

vDomain :: SDomainConfiguration dom conf -> VDomainConfiguration Source #

Convert SDomainConfiguration to VDomainConfiguration. Should be used in combination with createDomain only.

createDomain :: VDomainConfiguration -> Q [Dec] Source #

Convenience method to express new domains in terms of others.

createDomain (knownVDomain @System){vName="System10", vPeriod=10}

This duplicates the settings in the System domain, replaces the name and period, and creates an instance for it. As most users often want to update the system domain, a shortcut is available in the form:

createDomain vSystem{vName="System10", vPeriod=10}

The function will create two extra identifiers. The first:

type System10 = ..

You can use that as the dom to Clocks/Resets/Enables/Signals. For example: Signal System10 Int. Additionally, it will create a VDomainConfiguration that you can use in later calls to createDomain:

vSystem10 = knownVDomain @System10

It will also make System10 an instance of KnownDomain.

If either identifier is already in scope it will not be generated a second time. Note: This can be useful for example when documenting a new domain:

-- | Here is some documentation for CustomDomain
type CustomDomain = ("CustomDomain" :: Domain)

-- | Here is some documentation for vCustomDomain
createDomain vSystem{vName="CustomDomain"}

sameDomain :: forall (domA :: Domain) (domB :: Domain). (KnownDomain domA, KnownDomain domB) => Maybe (domA :~: domB) Source #

We either get evidence that this function was instantiated with the same domains, or Nothing.

fromEnable :: Enable dom -> Signal dom Bool Source #

Convert Enable construct to its underlying representation: a signal of bools.

toEnable :: Signal dom Bool -> Enable dom Source #

Convert a signal of bools to an Enable construct

enableGen :: Enable dom Source #

Enable generator for some domain. Is simply always True.

clockGen :: KnownDomain dom => Clock dom Source #

Clock generator for simulations. Do not use this clock generator for the testBench function, use tbClockGen instead.

To be used like:

clkSystem = clockGen @System

See DomainConfiguration for more information on how to use synthesis domains.

resetGen :: forall dom. KnownDomain dom => Reset dom Source #

Reset generator

To be used like:

rstSystem = resetGen @System

See tbClockGen for example usage.

resetGenN Source #

Arguments

:: forall dom n. (KnownDomain dom, 1 <= n)
=> SNat n	Number of initial cycles to hold reset high
-> Reset dom

Generate reset that's asserted for the first n cycles.

To be used like:

rstSystem5 = resetGen System (SNat 5)

Example usage:

>>> sampleN 7 (unsafeToHighPolarity (resetGenN @System (SNat @3)))
[True,True,True,False,False,False,False]

unsafeToHighPolarity :: forall dom. KnownDomain dom => Reset dom -> Signal dom Bool Source #

Convert a reset to an active high reset. Has no effect if reset is already an active high reset. Is unsafe because it can introduce:

meta-stability

For asynchronous resets it is unsafe because it can cause combinatorial loops. In case of synchronous resets it can lead to meta-stability in the presence of asynchronous resets.

unsafeToLowPolarity :: forall dom. KnownDomain dom => Reset dom -> Signal dom Bool Source #

Convert a reset to an active low reset. Has no effect if reset is already an active low reset. It is unsafe because it can introduce:

meta-stability

For asynchronous resets it is unsafe because it can cause combinatorial loops. In case of synchronous resets it can lead to meta-stability in the presence of asynchronous resets.

unsafeFromReset :: Reset dom -> Signal dom Bool Source #

unsafeFromReset is unsafe because it can introduce:

meta-stability

For asynchronous resets it is unsafe because it can cause combinatorial loops. In case of synchronous resets it can lead to meta-stability in the presence of asynchronous resets.

NB: You probably want to use unsafeToLowPolarity or unsafeToHighPolarity.

unsafeToReset :: Signal dom Bool -> Reset dom Source #

unsafeToReset is unsafe. For asynchronous resets it is unsafe because it can introduce combinatorial loops. In case of synchronous resets it can lead to meta-stability issues in the presence of asynchronous resets.

NB: You probably want to use unsafeFromLowPolarity or unsafeFromHighPolarity.

unsafeFromHighPolarity Source #

Arguments

:: forall dom. KnownDomain dom
=> Signal dom Bool	Reset signal that's `True` when active, and `False` when inactive.
-> Reset dom

Interpret a signal of bools as an active high reset and convert it to a reset signal corresponding to the domain's setting.

For asynchronous resets it is unsafe because it can cause combinatorial loops. In case of synchronous resets it can lead to meta-stability in the presence of asynchronous resets.

unsafeFromLowPolarity Source #

Arguments

:: forall dom. KnownDomain dom
=> Signal dom Bool	Reset signal that's `False` when active, and `True` when inactive.
-> Reset dom

Interpret a signal of bools as an active low reset and convert it to a reset signal corresponding to the domain's setting.

For asynchronous resets it is unsafe because it can cause combinatorial loops. In case of synchronous resets it can lead to meta-stability in the presence of asynchronous resets.

(.||.) :: Applicative f => f Bool -> f Bool -> f Bool infixr 2 Source #

The above type is a generalization for:

(.||.) :: Signal Bool -> Signal Bool -> Signal Bool

It is a version of (||) that returns a Signal of Bool

(.&&.) :: Applicative f => f Bool -> f Bool -> f Bool infixr 3 Source #

The above type is a generalization for:

(.&&.) :: Signal Bool -> Signal Bool -> Signal Bool

It is a version of (&&) that returns a Signal of Bool

mux :: Applicative f => f Bool -> f a -> f a -> f a Source #

The above type is a generalization for:

mux :: Signal Bool -> Signal a -> Signal a -> Signal a

A multiplexer. Given "mux b t f", output t when b is True, and f when b is False.

(.==.) :: (Eq a, Applicative f) => f a -> f a -> f Bool infix 4 Source #

The above type is a generalization for:

(.==.) :: Eq a => Signal a -> Signal a -> Signal Bool

It is a version of (==) that returns a Signal of Bool

(./=.) :: (Eq a, Applicative f) => f a -> f a -> f Bool infix 4 Source #

The above type is a generalization for:

(./=.) :: Eq a => Signal a -> Signal a -> Signal Bool

It is a version of (/=) that returns a Signal of Bool

(.<.) :: (Ord a, Applicative f) => f a -> f a -> f Bool infix 4 Source #

The above type is a generalization for:

(.<.) :: Ord a => Signal a -> Signal a -> Signal Bool

It is a version of (<) that returns a Signal of Bool

(.<=.) :: (Ord a, Applicative f) => f a -> f a -> f Bool infix 4 Source #

The above type is a generalization for:

(.<=.) :: Ord a => Signal a -> Signal a -> Signal Bool

It is a version of (<=) that returns a Signal of Bool

(.>.) :: (Ord a, Applicative f) => f a -> f a -> f Bool infix 4 Source #

The above type is a generalization for:

(.>.) :: Ord a => Signal a -> Signal a -> Signal Bool

It is a version of (>) that returns a Signal of Bool

(.>=.) :: (Ord a, Applicative f) => f a -> f a -> f Bool infix 4 Source #

The above type is a generalization for:

(.>=.) :: Ord a => Signal a -> Signal a -> Signal Bool

It is a version of (>=) that returns a Signal of Bool

fromList :: NFDataX a => [a] -> Signal dom a Source #

Create a Signal from a list

Every element in the list will correspond to a value of the signal for one clock cycle.

>>> sampleN 2 (fromList [1,2,3,4,5])
[1,2]

NB: This function is not synthesizable

fromList_lazy :: [a] -> Signal dom a Source #

Create a Signal from a list

Every element in the list will correspond to a value of the signal for one clock cycle.

>>> sampleN 2 (fromList [1,2,3,4,5] :: Signal System Int)
[1,2]

NB: This function is not synthesizable

hzToPeriod :: HasCallStack => Ratio Natural -> Natural Source #

Calculate the period, in ps, given a frequency in Hz

i.e. to calculate the clock period for a circuit to run at 240 MHz we get

>>> hzToPeriod 240e6
4166

NB: This function is not synthesizable

NB: This function is lossy. I.e., periodToHz . hzToPeriod /= id.

periodToHz :: Natural -> Ratio Natural Source #

Calculate the frequence in Hz, given the period in ps

i.e. to calculate the clock frequency of a clock with a period of 5000 ps:

>>> periodToHz 5000
200000000 % 1

NB: This function is not synthesizable

clockPeriod :: forall dom period. (KnownDomain dom, DomainPeriod dom ~ period) => SNat period Source #

Get the clock period from a KnownDomain context

activeEdge :: forall dom edge. (KnownDomain dom, DomainActiveEdge dom ~ edge) => SActiveEdge edge Source #

Get ActiveEdge from a KnownDomain context. Example usage:

f :: forall dom . KnownDomain dom => ....
f a b c =
  case activeEdge @dom of
    SRising -> foo
    SFalling -> bar

resetKind :: forall dom sync. (KnownDomain dom, DomainResetKind dom ~ sync) => SResetKind sync Source #

Get ResetKind from a KnownDomain context. Example usage:

f :: forall dom . KnownDomain dom => ....
f a b c =
  case resetKind @dom of
    SAsynchronous -> foo
    SSynchronous -> bar

initBehavior :: forall dom init. (KnownDomain dom, DomainInitBehavior dom ~ init) => SInitBehavior init Source #

Get InitBehavior from a KnownDomain context. Example usage:

f :: forall dom . KnownDomain dom => ....
f a b c =
  case initBehavior @dom of
    SDefined -> foo
    SUnknown -> bar

resetPolarity :: forall dom polarity. (KnownDomain dom, DomainResetPolarity dom ~ polarity) => SResetPolarity polarity Source #

Get ResetPolarity from a KnownDomain context. Example usage:

f :: forall dom . KnownDomain dom => ....
f a b c =
  case resetPolarity @dom of
    SActiveHigh -> foo
    SActiveLow -> bar

knownVDomain :: forall dom. KnownDomain dom => VDomainConfiguration Source #

Like 'knownDomain but yields a VDomainConfiguration. Should only be used in combination with createDomain.

data BiSignalOut (ds :: BiSignalDefault) (dom :: Domain) (n :: Nat) Source #

The out part of an inout port

Wraps (multiple) writing signals. The semantics are such that only one of the signals may write at a single time step.

BiSignalOut has the type role

>>> :i BiSignalOut
type role BiSignalOut nominal nominal nominal
...

as it is not safe to coerce the default behaviour, synthesis domain or width of the data in the signal.

Instances

Instances details

Semigroup (BiSignalOut defaultState dom n) Source #	NB Not synthesizable
Instance details Defined in Clash.Signal.BiSignal Methods (<>) :: BiSignalOut defaultState dom n -> BiSignalOut defaultState dom n -> BiSignalOut defaultState dom n # sconcat :: NonEmpty (BiSignalOut defaultState dom n) -> BiSignalOut defaultState dom n # stimes :: Integral b => b -> BiSignalOut defaultState dom n -> BiSignalOut defaultState dom n #
Monoid (BiSignalOut defaultState dom n) Source #	Monoid instance to support concatenating NB Not synthesizable
Instance details Defined in Clash.Signal.BiSignal Methods mempty :: BiSignalOut defaultState dom n # mappend :: BiSignalOut defaultState dom n -> BiSignalOut defaultState dom n -> BiSignalOut defaultState dom n # mconcat :: [BiSignalOut defaultState dom n] -> BiSignalOut defaultState dom n #
type HasDomain dom1 (BiSignalOut ds dom2 n) Source #
Instance details Defined in Clash.Signal.BiSignal type HasDomain dom1 (BiSignalOut ds dom2 n) = DomEq dom1 dom2
type TryDomain t (BiSignalOut ds dom n) Source #
Instance details Defined in Clash.Signal.BiSignal type TryDomain t (BiSignalOut ds dom n) = 'Found dom

data BiSignalIn (ds :: BiSignalDefault) (dom :: Domain) (n :: Nat) Source #

The in part of an inout port. BiSignalIn has the type role

>>> :i BiSignalIn
type role BiSignalIn nominal nominal nominal
...

as it is not safe to coerce the default behaviour, synthesis domain or width of the data in the signal.

data BiSignalDefault Source #

Used to specify the default behavior of a "BiSignal", i.e. what value is read when no value is being written to it.

Constructors

PullUp	inout port behaves as if connected to a pull-up resistor
PullDown	inout port behaves as if connected to a pull-down resistor
Floating	inout port behaves as if is floating. Reading a floating "BiSignal" value in simulation will yield an errorX (undefined value).

Instances

Instances details

Show BiSignalDefault Source #
Instance details Defined in Clash.Signal.BiSignal Methods showsPrec :: Int -> BiSignalDefault -> ShowS # show :: BiSignalDefault -> String # showList :: [BiSignalDefault] -> ShowS #

readFromBiSignal Source #

Arguments

:: (HasCallStack, BitPack a)
=> BiSignalIn ds d (BitSize a)	A `BiSignalIn` with a number of bits needed to represent a
-> Signal d a

Read the value from an inout port

mergeBiSignalOuts :: (HasCallStack, KnownNat n) => Vec n (BiSignalOut defaultState dom m) -> BiSignalOut defaultState dom m Source #

Combine several inout signals into one.

writeToBiSignal Source #

Arguments

:: (HasCallStack, BitPack a)
=> BiSignalIn ds d (BitSize a)
-> Signal d (Maybe a)	Value to write Just a writes an a value Nothing puts the port in a high-impedance state
-> BiSignalOut ds d (BitSize a)

Write to an inout port

veryUnsafeToBiSignalIn :: (HasCallStack, KnownNat n, Given (SBiSignalDefault ds)) => BiSignalOut ds d n -> BiSignalIn ds d n Source #

Converts the out part of a BiSignal to an in part. In simulation it checks whether multiple components are writing and will error accordingly. Make sure this is only called ONCE for every BiSignal.

class Bundle a where Source #

Isomorphism between a Signal of a product type (e.g. a tuple) and a product type of Signals.

Instances of Bundle must satisfy the following laws:

bundle . unbundle = id
unbundle . bundle = id

By default, bundle and unbundle, are defined as the identity, that is, writing:

data D = A | B

instance Bundle D

is the same as:

data D = A | B

instance Bundle D where
  type Unbundled clk D = Signal clk D
  bundle   s = s
  unbundle s = s

For custom product types you'll have to write the instance manually:

data Pair a b = MkPair { getA :: a, getB :: b }

instance Bundle (Pair a b) where
  type Unbundled dom (Pair a b) = Pair (Signal dom a) (Signal dom b)

  -- bundle :: Pair (Signal dom a) (Signal dom b) -> Signal dom (Pair a b)
  bundle   (MkPair as bs) = MkPair $ as * bs

  -- unbundle :: Signal dom (Pair a b) -> Pair (Signal dom a) (Signal dom b)
  unbundle pairs = MkPair (getA $ pairs) (getB $ pairs)

Minimal complete definition

Nothing

Associated Types

type Unbundled (dom :: Domain) a = res | res -> dom a Source #

type Unbundled dom a = Signal dom a

Methods

bundle :: Unbundled dom a -> Signal dom a Source #

Example:

bundle :: (Signal dom a, Signal dom b) -> Signal dom (a,b)

However:

bundle :: Signal dom Bit -> Signal dom Bit

default bundle :: Signal dom a ~ Unbundled dom a => Unbundled dom a -> Signal dom a Source #

unbundle :: Signal dom a -> Unbundled dom a Source #

Example:

unbundle :: Signal dom (a,b) -> (Signal dom a, Signal dom b)

However:

unbundle :: Signal dom Bit -> Signal dom Bit

default unbundle :: Unbundled dom a ~ Signal dom a => Signal dom a -> Unbundled dom a Source #

Instances

Instances details

Bundle Bool Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom Bool = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom Bool -> Signal dom Bool Source # unbundle :: forall (dom :: Domain). Signal dom Bool -> Unbundled dom Bool Source #
Bundle Double Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom Double = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom Double -> Signal dom Double Source # unbundle :: forall (dom :: Domain). Signal dom Double -> Unbundled dom Double Source #
Bundle Float Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom Float = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom Float -> Signal dom Float Source # unbundle :: forall (dom :: Domain). Signal dom Float -> Unbundled dom Float Source #
Bundle Int Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom Int = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom Int -> Signal dom Int Source # unbundle :: forall (dom :: Domain). Signal dom Int -> Unbundled dom Int Source #
Bundle Integer Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom Integer = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom Integer -> Signal dom Integer Source # unbundle :: forall (dom :: Domain). Signal dom Integer -> Unbundled dom Integer Source #
Bundle () Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom () = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom () -> Signal dom () Source # unbundle :: forall (dom :: Domain). Signal dom () -> Unbundled dom () Source #
Bundle Bit Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom Bit = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom Bit -> Signal dom Bit Source # unbundle :: forall (dom :: Domain). Signal dom Bit -> Unbundled dom Bit Source #
Bundle EmptyTuple Source #	See commit 94b0bff5 and documentation for `TaggedEmptyTuple`.
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom EmptyTuple = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom EmptyTuple -> Signal dom EmptyTuple Source # unbundle :: forall (dom :: Domain). Signal dom EmptyTuple -> Unbundled dom EmptyTuple Source #
Bundle (Maybe a) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (Maybe a) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (Maybe a) -> Signal dom (Maybe a) Source # unbundle :: forall (dom :: Domain). Signal dom (Maybe a) -> Unbundled dom (Maybe a) Source #
Bundle (BitVector n) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (BitVector n) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (BitVector n) -> Signal dom (BitVector n) Source # unbundle :: forall (dom :: Domain). Signal dom (BitVector n) -> Unbundled dom (BitVector n) Source #
Bundle (Index n) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (Index n) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (Index n) -> Signal dom (Index n) Source # unbundle :: forall (dom :: Domain). Signal dom (Index n) -> Unbundled dom (Index n) Source #
Bundle (Unsigned n) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (Unsigned n) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (Unsigned n) -> Signal dom (Unsigned n) Source # unbundle :: forall (dom :: Domain). Signal dom (Unsigned n) -> Unbundled dom (Unsigned n) Source #
Bundle (Signed n) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (Signed n) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (Signed n) -> Signal dom (Signed n) Source # unbundle :: forall (dom :: Domain). Signal dom (Signed n) -> Unbundled dom (Signed n) Source #
Bundle (Either a b) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (Either a b) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (Either a b) -> Signal dom (Either a b) Source # unbundle :: forall (dom :: Domain). Signal dom (Either a b) -> Unbundled dom (Either a b) Source #
Bundle (a1, a2) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (a1, a2) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (a1, a2) -> Signal dom (a1, a2) Source # unbundle :: forall (dom :: Domain). Signal dom (a1, a2) -> Unbundled dom (a1, a2) Source #
KnownNat n => Bundle (Vec n a) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (Vec n a) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (Vec n a) -> Signal dom (Vec n a) Source # unbundle :: forall (dom :: Domain). Signal dom (Vec n a) -> Unbundled dom (Vec n a) Source #
KnownNat d => Bundle (RTree d a) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (RTree d a) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (RTree d a) -> Signal dom (RTree d a) Source # unbundle :: forall (dom :: Domain). Signal dom (RTree d a) -> Unbundled dom (RTree d a) Source #
Bundle (a1, a2, a3) Source #	N.B.: The documentation only shows 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.
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (a1, a2, a3) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3) -> Signal dom (a1, a2, a3) Source # unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3) -> Unbundled dom (a1, a2, a3) Source #
Bundle (Fixed rep int frac) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (Fixed rep int frac) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (Fixed rep int frac) -> Signal dom (Fixed rep int frac) Source # unbundle :: forall (dom :: Domain). Signal dom (Fixed rep int frac) -> Unbundled dom (Fixed rep int frac) Source #
Bundle ((f :*: g) a) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom ((f :: g) a) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom ((f :: g) a) -> Signal dom ((f :: g) a) Source # unbundle :: forall (dom :: Domain). Signal dom ((f :: g) a) -> Unbundled dom ((f :*: g) a) Source #

data TaggedEmptyTuple (dom :: Domain) Source #

Helper type to emulate the "old" behavior of Bundle's unit instance. I.e., the instance for Bundle () used to be defined as:

class Bundle () where
  bundle   :: () -> Signal dom ()
  unbundle :: Signal dom () -> ()

In order to have sensible type inference, the Bundle class specifies that the argument type of bundle should uniquely identify the result type, and vice versa for unbundle. The type signatures in the snippet above don't though, as () doesn't uniquely map to a specific domain. In other words, domain should occur in both the argument and result of both functions.

TaggedEmptyTuple tackles this by carrying the domain in its type. The bundle and unbundle instance now looks like:

class Bundle EmptyTuple where
  bundle   :: TaggedEmptyTuple dom -> Signal dom EmptyTuple
  unbundle :: Signal dom EmptyTuple -> TaggedEmptyTuple dom

dom is now mentioned both the argument and result for both bundle and unbundle.

Constructors

TaggedEmptyTuple

data EmptyTuple Source #

See TaggedEmptyTuple

Constructors

EmptyTuple

Instances

Instances details

Bundle EmptyTuple Source #	See commit 94b0bff5 and documentation for `TaggedEmptyTuple`.
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom EmptyTuple = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom EmptyTuple -> Signal dom EmptyTuple Source # unbundle :: forall (dom :: Domain). Signal dom EmptyTuple -> Unbundled dom EmptyTuple Source #
Bundle EmptyTuple Source #	See commit 94b0bff5 and documentation for `TaggedEmptyTuple`.
Instance details Defined in Clash.Signal.Delayed.Bundle Associated Types type Unbundled dom d EmptyTuple = (res :: Type) Source # Methods bundle :: forall (dom :: Domain) (d :: Nat). Unbundled dom d EmptyTuple -> DSignal dom d EmptyTuple Source # unbundle :: forall (dom :: Domain) (d :: Nat). DSignal dom d EmptyTuple -> Unbundled dom d EmptyTuple Source #
type Unbundled dom EmptyTuple Source #
Instance details Defined in Clash.Signal.Bundle type Unbundled dom EmptyTuple = TaggedEmptyTuple dom
type Unbundled dom d EmptyTuple Source #
Instance details Defined in Clash.Signal.Delayed.Bundle type Unbundled dom d EmptyTuple = TaggedEmptyTuple dom d

systemClockGen :: Clock System Source #

Clock generator for the System clock domain.

NB: should only be used for simulation, and not for the testBench function. For the testBench function, used tbSystemClockGen

systemResetGen :: Reset System Source #

Reset generator for the System clock domain.

NB: should only be used for simulation or the testBench function.

Example

Expand

topEntity :: Vec 2 (Vec 3 (Unsigned 8)) -> Vec 6 (Unsigned 8)
topEntity = concat

testBench :: Signal System Bool
testBench = done
  where
    testInput      = pure ((1 :> 2 :> 3 :> Nil) :> (4 :> 5 :> 6 :> Nil) :> Nil)
    expectedOutput = outputVerifier' ((1:>2:>3:>4:>5:>6:>Nil):>Nil)
    done           = exposeClockResetEnable (expectedOutput (topEntity $ testInput)) clk rst
    clk            = tbSystemClockGen (not <$> done)
    rst            = systemResetGen

resetSynchronizer :: forall dom. KnownDomain dom => Clock dom -> Reset dom -> Reset dom Source #

The resetSynchronizer will synchronize an incoming reset according to whether the domain is synchronous or asynchronous.

For asynchronous resets this synchronizer ensures the reset will only be de-asserted synchronously but it can still be asserted asynchronously. The reset assert is immediate, but reset de-assertion is delayed by two cycles.

Normally, asynchronous resets can be both asynchronously asserted and de-asserted. Asynchronous de-assertion can induce meta-stability in the component which is being reset. To ensure this doesn't happen, resetSynchronizer ensures that de-assertion of a reset happens synchronously. Assertion of the reset remains asynchronous.

Note that asynchronous assertion does not induce meta-stability in the component whose reset is asserted. However, when a component "A" in another clock or reset domain depends on the value of a component "B" being reset, then asynchronous assertion of the reset of component "B" can induce meta-stability in component "A". To prevent this from happening you need to use a proper synchronizer, for example one of the synchronizers in Clash.Explicit.Synchronizer.

For synchronous resets this function ensures that the reset is asserted and de-asserted synchronously. Both the assertion and de-assertion of the reset are delayed by two cycles.

Example 1

Expand

The circuit below detects a rising bit (i.e., a transition from 0 to 1) in a given argument. It takes a reset that is not synchronized to any of the other incoming signals and synchronizes it using resetSynchronizer.

topEntity
  :: Clock  System
  -> Reset  System
  -> Signal System Bit
  -> Signal System (BitVector 8)
topEntity clk asyncRst key1 =
  withClockResetEnable clk rst enableGen leds
 where
  rst   = resetSynchronizer clk asyncRst
  key1R = isRising 1 key1
  leds  = mealy blinkerT (1, False, 0) key1R

Example 2

Expand

Similar to Example 1 this circuit detects a rising bit (i.e., a transition from 0 to 1) in a given argument. It takes a clock that is not stable yet and a reset singal that is not synchronized to any other signals. It stabalizes the clock and then synchronizes the reset signal.

topEntity
  :: Clock  System
  -> Reset  System
  -> Signal System Bit
  -> Signal System (BitVector 8)
topEntity clk rst key1 =
    let  (pllOut,pllStable) = altpll (SSymbol @"altpll50") clk rst
         rstSync            = resetSynchronizer pllOut (unsafeToHighPolarity pllStable)
    in   exposeClockResetEnable leds pllOut rstSync enableGen
  where
    key1R  = isRising 1 key1
    leds   = mealy blinkerT (1, False, 0) key1R

Implementation details

Expand

resetSynchronizer implements the following circuit for asynchronous domains:

                                  rst
  --------------------------------------+
                      |                 |
                 +----v----+       +----v----+
    deasserted   |         |       |         |
  --------------->         +------->         +-------->
                 |         |       |         |
             +---|>        |   +---|>        |
             |   |         |   |   |         |
             |   +---------+   |   +---------+
     clk     |                 |
  -----------------------------+

This corresponds to figure 3d at https://www.embedded.com/asynchronous-reset-synchronization-and-distribution-challenges-and-solutions/

For synchronous domains two sequential dflipflops are used:

                 +---------+       +---------+
    rst          |         |       |         |
  --------------->         +------->         +-------->
                 |         |       |         |
             +---|>        |   +---|>        |
             |   |         |   |   |         |
             |   +---------+   |   +---------+
     clk     |                 |
  -----------------------------+

resetGlitchFilter Source #

Arguments

:: forall dom glitchlessPeriod n. (KnownDomain dom, glitchlessPeriod ~ (n + 1))
=> SNat glitchlessPeriod	Consider a reset signal to be properly asserted after having seen the reset asserted for glitchlessPeriod cycles straight.
-> Clock dom
-> Reset dom
-> Reset dom

Filter glitches from reset signals by only triggering a reset after it has been asserted for glitchlessPeriod cycles. It will then stay asserted for as long as the given reset was asserted consecutively.

If synthesized on a domain with initial values, resetGlitchFilter will output an asserted reset for glitchlessPeriod cycles (plus any cycles added by the given reset). If initial values can't be used, it will only output defined reset values after glitchlessPeriod cycles.

Example 1

Expand

>>> let sampleResetN n = sampleN n . unsafeToHighPolarity
>>> let resetFromList = unsafeFromHighPolarity . fromList
>>> let rst = resetFromList [True, True, False, False, True, False, False, True, True, False, True]
>>> sampleResetN 12 (resetGlitchFilter d2 systemClockGen rst)
[True,True,True,True,False,False,False,False,False,True,True,False]

type SystemClockResetEnable = (Hidden (HiddenClockName System) (Clock System), Hidden (HiddenResetName System) (Reset System), Hidden (HiddenEnableName System) (Enable System)) Source #

A constraint that indicates the component needs a Clock, a Reset, and an Enable belonging to the System domain.

Click here to read more about hidden clocks, resets, and enables

type HiddenClockResetEnable dom = (HiddenClock dom, HiddenReset dom, HiddenEnable dom) Source #

A constraint that indicates the component needs a Clock, a Reset, and an Enable belonging to the same dom.

Click here to read more about hidden clocks, resets, and enables

type HiddenEnable dom = (Hidden (HiddenEnableName dom) (Enable dom), KnownDomain dom) Source #

A constraint that indicates the component needs an Enable

Click here to read more about hidden clocks, resets, and enables

type HiddenReset dom = (Hidden (HiddenResetName dom) (Reset dom), KnownDomain dom) Source #

A constraint that indicates the component needs a Reset

Click here to read more about hidden clocks, resets, and enables

type HiddenClock dom = (Hidden (HiddenClockName dom) (Clock dom), KnownDomain dom) Source #

A constraint that indicates the component has a hidden Clock

Click here to read more about hidden clocks, resets, and enables

exposeClock Source #

Arguments

:: forall dom r. WithSingleDomain dom r
=> (HiddenClock dom => r)	The component with a hidden clock
-> KnownDomain dom => Clock dom -> r	The component with its clock argument exposed

Expose a hidden Clock argument of a component, so it can be applied explicitly.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenClock dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenClock dom => Signal dom a -> Signal dom a

If you want to expose a clock of a component working on multiple domains (such as the first example), use exposeSpecificClock.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> sig = exposeClock reg clockGen
>>> sampleN @System 10 sig
[5,5,6,7,8,9,10,11,12,13]

Force exposeClock to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> sig = exposeClock @System reg clockGen
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

exposeSpecificClock Source #

Arguments

:: forall dom r. WithSpecificDomain dom r
=> (HiddenClock dom => r)	The component with a hidden clock
-> KnownDomain dom => Clock dom -> r	The component with its clock argument exposed

Expose a hidden Clock argument of a component, so it can be applied explicitly. This function can be used on components with multiple domains. As opposed to exposeClock, callers should explicitly state what the clock domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

exposeSpecificClock can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> sig = exposeSpecificClock @System reg clockGen
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
sig = exposeSpecificClock @dom reg clockGen

hideClock Source #

Arguments

:: forall dom r. HiddenClock dom
=> (Clock dom -> r)	Function whose clock argument you want to hide
-> r

Hide the Clock argument of a component, so it can be routed implicitly.

Click here to read more about hidden clocks, resets, and enables

withClock Source #

Arguments

:: forall dom r. WithSingleDomain dom r
=> KnownDomain dom
=> Clock dom	The `Clock` we want to connect
-> (HiddenClock dom => r)	The function with a hidden `Clock` argument
-> r

Connect an explicit Clock to a function with a hidden Clock.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenClock dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenClock dom => Signal dom a -> Signal dom a

If you want to connect a clock to a component working on multiple domains (such as the first example), use withSpecificClock.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> sig = withClock clockGen reg
>>> sampleN @System 10 sig
[5,5,6,7,8,9,10,11,12,13]

Force withClock to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> sig = withClock @System clockGen reg
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

withSpecificClock Source #

Arguments

:: forall dom r. (KnownDomain dom, WithSpecificDomain dom r)
=> Clock dom	The `Clock` we want to connect
-> (HiddenClock dom => r)	The function with a hidden `Clock` argument
-> r

Connect an explicit Clock to a function with a hidden Clock. This function can be used on components with multiple domains. As opposed to withClock, callers should explicitly state what the clock domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

withSpecificClock can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> sig = withSpecificClock @System clockGen reg
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
sig = withSpecificClock @dom clockGen reg

hasClock :: forall dom. HiddenClock dom => Clock dom Source #

Connect a hidden Clock to an argument where a normal Clock argument was expected.

Click here to read more about hidden clocks, resets, and enables

exposeReset Source #

Arguments

:: forall dom r. WithSingleDomain dom r
=> (HiddenReset dom => r)	The component with a hidden reset
-> KnownDomain dom => Reset dom -> r	The component with its reset argument exposed

Expose a hidden Reset argument of a component, so it can be applied explicitly.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenReset dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenReset dom => Signal dom a -> Signal dom a

If you want to expose a reset of a component working on multiple domains (such as the first example), use exposeSpecificReset.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> sig = exposeReset reg resetGen
>>> sampleN @System 10 sig
[5,5,6,7,8,9,10,11,12,13]

Force exposeReset to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> sig = exposeReset @System reg resetGen
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

exposeSpecificReset Source #

Arguments

:: forall dom r. WithSpecificDomain dom r
=> (HiddenReset dom => r)	The component with a hidden reset
-> KnownDomain dom => Reset dom -> r	The component with its reset argument exposed

Expose a hidden Reset argument of a component, so it can be applied explicitly. This function can be used on components with multiple domains. As opposed to exposeReset, callers should explicitly state what the reset domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

exposeSpecificReset can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> sig = exposeSpecificReset @System reg resetGen
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
sig = exposeSpecificReset @dom reg resetGen

hideReset Source #

Arguments

:: forall dom r. HiddenReset dom
=> (Reset dom -> r)	Component whose reset argument you want to hide
-> r

Hide the Reset argument of a component, so it can be routed implicitly.

Click here to read more about hidden clocks, resets, and enables

withReset Source #

Arguments

:: forall dom r. WithSingleDomain dom r
=> KnownDomain dom
=> Reset dom	The `Reset` we want to connect
-> (HiddenReset dom => r)	The function with a hidden `Reset` argument
-> r

Connect an explicit Reset to a function with a hidden Reset.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenReset dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenReset dom => Signal dom a -> Signal dom a

If you want to connect a reset to a component working on multiple domains (such as the first example), use withSpecificReset.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> sig = withReset resetGen reg
>>> sampleN @System 10 sig
[5,5,6,7,8,9,10,11,12,13]

Force withReset to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> sig = withReset @System resetGen reg
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

withSpecificReset Source #

Arguments

:: forall dom r. (KnownDomain dom, WithSpecificDomain dom r)
=> Reset dom	The `Reset` we want to connect
-> (HiddenReset dom => r)	The function with a hidden `Reset` argument
-> r

Connect an explicit Reset to a function with a hidden Reset. This function can be used on components with multiple domains. As opposed to withReset, callers should explicitly state what the reset domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

withSpecificReset can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> sig = withSpecificReset @System resetGen reg
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
sig = withSpecificReset @dom resetGen reg

hasReset :: forall dom. HiddenReset dom => Reset dom Source #

Connect a hidden Reset to an argument where a normal Reset argument was expected.

Click here to read more about hidden clocks, resets, and enables

exposeEnable Source #

Arguments

:: forall dom r. WithSingleDomain dom r
=> (HiddenEnable dom => r)	The component with a hidden enable
-> KnownDomain dom => Enable dom -> r	The component with its enable argument exposed

Expose a hidden Enable argument of a component, so it can be applied explicitly.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenEnable dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenEnable dom => Signal dom a -> Signal dom a

If you want to expose a enable of a component working on multiple domains (such as the first example), use exposeSpecificEnable.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> sig = exposeEnable reg enableGen
>>> sampleN @System 10 sig
[5,5,6,7,8,9,10,11,12,13]

Force exposeEnable to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> sig = exposeEnable @System reg enableGen
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

exposeSpecificEnable Source #

Arguments

:: forall dom r. WithSpecificDomain dom r
=> (HiddenEnable dom => r)	The component with a hidden enable
-> KnownDomain dom => Enable dom -> r	The component with its enable argument exposed

Expose a hidden Enable argument of a component, so it can be applied explicitly. This function can be used on components with multiple domains. As opposed to exposeEnable, callers should explicitly state what the enable domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

exposeSpecificEnable can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> sig = exposeSpecificEnable @System reg enableGen
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
sig = exposeSpecificEnable @dom reg enableGen

hideEnable Source #

Arguments

:: forall dom r. HiddenEnable dom
=> (Enable dom -> r)	Component whose enable argument you want to hide
-> r

Hide the Enable argument of a component, so it can be routed implicitly.

Click here to read more about hidden clocks, resets, and enables

withEnable Source #

Arguments

:: forall dom r. KnownDomain dom
=> WithSingleDomain dom r
=> Enable dom	The `Enable` we want to connect
-> (HiddenEnable dom => r)	The function with a hidden `Enable` argument
-> r

Connect an explicit Enable to a function with a hidden Enable.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenEnable dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenEnable dom => Signal dom a -> Signal dom a

If you want to connect a enable to a component working on multiple domains (such as the first example), use withSpecificEnable.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> sig = withEnable enableGen reg
>>> sampleN @System 10 sig
[5,5,6,7,8,9,10,11,12,13]

Force withEnable to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> sig = withEnable @System enableGen reg
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

withSpecificEnable Source #

Arguments

:: forall dom r. (KnownDomain dom, WithSpecificDomain dom r)
=> Enable dom	The `Enable` we want to connect
-> (HiddenEnable dom => r)	The function with a hidden `Enable` argument
-> r

Connect an explicit Enable to a function with a hidden Enable. This function can be used on components with multiple domains. As opposed to withEnable, callers should explicitly state what the enable domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

withSpecificEnable can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> sig = withSpecificEnable @System enableGen reg
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
sig = withSpecificEnable @dom enableGen reg

hasEnable :: forall dom. HiddenEnable dom => Enable dom Source #

Connect a hidden Enable to an argument where a normal Enable argument was expected.

Click here to read more about hidden clocks, resets, and enables

andEnable Source #

Arguments

:: forall dom r. HiddenEnable dom
=> WithSingleDomain dom r
=> Signal dom Bool	The signal to AND with
-> (HiddenEnable dom => r)	The component whose enable is modified
-> r

Merge enable signal with signal of bools by applying the boolean AND operation.

NB: The component given to andEnable as an argument needs an explicit type signature. Please read Monomorphism restriction leads to surprising behavior.

The component whose enable is modified will only be enabled when both the encompassing HiddenEnable and the Signal dom Bool are asserted.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenEnable dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenEnable dom => Signal dom a -> Signal dom a

If you want to merge an enable of a component working on multiple domains (such as the first example), use andSpecificEnable.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> f en = andEnable en reg
>>> sampleN @System 10 (f (riseEvery d2))
[5,5,5,6,6,7,7,8,8,9]

Force andEnable to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> f en = andEnable @System en reg
>>> sampleN 10 (f (riseEvery d2))
[5,5,5,6,6,7,7,8,8,9]

andSpecificEnable Source #

Arguments

:: forall dom r. (HiddenEnable dom, WithSpecificDomain dom r)
=> Signal dom Bool	The signal to AND with
-> (HiddenEnable dom => r)	The component whose enable is modified
-> r

Merge enable signal with signal of bools by applying the boolean AND operation.

NB: The component given to andSpecificEnable as an argument needs an explicit type signature. Please read Monomorphism restriction leads to surprising behavior.

The component whose enable is modified will only be enabled when both the encompassing HiddenEnable and the Signal dom Bool are asserted.

This function can be used on components with multiple domains. As opposed to andEnable, callers should explicitly state what the enable domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

andSpecificEnable can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> f en = andSpecificEnable @System en reg
>>> sampleN 10 (f (riseEvery d2))
[5,5,5,6,6,7,7,8,8,9]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
f en = andSpecificEnable @dom en reg

exposeClockResetEnable Source #

Arguments

:: forall dom r. WithSingleDomain dom r
=> (HiddenClockResetEnable dom => r)	The component with hidden clock, reset, and enable arguments
-> KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> r	The component with its clock, reset, and enable arguments exposed

Expose hidden Clock, Reset, and Enable arguments of a component, so they can be applied explicitly.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenClockResetEnable dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenClockResetEnable dom => Signal dom a -> Signal dom a

If you want to expose a clock, reset, and enable of a component working on multiple domains (such as the first example), use exposeSpecificClockResetEnable.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> sig = exposeClockResetEnable reg clockGen resetGen enableGen
>>> sampleN @System 10 sig
[5,5,6,7,8,9,10,11,12,13]

Force exposeClockResetEnable to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> sig = exposeClockResetEnable @System reg clockGen resetGen enableGen
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Usage in a testbench context:

topEntity :: Vec 2 (Vec 3 (Unsigned 8)) -> Vec 6 (Unsigned 8)
topEntity = concat

testBench :: Signal System Bool
testBench = done
  where
    testInput      = pure ((1 :> 2 :> 3 :> Nil) :> (4 :> 5 :> 6 :> Nil) :> Nil)
    expectedOutput = outputVerifier' ((1:>2:>3:>4:>5:>6:>Nil):>Nil)
    done           = exposeClockResetEnable (expectedOutput (topEntity <$> testInput)) clk rst en
    clk            = tbSystemClockGen (not <$> done)
    rst            = systemResetGen
    en             = enableGen

exposeSpecificClockResetEnable Source #

Arguments

:: forall dom r. WithSpecificDomain dom r
=> (HiddenClockResetEnable dom => r)	The function with hidden `Clock`, `Reset`, and `Enable` arguments
-> KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> r	The component with its `Clock`, `Reset`, and `Enable` arguments exposed

Expose hidden Clock, Reset, and Enable arguments of a component, so they can be applied explicitly. This function can be used on components with multiple domains. As opposed to exposeClockResetEnable, callers should explicitly state what the domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

exposeSpecificClockResetEnable can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> sig = exposeSpecificClockResetEnable @System reg clockGen resetGen enableGen
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
sig = exposeSpecificClockResetEnable @dom reg clockGen resetGen enableGen

hideClockResetEnable Source #

Arguments

:: forall dom r. HiddenClockResetEnable dom
=> (KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> r)	Component whose clock, reset, and enable argument you want to hide
-> r

Hide the Clock, Reset, and Enable arguments of a component, so they can be routed implicitly.

Click here to read more about hidden clocks, resets, and enables

withClockResetEnable Source #

Arguments

:: forall dom r. KnownDomain dom
=> WithSingleDomain dom r
=> Clock dom	The `Clock` we want to connect
-> Reset dom	The `Reset` we want to connect
-> Enable dom	The `Enable` we want to connect
-> (HiddenClockResetEnable dom => r)	The function with a hidden `Clock`, hidden `Reset`, and hidden `Enable` argument
-> r

Connect an explicit Clock, Reset, and Enable to a function with a hidden Clock, Reset, and Enable.

This function can only be used on components with a single domain. For example, this function will refuse when:

r ~ HiddenClockResetEnable dom1 => Signal dom1 a -> Signal dom2 a

But will work when:

r ~ HiddenClockResetEnable dom => Signal dom a -> Signal dom a

If you want to connect a clock, reset, and enable to a component working on multiple domains (such as the first example), use withSpecificClockResetEnable.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

Usage with a polymorphic domain:

>>> reg = register 5 (reg + 1)
>>> sig = withClockResetEnable clockGen resetGen enableGen reg
>>> sampleN @System 10 sig
[5,5,6,7,8,9,10,11,12,13]

Force withClockResetEnable to work on System (hence sampleN not needing an explicit domain later):

>>> reg = register 5 (reg + 1)
>>> sig = withClockResetEnable @System clockGen resetGen enableGen reg
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

withSpecificClockResetEnable Source #

Arguments

:: forall dom r. (KnownDomain dom, WithSpecificDomain dom r)
=> Clock dom	The `Clock` we want to connect
-> Reset dom	The `Reset` we want to connect
-> Enable dom	The `Enable` we want to connect
-> (HiddenClockResetEnable dom => r)	The function with hidden `Clock`, `Reset`, and `Enable` arguments
-> r

Connect an explicit Clock, Reset, and Enable to a function with hidden Clock, Reset, and Enable arguments. This function can be used on components with multiple domains. As opposed to withClockResetEnable, callers should explicitly state what the domain is. See the examples for more information.

Click here to read more about hidden clocks, resets, and enables

Example

Expand

withSpecificClockResetEnable can only be used when it can find the specified domain in r:

>>> reg = register @System 5 (reg + 1)
>>> sig = withSpecificClockResetEnable @System clockGen resetGen enableGen reg
>>> sampleN 10 sig
[5,5,6,7,8,9,10,11,12,13]

Type variables work too, if they are in scope. For example:

reg = register @dom 5 (reg + 1)
sig = withSpecificClockResetEnable @dom clockGen resetGen enableGen reg

dflipflop :: forall dom a. (HiddenClock dom, NFDataX a) => Signal dom a -> Signal dom a Source #

Special version of delay that doesn't take enable signals of any kind. Initial value will be undefined.

delay Source #

Arguments

:: forall dom a. (NFDataX a, HiddenClock dom, HiddenEnable dom)
=> a	Initial value
-> Signal dom a	Signal to delay
-> Signal dom a

delay dflt s delays the values in Signal s for once cycle, the value at time 0 is dflt.

>>> sampleN @System 3 (delay 0 (fromList [1,2,3,4]))
[0,1,2]

delayMaybe Source #

Arguments

:: forall dom a. (NFDataX a, HiddenClock dom, HiddenEnable dom)
=> a	Initial value
-> Signal dom (Maybe a)
-> Signal dom a

Version of delay that only updates when its second argument is a Just value.

>>> let input = fromList [Just 1, Just 2, Nothing, Nothing, Just 5, Just 6, Just (7::Int)]
>>> sampleN @System 7 (delayMaybe 0 input)
[0,1,2,2,2,5,6]

delayEn Source #

Arguments

:: forall dom a. (NFDataX a, HiddenClock dom, HiddenEnable dom)
=> a	Initial value
-> Signal dom Bool	Enable
-> Signal dom a
-> Signal dom a

Version of delay that only updates when its second argument is asserted.

>>> let input = fromList [1,2,3,4,5,6,7::Int]
>>> let enable = fromList [True,True,False,False,True,True,True]
>>> sampleN @System 7 (delayEn 0 enable input)
[0,1,2,2,2,5,6]

register infixr 3 Source #

Arguments

:: forall dom a. (HiddenClockResetEnable dom, NFDataX a)
=> a	Reset value. `register` outputs the reset value when the reset is active. If the domain has initial values enabled, the reset value will also be the initial value.
-> Signal dom a
-> Signal dom a

register i s delays the values in Signal s for one cycle, and sets the value at time 0 to i

>>> sampleN @System 5 (register 8 (fromList [1,1,2,3,4]))
[8,8,1,2,3]

regMaybe infixr 3 Source #

Arguments

:: forall dom a. (HiddenClockResetEnable dom, NFDataX a)
=> a	Reset value. `regMaybe` outputs the reset value when the reset is active. If the domain has initial values enabled, the reset value will also be the initial value.
-> Signal dom (Maybe a)
-> Signal dom a

Version of register that only updates its content when its second argument is a Just value. So given:

sometimes1 = s where
  s = register Nothing (switch <$> s)

  switch Nothing = Just 1
  switch _       = Nothing

countSometimes = s where
  s     = regMaybe 0 (plusM (pure <$> s) sometimes1)
  plusM = liftA2 (liftA2 (+))

We get:

>>> sampleN @System 9 sometimes1
[Nothing,Nothing,Just 1,Nothing,Just 1,Nothing,Just 1,Nothing,Just 1]
>>> sampleN @System 9 countSometimes
[0,0,0,1,1,2,2,3,3]

regEn Source #

Arguments

:: forall dom a. (HiddenClockResetEnable dom, NFDataX a)
=> a	Reset value. `regEn` outputs the reset value when the reset is active. If the domain has initial values enabled, the reset value will also be the initial value.
-> Signal dom Bool
-> Signal dom a
-> Signal dom a

Version of register that only updates its content when its second argument is asserted. So given:

oscillate = register False (not <$> oscillate)
count     = regEn 0 oscillate (count + 1)

We get:

>>> sampleN @System 9 oscillate
[False,False,True,False,True,False,True,False,True]
>>> sampleN @System 9 count
[0,0,0,1,1,2,2,3,3]

sample Source #

Arguments

:: forall dom a. (KnownDomain dom, NFDataX a)
=> (HiddenClockResetEnable dom => Signal dom a)	`Signal` we want to sample, whose source potentially has a hidden clock (and reset)
-> [a]

Get an infinite list of samples from a Signal

The elements in the list correspond to the values of the Signal at consecutive clock cycles

sample s == [s0, s1, s2, s3, ...

If the given component has not yet been given a clock, reset, or enable line, sample will supply them. The reset will be asserted for a single cycle. sample will not drop the value produced by the circuit while the reset was asserted. If you want this, or if you want more than a single cycle reset, consider using sampleWithReset.

NB: This function is not synthesizable

sampleN Source #

Arguments

:: forall dom a. (KnownDomain dom, NFDataX a)
=> Int	Number of samples to produce
-> (HiddenClockResetEnable dom => Signal dom a)	`Signal` to sample, whose source potentially has a hidden clock (and reset)
-> [a]

Get a list of n samples from a Signal

The elements in the list correspond to the values of the Signal at consecutive clock cycles

sampleN @System 3 s == [s0, s1, s2]

If the given component has not yet been given a clock, reset, or enable line, sampleN will supply them. The reset will be asserted for a single cycle. sampleN will not drop the value produced by the circuit while the reset was asserted. If you want this, or if you want more than a single cycle reset, consider using sampleWithResetN.

NB: This function is not synthesizable

sampleWithReset Source #

Arguments

:: forall dom a m. (KnownDomain dom, NFDataX a, 1 <= m)
=> SNat m	Number of cycles to assert the reset
-> (HiddenClockResetEnable dom => Signal dom a)	`Signal` to sample, whose source potentially has a hidden clock (and reset)
-> [a]

Get an infinite list of samples from a Signal, while asserting the reset line for m clock cycles. sampleWithReset does not return the first m cycles, i.e., when the reset is asserted.

NB: This function is not synthesizable

sampleWithResetN Source #

Arguments

:: forall dom a m. (KnownDomain dom, NFDataX a, 1 <= m)
=> SNat m	Number of cycles to assert the reset
-> Int	Number of samples to produce
-> (HiddenClockResetEnable dom => Signal dom a)	`Signal` to sample, whose source potentially has a hidden clock (and reset)
-> [a]

Get a list of n samples from a Signal, while asserting the reset line for m clock cycles. sampleWithReset does not return the first m cycles, i.e., while the reset is asserted.

NB: This function is not synthesizable

sample_lazy Source #

Arguments

:: forall dom a. KnownDomain dom
=> (HiddenClockResetEnable dom => Signal dom a)	`Signal` we want to sample, whose source potentially has a hidden clock (and reset)
-> [a]

Lazily get an infinite list of samples from a Signal

The elements in the list correspond to the values of the Signal at consecutive clock cycles

sample s == [s0, s1, s2, s3, ...

If the given component has not yet been given a clock, reset, or enable line, sample_lazy will supply them. The reset will be asserted for a single cycle. sample_lazy will not drop the value produced by the circuit while the reset was asserted.

NB: This function is not synthesizable

sampleN_lazy Source #

Arguments

:: forall dom a. KnownDomain dom
=> Int
-> (HiddenClockResetEnable dom => Signal dom a)	`Signal` we want to sample, whose source potentially has a hidden clock (and reset)
-> [a]

Lazily get a list of n samples from a Signal

The elements in the list correspond to the values of the Signal at consecutive clock cycles

sampleN @System 3 s == [s0, s1, s2]

If the given component has not yet been given a clock, reset, or enable line, sampleN_lazy will supply them. The reset will be asserted for a single cycle. sampleN_lazy will not drop the value produced by the circuit while the reset was asserted.

NB: This function is not synthesizable

simulate Source #

Arguments

:: forall dom a b. (KnownDomain dom, NFDataX a, NFDataX b)
=> (HiddenClockResetEnable dom => Signal dom a -> Signal dom b)	Circuit to simulate, whose source potentially has a hidden clock, reset, and/or enable.
-> [a]
-> [b]

Simulate a (Signal a -> Signal b) function given a list of samples of type a

>>> simulate @System (register 8) [1, 2, 3]
[8,1,2,3...
...

Where System denotes the domain to simulate on. The reset line is asserted for a single cycle. The first value is therefore supplied twice to the circuit: once while reset is high, and once directly after. The first output value (the value produced while the reset is asserted) is dropped.

If you only want to simulate a finite number of samples, see simulateN. If you need the reset line to be asserted for more than one cycle or if you need a custom reset value, see simulateWithReset and simulateWithResetN.

NB: This function is not synthesizable

simulateN Source #

Arguments

:: forall dom a b. (KnownDomain dom, NFDataX a, NFDataX b)
=> Int	Number of cycles to simulate (excluding cycle spent in reset)
-> (HiddenClockResetEnable dom => Signal dom a -> Signal dom b)	`Signal` we want to sample, whose source potentially has a hidden clock (and reset)
-> [a]
-> [b]

Same as simulate, but only sample the first Int output values.

NB: This function is not synthesizable

simulateWithReset Source #

Arguments

:: forall dom a b m. (KnownDomain dom, NFDataX a, NFDataX b, 1 <= m)
=> SNat m	Number of cycles to assert the reset
-> a	Reset value
-> (HiddenClockResetEnable dom => Signal dom a -> Signal dom b)	`Signal` we want to sample, whose source potentially has a hidden clock (and reset)
-> [a]
-> [b]

Same as simulate, but with the reset line asserted for n cycles. Similar to simulate, simulateWithReset will drop the output values produced while the reset is asserted. While the reset is asserted, the reset value a is supplied to the circuit.

simulateWithResetN Source #

Arguments

:: forall dom a b m. (KnownDomain dom, NFDataX a, NFDataX b, 1 <= m)
=> SNat m	Number of cycles to assert the reset
-> a	Reset value
-> Int	Number of cycles to simulate (excluding cycles spent in reset)
-> (HiddenClockResetEnable dom => Signal dom a -> Signal dom b)	`Signal` we want to sample, whose source potentially has a hidden clock (and reset)
-> [a]
-> [b]

Same as simulateWithReset, but only sample the first Int output values.

simulate_lazy Source #

Arguments

:: forall dom a b. KnownDomain dom
=> (HiddenClockResetEnable dom => Signal dom a -> Signal dom b)	Function we want to simulate, whose components potentially have a hidden clock (and reset)
-> [a]
-> [b]

Lazily simulate a (Signal a -> Signal b) function given a list of samples of type a

>>> simulate @System (register 8) [1, 2, 3]
[8,1,2,3...
...

NB: This function is not synthesizable

simulateB Source #

Arguments

:: forall dom a b. (KnownDomain dom, Bundle a, Bundle b, NFDataX a, NFDataX b)
=> (HiddenClockResetEnable dom => Unbundled dom a -> Unbundled dom b)	Function we want to simulate, whose components potentially have a hidden clock (and reset)
-> [a]
-> [b]

Simulate a (Unbundled a -> Unbundled b) function given a list of samples of type a

>>> simulateB @System (unbundle . register (8,8) . bundle) [(1,1), (2,2), (3,3)] :: [(Int,Int)]
[(8,8),(1,1),(2,2),(3,3)...
...

NB: This function is not synthesizable

simulateB_lazy Source #

Arguments

:: forall dom a b. (KnownDomain dom, Bundle a, Bundle b)
=> (HiddenClockResetEnable dom => Unbundled dom a -> Unbundled dom b)	Function we want to simulate, whose components potentially have a hidden clock (and reset)
-> [a]
-> [b]

Lazily simulate a (Unbundled a -> Unbundled b) function given a list of samples of type a

>>> simulateB @System (unbundle . register (8,8) . bundle) [(1,1), (2,2), (3,3)] :: [(Int,Int)]
[(8,8),(1,1),(2,2),(3,3)...
...

NB: This function is not synthesizable

runUntil Source #

Arguments

:: forall dom a. (KnownDomain dom, NFDataX a, ShowX a)
=> (a -> Bool)	Condition checking function, should return `True` to finish run
-> (HiddenClockResetEnable dom => Signal dom a)	`Signal` we want to sample for the condition, potentially having a hidden clock, reset and/or enable
-> IO ()

Simulate a component until it matches a condition

If the given component has not yet been given a clock, reset, or enable line, runUntil will supply them. The reset will be asserted for a single cycle.

It prints a message of the form

Signal sampled for N cycles until value X

NB: This function is not synthesizable

Example with test bench

Expand

A common usage is with a test bench using outputVerifier.

NB: Since this uses assert, when using clashi, read the note at "Clash.Explicit.Testbench#assert-clashi".

import Clash.Prelude
import Clash.Explicit.Testbench

topEntity
  :: Signal System Int
  -> Signal System Int
topEntity = id

testBench
  :: Signal System Bool
testBench = done
 where
  testInput = stimuliGenerator clk rst $(listToVecTH [1 :: Int .. 10])
  expectedOutput =
    outputVerifier' clk rst $(listToVecTH $ [1 :: Int .. 9] <> [42])
  done = expectedOutput $ topEntity testInput
  clk = tbSystemClockGen (not <$> done)
  rst = systemResetGen

> runUntil id testBench


cycle(<Clock: System>): 10, outputVerifier
expected value: 42, not equal to actual value: 10
Signal sampled for 11 cycles until value True

When you need to verify multiple test benches, the following invocations come in handy:

> mapM_ (runUntil id) [ testBenchA, testBenchB ]

or when the test benches are in different clock domains:

testBenchA :: Signal DomA Bool
testBenchB :: Signal DomB Bool

> sequence_ [ runUntil id testBenchA, runUntil id testBenchB ]

testFor Source #

Arguments

:: KnownDomain dom
=> Int	The number of cycles we want to test for
-> (HiddenClockResetEnable dom => Signal dom Bool)	`Signal` we want to evaluate, whose source potentially has a hidden clock (and reset)
-> Property

testFor n s tests the signal s for n cycles.

NB: This function is not synthesizable

unsafeSynchronizer :: forall dom1 dom2 a. (HiddenClock dom1, HiddenClock dom2) => Signal dom1 a -> Signal dom2 a Source #

Implicit version of unsafeSynchronizer.

holdReset Source #

Arguments

:: forall dom m. HiddenClockResetEnable dom
=> SNat m	Hold for m cycles, counting from the moment the incoming reset signal becomes deasserted.
-> Reset dom

Hold reset for a number of cycles relative to an implicit reset signal.

Example:

>>> sampleN @System 8 (unsafeToHighPolarity (holdReset (SNat @2)))
[True,True,True,False,False,False,False,False]

holdReset holds the reset for an additional 2 clock cycles for a total of 3 clock cycles where the reset is asserted.

fromListWithReset :: forall dom a. (HiddenReset dom, NFDataX a) => a -> [a] -> Signal dom a Source #

Like fromList, but resets on reset and has a defined reset value.

>>> let rst = unsafeFromHighPolarity (fromList [True, True, False, False, True, False])
>>> let res = withReset rst (fromListWithReset Nothing [Just 'a', Just 'b', Just 'c'])
>>> sampleN @System 6 res
[Nothing,Nothing,Just 'a',Just 'b',Nothing,Just 'a']

NB: This function is not synthesizable

convertReset :: forall domA domB. (HiddenClock domA, HiddenClock domB) => Reset domA -> Reset domB Source #

Convert between different types of reset, adding a synchronizer in case it needs to convert from an asynchronous to a synchronous reset.

signalAutomaton :: forall dom a b. KnownDomain dom => (HiddenClockResetEnable dom => Signal dom a -> Signal dom b) -> Automaton (->) a b Source #

Build an Automaton from a function over Signals.

NB: Consumption of continuation of the Automaton must be affine; that is, you can only apply the continuation associated with a particular element at most once.

module Clash.Signal.Delayed

Datatypes

Fixed size vectors

data Vec :: Nat -> Type -> Type where Source #

Fixed size vectors.

Lists with their length encoded in their type
Vector elements have an ASCENDING subscript starting from 0 and ending at length - 1.

Constructors

Nil :: Vec 0 a
Cons :: a -> Vec n a -> Vec (n + 1) a infixr 5

Bundled Patterns

pattern (:<) :: Vec n a -> a -> Vec (n + 1) a infixl 5

Add an element to the tail of a vector.

>>> (3:>4:>5:>Nil) :< 1
3 :> 4 :> 5 :> 1 :> Nil
>>> let x = (3:>4:>5:>Nil) :< 1
>>> :t x
x :: Num a => Vec 4 a

Can be used as a pattern:

>>> let f (_ :< y :< x) = y + x
>>> :t f
f :: Num a => Vec ((n + 1) + 1) a -> a
>>> f (3:>4:>5:>6:>7:>Nil)
13

Also in conjunctions with (:>):

>>> let g (a :> b :> (_ :< y :< x)) = a + b +  x + y
>>> :t g
g :: Num a => Vec ((((n + 1) + 1) + 1) + 1) a -> a
>>> g (1:>2:>3:>4:>5:>Nil)
12

pattern (:>) :: a -> Vec n a -> Vec (n + 1) a infixr 5

Add an element to the head of a vector.

>>> 3:>4:>5:>Nil
3 :> 4 :> 5 :> Nil
>>> let x = 3:>4:>5:>Nil
>>> :t x
x :: Num a => Vec 3 a

Can be used as a pattern:

>>> let f (x :> y :> _) = x + y
>>> :t f
f :: Num a => Vec ((n + 1) + 1) a -> a
>>> f (3:>4:>5:>6:>7:>Nil)
7

Also in conjunctions with (:<):

>>> let g (a :> b :> (_ :< y :< x)) = a + b +  x + y
>>> :t g
g :: Num a => Vec ((((n + 1) + 1) + 1) + 1) a -> a
>>> g (1:>2:>3:>4:>5:>Nil)
12

Instances

Instances details

Lift a => Lift (Vec n a :: Type) Source #
Instance details Defined in Clash.Sized.Vector Methods lift :: Vec n a -> Q Exp # liftTyped :: Vec n a -> Q (TExp (Vec n a)) #
Functor (Vec n) Source #
Instance details Defined in Clash.Sized.Vector Methods fmap :: (a -> b) -> Vec n a -> Vec n b # (<$) :: a -> Vec n b -> Vec n a #
KnownNat n => Applicative (Vec n) Source #
Instance details Defined in Clash.Sized.Vector Methods pure :: a -> Vec n a # (<>) :: Vec n (a -> b) -> Vec n a -> Vec n b # liftA2 :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c # (>) :: Vec n a -> Vec n b -> Vec n b # (<*) :: Vec n a -> Vec n b -> Vec n a #
(KnownNat n, 1 <= n) => Foldable (Vec n) Source #
Instance details Defined in Clash.Sized.Vector Methods fold :: Monoid m => Vec n m -> m # foldMap :: Monoid m => (a -> m) -> Vec n a -> m # foldMap' :: Monoid m => (a -> m) -> Vec n a -> m # foldr :: (a -> b -> b) -> b -> Vec n a -> b # foldr' :: (a -> b -> b) -> b -> Vec n a -> b # foldl :: (b -> a -> b) -> b -> Vec n a -> b # foldl' :: (b -> a -> b) -> b -> Vec n a -> b # foldr1 :: (a -> a -> a) -> Vec n a -> a # foldl1 :: (a -> a -> a) -> Vec n a -> a # toList :: Vec n a -> [a] # null :: Vec n a -> Bool # length :: Vec n a -> Int # elem :: Eq a => a -> Vec n a -> Bool # maximum :: Ord a => Vec n a -> a # minimum :: Ord a => Vec n a -> a # sum :: Num a => Vec n a -> a # product :: Num a => Vec n a -> a #
(KnownNat n, 1 <= n) => Traversable (Vec n) Source #
Instance details Defined in Clash.Sized.Vector Methods traverse :: Applicative f => (a -> f b) -> Vec n a -> f (Vec n b) # sequenceA :: Applicative f => Vec n (f a) -> f (Vec n a) # mapM :: Monad m => (a -> m b) -> Vec n a -> m (Vec n b) # sequence :: Monad m => Vec n (m a) -> m (Vec n a) #
(KnownNat n, Eq a) => Eq (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods (==) :: Vec n a -> Vec n a -> Bool # (/=) :: Vec n a -> Vec n a -> Bool #
(KnownNat n, Typeable a, Data a) => Data (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vec n a -> c (Vec n a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vec n a) # toConstr :: Vec n a -> Constr # dataTypeOf :: Vec n a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vec n a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vec n a)) # gmapT :: (forall b. Data b => b -> b) -> Vec n a -> Vec n a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vec n a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vec n a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vec n a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vec n a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a) #
(KnownNat n, Ord a) => Ord (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods compare :: Vec n a -> Vec n a -> Ordering # (<) :: Vec n a -> Vec n a -> Bool # (<=) :: Vec n a -> Vec n a -> Bool # (>) :: Vec n a -> Vec n a -> Bool # (>=) :: Vec n a -> Vec n a -> Bool # max :: Vec n a -> Vec n a -> Vec n a # min :: Vec n a -> Vec n a -> Vec n a #
Show a => Show (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods showsPrec :: Int -> Vec n a -> ShowS # show :: Vec n a -> String # showList :: [Vec n a] -> ShowS #
KnownNat n => Generic (Vec n a) Source #	In many cases, this Generic instance only allows generic functions/instances over vectors of at least size 1, due to the n-1 in the Rep (Vec n a) definition. We'll have to wait for things like https://ryanglscott.github.io/2018/02/11/how-to-derive-generic-for-some-gadts/ before we can work around this limitation
Instance details Defined in Clash.Sized.Vector Associated Types type Rep (Vec n a) :: Type -> Type # Methods from :: Vec n a -> Rep (Vec n a) x # to :: Rep (Vec n a) x -> Vec n a #
(KnownNat n, Semigroup a) => Semigroup (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods (<>) :: Vec n a -> Vec n a -> Vec n a # sconcat :: NonEmpty (Vec n a) -> Vec n a # stimes :: Integral b => b -> Vec n a -> Vec n a #
(KnownNat n, Monoid a) => Monoid (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods mempty :: Vec n a # mappend :: Vec n a -> Vec n a -> Vec n a # mconcat :: [Vec n a] -> Vec n a #
(KnownNat n, Arbitrary a) => Arbitrary (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods arbitrary :: Gen (Vec n a) # shrink :: Vec n a -> [Vec n a] #
CoArbitrary a => CoArbitrary (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods coarbitrary :: Vec n a -> Gen b -> Gen b #
(Default a, KnownNat n) => Default (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods def :: Vec n a #
NFData a => NFData (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods rnf :: Vec n a -> () #
KnownNat n => Ixed (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods ix :: Index (Vec n a) -> Traversal' (Vec n a) (IxValue (Vec n a)) #
(NFDataX a, KnownNat n) => NFDataX (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods deepErrorX :: String -> Vec n a Source # hasUndefined :: Vec n a -> Bool Source # ensureSpine :: Vec n a -> Vec n a Source # rnfX :: Vec n a -> () Source #
ShowX a => ShowX (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Methods showsPrecX :: Int -> Vec n a -> ShowS Source # showX :: Vec n a -> String Source # showListX :: [Vec n a] -> ShowS Source #
(KnownNat n, BitPack a) => BitPack (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Associated Types type BitSize (Vec n a) :: Nat Source # Methods pack :: Vec n a -> BitVector (BitSize (Vec n a)) Source # unpack :: BitVector (BitSize (Vec n a)) -> Vec n a Source #
KnownNat n => Bundle (Vec n a) Source #
Instance details Defined in Clash.Signal.Bundle Associated Types type Unbundled dom (Vec n a) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain). Unbundled dom (Vec n a) -> Signal dom (Vec n a) Source # unbundle :: forall (dom :: Domain). Signal dom (Vec n a) -> Unbundled dom (Vec n a) Source #
KnownNat n => Bundle (Vec n a) Source #
Instance details Defined in Clash.Signal.Delayed.Bundle Associated Types type Unbundled dom d (Vec n a) = (res :: Type) Source # Methods bundle :: forall (dom :: Domain) (d :: Nat). Unbundled dom d (Vec n a) -> DSignal dom d (Vec n a) Source # unbundle :: forall (dom :: Domain) (d :: Nat). DSignal dom d (Vec n a) -> Unbundled dom d (Vec n a) Source #
(KnownNat n, AutoReg a) => AutoReg (Vec n a) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Vec n a -> Signal dom (Vec n a) -> Signal dom (Vec n a) Source #
(LockStep en a, KnownNat n) => LockStep (Vec n en) (Vec n a) Source #
Instance details Defined in Clash.Prelude.DataFlow Methods lockStep :: forall (dom :: Domain). DataFlow dom (Vec n en) Bool (Vec n a) (Vec n a) Source # stepLock :: forall (dom :: Domain). DataFlow dom Bool (Vec n en) (Vec n a) (Vec n a) Source #
type Unbundled t d (Vec n a) Source #
Instance details Defined in Clash.Signal.Delayed.Bundle type Unbundled t d (Vec n a) = Vec n (DSignal t d a)
type HasDomain dom (Vec n a) Source #
Instance details Defined in Clash.Class.HasDomain.HasSpecificDomain type HasDomain dom (Vec n a) = HasDomain dom a
type TryDomain t (Vec n a) Source #
Instance details Defined in Clash.Class.HasDomain.HasSingleDomain type TryDomain t (Vec n a) = TryDomain t a
type Unbundled t (Vec n a) Source #
Instance details Defined in Clash.Signal.Bundle type Unbundled t (Vec n a) = Vec n (Signal t a)
type Rep (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector type Rep (Vec n a) = D1 ('MetaData "Vec" "Clash.Data.Vector" "clash-prelude" 'False) (C1 ('MetaCons "Nil" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Cons" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Vec (n - 1) a))))
type Index (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector type Index (Vec n a) = Index n
type IxValue (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector type IxValue (Vec n a) = a
type BitSize (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector type BitSize (Vec n a) = n * BitSize a

foldl :: (b -> a -> b) -> b -> Vec n a -> b Source #

foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a vector, reduces the vector using the binary operator, from left to right:

foldl f z (x1 :> x2 :> ... :> xn :> Nil) == (...((z `f` x1) `f` x2) `f`...) `f` xn
foldl f z Nil                            == z

>>> foldl (/) 1 (5 :> 4 :> 3 :> 2 :> Nil)
8.333333333333333e-3

"foldl f z xs" corresponds to the following circuit layout:

NB: "foldl f z xs" produces a linear structure, which has a depth, or delay, of O(length xs). Use fold if your binary operator f is associative, as "fold f xs" produces a structure with a depth of O(log_2(length xs)).

foldr :: (a -> b -> b) -> b -> Vec n a -> b Source #

foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a vector, reduces the vector using the binary operator, from right to left:

foldr f z (x1 :> ... :> xn1 :> xn :> Nil) == x1 `f` (... (xn1 `f` (xn `f` z))...)
foldr r z Nil                             == z

>>> foldr (/) 1 (5 :> 4 :> 3 :> 2 :> Nil)
1.875

"foldr f z xs" corresponds to the following circuit layout:

NB: "foldr f z xs" produces a linear structure, which has a depth, or delay, of O(length xs). Use fold if your binary operator f is associative, as "fold f xs" produces a structure with a depth of O(log_2(length xs)).

map :: (a -> b) -> Vec n a -> Vec n b Source #

"map f xs" is the vector obtained by applying f to each element of xs, i.e.,

map f (x1 :> x2 :>  ... :> xn :> Nil) == (f x1 :> f x2 :> ... :> f xn :> Nil)

and corresponds to the following circuit layout:

bv2v :: KnownNat n => BitVector n -> Vec n Bit Source #

Convert a BitVector to a Vec of Bits.

>>> let x = 6 :: BitVector 8
>>> x
0b0000_0110
>>> bv2v x
0 :> 0 :> 0 :> 0 :> 0 :> 1 :> 1 :> 0 :> Nil

data VCons (a :: Type) (f :: TyFun Nat Type) :: Type Source #

To be used as the motive p for dfold, when the f in "dfold p f" is a variation on (:>), e.g.:

map' :: forall n a b . KnownNat n => (a -> b) -> Vec n a -> Vec n b
map' f = dfold (Proxy @(VCons b)) (_ x xs -> f x :> xs)

Instances

Instances details

type Apply (VCons a :: TyFun Nat Type -> Type) (l :: Nat) Source #
Instance details Defined in Clash.Sized.Vector type Apply (VCons a :: TyFun Nat Type -> Type) (l :: Nat) = Vec l a

traverse# :: forall a f b n. Applicative f => (a -> f b) -> Vec n a -> f (Vec n b) Source #

singleton :: a -> Vec 1 a Source #

Create a vector of one element

>>> singleton 5
5 :> Nil

head :: Vec (n + 1) a -> a Source #

Extract the first element of a vector

>>> head (1:>2:>3:>Nil)
1

# 391 "srcClashSized/Vector.hs" >>> head Nil BLANKLINE interactive:... • Couldn't match type ‘1’ with ‘0’ Expected type: Vec (0 + 1) a Actual type: Vec 0 a • In the first argument of ‘head’, namely ‘Nil’ In the expression: head Nil In an equation for ‘it’: it = head Nil

tail :: Vec (n + 1) a -> Vec n a Source #

Extract the elements after the head of a vector

>>> tail (1:>2:>3:>Nil)
2 :> 3 :> Nil

# 425 "srcClashSized/Vector.hs" >>> tail Nil BLANKLINE interactive:... • Couldn't match type ‘1’ with ‘0’ Expected type: Vec (0 + 1) a Actual type: Vec 0 a • In the first argument of ‘tail’, namely ‘Nil’ In the expression: tail Nil In an equation for ‘it’: it = tail Nil

last :: Vec (n + 1) a -> a Source #

Extract the last element of a vector

>>> last (1:>2:>3:>Nil)
3

# 459 "srcClashSized/Vector.hs" >>> last Nil BLANKLINE interactive:... • Couldn't match type ‘1’ with ‘0’ Expected type: Vec (0 + 1) a Actual type: Vec 0 a • In the first argument of ‘last’, namely ‘Nil’ In the expression: last Nil In an equation for ‘it’: it = last Nil

init :: Vec (n + 1) a -> Vec n a Source #

Extract all the elements of a vector except the last element

>>> init (1:>2:>3:>Nil)
1 :> 2 :> Nil

# 494 "srcClashSized/Vector.hs" >>> init Nil BLANKLINE interactive:... • Couldn't match type ‘1’ with ‘0’ Expected type: Vec (0 + 1) a Actual type: Vec 0 a • In the first argument of ‘init’, namely ‘Nil’ In the expression: init Nil In an equation for ‘it’: it = init Nil

shiftInAt0 Source #

Arguments

:: KnownNat n
=> Vec n a	The old vector
-> Vec m a	The elements to shift in at the head
-> (Vec n a, Vec m a)	(The new vector, shifted out elements)

Shift in elements to the head of a vector, bumping out elements at the tail. The result is a tuple containing:

The new vector
The shifted out elements

>>> shiftInAt0 (1 :> 2 :> 3 :> 4 :> Nil) ((-1) :> 0 :> Nil)
(-1 :> 0 :> 1 :> 2 :> Nil,3 :> 4 :> Nil)
>>> shiftInAt0 (1 :> Nil) ((-1) :> 0 :> Nil)
(-1 :> Nil,0 :> 1 :> Nil)

shiftInAtN Source #

Arguments

:: KnownNat m
=> Vec n a	The old vector
-> Vec m a	The elements to shift in at the tail
-> (Vec n a, Vec m a)	(The new vector, shifted out elements)

Shift in element to the tail of a vector, bumping out elements at the head. The result is a tuple containing:

The new vector
The shifted out elements

>>> shiftInAtN (1 :> 2 :> 3 :> 4 :> Nil) (5 :> 6 :> Nil)
(3 :> 4 :> 5 :> 6 :> Nil,1 :> 2 :> Nil)
>>> shiftInAtN (1 :> Nil) (2 :> 3 :> Nil)
(3 :> Nil,1 :> 2 :> Nil)

(+>>) :: KnownNat n => a -> Vec n a -> Vec n a infixr 4 Source #

Add an element to the head of a vector, and extract all but the last element.

>>> 1 +>> (3:>4:>5:>Nil)
1 :> 3 :> 4 :> Nil
>>> 1 +>> Nil
Nil

(<<+) :: Vec n a -> a -> Vec n a infixl 4 Source #

Add an element to the tail of a vector, and extract all but the first element.

>>> (3:>4:>5:>Nil) <<+ 1
4 :> 5 :> 1 :> Nil
>>> Nil <<+ 1
Nil

shiftOutFrom0 Source #

Arguments

:: (Default a, KnownNat m)
=> SNat m	`m`, the number of elements to shift out
-> Vec (m + n) a	The old vector
-> (Vec (m + n) a, Vec m a)	(The new vector, shifted out elements)

Shift m elements out from the head of a vector, filling up the tail with Default values. The result is a tuple containing:

The new vector
The shifted out values

>>> shiftOutFrom0 d2 ((1 :> 2 :> 3 :> 4 :> 5 :> Nil) :: Vec 5 Integer)
(3 :> 4 :> 5 :> 0 :> 0 :> Nil,1 :> 2 :> Nil)

shiftOutFromN Source #

Arguments

:: (Default a, KnownNat n)
=> SNat m	`m`, the number of elements to shift out
-> Vec (m + n) a	The old vector
-> (Vec (m + n) a, Vec m a)	(The new vector, shifted out elements)

Shift m elements out from the tail of a vector, filling up the head with Default values. The result is a tuple containing:

The new vector
The shifted out values

>>> shiftOutFromN d2 ((1 :> 2 :> 3 :> 4 :> 5 :> Nil) :: Vec 5 Integer)
(0 :> 0 :> 1 :> 2 :> 3 :> Nil,4 :> 5 :> Nil)

(++) :: Vec n a -> Vec m a -> Vec (n + m) a infixr 5 Source #

Append two vectors.

>>> (1:>2:>3:>Nil) ++ (7:>8:>Nil)
1 :> 2 :> 3 :> 7 :> 8 :> Nil

splitAt :: SNat m -> Vec (m + n) a -> (Vec m a, Vec n a) Source #

Split a vector into two vectors at the given point.

>>> splitAt (SNat :: SNat 3) (1:>2:>3:>7:>8:>Nil)
(1 :> 2 :> 3 :> Nil,7 :> 8 :> Nil)
>>> splitAt d3 (1:>2:>3:>7:>8:>Nil)
(1 :> 2 :> 3 :> Nil,7 :> 8 :> Nil)

splitAtI :: KnownNat m => Vec (m + n) a -> (Vec m a, Vec n a) Source #

Split a vector into two vectors where the length of the two is determined by the context.

>>> splitAtI (1:>2:>3:>7:>8:>Nil) :: (Vec 2 Int, Vec 3 Int)
(1 :> 2 :> Nil,3 :> 7 :> 8 :> Nil)

concat :: Vec n (Vec m a) -> Vec (n * m) a Source #

Concatenate a vector of vectors.

>>> concat ((1:>2:>3:>Nil) :> (4:>5:>6:>Nil) :> (7:>8:>9:>Nil) :> (10:>11:>12:>Nil) :> Nil)
1 :> 2 :> 3 :> 4 :> 5 :> 6 :> 7 :> 8 :> 9 :> 10 :> 11 :> 12 :> Nil

concatMap :: (a -> Vec m b) -> Vec n a -> Vec (n * m) b Source #

Map a function over all the elements of a vector and concatentate the resulting vectors.

>>> concatMap (replicate d3) (1:>2:>3:>Nil)
1 :> 1 :> 1 :> 2 :> 2 :> 2 :> 3 :> 3 :> 3 :> Nil

unconcat :: KnownNat n => SNat m -> Vec (n * m) a -> Vec n (Vec m a) Source #

Split a vector of (n * m) elements into a vector of "vectors of length m", where the length m is given.

>>> unconcat d4 (1:>2:>3:>4:>5:>6:>7:>8:>9:>10:>11:>12:>Nil)
(1 :> 2 :> 3 :> 4 :> Nil) :> (5 :> 6 :> 7 :> 8 :> Nil) :> (9 :> 10 :> 11 :> 12 :> Nil) :> Nil

unconcatI :: (KnownNat n, KnownNat m) => Vec (n * m) a -> Vec n (Vec m a) Source #

Split a vector of (n * m) elements into a vector of "vectors of length m", where the length m is determined by the context.

>>> unconcatI (1:>2:>3:>4:>5:>6:>7:>8:>9:>10:>11:>12:>Nil) :: Vec 2 (Vec 6 Int)
(1 :> 2 :> 3 :> 4 :> 5 :> 6 :> Nil) :> (7 :> 8 :> 9 :> 10 :> 11 :> 12 :> Nil) :> Nil

merge :: KnownNat n => Vec n a -> Vec n a -> Vec (2 * n) a Source #

Merge two vectors, alternating their elements, i.e.,

>>> merge (1 :> 2 :> 3 :> 4 :> Nil) (5 :> 6 :> 7 :> 8 :> Nil)
1 :> 5 :> 2 :> 6 :> 3 :> 7 :> 4 :> 8 :> Nil

reverse :: Vec n a -> Vec n a Source #

The elements in a vector in reverse order.

>>> reverse (1:>2:>3:>4:>Nil)
4 :> 3 :> 2 :> 1 :> Nil

imap :: forall n a b. KnownNat n => (Index n -> a -> b) -> Vec n a -> Vec n b Source #

Apply a function of every element of a vector and its index.

>>> :t imap (+) (2 :> 2 :> 2 :> 2 :> Nil)
imap (+) (2 :> 2 :> 2 :> 2 :> Nil) :: Vec 4 (Index 4)
>>> imap (+) (2 :> 2 :> 2 :> 2 :> Nil)
2 :> 3 :> *** Exception: X: Clash.Sized.Index: result 4 is out of bounds: [0..3]
...
>>> imap (\i a -> fromIntegral i + a) (2 :> 2 :> 2 :> 2 :> Nil) :: Vec 4 (Unsigned 8)
2 :> 3 :> 4 :> 5 :> Nil

"imap f xs" corresponds to the following circuit layout:

izipWith :: KnownNat n => (Index n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n c Source #

Zip two vectors with a functions that also takes the elements' indices.

>>> izipWith (\i a b -> i + a + b) (2 :> 2 :> Nil)  (3 :> 3:> Nil)
*** Exception: X: Clash.Sized.Index: result 3 is out of bounds: [0..1]
...

>>> izipWith (\i a b -> fromIntegral i + a + b) (2 :> 2 :> Nil) (3 :> 3 :> Nil) :: Vec 2 (Unsigned 8)
5 :> 6 :> Nil

"imap f xs" corresponds to the following circuit layout:

NB: izipWith is strict in its second argument, and lazy in its third. This matters when izipWith is used in a recursive setting. See lazyV for more information.

ifoldr :: KnownNat n => (Index n -> a -> b -> b) -> b -> Vec n a -> b Source #

Right fold (function applied to each element and its index)

>>> let findLeftmost x xs = ifoldr (\i a b -> if a == x then Just i else b) Nothing xs
>>> findLeftmost 3 (1:>3:>2:>4:>3:>5:>6:>Nil)
Just 1
>>> findLeftmost 8 (1:>3:>2:>4:>3:>5:>6:>Nil)
Nothing

"ifoldr f z xs" corresponds to the following circuit layout:

ifoldl :: KnownNat n => (a -> Index n -> b -> a) -> a -> Vec n b -> a Source #

Left fold (function applied to each element and its index)

>>> let findRightmost x xs = ifoldl (\a i b -> if b == x then Just i else a) Nothing xs
>>> findRightmost 3 (1:>3:>2:>4:>3:>5:>6:>Nil)
Just 4
>>> findRightmost 8 (1:>3:>2:>4:>3:>5:>6:>Nil)
Nothing

"ifoldl f z xs" corresponds to the following circuit layout:

indices :: KnownNat n => SNat n -> Vec n (Index n) Source #

Generate a vector of indices.

>>> indices d4
0 :> 1 :> 2 :> 3 :> Nil

indicesI :: KnownNat n => Vec n (Index n) Source #

Generate a vector of indices, where the length of the vector is determined by the context.

>>> indicesI :: Vec 4 (Index 4)
0 :> 1 :> 2 :> 3 :> Nil

findIndex :: KnownNat n => (a -> Bool) -> Vec n a -> Maybe (Index n) Source #

"findIndex p xs" returns the index of the first element of xs satisfying the predicate p, or Nothing if there is no such element.

>>> findIndex (> 3) (1:>3:>2:>4:>3:>5:>6:>Nil)
Just 3
>>> findIndex (> 8) (1:>3:>2:>4:>3:>5:>6:>Nil)
Nothing

elemIndex :: (KnownNat n, Eq a) => a -> Vec n a -> Maybe (Index n) Source #

"elemIndex a xs" returns the index of the first element which is equal (by ==) to the query element a, or Nothing if there is no such element.

>>> elemIndex 3 (1:>3:>2:>4:>3:>5:>6:>Nil)
Just 1
>>> elemIndex 8 (1:>3:>2:>4:>3:>5:>6:>Nil)
Nothing

zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c Source #

zipWith generalizes zip by zipping with the function given as the first argument, instead of a tupling function. For example, "zipWith (+)" applied to two vectors produces the vector of corresponding sums.

zipWith f (x1 :> x2 :> ... xn :> Nil) (y1 :> y2 :> ... :> yn :> Nil) == (f x1 y1 :> f x2 y2 :> ... :> f xn yn :> Nil)

"zipWith f xs ys" corresponds to the following circuit layout:

NB: zipWith is strict in its second argument, and lazy in its third. This matters when zipWith is used in a recursive setting. See lazyV for more information.

zipWith3 :: (a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d Source #

zipWith3 generalizes zip3 by zipping with the function given as the first argument, instead of a tupling function.

zipWith3 f (x1 :> x2 :> ... xn :> Nil) (y1 :> y2 :> ... :> yn :> Nil) (z1 :> z2 :> ... :> zn :> Nil) == (f x1 y1 z1 :> f x2 y2 z2 :> ... :> f xn yn zn :> Nil)

"zipWith3 f xs ys zs" corresponds to the following circuit layout:

NB: zipWith3 is strict in its second argument, and lazy in its third and fourth. This matters when zipWith3 is used in a recursive setting. See lazyV for more information.

zipWith4 :: (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e Source #

zipWith5 :: (a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f Source #

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g Source #

zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g -> Vec n h Source #

foldr1 :: (a -> a -> a) -> Vec (n + 1) a -> a Source #

foldr1 is a variant of foldr that has no starting value argument, and thus must be applied to non-empty vectors.

foldr1 f (x1 :> ... :> xn2 :> xn1 :> xn :> Nil) == x1 `f` (... (xn2 `f` (xn1 `f` xn))...)
foldr1 f (x1 :> Nil)                            == x1
foldr1 f Nil                                    == TYPE ERROR

>>> foldr1 (/) (5 :> 4 :> 3 :> 2 :> 1 :> Nil)
1.875

"foldr1 f xs" corresponds to the following circuit layout:

NB: "foldr1 f z xs" produces a linear structure, which has a depth, or delay, of O(length xs). Use fold if your binary operator f is associative, as "fold f xs" produces a structure with a depth of O(log_2(length xs)).

foldl1 :: (a -> a -> a) -> Vec (n + 1) a -> a Source #

foldl1 is a variant of foldl that has no starting value argument, and thus must be applied to non-empty vectors.

foldl1 f (x1 :> x2 :> x3 :> ... :> xn :> Nil) == (...((x1 `f` x2) `f` x3) `f`...) `f` xn
foldl1 f (x1 :> Nil)                          == x1
foldl1 f Nil                                  == TYPE ERROR

>>> foldl1 (/) (1 :> 5 :> 4 :> 3 :> 2 :> Nil)
8.333333333333333e-3

"foldl1 f xs" corresponds to the following circuit layout:

NB: "foldl1 f z xs" produces a linear structure, which has a depth, or delay, of O(length xs). Use fold if your binary operator f is associative, as "fold f xs" produces a structure with a depth of O(log_2(length xs)).

fold :: forall n a. (a -> a -> a) -> Vec (n + 1) a -> a Source #

fold is a variant of foldr1 and foldl1, but instead of reducing from right to left, or left to right, it reduces a vector using a tree-like structure. The depth, or delay, of the structure produced by "fold f xs", is hence O(log_2(length xs)), and not O(length xs).

NB: The binary operator "f" in "fold f xs" must be associative.

fold f (x1 :> x2 :> ... :> xn1 :> xn :> Nil) == ((x1 `f` x2) `f` ...) `f` (... `f` (xn1 `f` xn))
fold f (x1 :> Nil)                           == x1
fold f Nil                                   == TYPE ERROR

>>> fold (+) (5 :> 4 :> 3 :> 2 :> 1 :> Nil)
15

"fold f xs" corresponds to the following circuit layout:

scanl :: (b -> a -> b) -> b -> Vec n a -> Vec (n + 1) b Source #

scanl is similar to foldl, but returns a vector of successive reduced values from the left:

scanl f z (x1 :> x2 :> ... :> Nil) == z :> (z `f` x1) :> ((z `f` x1) `f` x2) :> ... :> Nil

>>> scanl (+) 0 (5 :> 4 :> 3 :> 2 :> Nil)
0 :> 5 :> 9 :> 12 :> 14 :> Nil

"scanl f z xs" corresponds to the following circuit layout:

NB:

last (scanl f z xs) == foldl f z xs

postscanl :: (b -> a -> b) -> b -> Vec n a -> Vec n b Source #

postscanl is a variant of scanl where the first result is dropped:

postscanl f z (x1 :> x2 :> ... :> Nil) == (z `f` x1) :> ((z `f` x1) `f` x2) :> ... :> Nil

>>> postscanl (+) 0 (5 :> 4 :> 3 :> 2 :> Nil)
5 :> 9 :> 12 :> 14 :> Nil

"postscanl f z xs" corresponds to the following circuit layout:

scanr :: (a -> b -> b) -> b -> Vec n a -> Vec (n + 1) b Source #

scanr is similar to foldr, but returns a vector of successive reduced values from the right:

scanr f z (... :> xn1 :> xn :> Nil) == ... :> (xn1 `f` (xn `f` z)) :> (xn `f` z) :> z :> Nil

>>> scanr (+) 0 (5 :> 4 :> 3 :> 2 :> Nil)
14 :> 9 :> 5 :> 2 :> 0 :> Nil

"scanr f z xs" corresponds to the following circuit layout:

NB:

head (scanr f z xs) == foldr f z xs

postscanr :: (a -> b -> b) -> b -> Vec n a -> Vec n b Source #

postscanr is a variant of scanr that where the last result is dropped:

postscanr f z (... :> xn1 :> xn :> Nil) == ... :> (xn1 `f` (xn `f` z)) :> (xn `f` z) :> Nil

>>> postscanr (+) 0 (5 :> 4 :> 3 :> 2 :> Nil)
14 :> 9 :> 5 :> 2 :> Nil

"postscanr f z xs" corresponds to the following circuit layout:

mapAccumL :: (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y) Source #

The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a vector, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new vector.

>>> mapAccumL (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
(10,1 :> 2 :> 4 :> 7 :> Nil)

"mapAccumL f acc xs" corresponds to the following circuit layout:

mapAccumR :: (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y) Source #

The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a vector, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new vector.

>>> mapAccumR (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
(10,10 :> 8 :> 5 :> 1 :> Nil)

"mapAccumR f acc xs" corresponds to the following circuit layout:

zip :: Vec n a -> Vec n b -> Vec n (a, b) Source #

zip takes two vectors and returns a vector of corresponding pairs.

>>> zip (1:>2:>3:>4:>Nil) (4:>3:>2:>1:>Nil)
(1,4) :> (2,3) :> (3,2) :> (4,1) :> Nil

zip3 :: Vec n a -> Vec n b -> Vec n c -> Vec n (a, b, c) Source #

zip3 takes three vectors and returns a vector of corresponding triplets.

>>> zip3 (1:>2:>3:>4:>Nil) (4:>3:>2:>1:>Nil) (5:>6:>7:>8:>Nil)
(1,4,5) :> (2,3,6) :> (3,2,7) :> (4,1,8) :> Nil

zip4 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n (a, b, c, d) Source #

zip4 takes four vectors and returns a list of quadruples, analogous to zip.

zip5 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n (a, b, c, d, e) Source #

zip5 takes five vectors and returns a list of five-tuples, analogous to zip.

zip6 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n (a, b, c, d, e, f) Source #

zip6 takes six vectors and returns a list of six-tuples, analogous to zip.

zip7 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g -> Vec n (a, b, c, d, e, f, g) Source #

zip7 takes seven vectors and returns a list of seven-tuples, analogous to zip.

unzip :: Vec n (a, b) -> (Vec n a, Vec n b) Source #

unzip transforms a vector of pairs into a vector of first components and a vector of second components.

>>> unzip ((1,4):>(2,3):>(3,2):>(4,1):>Nil)
(1 :> 2 :> 3 :> 4 :> Nil,4 :> 3 :> 2 :> 1 :> Nil)

unzip3 :: Vec n (a, b, c) -> (Vec n a, Vec n b, Vec n c) Source #

unzip3 transforms a vector of triplets into a vector of first components, a vector of second components, and a vector of third components.

>>> unzip3 ((1,4,5):>(2,3,6):>(3,2,7):>(4,1,8):>Nil)
(1 :> 2 :> 3 :> 4 :> Nil,4 :> 3 :> 2 :> 1 :> Nil,5 :> 6 :> 7 :> 8 :> Nil)

unzip4 :: Vec n (a, b, c, d) -> (Vec n a, Vec n b, Vec n c, Vec n d) Source #

unzip4 takes a vector of quadruples and returns four vectors, analogous to unzip.

unzip5 :: Vec n (a, b, c, d, e) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e) Source #

unzip5 takes a vector of five-tuples and returns five vectors, analogous to unzip.

unzip6 :: Vec n (a, b, c, d, e, f) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e, Vec n f) Source #

unzip6 takes a vector of six-tuples and returns six vectors, analogous to unzip.

unzip7 :: Vec n (a, b, c, d, e, f, g) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e, Vec n f, Vec n g) Source #

unzip7 takes a vector of seven-tuples and returns seven vectors, analogous to unzip.

(!!) :: (KnownNat n, Enum i) => Vec n a -> i -> a Source #

"xs !! n" returns the n'th element of xs.

NB: vector elements have an ASCENDING subscript starting from 0 and ending at length - 1.

>>> (1:>2:>3:>4:>5:>Nil) !! 4
5
>>> (1:>2:>3:>4:>5:>Nil) !! (length (1:>2:>3:>4:>5:>Nil) - 1)
5
>>> (1:>2:>3:>4:>5:>Nil) !! 1
2
>>> (1:>2:>3:>4:>5:>Nil) !! 14
*** Exception: Clash.Sized.Vector.(!!): index 14 is larger than maximum index 4
...

length :: KnownNat n => Vec n a -> Int Source #

The length of a Vector as an Int value.

>>> length (6 :> 7 :> 8 :> Nil)
3

replace :: (KnownNat n, Enum i) => i -> a -> Vec n a -> Vec n a Source #

"replace n a xs" returns the vector xs where the n'th element is replaced by a.

NB: vector elements have an ASCENDING subscript starting from 0 and ending at length - 1.

>>> replace 3 7 (1:>2:>3:>4:>5:>Nil)
1 :> 2 :> 3 :> 7 :> 5 :> Nil
>>> replace 0 7 (1:>2:>3:>4:>5:>Nil)
7 :> 2 :> 3 :> 4 :> 5 :> Nil
>>> replace 9 7 (1:>2:>3:>4:>5:>Nil)
1 :> 2 :> 3 :> 4 :> 5 :> *** Exception: Clash.Sized.Vector.replace: index 9 is larger than maximum index 4
...

take :: SNat m -> Vec (m + n) a -> Vec m a Source #

"take n xs" returns the n-length prefix of xs.

>>> take (SNat :: SNat 3) (1:>2:>3:>4:>5:>Nil)
1 :> 2 :> 3 :> Nil
>>> take d3               (1:>2:>3:>4:>5:>Nil)
1 :> 2 :> 3 :> Nil
>>> take d0               (1:>2:>Nil)
Nil

# 1432 "srcClashSized/Vector.hs" >>> take d4 (1:>2:>Nil) BLANKLINE interactive:... • Couldn't match type ‘4 + n0’ with ‘2’ Expected type: Vec (4 + n0) a Actual type: Vec (1 + 1) a The type variable ‘n0’ is ambiguous • In the second argument of ‘take’, namely ‘(1 :> 2 :> Nil)’ In the expression: take d4 (1 :> 2 :> Nil) In an equation for ‘it’: it = take d4 (1 :> 2 :> Nil)

takeI :: KnownNat m => Vec (m + n) a -> Vec m a Source #

"takeI xs" returns the prefix of xs as demanded by the context.

>>> takeI (1:>2:>3:>4:>5:>Nil) :: Vec 2 Int
1 :> 2 :> Nil

drop :: SNat m -> Vec (m + n) a -> Vec n a Source #

"drop n xs" returns the suffix of xs after the first n elements.

>>> drop (SNat :: SNat 3) (1:>2:>3:>4:>5:>Nil)
4 :> 5 :> Nil
>>> drop d3               (1:>2:>3:>4:>5:>Nil)
4 :> 5 :> Nil
>>> drop d0               (1:>2:>Nil)
1 :> 2 :> Nil
>>> drop d4               (1:>2:>Nil)

<interactive>:...: error:
    • Couldn't match...type ‘4 + n0...
      The type variable ‘n0’ is ambiguous
    • In the first argument of ‘print’, namely ‘it’
      In a stmt of an interactive GHCi command: print it

dropI :: KnownNat m => Vec (m + n) a -> Vec n a Source #

"dropI xs" returns the suffix of xs as demanded by the context.

>>> dropI (1:>2:>3:>4:>5:>Nil) :: Vec 2 Int
4 :> 5 :> Nil

at :: SNat m -> Vec (m + (n + 1)) a -> a Source #

"at n xs" returns n'th element of xs

NB: vector elements have an ASCENDING subscript starting from 0 and ending at length - 1.

>>> at (SNat :: SNat 1) (1:>2:>3:>4:>5:>Nil)
2
>>> at d1               (1:>2:>3:>4:>5:>Nil)
2

select :: CmpNat (i + s) (s * n) ~ 'GT => SNat f -> SNat s -> SNat n -> Vec (f + i) a -> Vec n a Source #

"select f s n xs" selects n elements with step-size s and offset f from xs.

>>> select (SNat :: SNat 1) (SNat :: SNat 2) (SNat :: SNat 3) (1:>2:>3:>4:>5:>6:>7:>8:>Nil)
2 :> 4 :> 6 :> Nil
>>> select d1 d2 d3 (1:>2:>3:>4:>5:>6:>7:>8:>Nil)
2 :> 4 :> 6 :> Nil

selectI :: (CmpNat (i + s) (s * n) ~ 'GT, KnownNat n) => SNat f -> SNat s -> Vec (f + i) a -> Vec n a Source #

"selectI f s xs" selects as many elements as demanded by the context with step-size s and offset f from xs.

>>> selectI d1 d2 (1:>2:>3:>4:>5:>6:>7:>8:>Nil) :: Vec 2 Int
2 :> 4 :> Nil

replicate :: SNat n -> a -> Vec n a Source #

"replicate n a" returns a vector that has n copies of a.

>>> replicate (SNat :: SNat 3) 6
6 :> 6 :> 6 :> Nil
>>> replicate d3 6
6 :> 6 :> 6 :> Nil

repeat :: KnownNat n => a -> Vec n a Source #

"repeat a" creates a vector with as many copies of a as demanded by the context.

>>> repeat 6 :: Vec 5 Int
6 :> 6 :> 6 :> 6 :> 6 :> Nil

iterate :: SNat n -> (a -> a) -> a -> Vec n a Source #

"iterate n f x" returns a vector starting with x followed by n repeated applications of f to x.

iterate (SNat :: SNat 4) f x == (x :> f x :> f (f x) :> f (f (f x)) :> Nil)
iterate d4 f x               == (x :> f x :> f (f x) :> f (f (f x)) :> Nil)

>>> iterate d4 (+1) 1
1 :> 2 :> 3 :> 4 :> Nil

"iterate n f z" corresponds to the following circuit layout:

iterateI :: forall n a. KnownNat n => (a -> a) -> a -> Vec n a Source #

"iterate f x" returns a vector starting with x followed by n repeated applications of f to x, where n is determined by the context.

iterateI f x :: Vec 3 a == (x :> f x :> f (f x) :> Nil)

>>> iterateI (+1) 1 :: Vec 3 Int
1 :> 2 :> 3 :> Nil

"iterateI f z" corresponds to the following circuit layout:

unfoldr :: SNat n -> (s -> (a, s)) -> s -> Vec n a Source #

"'unfoldr n f s" builds a vector of length n from a seed value s, where every element a is created by successive calls of f on s. Unlike unfoldr from Data.List the generating function f cannot dictate the length of the resulting vector, it must be statically known.

a simple use of unfoldr:

>>> unfoldr d10 (\s -> (s,s-1)) 10
10 :> 9 :> 8 :> 7 :> 6 :> 5 :> 4 :> 3 :> 2 :> 1 :> Nil

unfoldrI :: KnownNat n => (s -> (a, s)) -> s -> Vec n a Source #

"'unfoldr f s" builds a vector from a seed value s, where every element a is created by successive calls of f on s; the length of the vector is inferred from the context. Unlike unfoldr from Data.List the generating function f cannot dictate the length of the resulting vector, it must be statically known.

a simple use of unfoldrI:

>>> unfoldrI (\s -> (s,s-1)) 10 :: Vec 10 Int
10 :> 9 :> 8 :> 7 :> 6 :> 5 :> 4 :> 3 :> 2 :> 1 :> Nil

generate :: SNat n -> (a -> a) -> a -> Vec n a Source #

"generate n f x" returns a vector with n repeated applications of f to x.

generate (SNat :: SNat 4) f x == (f x :> f (f x) :> f (f (f x)) :> f (f (f (f x))) :> Nil)
generate d4 f x               == (f x :> f (f x) :> f (f (f x)) :> f (f (f (f x))) :> Nil)

>>> generate d4 (+1) 1
2 :> 3 :> 4 :> 5 :> Nil

"generate n f z" corresponds to the following circuit layout:

generateI :: KnownNat n => (a -> a) -> a -> Vec n a Source #

"generateI f x" returns a vector with n repeated applications of f to x, where n is determined by the context.

generateI f x :: Vec 3 a == (f x :> f (f x) :> f (f (f x)) :> Nil)

>>> generateI (+1) 1 :: Vec 3 Int
2 :> 3 :> 4 :> Nil

"generateI f z" corresponds to the following circuit layout:

transpose :: KnownNat n => Vec m (Vec n a) -> Vec n (Vec m a) Source #

Transpose a matrix: go from row-major to column-major

>>> let xss = (1:>2:>Nil):>(3:>4:>Nil):>(5:>6:>Nil):>Nil
>>> xss
(1 :> 2 :> Nil) :> (3 :> 4 :> Nil) :> (5 :> 6 :> Nil) :> Nil
>>> transpose xss
(1 :> 3 :> 5 :> Nil) :> (2 :> 4 :> 6 :> Nil) :> Nil

stencil1d Source #

Arguments

:: KnownNat n
=> SNat (stX + 1)	Windows length stX, at least size 1
-> (Vec (stX + 1) a -> b)	The stencil (function)
-> Vec ((stX + n) + 1) a
-> Vec (n + 1) b

1-dimensional stencil computations

"stencil1d stX f xs", where xs has stX + n elements, applies the stencil computation f on: n + 1 overlapping (1D) windows of length stX, drawn from xs. The resulting vector has n + 1 elements.

>>> let xs = (1:>2:>3:>4:>5:>6:>Nil)
>>> :t xs
xs :: Num a => Vec 6 a
>>> :t stencil1d d2 sum xs
stencil1d d2 sum xs :: Num b => Vec 5 b
>>> stencil1d d2 sum xs
3 :> 5 :> 7 :> 9 :> 11 :> Nil

stencil2d Source #

Arguments

:: (KnownNat n, KnownNat m)
=> SNat (stY + 1)	Window hight stY, at least size 1
-> SNat (stX + 1)	Window width stX, at least size 1
-> (Vec (stY + 1) (Vec (stX + 1) a) -> b)	The stencil (function)
-> Vec ((stY + m) + 1) (Vec ((stX + n) + 1) a)
-> Vec (m + 1) (Vec (n + 1) b)

2-dimensional stencil computations

"stencil2d stY stX f xss", where xss is a matrix of stY + m rows of stX + n elements, applies the stencil computation f on: (m + 1) * (n + 1) overlapping (2D) windows of stY rows of stX elements, drawn from xss. The result matrix has m + 1 rows of n + 1 elements.

>>> let xss = ((1:>2:>3:>4:>Nil):>(5:>6:>7:>8:>Nil):>(9:>10:>11:>12:>Nil):>(13:>14:>15:>16:>Nil):>Nil)
>>> :t xss
xss :: Num a => Vec 4 (Vec 4 a)
>>> :t stencil2d d2 d2 (sum . map sum) xss
stencil2d d2 d2 (sum . map sum) xss :: Num b => Vec 3 (Vec 3 b)
>>> stencil2d d2 d2 (sum . map sum) xss
(14 :> 18 :> 22 :> Nil) :> (30 :> 34 :> 38 :> Nil) :> (46 :> 50 :> 54 :> Nil) :> Nil

windows1d Source #

Arguments

:: KnownNat n
=> SNat (stX + 1)	Length of the window, at least size 1
-> Vec ((stX + n) + 1) a
-> Vec (n + 1) (Vec (stX + 1) a)

"windows1d stX xs", where the vector xs has stX + n elements, returns a vector of n + 1 overlapping (1D) windows of xs of length stX.

>>> let xs = (1:>2:>3:>4:>5:>6:>Nil)
>>> :t xs
xs :: Num a => Vec 6 a
>>> :t windows1d d2 xs
windows1d d2 xs :: Num a => Vec 5 (Vec 2 a)
>>> windows1d d2 xs
(1 :> 2 :> Nil) :> (2 :> 3 :> Nil) :> (3 :> 4 :> Nil) :> (4 :> 5 :> Nil) :> (5 :> 6 :> Nil) :> Nil

windows2d Source #

Arguments

:: (KnownNat n, KnownNat m)
=> SNat (stY + 1)	Window hight stY, at least size 1
-> SNat (stX + 1)	Window width stX, at least size 1
-> Vec ((stY + m) + 1) (Vec ((stX + n) + 1) a)
-> Vec (m + 1) (Vec (n + 1) (Vec (stY + 1) (Vec (stX + 1) a)))

"windows2d stY stX xss", where matrix xss has stY + m rows of stX + n, returns a matrix of m+1 rows of n+1 elements. The elements of this new matrix are the overlapping (2D) windows of xss, where every window has stY rows of stX elements.

>>> let xss = ((1:>2:>3:>4:>Nil):>(5:>6:>7:>8:>Nil):>(9:>10:>11:>12:>Nil):>(13:>14:>15:>16:>Nil):>Nil)
>>> :t xss
xss :: Num a => Vec 4 (Vec 4 a)
>>> :t windows2d d2 d2 xss
windows2d d2 d2 xss :: Num a => Vec 3 (Vec 3 (Vec 2 (Vec 2 a)))
>>> windows2d d2 d2 xss
(((1 :> 2 :> Nil) :> (5 :> 6 :> Nil) :> Nil) :> ((2 :> 3 :> Nil) :> (6 :> 7 :> Nil) :> Nil) :> ((3 :> 4 :> Nil) :> (7 :> 8 :> Nil) :> Nil) :> Nil) :> (((5 :> 6 :> Nil) :> (9 :> 10 :> Nil) :> Nil) :> ((6 :> 7 :> Nil) :> (10 :> 11 :> Nil) :> Nil) :> ((7 :> 8 :> Nil) :> (11 :> 12 :> Nil) :> Nil) :> Nil) :> (((9 :> 10 :> Nil) :> (13 :> 14 :> Nil) :> Nil) :> ((10 :> 11 :> Nil) :> (14 :> 15 :> Nil) :> Nil) :> ((11 :> 12 :> Nil) :> (15 :> 16 :> Nil) :> Nil) :> Nil) :> Nil

permute Source #

Arguments

:: (Enum i, KnownNat n, KnownNat m)
=> (a -> a -> a)	Combination function, f
-> Vec n a	Default values, def
-> Vec m i	Index mapping, is
-> Vec (m + k) a	Vector to be permuted, xs
-> Vec n a

Forward permutation specified by an index mapping, ix. The result vector is initialized by the given defaults, def, and an further values that are permuted into the result are added to the current value using the given combination function, f.

The combination function must be associative and commutative.

backpermute Source #

Arguments

:: (Enum i, KnownNat n)
=> Vec n a	Source vector, xs
-> Vec m i	Index mapping, is
-> Vec m a

Backwards permutation specified by an index mapping, is, from the destination vector specifying which element of the source vector xs to read.

"backpermute xs is" is equivalent to "map (xs !!) is".

For example:

>>> let input = 1:>9:>6:>4:>4:>2:>0:>1:>2:>Nil
>>> let from  = 1:>3:>7:>2:>5:>3:>Nil
>>> backpermute input from
9 :> 4 :> 1 :> 6 :> 2 :> 4 :> Nil

scatter Source #

Arguments

:: (Enum i, KnownNat n, KnownNat m)
=> Vec n a	Default values, def
-> Vec m i	Index mapping, is
-> Vec (m + k) a	Vector to be scattered, xs
-> Vec n a

Copy elements from the source vector, xs, to the destination vector according to an index mapping is. This is a forward permute operation where a to vector encodes an input to output index mapping. Output elements for indices that are not mapped assume the value in the default vector def.

For example:

>>> let defVec = 0:>0:>0:>0:>0:>0:>0:>0:>0:>Nil
>>> let to = 1:>3:>7:>2:>5:>8:>Nil
>>> let input = 1:>9:>6:>4:>4:>2:>5:>Nil
>>> scatter defVec to input
0 :> 1 :> 4 :> 9 :> 0 :> 4 :> 0 :> 6 :> 2 :> Nil

NB: If the same index appears in the index mapping more than once, the latest mapping is chosen.

gather Source #

Arguments

:: (Enum i, KnownNat n)
=> Vec n a	Source vector, xs
-> Vec m i	Index mapping, is
-> Vec m a

Backwards permutation specified by an index mapping, is, from the destination vector specifying which element of the source vector xs to read.

"gather xs is" is equivalent to "map (xs !!) is".

For example:

>>> let input = 1:>9:>6:>4:>4:>2:>0:>1:>2:>Nil
>>> let from  = 1:>3:>7:>2:>5:>3:>Nil
>>> gather input from
9 :> 4 :> 1 :> 6 :> 2 :> 4 :> Nil

interleave Source #

Arguments

:: (KnownNat n, KnownNat d)
=> SNat d	Interleave step, d
-> Vec (n * d) a
-> Vec (d * n) a

"interleave d xs" creates a vector:

<x_0,x_d,x_(2d),...,x_1,x_(d+1),x_(2d+1),...,x_(d-1),x_(2d-1),x_(3d-1)>

>>> let xs = 1 :> 2 :> 3 :> 4 :> 5 :> 6 :> 7 :> 8 :> 9 :> Nil
>>> interleave d3 xs
1 :> 4 :> 7 :> 2 :> 5 :> 8 :> 3 :> 6 :> 9 :> Nil

rotateLeft :: (Enum i, KnownNat n) => Vec n a -> i -> Vec n a Source #

Dynamically rotate a Vector to the left:

>>> let xs = 1 :> 2 :> 3 :> 4 :> Nil
>>> rotateLeft xs 1
2 :> 3 :> 4 :> 1 :> Nil
>>> rotateLeft xs 2
3 :> 4 :> 1 :> 2 :> Nil
>>> rotateLeft xs (-1)
4 :> 1 :> 2 :> 3 :> Nil

NB: use rotateLeftS if you want to rotate left by a static amount.

rotateRight :: (Enum i, KnownNat n) => Vec n a -> i -> Vec n a Source #

Dynamically rotate a Vector to the right:

>>> let xs = 1 :> 2 :> 3 :> 4 :> Nil
>>> rotateRight xs 1
4 :> 1 :> 2 :> 3 :> Nil
>>> rotateRight xs 2
3 :> 4 :> 1 :> 2 :> Nil
>>> rotateRight xs (-1)
2 :> 3 :> 4 :> 1 :> Nil

NB: use rotateRightS if you want to rotate right by a static amount.

rotateLeftS :: KnownNat n => Vec n a -> SNat d -> Vec n a Source #

Statically rotate a Vector to the left:

>>> let xs = 1 :> 2 :> 3 :> 4 :> Nil
>>> rotateLeftS xs d1
2 :> 3 :> 4 :> 1 :> Nil

NB: use rotateLeft if you want to rotate left by a dynamic amount.

rotateRightS :: KnownNat n => Vec n a -> SNat d -> Vec n a Source #

Statically rotate a Vector to the right:

>>> let xs = 1 :> 2 :> 3 :> 4 :> Nil
>>> rotateRightS xs d1
4 :> 1 :> 2 :> 3 :> Nil

NB: use rotateRight if you want to rotate right by a dynamic amount.

toList :: Vec n a -> [a] Source #

Convert a vector to a list.

>>> toList (1:>2:>3:>Nil)
[1,2,3]

NB: this function is not synthesizable

listToVecTH :: Lift a => [a] -> ExpQ Source #

Create a vector literal from a list literal.

$(listToVecTH [1::Signed 8,2,3,4,5]) == (8:>2:>3:>4:>5:>Nil) :: Vec 5 (Signed 8)

>>> [1 :: Signed 8,2,3,4,5]
[1,2,3,4,5]
>>> $(listToVecTH [1::Signed 8,2,3,4,5])
1 :> 2 :> 3 :> 4 :> 5 :> Nil

asNatProxy :: Vec n a -> Proxy n Source #

Vector as a Proxy for Nat

lengthS :: KnownNat n => Vec n a -> SNat n Source #

Length of a Vector as an SNat value

lazyV :: KnownNat n => Vec n a -> Vec n a Source #

What you should use when your vector functions are too strict in their arguments.

doctests setup

Expand

>>> let compareSwapL a b = if a < b then (a,b) else (b,a)
>>> :{
let sortVL :: (Ord a, KnownNat (n + 1)) => Vec ((n + 1) + 1) a -> Vec ((n + 1) + 1) a
    sortVL xs = map fst sorted :< (snd (last sorted))
      where
        lefts  = head xs :> map snd (init sorted)
        rights = tail xs
        sorted = zipWith compareSwapL (lazyV lefts) rights
:}

>>> :{
let sortV_flip xs = map fst sorted :< (snd (last sorted))
      where
        lefts  = head xs :> map snd (init sorted)
        rights = tail xs
        sorted = zipWith (flip compareSwapL) rights lefts
:}

Example usage

For example:

-- Bubble sort for 1 iteration
sortV xs = map fst sorted :< (snd (last sorted))
 where
   lefts  = head xs :> map snd (init sorted)
   rights = tail xs
   sorted = zipWith compareSwapL lefts rights

-- Compare and swap
compareSwapL a b = if a < b then (a,b)
                            else (b,a)

Will not terminate because zipWith is too strict in its second argument.

In this case, adding lazyV on zipWiths second argument:

sortVL xs = map fst sorted :< (snd (last sorted))
 where
   lefts  = head xs :> map snd (init sorted)
   rights = tail xs
   sorted = zipWith compareSwapL (lazyV lefts) rights

Results in a successful computation:

>>> sortVL (4 :> 1 :> 2 :> 3 :> Nil)
1 :> 2 :> 3 :> 4 :> Nil

NB: There is also a solution using flip, but it slightly obfuscates the meaning of the code:

sortV_flip xs = map fst sorted :< (snd (last sorted))
 where
   lefts  = head xs :> map snd (init sorted)
   rights = tail xs
   sorted = zipWith (flip compareSwapL) rights lefts

>>> sortV_flip (4 :> 1 :> 2 :> 3 :> Nil)
1 :> 2 :> 3 :> 4 :> Nil

dfold Source #

Arguments

:: forall p k a. KnownNat k
=> Proxy (p :: TyFun Nat Type -> Type)	The motive
-> (forall l. SNat l -> a -> (p @@ l) -> p @@ (l + 1))	Function to fold. NB: The `SNat l` is not the index (see (`!!`)) to the element a. `SNat l` is the number of elements that occur to the right of a.
-> (p @@ 0)	Initial element
-> Vec k a	Vector to fold over
-> p @@ k

A dependently typed fold.

doctests setup

Expand

>>> :seti -fplugin GHC.TypeLits.Normalise
>>> import Data.Singletons (Apply, Proxy (..), TyFun)
>>> data Append (m :: Nat) (a :: Type) (f :: TyFun Nat Type) :: Type
>>> type instance Apply (Append m a) l = Vec (l + m) a
>>> let append' xs ys = dfold (Proxy :: Proxy (Append m a)) (const (:>)) ys xs

Example usage

Using lists, we can define append (a.k.a. Data.List.++) in terms of Data.List.foldr:

>>> import qualified Data.List
>>> let append xs ys = Data.List.foldr (:) ys xs
>>> append [1,2] [3,4]
[1,2,3,4]

However, when we try to do the same for Vec, by defining append' in terms of Clash.Sized.Vector.foldr:

append' xs ys = foldr (:>) ys xs

we get a type error:

>>> let append' xs ys = foldr (:>) ys xs

<interactive>:...
    • Occurs check: cannot construct the infinite type: ... ~ ... + 1
      Expected type: a -> Vec ... a -> Vec ... a
        Actual type: a -> Vec ... a -> Vec (... + 1) a
    • In the first argument of ‘foldr’, namely ‘(:>)’
      In the expression: foldr (:>) ys xs
      In an equation for ‘append'’: append' xs ys = foldr (:>) ys xs
    • Relevant bindings include
        ys :: Vec ... a (bound at ...)
        append' :: Vec n a -> Vec ... a -> Vec ... a
          (bound at ...)

The reason is that the type of foldr is:

>>> :t foldr
foldr :: (a -> b -> b) -> b -> Vec n a -> b

While the type of (:>) is:

>>> :t (:>)
(:>) :: a -> Vec n a -> Vec (n + 1) a

We thus need a fold function that can handle the growing vector type: dfold. Compared to foldr, dfold takes an extra parameter, called the motive, that allows the folded function to have an argument and result type that depends on the current length of the vector. Using dfold, we can now correctly define append':

import Data.Singletons
import Data.Proxy

data Append (m :: Nat) (a :: Type) (f :: TyFun Nat Type) :: Type
type instance Apply (Append m a) l = Vec (l + m) a

append' xs ys = dfold (Proxy :: Proxy (Append m a)) (const (:>)) ys xs

We now see that append' has the appropriate type:

>>> :t append'
append' :: KnownNat k => Vec k a -> Vec m a -> Vec (k + m) a

And that it works:

>>> append' (1 :> 2 :> Nil) (3 :> 4 :> Nil)
1 :> 2 :> 3 :> 4 :> Nil

NB: "dfold m f z xs" creates a linear structure, which has a depth, or delay, of O(length xs). Look at dtfold for a dependently typed fold that produces a structure with a depth of O(log_2(length xs)).

dtfold Source #

Arguments

:: forall p k a. KnownNat k
=> Proxy (p :: TyFun Nat Type -> Type)	The motive
-> (a -> p @@ 0)	Function to apply to every element
-> (forall l. SNat l -> (p @@ l) -> (p @@ l) -> p @@ (l + 1))	Function to combine results. NB: The `SNat l` indicates the depth/height of the node in the tree that is created by applying this function. The leafs of the tree have depth/height 0, and the root of the tree has height k.
-> Vec (2 ^ k) a	Vector to fold over. NB: Must have a length that is a power of 2.
-> p @@ k

A combination of dfold and fold: a dependently typed fold that reduces a vector in a tree-like structure.

doctests setup

Expand

>>> :seti -XUndecidableInstances
>>> import Data.Singletons (Apply, Proxy (..), TyFun)
>>> data IIndex (f :: TyFun Nat Type) :: Type
>>> type instance Apply IIndex l = Index ((2^l)+1)
>>> :{
let populationCount' :: (KnownNat k, KnownNat (2^k)) => BitVector (2^k) -> Index ((2^k)+1)
    populationCount' bv = dtfold (Proxy @IIndex)
                                 fromIntegral
                                 (\_ x y -> add x y)
                                 (bv2v bv)
:}

Example usage

As an example of when you might want to use dtfold we will build a population counter: a circuit that counts the number of bits set to '1' in a BitVector. Given a vector of n bits, we only need we need a data type that can represent the number n: Index (n+1). Index k has a range of [0 .. k-1] (using ceil(log2(k)) bits), hence we need Index n+1. As an initial attempt we will use sum, because it gives a nice (log2(n)) tree-structure of adders:

populationCount :: (KnownNat (n+1), KnownNat (n+2))
                => BitVector (n+1) -> Index (n+2)
populationCount = sum . map fromIntegral . bv2v

The "problem" with this description is that all adders have the same bit-width, i.e. all adders are of the type:

(+) :: Index (n+2) -> Index (n+2) -> Index (n+2).

This is a "problem" because we could have a more efficient structure: one where each layer of adders is precisely wide enough to count the number of bits at that layer. That is, at height d we want the adder to be of type:

Index ((2^d)+1) -> Index ((2^d)+1) -> Index ((2^(d+1))+1)

We have such an adder in the form of the add function, as defined in the instance ExtendingNum instance of Index. However, we cannot simply use fold to create a tree-structure of addes:

# 2271 "srcClashSized/Vector.hs" >>> :{ let populationCount' :: (KnownNat (n+1), KnownNat (n+2)) => BitVector (n+1) -> Index (n+2) populationCount' = fold add . map fromIntegral . bv2v :} BLANKLINE interactive:... • Couldn't match type ‘((n + 2) + (n + 2)) - 1’ with ‘n + 2’ Expected type: Index (n + 2) -> Index (n + 2) -> Index (n + 2) Actual type: Index (n + 2) -> Index (n + 2) -> AResult (Index (n + 2)) (Index (n + 2)) • In the first argument of ‘fold’, namely ‘add’ In the first argument of ‘(.)’, namely ‘fold add’ In the expression: fold add . map fromIntegral . bv2v • Relevant bindings include populationCount' :: BitVector (n + 1) -> Index (n + 2) (bound at ...)

because fold expects a function of type "a -> a -> a", i.e. a function where the arguments and result all have exactly the same type.

In order to accommodate the type of our add, where the result is larger than the arguments, we must use a dependently typed fold in the form of dtfold:

{-# LANGUAGE UndecidableInstances #-}
import Data.Singletons
import Data.Proxy

data IIndex (f :: TyFun Nat Type) :: Type
type instance Apply IIndex l = Index ((2^l)+1)

populationCount' :: (KnownNat k, KnownNat (2^k))
                 => BitVector (2^k) -> Index ((2^k)+1)
populationCount' bv = dtfold (Proxy @IIndex)
                             fromIntegral
                             (\_ x y -> add x y)
                             (bv2v bv)

And we can test that it works:

>>> :t populationCount' (7 :: BitVector 16)
populationCount' (7 :: BitVector 16) :: Index 17
>>> populationCount' (7 :: BitVector 16)
3

Some final remarks:

By using dtfold instead of fold, we had to restrict our BitVector argument to have bit-width that is a power of 2.
Even though our original populationCount function specified a structure where all adders had the same width. Most VHDL/(System)Verilog synthesis tools will create a more efficient circuit, i.e. one where the adders have an increasing bit-width for every layer, from the VHDL/(System)Verilog produced by the Clash compiler.

NB: The depth, or delay, of the structure produced by "dtfold m f g xs" is O(log_2(length xs)).

vfold :: forall k a b. KnownNat k => (forall l. SNat l -> a -> Vec l b -> Vec (l + 1) b) -> Vec k a -> Vec k b Source #

Specialised version of dfold that builds a triangular computational structure.

doctests setup

Expand

>>> let compareSwap a b = if a > b then (a,b) else (b,a)
>>> let insert y xs = let (y',xs') = mapAccumL compareSwap y xs in xs' :< y'
>>> let insertionSort = vfold (const insert)

Example usage

compareSwap a b = if a > b then (a,b) else (b,a)
insert y xs     = let (y',xs') = mapAccumL compareSwap y xs in xs' :< y'
insertionSort   = vfold (const insert)

Builds a triangular structure of compare and swaps to sort a row.

>>> insertionSort (7 :> 3 :> 9 :> 1 :> Nil)
1 :> 3 :> 7 :> 9 :> Nil

The circuit layout of insertionSort, build using vfold, is:

smap :: forall k a b. KnownNat k => (forall l. SNat l -> a -> b) -> Vec k a -> Vec k b Source #

Apply a function to every element of a vector and the element's position (as an SNat value) in the vector.

>>> let rotateMatrix = smap (flip rotateRightS)
>>> let xss = (1:>2:>3:>Nil):>(1:>2:>3:>Nil):>(1:>2:>3:>Nil):>Nil
>>> xss
(1 :> 2 :> 3 :> Nil) :> (1 :> 2 :> 3 :> Nil) :> (1 :> 2 :> 3 :> Nil) :> Nil
>>> rotateMatrix xss
(1 :> 2 :> 3 :> Nil) :> (3 :> 1 :> 2 :> Nil) :> (2 :> 3 :> 1 :> Nil) :> Nil

concatBitVector# :: forall n m. (KnownNat n, KnownNat m) => Vec n (BitVector m) -> BitVector (n * m) Source #

unconcatBitVector# :: forall n m. (KnownNat n, KnownNat m) => BitVector (n * m) -> Vec n (BitVector m) Source #

v2bv :: KnownNat n => Vec n Bit -> BitVector n Source #

Convert a Vec of Bits to a BitVector.

>>> let x = (0:>0:>0:>1:>0:>0:>1:>0:>Nil) :: Vec 8 Bit
>>> x
0 :> 0 :> 0 :> 1 :> 0 :> 0 :> 1 :> 0 :> Nil
>>> v2bv x
0b0001_0010

seqV :: KnownNat n => Vec n a -> b -> b infixr 0 Source #

Evaluate all elements of a vector to WHNF, returning the second argument

forceV :: KnownNat n => Vec n a -> Vec n a Source #

Evaluate all elements of a vector to WHNF

seqVX :: KnownNat n => Vec n a -> b -> b infixr 0 Source #

Evaluate all elements of a vector to WHNF, returning the second argument. Does not propagate XExceptions.

forceVX :: KnownNat n => Vec n a -> Vec n a Source #

Evaluate all elements of a vector to WHNF. Does not propagate XExceptions.

Perfect depth trees

module Clash.Sized.RTree

Annotations

module Clash.Annotations.TopEntity

Generics type-classes

class Generic a #

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Instances details

Generic Bool	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Generic Ordering	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Generic Exp
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Exp :: Type -> Type # Methods from :: Exp -> Rep Exp x # to :: Rep Exp x -> Exp #
Generic Match
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Match :: Type -> Type # Methods from :: Match -> Rep Match x # to :: Rep Match x -> Match #
Generic Clause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Clause :: Type -> Type # Methods from :: Clause -> Rep Clause x # to :: Rep Clause x -> Clause #
Generic Pat
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pat :: Type -> Type # Methods from :: Pat -> Rep Pat x # to :: Rep Pat x -> Pat #
Generic Type
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Type :: Type -> Type # Methods from :: Type -> Rep Type x # to :: Rep Type x -> Type #
Generic Dec
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Dec :: Type -> Type # Methods from :: Dec -> Rep Dec x # to :: Rep Dec x -> Dec #
Generic Name
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Name :: Type -> Type # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
Generic FunDep
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FunDep :: Type -> Type # Methods from :: FunDep -> Rep FunDep x # to :: Rep FunDep x -> FunDep #
Generic InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep InjectivityAnn :: Type -> Type # Methods from :: InjectivityAnn -> Rep InjectivityAnn x # to :: Rep InjectivityAnn x -> InjectivityAnn #
Generic Overlap
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Overlap :: Type -> Type # Methods from :: Overlap -> Rep Overlap x # to :: Rep Overlap x -> Overlap #
Generic ()	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type # Methods from :: () -> Rep () x # to :: Rep () x -> () #
Generic Version	Since: base-4.9.0.0
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type # Methods from :: Version -> Rep Version x # to :: Rep Version x -> Version #
Generic Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type # Methods from :: Void -> Rep Void x # to :: Rep Void x -> Void #
Generic ExitCode
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type # Methods from :: ExitCode -> Rep ExitCode x # to :: Rep ExitCode x -> ExitCode #
Generic All	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type # Methods from :: All -> Rep All x # to :: Rep All x -> All #
Generic Any	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type # Methods from :: Any -> Rep Any x # to :: Rep Any x -> Any #
Generic Fixity	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic Associativity	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type # Methods from :: Associativity -> Rep Associativity x # to :: Rep Associativity x -> Associativity #
Generic SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic Extension
Instance details Defined in GHC.LanguageExtensions.Type Associated Types type Rep Extension :: Type -> Type # Methods from :: Extension -> Rep Extension x # to :: Rep Extension x -> Extension #
Generic ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Associated Types type Rep ForeignSrcLang :: Type -> Type # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x # to :: Rep ForeignSrcLang x -> ForeignSrcLang #
Generic Half
Instance details Defined in Numeric.Half.Internal Associated Types type Rep Half :: Type -> Type # Methods from :: Half -> Rep Half x # to :: Rep Half x -> Half #
Generic Boxed
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep Boxed :: Type -> Type # Methods from :: Boxed -> Rep Boxed x # to :: Rep Boxed x -> Boxed #
Generic Tool
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep Tool :: Type -> Type # Methods from :: Tool -> Rep Tool x # to :: Rep Tool x -> Tool #
Generic SrcLoc
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcLoc :: Type -> Type # Methods from :: SrcLoc -> Rep SrcLoc x # to :: Rep SrcLoc x -> SrcLoc #
Generic SrcSpan
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcSpan :: Type -> Type # Methods from :: SrcSpan -> Rep SrcSpan x # to :: Rep SrcSpan x -> SrcSpan #
Generic SrcSpanInfo
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcSpanInfo :: Type -> Type # Methods from :: SrcSpanInfo -> Rep SrcSpanInfo x # to :: Rep SrcSpanInfo x -> SrcSpanInfo #
Generic Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Mode :: Type -> Type # Methods from :: Mode -> Rep Mode x # to :: Rep Mode x -> Mode #
Generic Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Style :: Type -> Type # Methods from :: Style -> Rep Style x # to :: Rep Style x -> Style #
Generic Stmt
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Stmt :: Type -> Type # Methods from :: Stmt -> Rep Stmt x # to :: Rep Stmt x -> Stmt #
Generic ModName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModName :: Type -> Type # Methods from :: ModName -> Rep ModName x # to :: Rep ModName x -> ModName #
Generic Phases
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Phases :: Type -> Type # Methods from :: Phases -> Rep Phases x # to :: Rep Phases x -> Phases #
Generic RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleBndr :: Type -> Type # Methods from :: RuleBndr -> Rep RuleBndr x # to :: Rep RuleBndr x -> RuleBndr #
Generic Pragma
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pragma :: Type -> Type # Methods from :: Pragma -> Rep Pragma x # to :: Rep Pragma x -> Pragma #
Generic DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivClause :: Type -> Type # Methods from :: DerivClause -> Rep DerivClause x # to :: Rep DerivClause x -> DerivClause #
Generic Con
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Con :: Type -> Type # Methods from :: Con -> Rep Con x # to :: Rep Con x -> Con #
Generic DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivStrategy :: Type -> Type # Methods from :: DerivStrategy -> Rep DerivStrategy x # to :: Rep DerivStrategy x -> DerivStrategy #
Generic TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TySynEqn :: Type -> Type # Methods from :: TySynEqn -> Rep TySynEqn x # to :: Rep TySynEqn x -> TySynEqn #
Generic TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyVarBndr :: Type -> Type # Methods from :: TyVarBndr -> Rep TyVarBndr x # to :: Rep TyVarBndr x -> TyVarBndr #
Generic Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Associated Types type Rep Doc :: Type -> Type # Methods from :: Doc -> Rep Doc x # to :: Rep Doc x -> Doc #
Generic TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep TextDetails :: Type -> Type # Methods from :: TextDetails -> Rep TextDetails x # to :: Rep TextDetails x -> TextDetails #
Generic PkgName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PkgName :: Type -> Type # Methods from :: PkgName -> Rep PkgName x # to :: Rep PkgName x -> PkgName #
Generic Module
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Module :: Type -> Type # Methods from :: Module -> Rep Module x # to :: Rep Module x -> Module #
Generic OccName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep OccName :: Type -> Type # Methods from :: OccName -> Rep OccName x # to :: Rep OccName x -> OccName #
Generic NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameFlavour :: Type -> Type # Methods from :: NameFlavour -> Rep NameFlavour x # to :: Rep NameFlavour x -> NameFlavour #
Generic NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameSpace :: Type -> Type # Methods from :: NameSpace -> Rep NameSpace x # to :: Rep NameSpace x -> NameSpace #
Generic Loc
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Loc :: Type -> Type # Methods from :: Loc -> Rep Loc x # to :: Rep Loc x -> Loc #
Generic Info
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Info :: Type -> Type # Methods from :: Info -> Rep Info x # to :: Rep Info x -> Info #
Generic ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModuleInfo :: Type -> Type # Methods from :: ModuleInfo -> Rep ModuleInfo x # to :: Rep ModuleInfo x -> ModuleInfo #
Generic Fixity
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FixityDirection :: Type -> Type # Methods from :: FixityDirection -> Rep FixityDirection x # to :: Rep FixityDirection x -> FixityDirection #
Generic Lit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Lit :: Type -> Type # Methods from :: Lit -> Rep Lit x # to :: Rep Lit x -> Lit #
Generic Bytes
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bytes :: Type -> Type # Methods from :: Bytes -> Rep Bytes x # to :: Rep Bytes x -> Bytes #
Generic Body
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Body :: Type -> Type # Methods from :: Body -> Rep Body x # to :: Rep Body x -> Body #
Generic Guard
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Guard :: Type -> Type # Methods from :: Guard -> Rep Guard x # to :: Rep Guard x -> Guard #
Generic Range
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Range :: Type -> Type # Methods from :: Range -> Rep Range x # to :: Rep Range x -> Range #
Generic TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TypeFamilyHead :: Type -> Type # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x # to :: Rep TypeFamilyHead x -> TypeFamilyHead #
Generic Foreign
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Foreign :: Type -> Type # Methods from :: Foreign -> Rep Foreign x # to :: Rep Foreign x -> Foreign #
Generic Callconv
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Callconv :: Type -> Type # Methods from :: Callconv -> Rep Callconv x # to :: Rep Callconv x -> Callconv #
Generic Safety
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Safety :: Type -> Type # Methods from :: Safety -> Rep Safety x # to :: Rep Safety x -> Safety #
Generic Inline
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Inline :: Type -> Type # Methods from :: Inline -> Rep Inline x # to :: Rep Inline x -> Inline #
Generic RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleMatch :: Type -> Type # Methods from :: RuleMatch -> Rep RuleMatch x # to :: Rep RuleMatch x -> RuleMatch #
Generic AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnTarget :: Type -> Type # Methods from :: AnnTarget -> Rep AnnTarget x # to :: Rep AnnTarget x -> AnnTarget #
Generic SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic Bang
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bang :: Type -> Type # Methods from :: Bang -> Rep Bang x # to :: Rep Bang x -> Bang #
Generic PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynDir :: Type -> Type # Methods from :: PatSynDir -> Rep PatSynDir x # to :: Rep PatSynDir x -> PatSynDir #
Generic PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynArgs :: Type -> Type # Methods from :: PatSynArgs -> Rep PatSynArgs x # to :: Rep PatSynArgs x -> PatSynArgs #
Generic FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FamilyResultSig :: Type -> Type # Methods from :: FamilyResultSig -> Rep FamilyResultSig x # to :: Rep FamilyResultSig x -> FamilyResultSig #
Generic TyLit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyLit :: Type -> Type # Methods from :: TyLit -> Rep TyLit x # to :: Rep TyLit x -> TyLit #
Generic Role
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Role :: Type -> Type # Methods from :: Role -> Rep Role x # to :: Rep Role x -> Role #
Generic AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnLookup :: Type -> Type # Methods from :: AnnLookup -> Rep AnnLookup x # to :: Rep AnnLookup x -> AnnLookup #
Generic DatatypeInfo
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep DatatypeInfo :: Type -> Type # Methods from :: DatatypeInfo -> Rep DatatypeInfo x # to :: Rep DatatypeInfo x -> DatatypeInfo #
Generic DatatypeVariant
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep DatatypeVariant :: Type -> Type # Methods from :: DatatypeVariant -> Rep DatatypeVariant x # to :: Rep DatatypeVariant x -> DatatypeVariant #
Generic ConstructorInfo
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep ConstructorInfo :: Type -> Type # Methods from :: ConstructorInfo -> Rep ConstructorInfo x # to :: Rep ConstructorInfo x -> ConstructorInfo #
Generic ConstructorVariant
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep ConstructorVariant :: Type -> Type # Methods from :: ConstructorVariant -> Rep ConstructorVariant x # to :: Rep ConstructorVariant x -> ConstructorVariant #
Generic FieldStrictness
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep FieldStrictness :: Type -> Type # Methods from :: FieldStrictness -> Rep FieldStrictness x # to :: Rep FieldStrictness x -> FieldStrictness #
Generic Unpackedness
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep Unpackedness :: Type -> Type # Methods from :: Unpackedness -> Rep Unpackedness x # to :: Rep Unpackedness x -> Unpackedness #
Generic Strictness
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep Strictness :: Type -> Type # Methods from :: Strictness -> Rep Strictness x # to :: Rep Strictness x -> Strictness #
Generic Specificity
Instance details Defined in Language.Haskell.TH.Datatype.TyVarBndr Associated Types type Rep Specificity :: Type -> Type # Methods from :: Specificity -> Rep Specificity x # to :: Rep Specificity x -> Specificity #
Generic DTypeArg
Instance details Defined in Language.Haskell.TH.Desugar.Core Associated Types type Rep DTypeArg :: Type -> Type # Methods from :: DTypeArg -> Rep DTypeArg x # to :: Rep DTypeArg x -> DTypeArg #
Generic DFunArgs
Instance details Defined in Language.Haskell.TH.Desugar.Core Associated Types type Rep DFunArgs :: Type -> Type # Methods from :: DFunArgs -> Rep DFunArgs x # to :: Rep DFunArgs x -> DFunArgs #
Generic DVisFunArg
Instance details Defined in Language.Haskell.TH.Desugar.Core Associated Types type Rep DVisFunArg :: Type -> Type # Methods from :: DVisFunArg -> Rep DVisFunArg x # to :: Rep DVisFunArg x -> DVisFunArg #
Generic DExp
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DExp :: Type -> Type # Methods from :: DExp -> Rep DExp x # to :: Rep DExp x -> DExp #
Generic DPat
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DPat :: Type -> Type # Methods from :: DPat -> Rep DPat x # to :: Rep DPat x -> DPat #
Generic DType
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DType :: Type -> Type # Methods from :: DType -> Rep DType x # to :: Rep DType x -> DType #
Generic DTyVarBndr
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DTyVarBndr :: Type -> Type # Methods from :: DTyVarBndr -> Rep DTyVarBndr x # to :: Rep DTyVarBndr x -> DTyVarBndr #
Generic DMatch
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DMatch :: Type -> Type # Methods from :: DMatch -> Rep DMatch x # to :: Rep DMatch x -> DMatch #
Generic DClause
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DClause :: Type -> Type # Methods from :: DClause -> Rep DClause x # to :: Rep DClause x -> DClause #
Generic DLetDec
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DLetDec :: Type -> Type # Methods from :: DLetDec -> Rep DLetDec x # to :: Rep DLetDec x -> DLetDec #
Generic NewOrData
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep NewOrData :: Type -> Type # Methods from :: NewOrData -> Rep NewOrData x # to :: Rep NewOrData x -> NewOrData #
Generic DDec
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DDec :: Type -> Type # Methods from :: DDec -> Rep DDec x # to :: Rep DDec x -> DDec #
Generic DPatSynDir
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DPatSynDir :: Type -> Type # Methods from :: DPatSynDir -> Rep DPatSynDir x # to :: Rep DPatSynDir x -> DPatSynDir #
Generic DTypeFamilyHead
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DTypeFamilyHead :: Type -> Type # Methods from :: DTypeFamilyHead -> Rep DTypeFamilyHead x # to :: Rep DTypeFamilyHead x -> DTypeFamilyHead #
Generic DFamilyResultSig
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DFamilyResultSig :: Type -> Type # Methods from :: DFamilyResultSig -> Rep DFamilyResultSig x # to :: Rep DFamilyResultSig x -> DFamilyResultSig #
Generic DCon
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DCon :: Type -> Type # Methods from :: DCon -> Rep DCon x # to :: Rep DCon x -> DCon #
Generic DConFields
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DConFields :: Type -> Type # Methods from :: DConFields -> Rep DConFields x # to :: Rep DConFields x -> DConFields #
Generic DForeign
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DForeign :: Type -> Type # Methods from :: DForeign -> Rep DForeign x # to :: Rep DForeign x -> DForeign #
Generic DPragma
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DPragma :: Type -> Type # Methods from :: DPragma -> Rep DPragma x # to :: Rep DPragma x -> DPragma #
Generic DRuleBndr
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DRuleBndr :: Type -> Type # Methods from :: DRuleBndr -> Rep DRuleBndr x # to :: Rep DRuleBndr x -> DRuleBndr #
Generic DTySynEqn
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DTySynEqn :: Type -> Type # Methods from :: DTySynEqn -> Rep DTySynEqn x # to :: Rep DTySynEqn x -> DTySynEqn #
Generic DInfo
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DInfo :: Type -> Type # Methods from :: DInfo -> Rep DInfo x # to :: Rep DInfo x -> DInfo #
Generic DDerivClause
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DDerivClause :: Type -> Type # Methods from :: DDerivClause -> Rep DDerivClause x # to :: Rep DDerivClause x -> DDerivClause #
Generic DDerivStrategy
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DDerivStrategy :: Type -> Type # Methods from :: DDerivStrategy -> Rep DDerivStrategy x # to :: Rep DDerivStrategy x -> DDerivStrategy #
Generic ConstrRepr Source #
Instance details Defined in Clash.Annotations.BitRepresentation Associated Types type Rep ConstrRepr :: Type -> Type # Methods from :: ConstrRepr -> Rep ConstrRepr x # to :: Rep ConstrRepr x -> ConstrRepr #
Generic DataReprAnn Source #
Instance details Defined in Clash.Annotations.BitRepresentation Associated Types type Rep DataReprAnn :: Type -> Type # Methods from :: DataReprAnn -> Rep DataReprAnn x # to :: Rep DataReprAnn x -> DataReprAnn #
Generic ConstrRepr' Source #
Instance details Defined in Clash.Annotations.BitRepresentation.Internal Associated Types type Rep ConstrRepr' :: Type -> Type # Methods from :: ConstrRepr' -> Rep ConstrRepr' x # to :: Rep ConstrRepr' x -> ConstrRepr' #
Generic DataRepr' Source #
Instance details Defined in Clash.Annotations.BitRepresentation.Internal Associated Types type Rep DataRepr' :: Type -> Type # Methods from :: DataRepr' -> Rep DataRepr' x # to :: Rep DataRepr' x -> DataRepr' #
Generic Type' Source #
Instance details Defined in Clash.Annotations.BitRepresentation.Internal Associated Types type Rep Type' :: Type -> Type # Methods from :: Type' -> Rep Type' x # to :: Rep Type' x -> Type' #
Generic PrimitiveWarning Source #
Instance details Defined in Clash.Annotations.Primitive Associated Types type Rep PrimitiveWarning :: Type -> Type # Methods from :: PrimitiveWarning -> Rep PrimitiveWarning x # to :: Rep PrimitiveWarning x -> PrimitiveWarning #
Generic Primitive Source #
Instance details Defined in Clash.Annotations.Primitive Associated Types type Rep Primitive :: Type -> Type # Methods from :: Primitive -> Rep Primitive x # to :: Rep Primitive x -> Primitive #
Generic HDL Source #
Instance details Defined in Clash.Annotations.Primitive Associated Types type Rep HDL :: Type -> Type # Methods from :: HDL -> Rep HDL x # to :: Rep HDL x -> HDL #
Generic Bit Source #
Instance details Defined in Clash.Sized.Internal.BitVector Associated Types type Rep Bit :: Type -> Type # Methods from :: Bit -> Rep Bit x # to :: Rep Bit x -> Bit #
Generic VDomainConfiguration Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep VDomainConfiguration :: Type -> Type # Methods from :: VDomainConfiguration -> Rep VDomainConfiguration x # to :: Rep VDomainConfiguration x -> VDomainConfiguration #
Generic InitBehavior Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep InitBehavior :: Type -> Type # Methods from :: InitBehavior -> Rep InitBehavior x # to :: Rep InitBehavior x -> InitBehavior #
Generic ResetPolarity Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep ResetPolarity :: Type -> Type # Methods from :: ResetPolarity -> Rep ResetPolarity x # to :: Rep ResetPolarity x -> ResetPolarity #
Generic ResetKind Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep ResetKind :: Type -> Type # Methods from :: ResetKind -> Rep ResetKind x # to :: Rep ResetKind x -> ResetKind #
Generic ActiveEdge Source #
Instance details Defined in Clash.Signal.Internal Associated Types type Rep ActiveEdge :: Type -> Type # Methods from :: ActiveEdge -> Rep ActiveEdge x # to :: Rep ActiveEdge x -> ActiveEdge #
Generic PortName Source #
Instance details Defined in Clash.Annotations.TopEntity Associated Types type Rep PortName :: Type -> Type # Methods from :: PortName -> Rep PortName x # to :: Rep PortName x -> PortName #
Generic TopEntity Source #
Instance details Defined in Clash.Annotations.TopEntity Associated Types type Rep TopEntity :: Type -> Type # Methods from :: TopEntity -> Rep TopEntity x # to :: Rep TopEntity x -> TopEntity #
Generic RxReg Source #
Instance details Defined in Clash.Examples.Internal Associated Types type Rep RxReg :: Type -> Type # Methods from :: RxReg -> Rep RxReg x # to :: Rep RxReg x -> RxReg #
Generic TxReg Source #
Instance details Defined in Clash.Examples.Internal Associated Types type Rep TxReg :: Type -> Type # Methods from :: TxReg -> Rep TxReg x # to :: Rep TxReg x -> TxReg #
Generic [a]	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type # Methods from :: [a] -> Rep [a] x # to :: Rep [a] x -> [a] #
Generic (Maybe a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type # Methods from :: Par1 p -> Rep (Par1 p) x # to :: Rep (Par1 p) x -> Par1 p #
Generic (Solo a)
Instance details Defined in Data.Tuple.Solo Associated Types type Rep (Solo a) :: Type -> Type # Methods from :: Solo a -> Rep (Solo a) x # to :: Rep (Solo a) x -> Solo a #
Generic (Complex a)	Since: base-4.9.0.0
Instance details Defined in Data.Complex Associated Types type Rep (Complex a) :: Type -> Type # Methods from :: Complex a -> Rep (Complex a) x # to :: Rep (Complex a) x -> Complex a #
Generic (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type # Methods from :: Min a -> Rep (Min a) x # to :: Rep (Min a) x -> Min a #
Generic (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type # Methods from :: Max a -> Rep (Max a) x # to :: Rep (Max a) x -> Max a #
Generic (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m #
Generic (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep (Option a) :: Type -> Type # Methods from :: Option a -> Rep (Option a) x # to :: Rep (Option a) x -> Option a #
Generic (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type # Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
Generic (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Generic (First a)	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Dual a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type # Methods from :: Dual a -> Rep (Dual a) x # to :: Rep (Dual a) x -> Dual a #
Generic (Endo a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type # Methods from :: Endo a -> Rep (Endo a) x # to :: Rep (Endo a) x -> Endo a #
Generic (Sum a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type # Methods from :: Sum a -> Rep (Sum a) x # to :: Rep (Sum a) x -> Sum a #
Generic (Product a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type # Methods from :: Product a -> Rep (Product a) x # to :: Rep (Product a) x -> Product a #
Generic (Down a)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type # Methods from :: Down a -> Rep (Down a) x # to :: Rep (Down a) x -> Down a #
Generic (NonEmpty a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type # Methods from :: NonEmpty a -> Rep (NonEmpty a) x # to :: Rep (NonEmpty a) x -> NonEmpty a #
Generic (Tree a)	Since: containers-0.5.8
Instance details Defined in Data.Tree Associated Types type Rep (Tree a) :: Type -> Type # Methods from :: Tree a -> Rep (Tree a) x # to :: Rep (Tree a) x -> Tree a #
Generic (FingerTree a)	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type # Methods from :: FingerTree a -> Rep (FingerTree a) x # to :: Rep (FingerTree a) x -> FingerTree a #
Generic (Digit a)	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Digit a) :: Type -> Type # Methods from :: Digit a -> Rep (Digit a) x # to :: Rep (Digit a) x -> Digit a #
Generic (Node a)	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Node a) :: Type -> Type # Methods from :: Node a -> Rep (Node a) x # to :: Rep (Node a) x -> Node a #
Generic (Elem a)	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Elem a) :: Type -> Type # Methods from :: Elem a -> Rep (Elem a) x # to :: Rep (Elem a) x -> Elem a #
Generic (ViewL a)	Since: containers-0.5.8
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewL a) :: Type -> Type # Methods from :: ViewL a -> Rep (ViewL a) x # to :: Rep (ViewL a) x -> ViewL a #
Generic (ViewR a)	Since: containers-0.5.8
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewR a) :: Type -> Type # Methods from :: ViewR a -> Rep (ViewR a) x # to :: Rep (ViewR a) x -> ViewR a #
Generic (Fix f)
Instance details Defined in Data.Fix Associated Types type Rep (Fix f) :: Type -> Type # Methods from :: Fix f -> Rep (Fix f) x # to :: Rep (Fix f) x -> Fix f #
Generic (ModuleName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModuleName l) :: Type -> Type # Methods from :: ModuleName l -> Rep (ModuleName l) x # to :: Rep (ModuleName l) x -> ModuleName l #
Generic (SpecialCon l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (SpecialCon l) :: Type -> Type # Methods from :: SpecialCon l -> Rep (SpecialCon l) x # to :: Rep (SpecialCon l) x -> SpecialCon l #
Generic (QName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QName l) :: Type -> Type # Methods from :: QName l -> Rep (QName l) x # to :: Rep (QName l) x -> QName l #
Generic (Name l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Name l) :: Type -> Type # Methods from :: Name l -> Rep (Name l) x # to :: Rep (Name l) x -> Name l #
Generic (IPName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (IPName l) :: Type -> Type # Methods from :: IPName l -> Rep (IPName l) x # to :: Rep (IPName l) x -> IPName l #
Generic (QOp l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QOp l) :: Type -> Type # Methods from :: QOp l -> Rep (QOp l) x # to :: Rep (QOp l) x -> QOp l #
Generic (Op l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Op l) :: Type -> Type # Methods from :: Op l -> Rep (Op l) x # to :: Rep (Op l) x -> Op l #
Generic (CName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (CName l) :: Type -> Type # Methods from :: CName l -> Rep (CName l) x # to :: Rep (CName l) x -> CName l #
Generic (Module l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Module l) :: Type -> Type # Methods from :: Module l -> Rep (Module l) x # to :: Rep (Module l) x -> Module l #
Generic (ModuleHead l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModuleHead l) :: Type -> Type # Methods from :: ModuleHead l -> Rep (ModuleHead l) x # to :: Rep (ModuleHead l) x -> ModuleHead l #
Generic (ExportSpecList l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ExportSpecList l) :: Type -> Type # Methods from :: ExportSpecList l -> Rep (ExportSpecList l) x # to :: Rep (ExportSpecList l) x -> ExportSpecList l #
Generic (ExportSpec l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ExportSpec l) :: Type -> Type # Methods from :: ExportSpec l -> Rep (ExportSpec l) x # to :: Rep (ExportSpec l) x -> ExportSpec l #
Generic (EWildcard l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (EWildcard l) :: Type -> Type # Methods from :: EWildcard l -> Rep (EWildcard l) x # to :: Rep (EWildcard l) x -> EWildcard l #
Generic (Namespace l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Namespace l) :: Type -> Type # Methods from :: Namespace l -> Rep (Namespace l) x # to :: Rep (Namespace l) x -> Namespace l #
Generic (ImportDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportDecl l) :: Type -> Type # Methods from :: ImportDecl l -> Rep (ImportDecl l) x # to :: Rep (ImportDecl l) x -> ImportDecl l #
Generic (ImportSpecList l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportSpecList l) :: Type -> Type # Methods from :: ImportSpecList l -> Rep (ImportSpecList l) x # to :: Rep (ImportSpecList l) x -> ImportSpecList l #
Generic (ImportSpec l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportSpec l) :: Type -> Type # Methods from :: ImportSpec l -> Rep (ImportSpec l) x # to :: Rep (ImportSpec l) x -> ImportSpec l #
Generic (Assoc l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Assoc l) :: Type -> Type # Methods from :: Assoc l -> Rep (Assoc l) x # to :: Rep (Assoc l) x -> Assoc l #
Generic (Decl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Decl l) :: Type -> Type # Methods from :: Decl l -> Rep (Decl l) x # to :: Rep (Decl l) x -> Decl l #
Generic (PatternSynDirection l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PatternSynDirection l) :: Type -> Type # Methods from :: PatternSynDirection l -> Rep (PatternSynDirection l) x # to :: Rep (PatternSynDirection l) x -> PatternSynDirection l #
Generic (TypeEqn l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (TypeEqn l) :: Type -> Type # Methods from :: TypeEqn l -> Rep (TypeEqn l) x # to :: Rep (TypeEqn l) x -> TypeEqn l #
Generic (Annotation l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Annotation l) :: Type -> Type # Methods from :: Annotation l -> Rep (Annotation l) x # to :: Rep (Annotation l) x -> Annotation l #
Generic (BooleanFormula l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (BooleanFormula l) :: Type -> Type # Methods from :: BooleanFormula l -> Rep (BooleanFormula l) x # to :: Rep (BooleanFormula l) x -> BooleanFormula l #
Generic (Role l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Role l) :: Type -> Type # Methods from :: Role l -> Rep (Role l) x # to :: Rep (Role l) x -> Role l #
Generic (DataOrNew l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DataOrNew l) :: Type -> Type # Methods from :: DataOrNew l -> Rep (DataOrNew l) x # to :: Rep (DataOrNew l) x -> DataOrNew l #
Generic (InjectivityInfo l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InjectivityInfo l) :: Type -> Type # Methods from :: InjectivityInfo l -> Rep (InjectivityInfo l) x # to :: Rep (InjectivityInfo l) x -> InjectivityInfo l #
Generic (ResultSig l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ResultSig l) :: Type -> Type # Methods from :: ResultSig l -> Rep (ResultSig l) x # to :: Rep (ResultSig l) x -> ResultSig l #
Generic (DeclHead l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DeclHead l) :: Type -> Type # Methods from :: DeclHead l -> Rep (DeclHead l) x # to :: Rep (DeclHead l) x -> DeclHead l #
Generic (InstRule l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstRule l) :: Type -> Type # Methods from :: InstRule l -> Rep (InstRule l) x # to :: Rep (InstRule l) x -> InstRule l #
Generic (InstHead l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstHead l) :: Type -> Type # Methods from :: InstHead l -> Rep (InstHead l) x # to :: Rep (InstHead l) x -> InstHead l #
Generic (Deriving l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Deriving l) :: Type -> Type # Methods from :: Deriving l -> Rep (Deriving l) x # to :: Rep (Deriving l) x -> Deriving l #
Generic (DerivStrategy l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DerivStrategy l) :: Type -> Type # Methods from :: DerivStrategy l -> Rep (DerivStrategy l) x # to :: Rep (DerivStrategy l) x -> DerivStrategy l #
Generic (Binds l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Binds l) :: Type -> Type # Methods from :: Binds l -> Rep (Binds l) x # to :: Rep (Binds l) x -> Binds l #
Generic (IPBind l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (IPBind l) :: Type -> Type # Methods from :: IPBind l -> Rep (IPBind l) x # to :: Rep (IPBind l) x -> IPBind l #
Generic (Match l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Match l) :: Type -> Type # Methods from :: Match l -> Rep (Match l) x # to :: Rep (Match l) x -> Match l #
Generic (QualConDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QualConDecl l) :: Type -> Type # Methods from :: QualConDecl l -> Rep (QualConDecl l) x # to :: Rep (QualConDecl l) x -> QualConDecl l #
Generic (ConDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ConDecl l) :: Type -> Type # Methods from :: ConDecl l -> Rep (ConDecl l) x # to :: Rep (ConDecl l) x -> ConDecl l #
Generic (FieldDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (FieldDecl l) :: Type -> Type # Methods from :: FieldDecl l -> Rep (FieldDecl l) x # to :: Rep (FieldDecl l) x -> FieldDecl l #
Generic (GadtDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (GadtDecl l) :: Type -> Type # Methods from :: GadtDecl l -> Rep (GadtDecl l) x # to :: Rep (GadtDecl l) x -> GadtDecl l #
Generic (ClassDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ClassDecl l) :: Type -> Type # Methods from :: ClassDecl l -> Rep (ClassDecl l) x # to :: Rep (ClassDecl l) x -> ClassDecl l #
Generic (InstDecl l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstDecl l) :: Type -> Type # Methods from :: InstDecl l -> Rep (InstDecl l) x # to :: Rep (InstDecl l) x -> InstDecl l #
Generic (BangType l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (BangType l) :: Type -> Type # Methods from :: BangType l -> Rep (BangType l) x # to :: Rep (BangType l) x -> BangType l #
Generic (Unpackedness l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Unpackedness l) :: Type -> Type # Methods from :: Unpackedness l -> Rep (Unpackedness l) x # to :: Rep (Unpackedness l) x -> Unpackedness l #
Generic (Rhs l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Rhs l) :: Type -> Type # Methods from :: Rhs l -> Rep (Rhs l) x # to :: Rep (Rhs l) x -> Rhs l #
Generic (GuardedRhs l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (GuardedRhs l) :: Type -> Type # Methods from :: GuardedRhs l -> Rep (GuardedRhs l) x # to :: Rep (GuardedRhs l) x -> GuardedRhs l #
Generic (Type l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Type l) :: Type -> Type # Methods from :: Type l -> Rep (Type l) x # to :: Rep (Type l) x -> Type l #
Generic (MaybePromotedName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (MaybePromotedName l) :: Type -> Type # Methods from :: MaybePromotedName l -> Rep (MaybePromotedName l) x # to :: Rep (MaybePromotedName l) x -> MaybePromotedName l #
Generic (Promoted l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Promoted l) :: Type -> Type # Methods from :: Promoted l -> Rep (Promoted l) x # to :: Rep (Promoted l) x -> Promoted l #
Generic (TyVarBind l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (TyVarBind l) :: Type -> Type # Methods from :: TyVarBind l -> Rep (TyVarBind l) x # to :: Rep (TyVarBind l) x -> TyVarBind l #
Generic (FunDep l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (FunDep l) :: Type -> Type # Methods from :: FunDep l -> Rep (FunDep l) x # to :: Rep (FunDep l) x -> FunDep l #
Generic (Context l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Context l) :: Type -> Type # Methods from :: Context l -> Rep (Context l) x # to :: Rep (Context l) x -> Context l #
Generic (Asst l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Asst l) :: Type -> Type # Methods from :: Asst l -> Rep (Asst l) x # to :: Rep (Asst l) x -> Asst l #
Generic (Literal l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Literal l) :: Type -> Type # Methods from :: Literal l -> Rep (Literal l) x # to :: Rep (Literal l) x -> Literal l #
Generic (Sign l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Sign l) :: Type -> Type # Methods from :: Sign l -> Rep (Sign l) x # to :: Rep (Sign l) x -> Sign l #
Generic (Exp l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Exp l) :: Type -> Type # Methods from :: Exp l -> Rep (Exp l) x # to :: Rep (Exp l) x -> Exp l #
Generic (XName l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (XName l) :: Type -> Type # Methods from :: XName l -> Rep (XName l) x # to :: Rep (XName l) x -> XName l #
Generic (XAttr l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (XAttr l) :: Type -> Type # Methods from :: XAttr l -> Rep (XAttr l) x # to :: Rep (XAttr l) x -> XAttr l #
Generic (Bracket l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Bracket l) :: Type -> Type # Methods from :: Bracket l -> Rep (Bracket l) x # to :: Rep (Bracket l) x -> Bracket l #
Generic (Splice l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Splice l) :: Type -> Type # Methods from :: Splice l -> Rep (Splice l) x # to :: Rep (Splice l) x -> Splice l #
Generic (Safety l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Safety l) :: Type -> Type # Methods from :: Safety l -> Rep (Safety l) x # to :: Rep (Safety l) x -> Safety l #
Generic (CallConv l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (CallConv l) :: Type -> Type # Methods from :: CallConv l -> Rep (CallConv l) x # to :: Rep (CallConv l) x -> CallConv l #
Generic (ModulePragma l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModulePragma l) :: Type -> Type # Methods from :: ModulePragma l -> Rep (ModulePragma l) x # to :: Rep (ModulePragma l) x -> ModulePragma l #
Generic (Overlap l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Overlap l) :: Type -> Type # Methods from :: Overlap l -> Rep (Overlap l) x # to :: Rep (Overlap l) x -> Overlap l #
Generic (Activation l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Activation l) :: Type -> Type # Methods from :: Activation l -> Rep (Activation l) x # to :: Rep (Activation l) x -> Activation l #
Generic (Rule l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Rule l) :: Type -> Type # Methods from :: Rule l -> Rep (Rule l) x # to :: Rep (Rule l) x -> Rule l #
Generic (RuleVar l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RuleVar l) :: Type -> Type # Methods from :: RuleVar l -> Rep (RuleVar l) x # to :: Rep (RuleVar l) x -> RuleVar l #
Generic (WarningText l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (WarningText l) :: Type -> Type # Methods from :: WarningText l -> Rep (WarningText l) x # to :: Rep (WarningText l) x -> WarningText l #
Generic (Pat l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Pat l) :: Type -> Type # Methods from :: Pat l -> Rep (Pat l) x # to :: Rep (Pat l) x -> Pat l #
Generic (PXAttr l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PXAttr l) :: Type -> Type # Methods from :: PXAttr l -> Rep (PXAttr l) x # to :: Rep (PXAttr l) x -> PXAttr l #
Generic (RPatOp l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RPatOp l) :: Type -> Type # Methods from :: RPatOp l -> Rep (RPatOp l) x # to :: Rep (RPatOp l) x -> RPatOp l #
Generic (RPat l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RPat l) :: Type -> Type # Methods from :: RPat l -> Rep (RPat l) x # to :: Rep (RPat l) x -> RPat l #
Generic (PatField l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PatField l) :: Type -> Type # Methods from :: PatField l -> Rep (PatField l) x # to :: Rep (PatField l) x -> PatField l #
Generic (Stmt l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Stmt l) :: Type -> Type # Methods from :: Stmt l -> Rep (Stmt l) x # to :: Rep (Stmt l) x -> Stmt l #
Generic (QualStmt l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QualStmt l) :: Type -> Type # Methods from :: QualStmt l -> Rep (QualStmt l) x # to :: Rep (QualStmt l) x -> QualStmt l #
Generic (FieldUpdate l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (FieldUpdate l) :: Type -> Type # Methods from :: FieldUpdate l -> Rep (FieldUpdate l) x # to :: Rep (FieldUpdate l) x -> FieldUpdate l #
Generic (Alt l)
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Alt l) :: Type -> Type # Methods from :: Alt l -> Rep (Alt l) x # to :: Rep (Alt l) x -> Alt l #
Generic (Loc a)
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep (Loc a) :: Type -> Type # Methods from :: Loc a -> Rep (Loc a) x # to :: Rep (Loc a) x -> Loc a #
Generic (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep (Doc a) :: Type -> Type # Methods from :: Doc a -> Rep (Doc a) x # to :: Rep (Doc a) x -> Doc a #
Generic (Maybe a)
Instance details Defined in Data.Strict.Maybe Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (PrimitiveGuard a) Source #
Instance details Defined in Clash.Annotations.Primitive Associated Types type Rep (PrimitiveGuard a) :: Type -> Type # Methods from :: PrimitiveGuard a -> Rep (PrimitiveGuard a) x # to :: Rep (PrimitiveGuard a) x -> PrimitiveGuard a #
Generic (BitVector n) Source #
Instance details Defined in Clash.Sized.Internal.BitVector Associated Types type Rep (BitVector n) :: Type -> Type # Methods from :: BitVector n -> Rep (BitVector n) x # to :: Rep (BitVector n) x -> BitVector n #
Generic (Index n) Source #
Instance details Defined in Clash.Sized.Internal.Index Associated Types type Rep (Index n) :: Type -> Type # Methods from :: Index n -> Rep (Index n) x # to :: Rep (Index n) x -> Index n #
Generic (Unsigned n) Source #
Instance details Defined in Clash.Sized.Internal.Unsigned Associated Types type Rep (Unsigned n) :: Type -> Type # Methods from :: Unsigned n -> Rep (Unsigned n) x # to :: Rep (Unsigned n) x -> Unsigned n #
Generic (Signed n) Source #
Instance details Defined in Clash.Sized.Internal.Signed Associated Types type Rep (Signed n) :: Type -> Type # Methods from :: Signed n -> Rep (Signed n) x # to :: Rep (Signed n) x -> Signed n #
Generic (Overflowing a) Source #
Instance details Defined in Clash.Num.Overflowing Associated Types type Rep (Overflowing a) :: Type -> Type # Methods from :: Overflowing a -> Rep (Overflowing a) x # to :: Rep (Overflowing a) x -> Overflowing a #
Generic (Either a b)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type # Methods from :: V1 p -> Rep (V1 p) x # to :: Rep (V1 p) x -> V1 p #
Generic (U1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type # Methods from :: U1 p -> Rep (U1 p) x # to :: Rep (U1 p) x -> U1 p #
Generic (a, b)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type # Methods from :: (a, b) -> Rep (a, b) x # to :: Rep (a, b) x -> (a, b) #
Generic (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type # Methods from :: Arg a b -> Rep (Arg a b) x # to :: Rep (Arg a b) x -> Arg a b #
Generic (WrappedMonad m a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a #
Generic (Proxy t)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type # Methods from :: Proxy t -> Rep (Proxy t) x # to :: Rep (Proxy t) x -> Proxy t #
Generic (Cofree f a)
Instance details Defined in Control.Comonad.Cofree Associated Types type Rep (Cofree f a) :: Type -> Type # Methods from :: Cofree f a -> Rep (Cofree f a) x # to :: Rep (Cofree f a) x -> Cofree f a #
Generic (Free f a)
Instance details Defined in Control.Monad.Free Associated Types type Rep (Free f a) :: Type -> Type # Methods from :: Free f a -> Rep (Free f a) x # to :: Rep (Free f a) x -> Free f a #
Generic (ListF a b)
Instance details Defined in Data.Functor.Base Associated Types type Rep (ListF a b) :: Type -> Type # Methods from :: ListF a b -> Rep (ListF a b) x # to :: Rep (ListF a b) x -> ListF a b #
Generic (NonEmptyF a b)
Instance details Defined in Data.Functor.Base Associated Types type Rep (NonEmptyF a b) :: Type -> Type # Methods from :: NonEmptyF a b -> Rep (NonEmptyF a b) x # to :: Rep (NonEmptyF a b) x -> NonEmptyF a b #
Generic (TreeF a b)
Instance details Defined in Data.Functor.Base Associated Types type Rep (TreeF a b) :: Type -> Type # Methods from :: TreeF a b -> Rep (TreeF a b) x # to :: Rep (TreeF a b) x -> TreeF a b #
Generic (Pair a b)
Instance details Defined in Data.Strict.Tuple Associated Types type Rep (Pair a b) :: Type -> Type # Methods from :: Pair a b -> Rep (Pair a b) x # to :: Rep (Pair a b) x -> Pair a b #
Generic (These a b)
Instance details Defined in Data.Strict.These Associated Types type Rep (These a b) :: Type -> Type # Methods from :: These a b -> Rep (These a b) x # to :: Rep (These a b) x -> These a b #
Generic (Either a b)
Instance details Defined in Data.Strict.Either Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (These a b)
Instance details Defined in Data.These Associated Types type Rep (These a b) :: Type -> Type # Methods from :: These a b -> Rep (These a b) x # to :: Rep (These a b) x -> These a b #
KnownNat n => Generic (Vec n a) Source #	In many cases, this Generic instance only allows generic functions/instances over vectors of at least size 1, due to the n-1 in the Rep (Vec n a) definition. We'll have to wait for things like https://ryanglscott.github.io/2018/02/11/how-to-derive-generic-for-some-gadts/ before we can work around this limitation
Instance details Defined in Clash.Sized.Vector Associated Types type Rep (Vec n a) :: Type -> Type # Methods from :: Vec n a -> Rep (Vec n a) x # to :: Rep (Vec n a) x -> Vec n a #
Generic (RamOp n a) Source #
Instance details Defined in Clash.Explicit.BlockRam Associated Types type Rep (RamOp n a) :: Type -> Type # Methods from :: RamOp n a -> Rep (RamOp n a) x # to :: Rep (RamOp n a) x -> RamOp n a #
Generic (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type # Methods from :: Rec1 f p -> Rep (Rec1 f p) x # to :: Rep (Rec1 f p) x -> Rec1 f p #
Generic (URec (Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p #
Generic (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Generic (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Generic (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Generic (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Generic (a, b, c)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type # Methods from :: (a, b, c) -> Rep (a, b, c) x # to :: Rep (a, b, c) x -> (a, b, c) #
Generic (Kleisli m a b)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Associated Types type Rep (Kleisli m a b) :: Type -> Type # Methods from :: Kleisli m a b -> Rep (Kleisli m a b) x # to :: Rep (Kleisli m a b) x -> Kleisli m a b #
Generic (WrappedArrow a b c)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c #
Generic (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Generic (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type # Methods from :: Ap f a -> Rep (Ap f a) x # to :: Rep (Ap f a) x -> Ap f a #
Generic (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type # Methods from :: Alt f a -> Rep (Alt f a) x # to :: Rep (Alt f a) x -> Alt f a #
Generic (Join p a)
Instance details Defined in Data.Bifunctor.Join Associated Types type Rep (Join p a) :: Type -> Type # Methods from :: Join p a -> Rep (Join p a) x # to :: Rep (Join p a) x -> Join p a #
Generic (Fix p a)
Instance details Defined in Data.Bifunctor.Fix Associated Types type Rep (Fix p a) :: Type -> Type # Methods from :: Fix p a -> Rep (Fix p a) x # to :: Rep (Fix p a) x -> Fix p a #
Generic (FreeF f a b)
Instance details Defined in Control.Monad.Trans.Free Associated Types type Rep (FreeF f a b) :: Type -> Type # Methods from :: FreeF f a b -> Rep (FreeF f a b) x # to :: Rep (FreeF f a b) x -> FreeF f a b #
Generic (CofreeF f a b)
Instance details Defined in Control.Comonad.Trans.Cofree Associated Types type Rep (CofreeF f a b) :: Type -> Type # Methods from :: CofreeF f a b -> Rep (CofreeF f a b) x # to :: Rep (CofreeF f a b) x -> CofreeF f a b #
Generic (Tagged s b)
Instance details Defined in Data.Tagged Associated Types type Rep (Tagged s b) :: Type -> Type # Methods from :: Tagged s b -> Rep (Tagged s b) x # to :: Rep (Tagged s b) x -> Tagged s b #
Generic (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type # Methods from :: K1 i c p -> Rep (K1 i c p) x # to :: Rep (K1 i c p) x -> K1 i c p #
Generic ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x # to :: Rep ((f :+: g) p) x -> (f :+: g) p #
Generic ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type # Methods from :: (f :: g) p -> Rep ((f :: g) p) x # to :: Rep ((f :: g) p) x -> (f :*: g) p #
Generic (a, b, c, d)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x # to :: Rep (a, b, c, d) x -> (a, b, c, d) #
Generic (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type # Methods from :: Product f g a -> Rep (Product f g a) x # to :: Rep (Product f g a) x -> Product f g a #
Generic (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type # Methods from :: Sum f g a -> Rep (Sum f g a) x # to :: Rep (Sum f g a) x -> Sum f g a #
Generic (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type # Methods from :: M1 i c f p -> Rep (M1 i c f p) x # to :: Rep (M1 i c f p) x -> M1 i c f p #
Generic ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x # to :: Rep ((f :.: g) p) x -> (f :.: g) p #
Generic (a, b, c, d, e)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) #
Generic (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type # Methods from :: Compose f g a -> Rep (Compose f g a) x # to :: Rep (Compose f g a) x -> Compose f g a #
Generic (WrappedBifunctor p a b)
Instance details Defined in Data.Bifunctor.Wrapped Associated Types type Rep (WrappedBifunctor p a b) :: Type -> Type # Methods from :: WrappedBifunctor p a b -> Rep (WrappedBifunctor p a b) x # to :: Rep (WrappedBifunctor p a b) x -> WrappedBifunctor p a b #
Generic (Joker g a b)
Instance details Defined in Data.Bifunctor.Joker Associated Types type Rep (Joker g a b) :: Type -> Type # Methods from :: Joker g a b -> Rep (Joker g a b) x # to :: Rep (Joker g a b) x -> Joker g a b #
Generic (Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Associated Types type Rep (Flip p a b) :: Type -> Type # Methods from :: Flip p a b -> Rep (Flip p a b) x # to :: Rep (Flip p a b) x -> Flip p a b #
Generic (Clown f a b)
Instance details Defined in Data.Bifunctor.Clown Associated Types type Rep (Clown f a b) :: Type -> Type # Methods from :: Clown f a b -> Rep (Clown f a b) x # to :: Rep (Clown f a b) x -> Clown f a b #
Generic (a, b, c, d, e, f)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f) :: Type -> Type # Methods from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x # to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) #
Generic (Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Associated Types type Rep (Sum p q a b) :: Type -> Type # Methods from :: Sum p q a b -> Rep (Sum p q a b) x # to :: Rep (Sum p q a b) x -> Sum p q a b #
Generic (Product f g a b)
Instance details Defined in Data.Bifunctor.Product Associated Types type Rep (Product f g a b) :: Type -> Type # Methods from :: Product f g a b -> Rep (Product f g a b) x # to :: Rep (Product f g a b) x -> Product f g a b #
Generic (a, b, c, d, e, f, g)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g) :: Type -> Type # Methods from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x # to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) #
Generic (Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Associated Types type Rep (Tannen f p a b) :: Type -> Type # Methods from :: Tannen f p a b -> Rep (Tannen f p a b) x # to :: Rep (Tannen f p a b) x -> Tannen f p a b #
Generic (Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Associated Types type Rep (Biff p f g a b) :: Type -> Type # Methods from :: Biff p f g a b -> Rep (Biff p f g a b) x # to :: Rep (Biff p f g a b) x -> Biff p f g a b #

class Generic1 (f :: k -> Type) #

Representable types of kind * -> * (or kind k -> *, when PolyKinds is enabled). This class is derivable in GHC with the DeriveGeneric flag on.

A Generic1 instance must satisfy the following laws:

from1 . to1 ≡ id
to1 . from1 ≡ id

Minimal complete definition

from1, to1

Instances

Instances details

Generic1 (V1 :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 V1 :: k -> Type # Methods from1 :: forall (a :: k0). V1 a -> Rep1 V1 a # to1 :: forall (a :: k0). Rep1 V1 a -> V1 a #
Generic1 (U1 :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 U1 :: k -> Type # Methods from1 :: forall (a :: k0). U1 a -> Rep1 U1 a # to1 :: forall (a :: k0). Rep1 U1 a -> U1 a #
Generic1 (Proxy :: k -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Proxy :: k -> Type # Methods from1 :: forall (a :: k0). Proxy a -> Rep1 Proxy a # to1 :: forall (a :: k0). Rep1 Proxy a -> Proxy a #
Generic1 (Alt f :: k -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 (Alt f) :: k -> Type # Methods from1 :: forall (a :: k0). Alt f a -> Rep1 (Alt f) a # to1 :: forall (a :: k0). Rep1 (Alt f) a -> Alt f a #
Generic1 (Ap f :: k -> Type)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 (Ap f) :: k -> Type # Methods from1 :: forall (a :: k0). Ap f a -> Rep1 (Ap f) a # to1 :: forall (a :: k0). Rep1 (Ap f) a -> Ap f a #
Generic1 (Const a :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Associated Types type Rep1 (Const a) :: k -> Type # Methods from1 :: forall (a0 :: k0). Const a a0 -> Rep1 (Const a) a0 # to1 :: forall (a0 :: k0). Rep1 (Const a) a0 -> Const a a0 #
Generic1 (URec (Ptr ()) :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec (Ptr ())) :: k -> Type # Methods from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a # to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a #
Generic1 (URec Char :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Char) :: k -> Type # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a # to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a #
Generic1 (URec Double :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Double) :: k -> Type # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a # to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a #
Generic1 (URec Float :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Float) :: k -> Type # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a # to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a #
Generic1 (URec Int :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Int) :: k -> Type # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a # to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a #
Generic1 (URec Word :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Word) :: k -> Type # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a # to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a #
Generic1 (Rec1 f :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (Rec1 f) :: k -> Type # Methods from1 :: forall (a :: k0). Rec1 f a -> Rep1 (Rec1 f) a # to1 :: forall (a :: k0). Rep1 (Rec1 f) a -> Rec1 f a #
Generic1 (Sum f g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Associated Types type Rep1 (Sum f g) :: k -> Type # Methods from1 :: forall (a :: k0). Sum f g a -> Rep1 (Sum f g) a # to1 :: forall (a :: k0). Rep1 (Sum f g) a -> Sum f g a #
Generic1 (Product f g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Associated Types type Rep1 (Product f g) :: k -> Type # Methods from1 :: forall (a :: k0). Product f g a -> Rep1 (Product f g) a # to1 :: forall (a :: k0). Rep1 (Product f g) a -> Product f g a #
Generic1 (K1 i c :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (K1 i c) :: k -> Type # Methods from1 :: forall (a :: k0). K1 i c a -> Rep1 (K1 i c) a # to1 :: forall (a :: k0). Rep1 (K1 i c) a -> K1 i c a #
Generic1 (f :+: g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :+: g) :: k -> Type # Methods from1 :: forall (a :: k0). (f :+: g) a -> Rep1 (f :+: g) a # to1 :: forall (a :: k0). Rep1 (f :+: g) a -> (f :+: g) a #
Generic1 (f :*: g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :: g) :: k -> Type # Methods from1 :: forall (a :: k0). (f :: g) a -> Rep1 (f :: g) a # to1 :: forall (a :: k0). Rep1 (f :: g) a -> (f :*: g) a #
Generic1 (WrappedBifunctor p a :: k1 -> Type)
Instance details Defined in Data.Bifunctor.Wrapped Associated Types type Rep1 (WrappedBifunctor p a) :: k -> Type # Methods from1 :: forall (a0 :: k). WrappedBifunctor p a a0 -> Rep1 (WrappedBifunctor p a) a0 # to1 :: forall (a0 :: k). Rep1 (WrappedBifunctor p a) a0 -> WrappedBifunctor p a a0 #
Generic1 (Joker g a :: k1 -> Type)
Instance details Defined in Data.Bifunctor.Joker Associated Types type Rep1 (Joker g a) :: k -> Type # Methods from1 :: forall (a0 :: k). Joker g a a0 -> Rep1 (Joker g a) a0 # to1 :: forall (a0 :: k). Rep1 (Joker g a) a0 -> Joker g a a0 #
Generic1 (Clown f a :: k1 -> Type)
Instance details Defined in Data.Bifunctor.Clown Associated Types type Rep1 (Clown f a) :: k -> Type # Methods from1 :: forall (a0 :: k). Clown f a a0 -> Rep1 (Clown f a) a0 # to1 :: forall (a0 :: k). Rep1 (Clown f a) a0 -> Clown f a a0 #
Functor f => Generic1 (Compose f g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Associated Types type Rep1 (Compose f g) :: k -> Type # Methods from1 :: forall (a :: k0). Compose f g a -> Rep1 (Compose f g) a # to1 :: forall (a :: k0). Rep1 (Compose f g) a -> Compose f g a #
Generic1 (M1 i c f :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (M1 i c f) :: k -> Type # Methods from1 :: forall (a :: k0). M1 i c f a -> Rep1 (M1 i c f) a # to1 :: forall (a :: k0). Rep1 (M1 i c f) a -> M1 i c f a #
Functor f => Generic1 (f :.: g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :.: g) :: k -> Type # Methods from1 :: forall (a :: k0). (f :.: g) a -> Rep1 (f :.: g) a # to1 :: forall (a :: k0). Rep1 (f :.: g) a -> (f :.: g) a #
Generic1 (Sum p q a :: k1 -> Type)
Instance details Defined in Data.Bifunctor.Sum Associated Types type Rep1 (Sum p q a) :: k -> Type # Methods from1 :: forall (a0 :: k). Sum p q a a0 -> Rep1 (Sum p q a) a0 # to1 :: forall (a0 :: k). Rep1 (Sum p q a) a0 -> Sum p q a a0 #
Generic1 (Product f g a :: k1 -> Type)
Instance details Defined in Data.Bifunctor.Product Associated Types type Rep1 (Product f g a) :: k -> Type # Methods from1 :: forall (a0 :: k). Product f g a a0 -> Rep1 (Product f g a) a0 # to1 :: forall (a0 :: k). Rep1 (Product f g a) a0 -> Product f g a a0 #
Functor f => Generic1 (Tannen f p a :: k2 -> Type)
Instance details Defined in Data.Bifunctor.Tannen Associated Types type Rep1 (Tannen f p a) :: k -> Type # Methods from1 :: forall (a0 :: k). Tannen f p a a0 -> Rep1 (Tannen f p a) a0 # to1 :: forall (a0 :: k). Rep1 (Tannen f p a) a0 -> Tannen f p a a0 #
Functor (p (f a)) => Generic1 (Biff p f g a :: k3 -> Type)
Instance details Defined in Data.Bifunctor.Biff Associated Types type Rep1 (Biff p f g a) :: k -> Type # Methods from1 :: forall (a0 :: k). Biff p f g a a0 -> Rep1 (Biff p f g a) a0 # to1 :: forall (a0 :: k). Rep1 (Biff p f g a) a0 -> Biff p f g a a0 #
Generic1 []	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 [] :: k -> Type # Methods from1 :: forall (a :: k). [a] -> Rep1 [] a # to1 :: forall (a :: k). Rep1 [] a -> [a] #
Generic1 Maybe	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Maybe :: k -> Type # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a #
Generic1 Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Par1 :: k -> Type # Methods from1 :: forall (a :: k). Par1 a -> Rep1 Par1 a # to1 :: forall (a :: k). Rep1 Par1 a -> Par1 a #
Generic1 Solo
Instance details Defined in Data.Tuple.Solo Associated Types type Rep1 Solo :: k -> Type # Methods from1 :: forall (a :: k). Solo a -> Rep1 Solo a # to1 :: forall (a :: k). Rep1 Solo a -> Solo a #
Generic1 Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Associated Types type Rep1 Complex :: k -> Type # Methods from1 :: forall (a :: k). Complex a -> Rep1 Complex a # to1 :: forall (a :: k). Rep1 Complex a -> Complex a #
Generic1 Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Min :: k -> Type # Methods from1 :: forall (a :: k). Min a -> Rep1 Min a # to1 :: forall (a :: k). Rep1 Min a -> Min a #
Generic1 Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Max :: k -> Type # Methods from1 :: forall (a :: k). Max a -> Rep1 Max a # to1 :: forall (a :: k). Rep1 Max a -> Max a #
Generic1 First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 First :: k -> Type # Methods from1 :: forall (a :: k). First a -> Rep1 First a # to1 :: forall (a :: k). Rep1 First a -> First a #
Generic1 Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Last :: k -> Type # Methods from1 :: forall (a :: k). Last a -> Rep1 Last a # to1 :: forall (a :: k). Rep1 Last a -> Last a #
Generic1 WrappedMonoid	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 WrappedMonoid :: k -> Type # Methods from1 :: forall (a :: k). WrappedMonoid a -> Rep1 WrappedMonoid a # to1 :: forall (a :: k). Rep1 WrappedMonoid a -> WrappedMonoid a #
Generic1 Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 Option :: k -> Type # Methods from1 :: forall (a :: k). Option a -> Rep1 Option a # to1 :: forall (a :: k). Rep1 Option a -> Option a #
Generic1 ZipList	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep1 ZipList :: k -> Type # Methods from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a # to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a #
Generic1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type # Methods from1 :: forall (a :: k). Identity a -> Rep1 Identity a # to1 :: forall (a :: k). Rep1 Identity a -> Identity a #
Generic1 First	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 First :: k -> Type # Methods from1 :: forall (a :: k). First a -> Rep1 First a # to1 :: forall (a :: k). Rep1 First a -> First a #
Generic1 Last	Since: base-4.7.0.0
Instance details Defined in Data.Monoid Associated Types type Rep1 Last :: k -> Type # Methods from1 :: forall (a :: k). Last a -> Rep1 Last a # to1 :: forall (a :: k). Rep1 Last a -> Last a #
Generic1 Dual	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Dual :: k -> Type # Methods from1 :: forall (a :: k). Dual a -> Rep1 Dual a # to1 :: forall (a :: k). Rep1 Dual a -> Dual a #
Generic1 Sum	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Sum :: k -> Type # Methods from1 :: forall (a :: k). Sum a -> Rep1 Sum a # to1 :: forall (a :: k). Rep1 Sum a -> Sum a #
Generic1 Product	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Product :: k -> Type # Methods from1 :: forall (a :: k). Product a -> Rep1 Product a # to1 :: forall (a :: k). Rep1 Product a -> Product a #
Generic1 Down	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 Down :: k -> Type # Methods from1 :: forall (a :: k). Down a -> Rep1 Down a # to1 :: forall (a :: k). Rep1 Down a -> Down a #
Generic1 NonEmpty	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 NonEmpty :: k -> Type # Methods from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a # to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a #
Generic1 Tree	Since: containers-0.5.8
Instance details Defined in Data.Tree Associated Types type Rep1 Tree :: k -> Type # Methods from1 :: forall (a :: k). Tree a -> Rep1 Tree a # to1 :: forall (a :: k). Rep1 Tree a -> Tree a #
Generic1 FingerTree	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 FingerTree :: k -> Type # Methods from1 :: forall (a :: k). FingerTree a -> Rep1 FingerTree a # to1 :: forall (a :: k). Rep1 FingerTree a -> FingerTree a #
Generic1 Digit	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 Digit :: k -> Type # Methods from1 :: forall (a :: k). Digit a -> Rep1 Digit a # to1 :: forall (a :: k). Rep1 Digit a -> Digit a #
Generic1 Node	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 Node :: k -> Type # Methods from1 :: forall (a :: k). Node a -> Rep1 Node a # to1 :: forall (a :: k). Rep1 Node a -> Node a #
Generic1 Elem	Since: containers-0.6.1
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 Elem :: k -> Type # Methods from1 :: forall (a :: k). Elem a -> Rep1 Elem a # to1 :: forall (a :: k). Rep1 Elem a -> Elem a #
Generic1 ViewL	Since: containers-0.5.8
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 ViewL :: k -> Type # Methods from1 :: forall (a :: k). ViewL a -> Rep1 ViewL a # to1 :: forall (a :: k). Rep1 ViewL a -> ViewL a #
Generic1 ViewR	Since: containers-0.5.8
Instance details Defined in Data.Sequence.Internal Associated Types type Rep1 ViewR :: k -> Type # Methods from1 :: forall (a :: k). ViewR a -> Rep1 ViewR a # to1 :: forall (a :: k). Rep1 ViewR a -> ViewR a #
Generic1 Maybe
Instance details Defined in Data.Strict.Maybe Associated Types type Rep1 Maybe :: k -> Type # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a #
Generic1 (Either a :: Type -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (Either a) :: k -> Type # Methods from1 :: forall (a0 :: k). Either a a0 -> Rep1 (Either a) a0 # to1 :: forall (a0 :: k). Rep1 (Either a) a0 -> Either a a0 #
Generic1 ((,) a :: Type -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,) a) :: k -> Type # Methods from1 :: forall (a0 :: k). (a, a0) -> Rep1 ((,) a) a0 # to1 :: forall (a0 :: k). Rep1 ((,) a) a0 -> (a, a0) #
Generic1 (Arg a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Associated Types type Rep1 (Arg a) :: k -> Type # Methods from1 :: forall (a0 :: k). Arg a a0 -> Rep1 (Arg a) a0 # to1 :: forall (a0 :: k). Rep1 (Arg a) a0 -> Arg a a0 #
Generic1 (WrappedMonad m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep1 (WrappedMonad m) :: k -> Type # Methods from1 :: forall (a :: k). WrappedMonad m a -> Rep1 (WrappedMonad m) a # to1 :: forall (a :: k). Rep1 (WrappedMonad m) a -> WrappedMonad m a #
Functor f => Generic1 (Cofree f :: Type -> Type)
Instance details Defined in Control.Comonad.Cofree Associated Types type Rep1 (Cofree f) :: k -> Type # Methods from1 :: forall (a :: k). Cofree f a -> Rep1 (Cofree f) a # to1 :: forall (a :: k). Rep1 (Cofree f) a -> Cofree f a #
Functor f => Generic1 (Free f :: Type -> Type)
Instance details Defined in Control.Monad.Free Associated Types type Rep1 (Free f) :: k -> Type # Methods from1 :: forall (a :: k). Free f a -> Rep1 (Free f) a # to1 :: forall (a :: k). Rep1 (Free f) a -> Free f a #
Generic1 (ListF a :: Type -> Type)
Instance details Defined in Data.Functor.Base Associated Types type Rep1 (ListF a) :: k -> Type # Methods from1 :: forall (a0 :: k). ListF a a0 -> Rep1 (ListF a) a0 # to1 :: forall (a0 :: k). Rep1 (ListF a) a0 -> ListF a a0 #
Generic1 (NonEmptyF a :: Type -> Type)
Instance details Defined in Data.Functor.Base Associated Types type Rep1 (NonEmptyF a) :: k -> Type # Methods from1 :: forall (a0 :: k). NonEmptyF a a0 -> Rep1 (NonEmptyF a) a0 # to1 :: forall (a0 :: k). Rep1 (NonEmptyF a) a0 -> NonEmptyF a a0 #
Generic1 (TreeF a :: Type -> Type)
Instance details Defined in Data.Functor.Base Associated Types type Rep1 (TreeF a) :: k -> Type # Methods from1 :: forall (a0 :: k). TreeF a a0 -> Rep1 (TreeF a) a0 # to1 :: forall (a0 :: k). Rep1 (TreeF a) a0 -> TreeF a a0 #
Generic1 (Pair a :: Type -> Type)
Instance details Defined in Data.Strict.Tuple Associated Types type Rep1 (Pair a) :: k -> Type # Methods from1 :: forall (a0 :: k). Pair a a0 -> Rep1 (Pair a) a0 # to1 :: forall (a0 :: k). Rep1 (Pair a) a0 -> Pair a a0 #
Generic1 (These a :: Type -> Type)
Instance details Defined in Data.Strict.These Associated Types type Rep1 (These a) :: k -> Type # Methods from1 :: forall (a0 :: k). These a a0 -> Rep1 (These a) a0 # to1 :: forall (a0 :: k). Rep1 (These a) a0 -> These a a0 #
Generic1 (Either a :: Type -> Type)
Instance details Defined in Data.Strict.Either Associated Types type Rep1 (Either a) :: k -> Type # Methods from1 :: forall (a0 :: k). Either a a0 -> Rep1 (Either a) a0 # to1 :: forall (a0 :: k). Rep1 (Either a) a0 -> Either a a0 #
Generic1 (These a :: Type -> Type)
Instance details Defined in Data.These Associated Types type Rep1 (These a) :: k -> Type # Methods from1 :: forall (a0 :: k). These a a0 -> Rep1 (These a) a0 # to1 :: forall (a0 :: k). Rep1 (These a) a0 -> These a a0 #
Generic1 ((,,) a b :: Type -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,) a b) :: k -> Type # Methods from1 :: forall (a0 :: k). (a, b, a0) -> Rep1 ((,,) a b) a0 # to1 :: forall (a0 :: k). Rep1 ((,,) a b) a0 -> (a, b, a0) #
Generic1 (Kleisli m a :: Type -> Type)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Associated Types type Rep1 (Kleisli m a) :: k -> Type # Methods from1 :: forall (a0 :: k). Kleisli m a a0 -> Rep1 (Kleisli m a) a0 # to1 :: forall (a0 :: k). Rep1 (Kleisli m a) a0 -> Kleisli m a a0 #
Generic1 (WrappedArrow a b :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Associated Types type Rep1 (WrappedArrow a b) :: k -> Type # Methods from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0 # to1 :: forall (a0 :: k). Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 #
Generic1 (FreeF f a :: Type -> Type)
Instance details Defined in Control.Monad.Trans.Free Associated Types type Rep1 (FreeF f a) :: k -> Type # Methods from1 :: forall (a0 :: k). FreeF f a a0 -> Rep1 (FreeF f a) a0 # to1 :: forall (a0 :: k). Rep1 (FreeF f a) a0 -> FreeF f a a0 #
Generic1 (CofreeF f a :: Type -> Type)
Instance details Defined in Control.Comonad.Trans.Cofree Associated Types type Rep1 (CofreeF f a) :: k -> Type # Methods from1 :: forall (a0 :: k). CofreeF f a a0 -> Rep1 (CofreeF f a) a0 # to1 :: forall (a0 :: k). Rep1 (CofreeF f a) a0 -> CofreeF f a a0 #
Generic1 (Tagged s :: Type -> Type)
Instance details Defined in Data.Tagged Associated Types type Rep1 (Tagged s) :: k -> Type # Methods from1 :: forall (a :: k). Tagged s a -> Rep1 (Tagged s) a # to1 :: forall (a :: k). Rep1 (Tagged s) a -> Tagged s a #
Generic1 ((,,,) a b c :: Type -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,) a b c) :: k -> Type # Methods from1 :: forall (a0 :: k). (a, b, c, a0) -> Rep1 ((,,,) a b c) a0 # to1 :: forall (a0 :: k). Rep1 ((,,,) a b c) a0 -> (a, b, c, a0) #
Generic1 ((,,,,) a b c d :: Type -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,) a b c d) :: k -> Type # Methods from1 :: forall (a0 :: k). (a, b, c, d, a0) -> Rep1 ((,,,,) a b c d) a0 # to1 :: forall (a0 :: k). Rep1 ((,,,,) a b c d) a0 -> (a, b, c, d, a0) #
Generic1 ((,,,,,) a b c d e :: Type -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,) a b c d e) :: k -> Type # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, a0) -> Rep1 ((,,,,,) a b c d e) a0 # to1 :: forall (a0 :: k). Rep1 ((,,,,,) a b c d e) a0 -> (a, b, c, d, e, a0) #
Generic1 ((,,,,,,) a b c d e f :: Type -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,) a b c d e f) :: k -> Type # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, f, a0) -> Rep1 ((,,,,,,) a b c d e f) a0 # to1 :: forall (a0 :: k). Rep1 ((,,,,,,) a b c d e f) a0 -> (a, b, c, d, e, f, a0) #

Type-level natural numbers

module GHC.TypeLits

module GHC.TypeLits.Extra

module Clash.Promoted.Nat

module Clash.Promoted.Nat.Literals

module Clash.Promoted.Nat.TH

Type-level strings

module Clash.Promoted.Symbol

Template Haskell

class Lift (t :: TYPE r) where #

A Lift instance can have any of its values turned into a Template Haskell expression. This is needed when a value used within a Template Haskell quotation is bound outside the Oxford brackets ([| ... |] or [|| ... ||]) but not at the top level. As an example:

add1 :: Int -> Q (TExp Int)
add1 x = [|| x + 1 ||]

Template Haskell has no way of knowing what value x will take on at splice-time, so it requires the type of x to be an instance of Lift.

A Lift instance must satisfy $(lift x) ≡ x and $$(liftTyped x) ≡ x for all x, where $(...) and $$(...) are Template Haskell splices. It is additionally expected that lift x ≡ unTypeQ (liftTyped x).

Lift instances can be derived automatically by use of the -XDeriveLift GHC language extension:

{-# LANGUAGE DeriveLift #-}
module Foo where

import Language.Haskell.TH.Syntax

data Bar a = Bar1 a (Bar a) | Bar2 String
  deriving Lift

Levity-polymorphic since template-haskell-2.16.0.0.

Minimal complete definition

liftTyped

Methods

lift :: t -> Q Exp #

Turn a value into a Template Haskell expression, suitable for use in a splice.

liftTyped :: t -> Q (TExp t) #

Turn a value into a Template Haskell typed expression, suitable for use in a typed splice.

Since: template-haskell-2.16.0.0

Instances

Instances details

Lift Bool
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Bool -> Q Exp # liftTyped :: Bool -> Q (TExp Bool) #
Lift Char
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Char -> Q Exp # liftTyped :: Char -> Q (TExp Char) #
Lift Double
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Double -> Q Exp # liftTyped :: Double -> Q (TExp Double) #
Lift Float
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Float -> Q Exp # liftTyped :: Float -> Q (TExp Float) #
Lift Int
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int -> Q Exp # liftTyped :: Int -> Q (TExp Int) #
Lift Int8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int8 -> Q Exp # liftTyped :: Int8 -> Q (TExp Int8) #
Lift Int16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int16 -> Q Exp # liftTyped :: Int16 -> Q (TExp Int16) #
Lift Int32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int32 -> Q Exp # liftTyped :: Int32 -> Q (TExp Int32) #
Lift Int64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int64 -> Q Exp # liftTyped :: Int64 -> Q (TExp Int64) #
Lift Integer
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Integer -> Q Exp # liftTyped :: Integer -> Q (TExp Integer) #
Lift Natural
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Natural -> Q Exp # liftTyped :: Natural -> Q (TExp Natural) #
Lift Word
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word -> Q Exp # liftTyped :: Word -> Q (TExp Word) #
Lift Word8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word8 -> Q Exp # liftTyped :: Word8 -> Q (TExp Word8) #
Lift Word16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word16 -> Q Exp # liftTyped :: Word16 -> Q (TExp Word16) #
Lift Word32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word32 -> Q Exp # liftTyped :: Word32 -> Q (TExp Word32) #
Lift Word64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word64 -> Q Exp # liftTyped :: Word64 -> Q (TExp Word64) #
Lift ()
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: () -> Q Exp # liftTyped :: () -> Q (TExp ()) #
Lift Void	Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Void -> Q Exp # liftTyped :: Void -> Q (TExp Void) #
Lift Half
Instance details Defined in Numeric.Half.Internal Methods lift :: Half -> Q Exp # liftTyped :: Half -> Q (TExp Half) #
Lift ConstrRepr Source #
Instance details Defined in Clash.Annotations.BitRepresentation Methods lift :: ConstrRepr -> Q Exp # liftTyped :: ConstrRepr -> Q (TExp ConstrRepr) #
Lift DataReprAnn Source #
Instance details Defined in Clash.Annotations.BitRepresentation Methods lift :: DataReprAnn -> Q Exp # liftTyped :: DataReprAnn -> Q (TExp DataReprAnn) #
Lift Bit Source #
Instance details Defined in Clash.Sized.Internal.BitVector Methods lift :: Bit -> Q Exp # liftTyped :: Bit -> Q (TExp Bit) #
Lift PortName Source #
Instance details Defined in Clash.Annotations.TopEntity Methods lift :: PortName -> Q Exp # liftTyped :: PortName -> Q (TExp PortName) #
Lift TopEntity Source #
Instance details Defined in Clash.Annotations.TopEntity Methods lift :: TopEntity -> Q Exp # liftTyped :: TopEntity -> Q (TExp TopEntity) #
Lift Int#	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Int# -> Q Exp # liftTyped :: Int# -> Q (TExp Int#) #
Lift Char#	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Char# -> Q Exp # liftTyped :: Char# -> Q (TExp Char#) #
Lift Word#	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Word# -> Q Exp # liftTyped :: Word# -> Q (TExp Word#) #
Lift Addr#	Produces an `Addr#` literal from the NUL-terminated C-string starting at the given memory address. Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Addr# -> Q Exp # liftTyped :: Addr# -> Q (TExp Addr#) #
Lift Float#	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Float# -> Q Exp # liftTyped :: Float# -> Q (TExp Float#) #
Lift Double#	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Double# -> Q Exp # liftTyped :: Double# -> Q (TExp Double#) #
Lift a => Lift ([a] :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: [a] -> Q Exp # liftTyped :: [a] -> Q (TExp [a]) #
Lift a => Lift (Maybe a :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Maybe a -> Q Exp # liftTyped :: Maybe a -> Q (TExp (Maybe a)) #
Integral a => Lift (Ratio a :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Ratio a -> Q Exp # liftTyped :: Ratio a -> Q (TExp (Ratio a)) #
Lift a => Lift (NonEmpty a :: Type)	Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: NonEmpty a -> Q Exp # liftTyped :: NonEmpty a -> Q (TExp (NonEmpty a)) #
KnownSymbol s => Lift (SSymbol s :: Type) Source #
Instance details Defined in Clash.Promoted.Symbol Methods lift :: SSymbol s -> Q Exp # liftTyped :: SSymbol s -> Q (TExp (SSymbol s)) #
KnownNat n => Lift (BitVector n :: Type) Source #
Instance details Defined in Clash.Sized.Internal.BitVector Methods lift :: BitVector n -> Q Exp # liftTyped :: BitVector n -> Q (TExp (BitVector n)) #
KnownNat n => Lift (Index n :: Type) Source #
Instance details Defined in Clash.Sized.Internal.Index Methods lift :: Index n -> Q Exp # liftTyped :: Index n -> Q (TExp (Index n)) #
Lift (SNat n :: Type) Source #
Instance details Defined in Clash.Promoted.Nat Methods lift :: SNat n -> Q Exp # liftTyped :: SNat n -> Q (TExp (SNat n)) #
KnownNat n => Lift (Unsigned n :: Type) Source #
Instance details Defined in Clash.Sized.Internal.Unsigned Methods lift :: Unsigned n -> Q Exp # liftTyped :: Unsigned n -> Q (TExp (Unsigned n)) #
KnownNat n => Lift (Signed n :: Type) Source #
Instance details Defined in Clash.Sized.Internal.Signed Methods lift :: Signed n -> Q Exp # liftTyped :: Signed n -> Q (TExp (Signed n)) #
(Lift a, Lift b) => Lift (Either a b :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Either a b -> Q Exp # liftTyped :: Either a b -> Q (TExp (Either a b)) #
(Lift a, Lift b) => Lift ((a, b) :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (a, b) -> Q Exp # liftTyped :: (a, b) -> Q (TExp (a, b)) #
Lift a => Lift (Vec n a :: Type) Source #
Instance details Defined in Clash.Sized.Vector Methods lift :: Vec n a -> Q Exp # liftTyped :: Vec n a -> Q (TExp (Vec n a)) #
Lift a => Lift (Signal dom a :: Type) Source #
Instance details Defined in Clash.Signal.Internal Methods lift :: Signal dom a -> Q Exp # liftTyped :: Signal dom a -> Q (TExp (Signal dom a)) #
Lift a => Lift (RTree d a :: Type) Source #
Instance details Defined in Clash.Sized.RTree Methods lift :: RTree d a -> Q Exp # liftTyped :: RTree d a -> Q (TExp (RTree d a)) #
(Lift a, Lift b, Lift c) => Lift ((a, b, c) :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (a, b, c) -> Q Exp # liftTyped :: (a, b, c) -> Q (TExp (a, b, c)) #
Lift a => Lift (DSignal dom delay a :: Type) Source #
Instance details Defined in Clash.Signal.Delayed.Internal Methods lift :: DSignal dom delay a -> Q Exp # liftTyped :: DSignal dom delay a -> Q (TExp (DSignal dom delay a)) #
(Lift (rep (int + frac)), KnownNat frac, KnownNat int, Typeable rep) => Lift (Fixed rep int frac :: Type) Source #
Instance details Defined in Clash.Sized.Fixed Methods lift :: Fixed rep int frac -> Q Exp # liftTyped :: Fixed rep int frac -> Q (TExp (Fixed rep int frac)) #
(Lift a, Lift b, Lift c, Lift d) => Lift ((a, b, c, d) :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (a, b, c, d) -> Q Exp # liftTyped :: (a, b, c, d) -> Q (TExp (a, b, c, d)) #
(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((a, b, c, d, e) :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (a, b, c, d, e) -> Q Exp # liftTyped :: (a, b, c, d, e) -> Q (TExp (a, b, c, d, e)) #
(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((a, b, c, d, e, f) :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (a, b, c, d, e, f) -> Q Exp # liftTyped :: (a, b, c, d, e, f) -> Q (TExp (a, b, c, d, e, f)) #
(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((a, b, c, d, e, f, g) :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (a, b, c, d, e, f, g) -> Q Exp # liftTyped :: (a, b, c, d, e, f, g) -> Q (TExp (a, b, c, d, e, f, g)) #
Lift (# #)	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# #) -> Q Exp # liftTyped :: (# #) -> Q (TExp (# #)) #
Lift a => Lift ((# a #) :: TYPE ('TupleRep '['LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a #) -> Q Exp # liftTyped :: (# a #) -> Q (TExp (# a #)) #
(Lift a, Lift b) => Lift ((# a, b #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a, b #) -> Q Exp # liftTyped :: (# a, b #) -> Q (TExp (# a, b #)) #
(Lift a, Lift b) => Lift ((# a \| b #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a \| b #) -> Q Exp # liftTyped :: (# a \| b #) -> Q (TExp (# a \| b #)) #
(Lift a, Lift b, Lift c) => Lift ((# a, b, c #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a, b, c #) -> Q Exp # liftTyped :: (# a, b, c #) -> Q (TExp (# a, b, c #)) #
(Lift a, Lift b, Lift c) => Lift ((# a \| b \| c #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a \| b \| c #) -> Q Exp # liftTyped :: (# a \| b \| c #) -> Q (TExp (# a \| b \| c #)) #
(Lift a, Lift b, Lift c, Lift d) => Lift ((# a, b, c, d #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a, b, c, d #) -> Q Exp # liftTyped :: (# a, b, c, d #) -> Q (TExp (# a, b, c, d #)) #
(Lift a, Lift b, Lift c, Lift d) => Lift ((# a \| b \| c \| d #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a \| b \| c \| d #) -> Q Exp # liftTyped :: (# a \| b \| c \| d #) -> Q (TExp (# a \| b \| c \| d #)) #
(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a, b, c, d, e #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a, b, c, d, e #) -> Q Exp # liftTyped :: (# a, b, c, d, e #) -> Q (TExp (# a, b, c, d, e #)) #
(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a \| b \| c \| d \| e #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a \| b \| c \| d \| e #) -> Q Exp # liftTyped :: (# a \| b \| c \| d \| e #) -> Q (TExp (# a \| b \| c \| d \| e #)) #
(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a, b, c, d, e, f #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a, b, c, d, e, f #) -> Q Exp # liftTyped :: (# a, b, c, d, e, f #) -> Q (TExp (# a, b, c, d, e, f #)) #
(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a \| b \| c \| d \| e \| f #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a \| b \| c \| d \| e \| f #) -> Q Exp # liftTyped :: (# a \| b \| c \| d \| e \| f #) -> Q (TExp (# a \| b \| c \| d \| e \| f #)) #
(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a, b, c, d, e, f, g #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a, b, c, d, e, f, g #) -> Q Exp # liftTyped :: (# a, b, c, d, e, f, g #) -> Q (TExp (# a, b, c, d, e, f, g #)) #
(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a \| b \| c \| d \| e \| f \| g #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))	Since: template-haskell-2.16.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: (# a \| b \| c \| d \| e \| f \| g #) -> Q Exp # liftTyped :: (# a \| b \| c \| d \| e \| f \| g #) -> Q (TExp (# a \| b \| c \| d \| e \| f \| g #)) #

Type classes

Clash

class NFDataX a => AutoReg a Source #

autoReg is a "smart" version of register. It does two things:

It splits product types over their fields. For example, given a 3-tuple, the corresponding HDL will end up with three instances of a register (or more if the three fields can be split up similarly).
Given a data type where a constructor indicates (parts) of the data will (not) be updated a given cycle, it will split the data in two parts. The first part will contain the "always interesting" parts (the constructor bits). The second holds the "potentially uninteresting" data (the rest). Both parts will be stored in separate registers. The register holding the "potentially uninteresting" part will only be enabled if the constructor bits indicate they're interesting.

The most important example of this is Maybe. Consider Maybe (Signed 16); when viewed as bits, a Nothing would look like:

>>> pack @(Maybe (Signed 16)) Nothing
0b0_...._...._...._....

and Just

>>> pack @(Maybe (Signed 16)) (Just 3)
0b1_0000_0000_0000_0011

In the first case, Nothing, we don't particularly care about updating the register holding the Signed 16 field, as they'll be unknown anyway. We can therefore deassert its enable line.

Making Clash lay it out like this increases the chances of synthesis tools clock gating the registers, saving energy.

This version of autoReg will split the given data type up recursively. For example, given a :: Maybe (Maybe Int, Maybe Int), a total of five registers will be rendered. Both the "interesting" and "uninteresting" enable lines of the inner Maybe types will be controlled by the outer one, in addition to the inner parts controlling their "uninteresting" parts as described in (2).

The default implementation is just register. If you don't need or want the special features of AutoReg, you can use that by writing an empty instance.

data MyDataType = ...
instance AutoReg MyDataType

If you have a product type you can use deriveAutoReg to derive an instance.

Instances

Instances details

AutoReg Bool Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Bool -> Signal dom Bool -> Signal dom Bool Source #
AutoReg Char Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Char -> Signal dom Char -> Signal dom Char Source #
AutoReg Double Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Double -> Signal dom Double -> Signal dom Double Source #
AutoReg Float Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Float -> Signal dom Float -> Signal dom Float Source #
AutoReg Int Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int -> Signal dom Int -> Signal dom Int Source #
AutoReg Int8 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int8 -> Signal dom Int8 -> Signal dom Int8 Source #
AutoReg Int16 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int16 -> Signal dom Int16 -> Signal dom Int16 Source #
AutoReg Int32 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int32 -> Signal dom Int32 -> Signal dom Int32 Source #
AutoReg Int64 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Int64 -> Signal dom Int64 -> Signal dom Int64 Source #
AutoReg Integer Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Integer -> Signal dom Integer -> Signal dom Integer Source #
AutoReg Word Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word -> Signal dom Word -> Signal dom Word Source #
AutoReg Word8 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word8 -> Signal dom Word8 -> Signal dom Word8 Source #
AutoReg Word16 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word16 -> Signal dom Word16 -> Signal dom Word16 Source #
AutoReg Word32 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word32 -> Signal dom Word32 -> Signal dom Word32 Source #
AutoReg Word64 Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Word64 -> Signal dom Word64 -> Signal dom Word64 Source #
AutoReg () Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> () -> Signal dom () -> Signal dom () Source #
AutoReg CUShort Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> CUShort -> Signal dom CUShort -> Signal dom CUShort Source #
AutoReg Half Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Half -> Signal dom Half -> Signal dom Half Source #
AutoReg Bit Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Bit -> Signal dom Bit -> Signal dom Bit Source #
AutoReg a => AutoReg (Maybe a) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Maybe a -> Signal dom (Maybe a) -> Signal dom (Maybe a) Source #
AutoReg a => AutoReg (Ratio a) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Ratio a -> Signal dom (Ratio a) -> Signal dom (Ratio a) Source #
AutoReg a => AutoReg (Complex a) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Complex a -> Signal dom (Complex a) -> Signal dom (Complex a) Source #
AutoReg a => AutoReg (Down a) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Down a -> Signal dom (Down a) -> Signal dom (Down a) Source #
KnownNat n => AutoReg (BitVector n) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> BitVector n -> Signal dom (BitVector n) -> Signal dom (BitVector n) Source #
AutoReg (Index n) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Index n -> Signal dom (Index n) -> Signal dom (Index n) Source #
AutoReg (Unsigned n) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Unsigned n -> Signal dom (Unsigned n) -> Signal dom (Unsigned n) Source #
AutoReg (Signed n) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Signed n -> Signal dom (Signed n) -> Signal dom (Signed n) Source #
(AutoReg a, AutoReg b) => AutoReg (a, b) Source #
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b) -> Signal dom (a, b) -> Signal dom (a, b) Source #
(KnownNat n, AutoReg a) => AutoReg (Vec n a) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Vec n a -> Signal dom (Vec n a) -> Signal dom (Vec n a) Source #
(KnownNat d, AutoReg a) => AutoReg (RTree d a) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> RTree d a -> Signal dom (RTree d a) -> Signal dom (RTree d a) Source #
(AutoReg a, AutoReg b, AutoReg c) => AutoReg (a, b, c) Source #	N.B.: The documentation only shows 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.
Instance details Defined in Clash.Class.AutoReg.Instances Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> (a, b, c) -> Signal dom (a, b, c) -> Signal dom (a, b, c) Source #
NFDataX (rep (int + frac)) => AutoReg (Fixed rep int frac) Source #
Instance details Defined in Clash.Class.AutoReg.Internal Methods autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Fixed rep int frac -> Signal dom (Fixed rep int frac) -> Signal dom (Fixed rep int frac) Source #

autoReg :: (HasCallStack, HiddenClockResetEnable dom, AutoReg a) => a -> Signal dom a -> Signal dom a Source #

Implicit version of autoReg

deriveAutoReg :: Name -> DecsQ Source #

Automatically derives an AutoReg instance for a product type

Usage:

data Pair a b = MkPair { getA :: a, getB :: b } deriving (Generic, NFDataX)
data Tup3 a b c = MkTup3 { getAB :: Pair a b, getC :: c } deriving (Generic, NFDataX)
deriveAutoReg ''Pair
deriveAutoReg ''Tup3

NB: Because of the way template haskell works the order here matters, if you try to deriveAutoReg ''Tup3 before Pair it will complain about missing an instance AutoReg (Pair a b).

module Clash.Class.BitPack

module Clash.Class.Exp

module Clash.Class.Num

module Clash.Class.Parity

module Clash.Class.Resize

Other

module Control.Applicative

module Data.Bits

module Data.Default.Class

type Type = Type #

The kind of types with lifted values. For example Int :: Type.

data Constraint #

The kind of constraints, like Show a

Clash.Prelude re-exports most of the Haskell Prelude with the exception of those functions that the Clash API defines to work on Vec from Clash.Sized.Vector instead of on lists as the Haskell Prelude does. In addition, for the odd and even functions a type class called Parity is available at Clash.Class.Parity.

module Clash.HaskellPrelude

Creating synchronous sequential circuits

Synchronizer circuits for safe clock domain crossings

ROMs

ROMs defined by a MemBlob

ROMs defined by a data file

RAM primitives with a combinational read port

BlockRAM primitives

BlockRAM primitives initialized with a MemBlob

Creating and inspecting MemBlob

Instances

Example

Example

BlockRAM primitives initialized with a data file

BlockRAM read/write conflict resolution

True dual-port block RAM

Instances

Utility functions

Tracing

Simple

Tracing in a multi-clock environment

VCD dump functions

Exported modules

Synchronous signals

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Example

Example 1

Example 2

Implementation details

Example 1

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example with test bench

Datatypes

Bit vectors

Arbitrary-width numbers

Fixed point numbers

Fixed size vectors

Instances

Instances

doctests setup

Example usage

doctests setup

Example usage

doctests setup

Example usage

doctests setup

ROMs defined by a `MemBlob`

BlockRAM primitives initialized with a `MemBlob`

Creating and inspecting `MemBlob`