Clash.Signal

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. More specifically, a domain looks like:

DomainConfiguration
  { _name :: Domain
  -- ^ Domain name
  , _period :: Nat
  -- ^ Clock period in ps
  , _edge :: ActiveEdge
  -- ^ Active edge of the clock
  , _reset :: ResetKind
  -- ^ Whether resets are synchronous (edge-sensitive) or asynchronous (level-sensitive)
  , _init :: InitBehavior
  -- ^ Whether the initial (or "power up") value of memory elements is
  -- unknown/undefined, or configurable to a specific value
  , _polarity :: ResetPolarity
  -- ^ Whether resets are active high or active low
  }

Check the documentation of each of the types to see the various options Clash provides. In order to specify a domain, an instance of KnownDomain should be made. Clash provides an implementation System with some common options chosen:

instance KnownDomain System where
  type KnownConf System = 'DomainConfiguration System 10000 'Rising 'Asynchronous 'Defined 'ActiveHigh
  knownDomain = SDomainConfiguration SSymbol SNat SRising SAsynchronous SDefined SActiveHigh

In words, System is a synthesis domain with a clock running with a period of 10000 ps. Memory elements respond to the rising edge of the clock, asynchronously to changes in their resets, and have defined power up values if applicable.

In order to create a new domain, you don't have to instantiate it explicitly. Instead, you can have createDomain create a domain for you. You can also use the same function to subclass existing domains.

• 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: Whether System has good defaults depends on your target platform. Check out IntelSystem and XilinxSystem too!

Synchronous signals

data Signal (dom :: Domain) a

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!

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

Instances

Functor (Signal dom)

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)

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)

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.

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)

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)

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)

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)

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> Signal dom a -> ShowS

show :: Signal dom a -> String

showList :: [Signal dom a] -> ShowS

Lift a => Lift (Signal dom a)

Defined in Clash.Signal.Internal

Methods

lift :: Signal dom a -> Q Exp

Arbitrary a => Arbitrary (Signal dom a)

Defined in Clash.Signal.Internal

Methods

arbitrary :: Gen (Signal dom a)

shrink :: Signal dom a -> [Signal dom a]

CoArbitrary a => CoArbitrary (Signal dom a)

Defined in Clash.Signal.Internal

Methods

coarbitrary :: Signal dom a -> Gen b -> Gen b

Default a => Default (Signal dom a)

Defined in Clash.Signal.Internal

Methods

def :: Signal dom a

Clocks (Clock c1, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

type HasDomain dom1 (Signal dom2 a)

Defined in Clash.Class.HasDomain.HasSpecificDomain

type HasDomain dom1 (Signal dom2 a) = DomEq dom1 dom2

type TryDomain t (Signal dom a)

Defined in Clash.Class.HasDomain.HasSingleDomain

type TryDomain t (Signal dom a) = 'Found dom

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

The in part of an inout port

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

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.

Instances

Semigroup (BiSignalOut defaultState dom n)

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)

Monoid instance to support concatenating

NB Not synthesizable

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

data BiSignalDefault

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

Show BiSignalDefault

Defined in Clash.Signal.BiSignal

Methods

showsPrec :: Int -> BiSignalDefault -> ShowS

show :: BiSignalDefault -> String

showList :: [BiSignalDefault] -> ShowS

Domain

type Domain = Symbol

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

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

Methods

knownDomain :: SDomainConfiguration dom (KnownConf dom)

Returns SDomainConfiguration corresponding to an instance's DomainConfiguration.

Example usage: > knownDomain @System

Instances

KnownDomain XilinxSystem

System instance with defaults set for Xilinx FPGAs

Defined in Clash.Signal.Internal

Associated Types

type KnownConf XilinxSystem :: DomainConfiguration

Methods

knownDomain :: SDomainConfiguration XilinxSystem (KnownConf XilinxSystem)

KnownDomain IntelSystem

System instance with defaults set for Intel FPGAs

Defined in Clash.Signal.Internal

Associated Types

type KnownConf IntelSystem :: DomainConfiguration

Methods

knownDomain :: SDomainConfiguration IntelSystem (KnownConf IntelSystem)

KnownDomain System

A clock (and reset) dom with clocks running at 100 MHz

Defined in Clash.Signal.Internal

Associated Types

type KnownConf System :: DomainConfiguration

Methods

knownDomain :: SDomainConfiguration System (KnownConf System)

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

data ActiveEdge

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

Eq ActiveEdge

Defined in Clash.Signal.Internal

Methods

(==) :: ActiveEdge -> ActiveEdge -> Bool

(/=) :: ActiveEdge -> ActiveEdge -> Bool

Data ActiveEdge

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

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

Show ActiveEdge

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> ActiveEdge -> ShowS

show :: ActiveEdge -> String

showList :: [ActiveEdge] -> ShowS

Generic ActiveEdge

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

Defined in Clash.Signal.Internal

Methods

put :: ActiveEdge -> Put

get :: Get ActiveEdge

putList :: [ActiveEdge] -> Put

NFData ActiveEdge

Defined in Clash.Signal.Internal

Methods

rnf :: ActiveEdge -> ()

Hashable ActiveEdge

Defined in Clash.Signal.Internal

Methods

hashWithSalt :: Int -> ActiveEdge -> Int

hash :: ActiveEdge -> Int

type Rep ActiveEdge

Defined in Clash.Signal.Internal

type Rep ActiveEdge = D1 ('MetaData "ActiveEdge" "Clash.Signal.Internal" "clash-prelude-0.9999-inplace" 'False) (C1 ('MetaCons "Rising" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Falling" 'PrefixI 'False) (U1 :: Type -> Type))

data SActiveEdge (edge :: ActiveEdge) where

Singleton version of ActiveEdge

Constructors

SRising :: SActiveEdge 'Rising

SFalling :: SActiveEdge 'Falling

Instances

Show (SActiveEdge edge)

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> SActiveEdge edge -> ShowS

show :: SActiveEdge edge -> String

showList :: [SActiveEdge edge] -> ShowS

data InitBehavior

Constructors

Unknown

Power up value of memory elements is unknown.

Defined

If applicable, power up value of a memory element is defined. Applies to registers for example, but not to blockRam.

Instances

Eq InitBehavior

Defined in Clash.Signal.Internal

Methods

(==) :: InitBehavior -> InitBehavior -> Bool

(/=) :: InitBehavior -> InitBehavior -> Bool

Data InitBehavior

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

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

Show InitBehavior

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> InitBehavior -> ShowS

show :: InitBehavior -> String

showList :: [InitBehavior] -> ShowS

Generic InitBehavior

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

Defined in Clash.Signal.Internal

Methods

rnf :: InitBehavior -> ()

Hashable InitBehavior

Defined in Clash.Signal.Internal

Methods

hashWithSalt :: Int -> InitBehavior -> Int

hash :: InitBehavior -> Int

type Rep InitBehavior

Defined in Clash.Signal.Internal

type Rep InitBehavior = D1 ('MetaData "InitBehavior" "Clash.Signal.Internal" "clash-prelude-0.9999-inplace" 'False) (C1 ('MetaCons "Unknown" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Defined" 'PrefixI 'False) (U1 :: Type -> Type))

data SInitBehavior (init :: InitBehavior) where

Constructors

SUnknown :: SInitBehavior 'Unknown

SDefined :: SInitBehavior 'Defined

Instances

Show (SInitBehavior init)

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> SInitBehavior init -> ShowS

show :: SInitBehavior init -> String

showList :: [SInitBehavior init] -> ShowS

data ResetKind

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

Eq ResetKind

Defined in Clash.Signal.Internal

Methods

(==) :: ResetKind -> ResetKind -> Bool

(/=) :: ResetKind -> ResetKind -> Bool

Data ResetKind

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

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

Show ResetKind

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> ResetKind -> ShowS

show :: ResetKind -> String

showList :: [ResetKind] -> ShowS

Generic ResetKind

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

Defined in Clash.Signal.Internal

Methods

rnf :: ResetKind -> ()

Hashable ResetKind

Defined in Clash.Signal.Internal

Methods

hashWithSalt :: Int -> ResetKind -> Int

hash :: ResetKind -> Int

type Rep ResetKind

Defined in Clash.Signal.Internal

type Rep ResetKind = D1 ('MetaData "ResetKind" "Clash.Signal.Internal" "clash-prelude-0.9999-inplace" 'False) (C1 ('MetaCons "Asynchronous" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Synchronous" 'PrefixI 'False) (U1 :: Type -> Type))

data SResetKind (resetKind :: ResetKind) where

Singleton version of ResetKind

Constructors

SAsynchronous :: SResetKind 'Asynchronous

SSynchronous :: SResetKind 'Synchronous

Instances

Show (SResetKind reset)

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> SResetKind reset -> ShowS

show :: SResetKind reset -> String

showList :: [SResetKind reset] -> ShowS

data ResetPolarity

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

Eq ResetPolarity

Defined in Clash.Signal.Internal

Methods

(==) :: ResetPolarity -> ResetPolarity -> Bool

(/=) :: ResetPolarity -> ResetPolarity -> Bool

Data ResetPolarity

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

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

Show ResetPolarity

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> ResetPolarity -> ShowS

show :: ResetPolarity -> String

showList :: [ResetPolarity] -> ShowS

Generic ResetPolarity

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

Defined in Clash.Signal.Internal

Methods

rnf :: ResetPolarity -> ()

Hashable ResetPolarity

Defined in Clash.Signal.Internal

Methods

hashWithSalt :: Int -> ResetPolarity -> Int

hash :: ResetPolarity -> Int

type Rep ResetPolarity

Defined in Clash.Signal.Internal

type Rep ResetPolarity = D1 ('MetaData "ResetPolarity" "Clash.Signal.Internal" "clash-prelude-0.9999-inplace" 'False) (C1 ('MetaCons "ActiveHigh" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ActiveLow" 'PrefixI 'False) (U1 :: Type -> Type))

data SResetPolarity (polarity :: ResetPolarity) where

Singleton version of ResetPolarity

Constructors

SActiveHigh :: SResetPolarity 'ActiveHigh

SActiveLow :: SResetPolarity 'ActiveLow

Instances

Show (SResetPolarity polarity)

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> SResetPolarity polarity -> ShowS

show :: SResetPolarity polarity -> String

showList :: [SResetPolarity polarity] -> ShowS

data DomainConfiguration

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 SDomainConfiguration (dom :: Domain) (conf :: DomainConfiguration) where

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

Show (SDomainConfiguration dom conf)

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> SDomainConfiguration dom conf -> ShowS

show :: SDomainConfiguration dom conf -> String

showList :: [SDomainConfiguration dom conf] -> ShowS

Configuration type families

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Default domains

type System = "System" :: Domain

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 XilinxSystem = "XilinxSystem" :: Domain

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

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.

vSystem :: VDomainConfiguration

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 in tact use:

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

vIntelSystem :: VDomainConfiguration

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 in tact use:

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

vXilinxSystem :: VDomainConfiguration

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 in tact use:

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

Domain utilities

data VDomainConfiguration

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 _edge on DomainConfiguration

• vResetKind :: ResetKind

  Corresponds to _reset on DomainConfiguration

• vInitBehavior :: InitBehavior

  Corresponds to _init on DomainConfiguration

• vResetPolarity :: ResetPolarity

  Corresponds to _polarity on DomainConfiguration

vDomain :: SDomainConfiguration dom conf -> VDomainConfiguration

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

createDomain :: VDomainConfiguration -> Q [Dec]

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

knownVDomain :: forall dom. KnownDomain dom => VDomainConfiguration

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

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

Get the clock period from a KnownDomain context

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

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

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

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

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

Clock

data Clock (dom :: Domain)

A clock signal belonging to a domain named dom.

Instances

Show (Clock dom)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). Clock domIn -> Reset domIn -> (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Signal pllLock Bool)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

Clocks (Clock c1, Clock c2, Clock c3, Clock c4, Clock c5, Clock c6, Clock c7, Clock c8, Clock c9, Clock c10, Signal pllLock Bool)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

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)

Defined in Clash.Clocks

Methods

clocks :: forall (domIn :: Domain). 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)

type HasDomain dom1 (Clock dom2)

Defined in Clash.Class.HasDomain.HasSpecificDomain

type HasDomain dom1 (Clock dom2) = DomEq dom1 dom2

type TryDomain t (Clock dom)

Defined in Clash.Class.HasDomain.HasSingleDomain

type TryDomain t (Clock dom) = 'Found dom

periodToHz :: Natural -> Double

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
2.0e8

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

hzToPeriod :: HasCallStack => Double -> Natural

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
4167

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

Synchronization primitive

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

Implicit version of unsafeSynchronizer.

Reset

data Reset (dom :: Domain)

A reset signal belonging to a domain called dom.

The underlying representation of resets is Bool.

Constructors

Reset (Signal dom Bool)

Instances

type HasDomain dom1 (Reset dom2)

Defined in Clash.Class.HasDomain.HasSpecificDomain

type HasDomain dom1 (Reset dom2) = DomEq dom1 dom2

type TryDomain t (Reset dom)

Defined in Clash.Class.HasDomain.HasSingleDomain

type TryDomain t (Reset dom) = 'Found dom

unsafeToReset :: Signal dom Bool -> Reset dom

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.

unsafeFromReset :: Reset dom -> Signal dom Bool

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.

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

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

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.

unsafeFromHighPolarity

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

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.

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

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

resetSynchronizer :: forall dom. KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> Reset dom

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

Example

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
  where
    key1R  = isRising 1 key1
    leds   = mealy blinkerT (1, False, 0) key1R

holdReset

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.

Enabling

newtype Enable dom

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.

Constructors

Enable (Signal dom Bool)

Instances

type HasDomain dom1 (Enable dom2)

Defined in Clash.Class.HasDomain.HasSpecificDomain

type HasDomain dom1 (Enable dom2) = DomEq dom1 dom2

type TryDomain t (Enable dom)

Defined in Clash.Class.HasDomain.HasSingleDomain

type TryDomain t (Enable dom) = 'Found dom

toEnable :: Signal dom Bool -> Enable dom

Convert a signal of bools to an Enable construct

fromEnable :: Enable dom -> Signal dom Bool

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

enableGen :: Enable dom

Enable generator for some domain. Is simply always True.

Hidden clocks and resets

Clocks and resets are by default implicitly routed to their components. You can see from the type of a component whether it has hidden clock or reset arguments:

It has a hidden clock when it has a:

f :: HiddenClock dom => ...

Constraint.

Or it has a hidden reset when it has a:

g :: HiddenReset dom polarity => ...

Constraint.

Or it has both a hidden clock argument and a hidden reset argument when it has a:

h :: HiddenClockReset dom  => ..

Constraint.

Given a component with an explicit clock and reset arguments, you can turn them into hidden arguments using hideClock and hideReset. So given a:

f :: Clock dom -> Reset dom -> Signal dom a -> ...

You hide the clock and reset arguments by:

-- g :: HiddenClockReset dom  => Signal dom a -> ...
g = hideClockReset f

Or, alternatively, by:

-- h :: HiddenClockResetEnable dom  => Signal dom a -> ...
h = f hasClock hasReset

Assigning explicit clock and reset arguments to hidden clocks and resets

Given a component:

f :: HiddenClockResetEnable dom
  => Signal dom Int
  -> Signal dom Int

which has hidden clock and routed reset arguments, we expose those hidden arguments so that we can explicitly apply them:

-- g :: Clock dom -> Reset dom -> Signal dom Int -> Signal dom Int
g = exposeClockResetEnable f

or, alternatively, by:

-- h :: Clock dom -> Reset dom -> Signal dom Int -> Signal dom Int
h clk rst = withClock clk rst f

Similarly, there are exposeClock and exposeReset to connect just expose the hidden clock or the hidden reset argument.

You will need to explicitly apply clocks and resets when you want to use components such as PPLs and resetSynchronizer:

topEntity
  :: Clock System
  -> Reset System
  -> Enable System
  -> Signal System Int
  -> Signal System Int
topEntity clk rst =
  let (pllOut,pllStable) = altpll (SSymbol @"altpll50") clk rst
      rstSync            = resetSynchronizer pllOut (unsafeToAsyncReset pllStable)
  in  exposeClockResetEnable f pllOut rstSync

or, using the alternative method:

topEntity2
  :: Clock System
  -> Reset System
  -> Signal System Int
  -> Signal System Int
topEntity2 clk rst =
  let (pllOut,pllStable) = altpll (SSymbol @"altpll50") clk rst
      rstSync            = resetSynchronizer pllOut (unsafeToAsyncReset pllStable)
  in  withClockReset pllOut rstSync f

Hidden clock

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

A constraint that indicates the component has a hidden Clock

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

hideClock

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

exposeClock

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.

exposeSpecificClock

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

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

withClock

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.

withSpecificClock

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 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

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

>>> reg = register @System 5 (reg + 1)
>>> sig = withClock @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 = withClock @dom clockGen reg

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

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

Hidden reset

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

A constraint that indicates the component needs a Reset

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

hideReset

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

exposeReset

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.

withReset

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.

exposeSpecificReset

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

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

withSpecificReset

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 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

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

>>> reg = register @System 5 (reg + 1)
>>> sig = withReset @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 = withReset @dom resetGen reg

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

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

Hidden enable

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

A constraint that indicates the component needs a Enable

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

hideEnable

Arguments

:: forall dom r. HiddenEnable dom

=> (Enable dom -> r)

Component whose reset 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

exposeEnable

Arguments

:: forall dom r. WithSingleDomain dom r

=> (HiddenEnable dom => r)

The component with a hidden reset

-> KnownDomain dom => Enable dom -> r

The component with its reset argument exposed

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

withEnable

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.

exposeSpecificEnable

Arguments

:: forall dom r. WithSpecificDomain dom r

=> (HiddenEnable dom => r)

The component with a hidden reset

-> KnownDomain dom => Enable dom -> r

The component with its reset 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

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

withSpecificEnable

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 Reset to a function with a hidden Enable. 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

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

>>> reg = register @System 5 (reg + 1)
>>> sig = withEnable @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 = withEnable @dom enableGen reg

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

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

Hidden clock, reset, and enable

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

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

hideClockResetEnable

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

exposeClockResetEnable

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 a hidden Clock, Reset, and Enable argument of a component, so it can be applied explicitly.

withClockResetEnable

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.

exposeSpecificClockResetEnable

Arguments

:: forall dom r. WithSpecificDomain 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 a hidden Clock, Reset, and Enable argument of a component, so it can be applied explicitly. This function can be used on components with multiple domains. As opposed to exposeClockResetEnable, 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

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

withSpecificClockResetEnable

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 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 be used on components with multiple domains. As opposed to exposeClockResetEnable, 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

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

>>> reg = register @System 5 (reg + 1)
>>> sig = withClockResetEnable @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 = withClockResetEnable @dom clockGen resetGen enableGen reg

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

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

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

Basic circuit functions

dflipflop :: forall dom a. (HiddenClock dom, Undefined a) => Signal dom a -> Signal dom a

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

delay

Arguments

:: forall dom a. (Undefined a, HiddenClock dom, HiddenEnable dom)

=> a

Initial value

-> Signal dom a

Signal to delay

-> Signal dom a

delay 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

Arguments

:: forall dom a. (Undefined 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

Arguments

:: forall dom a. (Undefined 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

Arguments

:: forall dom a. (HiddenClockResetEnable dom, Undefined a)

=> a

Reset value

register outputs the reset value when the reset value is active

-> 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

Arguments

:: forall dom a. (HiddenClockResetEnable dom, Undefined a)

=> a

Reset value. regMaybe outputs the reset value when the reset is active.

-> 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

Arguments

:: forall dom a. (HiddenClockResetEnable dom, Undefined a)

=> a

Reset value

regEn outputs the reset value when the reset value is active

-> 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]

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

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.

Simulation and testbench functions

clockGen :: KnownDomain dom => Clock dom

Clock generator for simulations. Do not use this clock generator for 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

Reset generator

To be used like:

rstSystem = resetGen @System

See tbClockGen for example usage.

resetGenN

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]

systemClockGen :: Clock System

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

Reset generator for the System clock domain.

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

Example

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

Boolean connectives

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

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 2

The above type is a generalization for:

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

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

Product/Signal isomorphism

class Bundle a where

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

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

Minimal complete definition

Nothing

Associated Types

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

type Unbundled dom a = Signal dom a

Methods

bundle :: Unbundled dom a -> Signal dom a

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

unbundle :: Signal dom a -> Unbundled dom a

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

Instances

Bundle Bool

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom Bool = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom Bool -> Signal dom Bool

unbundle :: forall (dom :: Domain). Signal dom Bool -> Unbundled dom Bool

Bundle Double

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom Double = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom Double -> Signal dom Double

unbundle :: forall (dom :: Domain). Signal dom Double -> Unbundled dom Double

Bundle Float

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom Float = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom Float -> Signal dom Float

unbundle :: forall (dom :: Domain). Signal dom Float -> Unbundled dom Float

Bundle Int

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom Int = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom Int -> Signal dom Int

unbundle :: forall (dom :: Domain). Signal dom Int -> Unbundled dom Int

Bundle Integer

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom Integer = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom Integer -> Signal dom Integer

unbundle :: forall (dom :: Domain). Signal dom Integer -> Unbundled dom Integer

Bundle ()

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom () = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom () -> Signal dom ()

unbundle :: forall (dom :: Domain). Signal dom () -> Unbundled dom ()

Bundle Bit

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom Bit = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom Bit -> Signal dom Bit

unbundle :: forall (dom :: Domain). Signal dom Bit -> Unbundled dom Bit

Bundle (Maybe a)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (Maybe a) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (Maybe a) -> Signal dom (Maybe a)

unbundle :: forall (dom :: Domain). Signal dom (Maybe a) -> Unbundled dom (Maybe a)

Bundle (BitVector n)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (BitVector n) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (BitVector n) -> Signal dom (BitVector n)

unbundle :: forall (dom :: Domain). Signal dom (BitVector n) -> Unbundled dom (BitVector n)

Bundle (Index n)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (Index n) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (Index n) -> Signal dom (Index n)

unbundle :: forall (dom :: Domain). Signal dom (Index n) -> Unbundled dom (Index n)

Bundle (Unsigned n)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (Unsigned n) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (Unsigned n) -> Signal dom (Unsigned n)

unbundle :: forall (dom :: Domain). Signal dom (Unsigned n) -> Unbundled dom (Unsigned n)

Bundle (Signed n)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (Signed n) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (Signed n) -> Signal dom (Signed n)

unbundle :: forall (dom :: Domain). Signal dom (Signed n) -> Unbundled dom (Signed n)

Bundle (Either a b)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (Either a b) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (Either a b) -> Signal dom (Either a b)

unbundle :: forall (dom :: Domain). Signal dom (Either a b) -> Unbundled dom (Either a b)

Bundle (a1, a2)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2) -> Signal dom (a1, a2)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2) -> Unbundled dom (a1, a2)

KnownNat n => Bundle (Vec n a)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (Vec n a) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (Vec n a) -> Signal dom (Vec n a)

unbundle :: forall (dom :: Domain). Signal dom (Vec n a) -> Unbundled dom (Vec n a)

KnownNat d => Bundle (RTree d a)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (RTree d a) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (RTree d a) -> Signal dom (RTree d a)

unbundle :: forall (dom :: Domain). Signal dom (RTree d a) -> Unbundled dom (RTree d a)

Bundle (a1, a2, a3)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3) -> Signal dom (a1, a2, a3)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3) -> Unbundled dom (a1, a2, a3)

Bundle (Fixed rep int frac)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (Fixed rep int frac) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (Fixed rep int frac) -> Signal dom (Fixed rep int frac)

unbundle :: forall (dom :: Domain). Signal dom (Fixed rep int frac) -> Unbundled dom (Fixed rep int frac)

Bundle (a1, a2, a3, a4)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4) -> Signal dom (a1, a2, a3, a4)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4) -> Unbundled dom (a1, a2, a3, a4)

Bundle (a1, a2, a3, a4, a5)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5) -> Signal dom (a1, a2, a3, a4, a5)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5) -> Unbundled dom (a1, a2, a3, a4, a5)

Bundle (a1, a2, a3, a4, a5, a6)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6) -> Signal dom (a1, a2, a3, a4, a5, a6)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6) -> Unbundled dom (a1, a2, a3, a4, a5, a6)

Bundle (a1, a2, a3, a4, a5, a6, a7)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7) -> Signal dom (a1, a2, a3, a4, a5, a6, a7)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61)

Bundle (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62) -> Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62)

unbundle :: forall (dom :: Domain). Signal dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62) -> Unbundled dom (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62)

Simulation functions (not synthesizable)

simulate

Arguments

:: forall dom a b. (KnownDomain dom, Undefined a, Undefined 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

simulateB

Arguments

:: forall dom a b. (KnownDomain dom, Bundle a, Bundle b, Undefined a, Undefined 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

simulateN

Arguments

:: forall dom a b. (KnownDomain dom, Undefined a, Undefined 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

Arguments

:: forall dom a b m. (KnownDomain dom, Undefined a, Undefined 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

Arguments

:: forall dom a b m. (KnownDomain dom, Undefined a, Undefined 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.

lazy versions

simulate_lazy

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_lazy

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

List <-> Signal conversion (not synthesizable)

sample

Arguments

:: forall dom a. (KnownDomain dom, Undefined 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

Arguments

:: forall dom a. (KnownDomain dom, Undefined 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

Arguments

:: forall dom a m. (KnownDomain dom, Undefined 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 a list of samples from a Signal, while asserting the reset line for n clock cycles. sampleWithReset does not return the first n cycles, i.e., when the reset is asserted.

NB: This function is not synthesizable

sampleWithResetN

Arguments

:: forall dom a m. (KnownDomain dom, Undefined 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 fine list of m samples from a Signal, while asserting the reset line for n clock cycles. sampleWithReset does not return the first n cycles, i.e., while the reset is asserted.

NB: This function is not synthesizable

fromList :: Undefined a => [a] -> Signal dom a

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

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

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

lazy versions

sample_lazy

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

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

fromList_lazy :: [a] -> Signal dom a

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

QuickCheck combinators

testFor

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

Type classes

Eq-like

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

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

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-like

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

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

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

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

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

Bisignal functions

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

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.

readFromBiSignal

Arguments

:: (HasCallStack, KnownNat (BitSize a), 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

writeToBiSignal

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

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

Combine several inout signals into one.