Clash.XException

X: An exception for uninitialized values

>>> show (errorX "undefined" :: Integer, 4 :: Int)
"(*** Exception: X: undefined
CallStack (from HasCallStack):
...
>>> showX (errorX "undefined" :: Integer, 4 :: Int)
"(X,4)"

X: An exception for uninitialized values

newtype XException

An exception representing an "uninitialized" value.

Constructors

XException String

Instances

Show XException

Defined in Clash.XException

Methods

showsPrec :: Int -> XException -> ShowS

show :: XException -> String

showList :: [XException] -> ShowS

Exception XException

Defined in Clash.XException

Methods

toException :: XException -> SomeException

fromException :: SomeException -> Maybe XException

displayException :: XException -> String

errorX :: HasCallStack => String -> a

Like error, but throwing an XException instead of an ErrorCall

The ShowX methods print these error-values as "X"; instead of error'ing out with an exception.

isX :: a -> Either String a

Evaluate a value to WHNF, returning Left msg if is a XException.

isX 42                  = Right 42
isX (XException msg)    = Left msg
isX (3, XException msg) = Right (3, XException msg)
isX (3, _|_)            = (3, _|_)
isX _|_                 = _|_

hasX :: NFData a => a -> Either String a

Fully evaluate a value, returning Left msg if it throws XException. If you want to determine if a value contains undefined parts, use hasUndefined instead.

hasX 42                  = Right 42
hasX (XException msg)    = Left msg
hasX (3, XException msg) = Left msg
hasX (3, _|_)            = _|_
hasX _|_                 = _|_

If a data structure contains multiple XExceptions, the "first" message is picked according to the implementation of rnf.

maybeIsX :: a -> Maybe a

Evaluate a value to WHNF, returning Nothing if it throws XException.

maybeIsX 42                  = Just 42
maybeIsX (XException msg)    = Nothing
maybeIsX (3, XException msg) = Just (3, XException msg)
maybeIsX (3, _|_)            = Just (3, _|_)
maybeIsX _|_                 = _|_

maybeHasX :: NFData a => a -> Maybe a

Fully evaluate a value, returning Nothing if it throws XException.

maybeX 42                  = Just 42
maybeX (XException msg)    = Nothing
maybeX (3, XException msg) = Nothing
maybeX (3, _|_)            = _|_
maybeX _|_                 = _|_

fromJustX :: HasCallStack => Maybe a -> a

Same as "Data.Maybe.fromJust", but returns a bottom/undefined value that other Clash constructs are aware of.

undefined :: HasCallStack => a

Printing X exceptions as "X"

class ShowX a where

Like the Show class, but values that normally throw an X exception are converted to "X", instead of error'ing out with an exception.

>>> show (errorX "undefined" :: Integer, 4 :: Int)
"(*** Exception: X: undefined
CallStack (from HasCallStack):
...
>>> showX (errorX "undefined" :: Integer, 4 :: Int)
"(X,4)"

Can be derived using Generics:

{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

import Clash.Prelude
import GHC.Generics

data T = MkTA Int | MkTB Bool
  deriving (Show,Generic,ShowX)

Minimal complete definition

Nothing

Methods

showsPrecX :: Int -> a -> ShowS

Like showsPrec, but values that normally throw an X exception are converted to "X", instead of error'ing out with an exception.

default showsPrecX :: (Generic a, GShowX (Rep a)) => Int -> a -> ShowS

showX :: a -> String

Like show, but values that normally throw an X exception are converted to "X", instead of error'ing out with an exception.

showListX :: [a] -> ShowS

Like showList, but values that normally throw an X exception are converted to "X", instead of error'ing out with an exception.

Instances

ShowX Bool

Defined in Clash.XException

Methods

showsPrecX :: Int -> Bool -> ShowS

showX :: Bool -> String

showListX :: [Bool] -> ShowS

ShowX Char

Defined in Clash.XException

Methods

showsPrecX :: Int -> Char -> ShowS

showX :: Char -> String

showListX :: [Char] -> ShowS

ShowX Double

Defined in Clash.XException

Methods

showsPrecX :: Int -> Double -> ShowS

showX :: Double -> String

showListX :: [Double] -> ShowS

ShowX Float

Defined in Clash.XException

Methods

showsPrecX :: Int -> Float -> ShowS

showX :: Float -> String

showListX :: [Float] -> ShowS

ShowX Int

Defined in Clash.XException

Methods

showsPrecX :: Int -> Int -> ShowS

showX :: Int -> String

showListX :: [Int] -> ShowS

ShowX Int8

Defined in Clash.XException

Methods

showsPrecX :: Int -> Int8 -> ShowS

showX :: Int8 -> String

showListX :: [Int8] -> ShowS

ShowX Int16

Defined in Clash.XException

Methods

showsPrecX :: Int -> Int16 -> ShowS

showX :: Int16 -> String

showListX :: [Int16] -> ShowS

ShowX Int32

Defined in Clash.XException

Methods

showsPrecX :: Int -> Int32 -> ShowS

showX :: Int32 -> String

showListX :: [Int32] -> ShowS

ShowX Int64

Defined in Clash.XException

Methods

showsPrecX :: Int -> Int64 -> ShowS

showX :: Int64 -> String

showListX :: [Int64] -> ShowS

ShowX Integer

Defined in Clash.XException

Methods

showsPrecX :: Int -> Integer -> ShowS

showX :: Integer -> String

showListX :: [Integer] -> ShowS

ShowX Natural

Defined in Clash.XException

Methods

showsPrecX :: Int -> Natural -> ShowS

showX :: Natural -> String

showListX :: [Natural] -> ShowS

ShowX Word

Defined in Clash.XException

Methods

showsPrecX :: Int -> Word -> ShowS

showX :: Word -> String

showListX :: [Word] -> ShowS

ShowX Word8

Defined in Clash.XException

Methods

showsPrecX :: Int -> Word8 -> ShowS

showX :: Word8 -> String

showListX :: [Word8] -> ShowS

ShowX Word16

Defined in Clash.XException

Methods

showsPrecX :: Int -> Word16 -> ShowS

showX :: Word16 -> String

showListX :: [Word16] -> ShowS

ShowX Word32

Defined in Clash.XException

Methods

showsPrecX :: Int -> Word32 -> ShowS

showX :: Word32 -> String

showListX :: [Word32] -> ShowS

ShowX Word64

Defined in Clash.XException

Methods

showsPrecX :: Int -> Word64 -> ShowS

showX :: Word64 -> String

showListX :: [Word64] -> ShowS

ShowX ()

Defined in Clash.XException

Methods

showsPrecX :: Int -> () -> ShowS

showX :: () -> String

showListX :: [()] -> ShowS

ShowX String

Defined in Clash.XException

Methods

showsPrecX :: Int -> String -> ShowS

showX :: String -> String

showListX :: [String] -> ShowS

ShowX Bit

Defined in Clash.Sized.Internal.BitVector

Methods

showsPrecX :: Int -> Bit -> ShowS

showX :: Bit -> String

showListX :: [Bit] -> ShowS

ShowX a => ShowX [a]

Defined in Clash.XException

Methods

showsPrecX :: Int -> [a] -> ShowS

showX :: [a] -> String

showListX :: [[a]] -> ShowS

ShowX a => ShowX (Maybe a)

Defined in Clash.XException

Methods

showsPrecX :: Int -> Maybe a -> ShowS

showX :: Maybe a -> String

showListX :: [Maybe a] -> ShowS

ShowX a => ShowX (Ratio a)

Defined in Clash.XException

Methods

showsPrecX :: Int -> Ratio a -> ShowS

showX :: Ratio a -> String

showListX :: [Ratio a] -> ShowS

ShowX a => ShowX (Complex a)

Defined in Clash.XException

Methods

showsPrecX :: Int -> Complex a -> ShowS

showX :: Complex a -> String

showListX :: [Complex a] -> ShowS

ShowX a => ShowX (Down a)

Defined in Clash.XException

Methods

showsPrecX :: Int -> Down a -> ShowS

showX :: Down a -> String

showListX :: [Down a] -> ShowS

ShowX a => ShowX (Seq a)

Defined in Clash.XException

Methods

showsPrecX :: Int -> Seq a -> ShowS

showX :: Seq a -> String

showListX :: [Seq a] -> ShowS

KnownNat n => ShowX (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

showsPrecX :: Int -> BitVector n -> ShowS

showX :: BitVector n -> String

showListX :: [BitVector n] -> ShowS

ShowX (Index n)

Defined in Clash.Sized.Internal.Index

Methods

showsPrecX :: Int -> Index n -> ShowS

showX :: Index n -> String

showListX :: [Index n] -> ShowS

KnownNat n => ShowX (BNat n)

Defined in Clash.Promoted.Nat

Methods

showsPrecX :: Int -> BNat n -> ShowS

showX :: BNat n -> String

showListX :: [BNat n] -> ShowS

KnownNat n => ShowX (UNat n)

Defined in Clash.Promoted.Nat

Methods

showsPrecX :: Int -> UNat n -> ShowS

showX :: UNat n -> String

showListX :: [UNat n] -> ShowS

ShowX (SNat n)

Defined in Clash.Promoted.Nat

Methods

showsPrecX :: Int -> SNat n -> ShowS

showX :: SNat n -> String

showListX :: [SNat n] -> ShowS

ShowX (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

showsPrecX :: Int -> Unsigned n -> ShowS

showX :: Unsigned n -> String

showListX :: [Unsigned n] -> ShowS

ShowX (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

showsPrecX :: Int -> Signed n -> ShowS

showX :: Signed n -> String

showListX :: [Signed n] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> Either a b -> ShowS

showX :: Either a b -> String

showListX :: [Either a b] -> ShowS

(ShowX a0, ShowX a1) => ShowX (a0, a1)

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1) -> ShowS

showX :: (a0, a1) -> String

showListX :: [(a0, a1)] -> ShowS

ShowX a => ShowX (Vec n a)

Defined in Clash.Sized.Vector

Methods

showsPrecX :: Int -> Vec n a -> ShowS

showX :: Vec n a -> String

showListX :: [Vec n a] -> ShowS

ShowX a => ShowX (RTree n a)

Defined in Clash.Sized.RTree

Methods

showsPrecX :: Int -> RTree n a -> ShowS

showX :: RTree n a -> String

showListX :: [RTree n a] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2) -> ShowS

showX :: (a0, a1, a2) -> String

showListX :: [(a0, a1, a2)] -> ShowS

(size ~ (int + frac), KnownNat frac, Integral (rep size)) => ShowX (Fixed rep int frac)

Defined in Clash.Sized.Fixed

Methods

showsPrecX :: Int -> Fixed rep int frac -> ShowS

showX :: Fixed rep int frac -> String

showListX :: [Fixed rep int frac] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3) -> ShowS

showX :: (a0, a1, a2, a3) -> String

showListX :: [(a0, a1, a2, a3)] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3, a4) -> ShowS

showX :: (a0, a1, a2, a3, a4) -> String

showListX :: [(a0, a1, a2, a3, a4)] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3, a4, a5) -> ShowS

showX :: (a0, a1, a2, a3, a4, a5) -> String

showListX :: [(a0, a1, a2, a3, a4, a5)] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3, a4, a5, a6) -> ShowS

showX :: (a0, a1, a2, a3, a4, a5, a6) -> String

showListX :: [(a0, a1, a2, a3, a4, a5, a6)] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3, a4, a5, a6, a7) -> ShowS

showX :: (a0, a1, a2, a3, a4, a5, a6, a7) -> String

showListX :: [(a0, a1, a2, a3, a4, a5, a6, a7)] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> ShowS

showX :: (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> String

showListX :: [(a0, a1, a2, a3, a4, a5, a6, a7, a8)] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ShowS

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

showListX :: [(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> ShowS

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

showListX :: [(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)] -> ShowS

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

Defined in Clash.XException

Methods

showsPrecX :: Int -> (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> ShowS

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

showListX :: [(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)] -> ShowS

showsX :: ShowX a => a -> ShowS

Like shows, but values that normally throw an X exception are converted to "X", instead of error'ing out with an exception.

printX :: ShowX a => a -> IO ()

Like print, but values that normally throw an X exception are converted to "X", instead of error'ing out with an exception

showsPrecXWith :: (Int -> a -> ShowS) -> Int -> a -> ShowS

Use when you want to create a ShowX instance where:

• There is no Generic instance for your data type
• The Generic derived ShowX method would traverse into the (hidden) implementation details of your data type, and you just want to show the entire value as "X".

Can be used like:

data T = ...

instance Show T where ...

instance ShowX T where
  showsPrecX = showsPrecXWith showsPrec

Strict evaluation

seqX :: a -> b -> b infixr 0

Like seq, however, whereas seq will always do:

seq  _|_              b = _|_

seqX will do:

seqX (XException msg) b = b
seqX _|_              b = _|_

forceX :: NFDataX a => a -> a

a variant of deepseqX that is useful in some circumstances:

forceX x = x `deepseqX` x

deepseqX :: NFDataX a => a -> b -> b

deepseqX: fully evaluates the first argument, before returning the second. Does not propagate XExceptions.

rwhnfX :: a -> ()

Reduce to weak head normal form

Equivalent to \x -> seqX x ().

Useful for defining rnfX for types for which NF=WHNF holds.

defaultSeqX :: NFDataX a => a -> b -> b

Either seqX or deepSeqX depending on the value of the cabal flag '-fsuper-strict'. If enabled, defaultSeqX will be deepseqX, otherwise seqX. Flag defaults to false and thus seqX.

hwSeqX :: a -> b -> b infixr 0

Like seqX in simulation, but will force its first argument to be rendered in HDL. This is useful for components that need to be rendered in hardware, but otherwise have no meaning in simulation. An example of such a component would be an ILA: a component monitoring an internal signal of a design. The output of such a component (typically a unit) can be passed as the first argument to hwSeqX to ensure the ILA ends up in the generated HDL.

NB: the result of hwSeqX must (indirectly) be used at the very top of a design. If it's not, Clash will remove it like it does for any other unused circuit parts.

NB: Make sure the blackbox for the component with zero-width results uses RenderVoid

Structured undefined / deep evaluation with undefined values

class NFDataX a where

Class that houses functions dealing with undefined values in Clash. See deepErrorX and rnfX.

Minimal complete definition

Nothing

Methods

deepErrorX :: HasCallStack => String -> a

Create a value where all the elements have an errorX, but the spine is defined.

default deepErrorX :: (HasCallStack, Generic a, GDeepErrorX (Rep a)) => String -> a

hasUndefined :: a -> Bool

Determines whether any of parts of a given construct contain undefined parts. Note that a negative answer does not mean its bit representation is fully defined. For example:

>>> m = Nothing :: Maybe Bool
>>> hasUndefined m
False
>>> pack m
0.
>>> hasUndefined (pack m)
True

default hasUndefined :: (Generic a, GHasUndefined (Rep a)) => a -> Bool

ensureSpine :: a -> a

Create a value where at the very least the spine is defined. For example:

>>> spined = ensureSpine (errorX "?" :: (Int, Int))
>>> case spined of (_, _) -> 'a'
'a'
>>> fmap (const 'b') (ensureSpine undefined :: Vec 3 Int)
<'b','b','b'>
>>> fmap (const 'c') (ensureSpine undefined :: RTree 2 Int)
<<'c','c'>,<'c','c'>>

For users familiar with lazyV: this is the generalized version of it.

default ensureSpine :: (Generic a, GEnsureSpine (Rep a)) => a -> a

rnfX :: a -> ()

Evaluate a value to NF. As opposed to NFDatas rnf, it does not bubble up XExceptions.

default rnfX :: (Generic a, GNFDataX Zero (Rep a)) => a -> ()

Instances

NFDataX Bool

Defined in Clash.XException

Methods

deepErrorX :: String -> Bool

hasUndefined :: Bool -> Bool

ensureSpine :: Bool -> Bool

rnfX :: Bool -> ()

NFDataX Char

Defined in Clash.XException

Methods

deepErrorX :: String -> Char

hasUndefined :: Char -> Bool

ensureSpine :: Char -> Char

rnfX :: Char -> ()

NFDataX Double

Defined in Clash.XException

Methods

deepErrorX :: String -> Double

hasUndefined :: Double -> Bool

ensureSpine :: Double -> Double

rnfX :: Double -> ()

NFDataX Float

Defined in Clash.XException

Methods

deepErrorX :: String -> Float

hasUndefined :: Float -> Bool

ensureSpine :: Float -> Float

rnfX :: Float -> ()

NFDataX Int

Defined in Clash.XException

Methods

deepErrorX :: String -> Int

hasUndefined :: Int -> Bool

ensureSpine :: Int -> Int

rnfX :: Int -> ()

NFDataX Int8

Defined in Clash.XException

Methods

deepErrorX :: String -> Int8

hasUndefined :: Int8 -> Bool

ensureSpine :: Int8 -> Int8

rnfX :: Int8 -> ()

NFDataX Int16

Defined in Clash.XException

Methods

deepErrorX :: String -> Int16

hasUndefined :: Int16 -> Bool

ensureSpine :: Int16 -> Int16

rnfX :: Int16 -> ()

NFDataX Int32

Defined in Clash.XException

Methods

deepErrorX :: String -> Int32

hasUndefined :: Int32 -> Bool

ensureSpine :: Int32 -> Int32

rnfX :: Int32 -> ()

NFDataX Int64

Defined in Clash.XException

Methods

deepErrorX :: String -> Int64

hasUndefined :: Int64 -> Bool

ensureSpine :: Int64 -> Int64

rnfX :: Int64 -> ()

NFDataX Integer

Defined in Clash.XException

Methods

deepErrorX :: String -> Integer

hasUndefined :: Integer -> Bool

ensureSpine :: Integer -> Integer

rnfX :: Integer -> ()

NFDataX Natural

Defined in Clash.XException

Methods

deepErrorX :: String -> Natural

hasUndefined :: Natural -> Bool

ensureSpine :: Natural -> Natural

rnfX :: Natural -> ()

NFDataX Word

Defined in Clash.XException

Methods

deepErrorX :: String -> Word

hasUndefined :: Word -> Bool

ensureSpine :: Word -> Word

rnfX :: Word -> ()

NFDataX Word8

Defined in Clash.XException

Methods

deepErrorX :: String -> Word8

hasUndefined :: Word8 -> Bool

ensureSpine :: Word8 -> Word8

rnfX :: Word8 -> ()

NFDataX Word16

Defined in Clash.XException

Methods

deepErrorX :: String -> Word16

hasUndefined :: Word16 -> Bool

ensureSpine :: Word16 -> Word16

rnfX :: Word16 -> ()

NFDataX Word32

Defined in Clash.XException

Methods

deepErrorX :: String -> Word32

hasUndefined :: Word32 -> Bool

ensureSpine :: Word32 -> Word32

rnfX :: Word32 -> ()

NFDataX Word64

Defined in Clash.XException

Methods

deepErrorX :: String -> Word64

hasUndefined :: Word64 -> Bool

ensureSpine :: Word64 -> Word64

rnfX :: Word64 -> ()

NFDataX ()

Defined in Clash.XException

Methods

deepErrorX :: String -> ()

hasUndefined :: () -> Bool

ensureSpine :: () -> ()

rnfX :: () -> ()

NFDataX All

Defined in Clash.XException

Methods

deepErrorX :: String -> All

hasUndefined :: All -> Bool

ensureSpine :: All -> All

rnfX :: All -> ()

NFDataX Any

Defined in Clash.XException

Methods

deepErrorX :: String -> Any

hasUndefined :: Any -> Bool

ensureSpine :: Any -> Any

rnfX :: Any -> ()

NFDataX CUShort

Defined in Clash.XException

Methods

deepErrorX :: String -> CUShort

hasUndefined :: CUShort -> Bool

ensureSpine :: CUShort -> CUShort

rnfX :: CUShort -> ()

NFDataX Half

Defined in Clash.XException

Methods

deepErrorX :: String -> Half

hasUndefined :: Half -> Bool

ensureSpine :: Half -> Half

rnfX :: Half -> ()

NFDataX Bit

Defined in Clash.Sized.Internal.BitVector

Methods

deepErrorX :: String -> Bit

hasUndefined :: Bit -> Bool

ensureSpine :: Bit -> Bit

rnfX :: Bit -> ()

NFDataX a => NFDataX [a]

Defined in Clash.XException

Methods

deepErrorX :: String -> [a]

hasUndefined :: [a] -> Bool

ensureSpine :: [a] -> [a]

rnfX :: [a] -> ()

NFDataX a => NFDataX (Maybe a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Maybe a

hasUndefined :: Maybe a -> Bool

ensureSpine :: Maybe a -> Maybe a

rnfX :: Maybe a -> ()

NFDataX a => NFDataX (Ratio a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Ratio a

hasUndefined :: Ratio a -> Bool

ensureSpine :: Ratio a -> Ratio a

rnfX :: Ratio a -> ()

NFDataX a => NFDataX (Complex a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Complex a

hasUndefined :: Complex a -> Bool

ensureSpine :: Complex a -> Complex a

rnfX :: Complex a -> ()

NFDataX a => NFDataX (Min a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Min a

hasUndefined :: Min a -> Bool

ensureSpine :: Min a -> Min a

rnfX :: Min a -> ()

NFDataX a => NFDataX (Max a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Max a

hasUndefined :: Max a -> Bool

ensureSpine :: Max a -> Max a

rnfX :: Max a -> ()

NFDataX a => NFDataX (First a)

Defined in Clash.XException

Methods

deepErrorX :: String -> First a

hasUndefined :: First a -> Bool

ensureSpine :: First a -> First a

rnfX :: First a -> ()

NFDataX a => NFDataX (Last a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Last a

hasUndefined :: Last a -> Bool

ensureSpine :: Last a -> Last a

rnfX :: Last a -> ()

NFDataX a => NFDataX (Option a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Option a

hasUndefined :: Option a -> Bool

ensureSpine :: Option a -> Option a

rnfX :: Option a -> ()

NFDataX a => NFDataX (Dual a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Dual a

hasUndefined :: Dual a -> Bool

ensureSpine :: Dual a -> Dual a

rnfX :: Dual a -> ()

NFDataX a => NFDataX (Endo a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Endo a

hasUndefined :: Endo a -> Bool

ensureSpine :: Endo a -> Endo a

rnfX :: Endo a -> ()

NFDataX a => NFDataX (Sum a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Sum a

hasUndefined :: Sum a -> Bool

ensureSpine :: Sum a -> Sum a

rnfX :: Sum a -> ()

NFDataX a => NFDataX (Product a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Product a

hasUndefined :: Product a -> Bool

ensureSpine :: Product a -> Product a

rnfX :: Product a -> ()

NFDataX a => NFDataX (Down a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Down a

hasUndefined :: Down a -> Bool

ensureSpine :: Down a -> Down a

rnfX :: Down a -> ()

NFDataX a => NFDataX (Seq a)

Defined in Clash.XException

Methods

deepErrorX :: String -> Seq a

hasUndefined :: Seq a -> Bool

ensureSpine :: Seq a -> Seq a

rnfX :: Seq a -> ()

NFDataX (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

deepErrorX :: String -> BitVector n

hasUndefined :: BitVector n -> Bool

ensureSpine :: BitVector n -> BitVector n

rnfX :: BitVector n -> ()

NFDataX (Index n)

Defined in Clash.Sized.Internal.Index

Methods

deepErrorX :: String -> Index n

hasUndefined :: Index n -> Bool

ensureSpine :: Index n -> Index n

rnfX :: Index n -> ()

NFDataX (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

deepErrorX :: String -> Unsigned n

hasUndefined :: Unsigned n -> Bool

ensureSpine :: Unsigned n -> Unsigned n

rnfX :: Unsigned n -> ()

NFDataX (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

deepErrorX :: String -> Signed n

hasUndefined :: Signed n -> Bool

ensureSpine :: Signed n -> Signed n

rnfX :: Signed n -> ()

NFDataX b => NFDataX (a -> b)

Defined in Clash.XException

Methods

deepErrorX :: String -> a -> b

hasUndefined :: (a -> b) -> Bool

ensureSpine :: (a -> b) -> a -> b

rnfX :: (a -> b) -> ()

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

Defined in Clash.XException

Methods

deepErrorX :: String -> Either a b

hasUndefined :: Either a b -> Bool

ensureSpine :: Either a b -> Either a b

rnfX :: Either a b -> ()

(NFDataX a0, NFDataX a1) => NFDataX (a0, a1)

Defined in Clash.XException

Methods

deepErrorX :: String -> (a0, a1)

hasUndefined :: (a0, a1) -> Bool

ensureSpine :: (a0, a1) -> (a0, a1)

rnfX :: (a0, a1) -> ()

(NFDataX a, NFDataX b) => NFDataX (Arg a b)

Defined in Clash.XException

Methods

deepErrorX :: String -> Arg a b

hasUndefined :: Arg a b -> Bool

ensureSpine :: Arg a b -> Arg a b

rnfX :: Arg a b -> ()

(NFDataX a, KnownNat n) => NFDataX (Vec n a)

Defined in Clash.Sized.Vector

Methods

deepErrorX :: String -> Vec n a

hasUndefined :: Vec n a -> Bool

ensureSpine :: Vec n a -> Vec n a

rnfX :: Vec n a -> ()

(KnownNat d, NFDataX a) => NFDataX (RTree d a)

Defined in Clash.Sized.RTree

Methods

deepErrorX :: String -> RTree d a

hasUndefined :: RTree d a -> Bool

ensureSpine :: RTree d a -> RTree d a

rnfX :: RTree d a -> ()

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

Defined in Clash.XException

Methods

deepErrorX :: String -> (a0, a1, a2)

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

ensureSpine :: (a0, a1, a2) -> (a0, a1, a2)

rnfX :: (a0, a1, a2) -> ()

NFDataX (rep (int + frac)) => NFDataX (Fixed rep int frac)

Defined in Clash.Sized.Fixed

Methods

deepErrorX :: String -> Fixed rep int frac

hasUndefined :: Fixed rep int frac -> Bool

ensureSpine :: Fixed rep int frac -> Fixed rep int frac

rnfX :: Fixed rep int frac -> ()

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

Defined in Clash.XException

Methods

deepErrorX :: String -> (a0, a1, a2, a3)

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

ensureSpine :: (a0, a1, a2, a3) -> (a0, a1, a2, a3)

rnfX :: (a0, a1, a2, a3) -> ()

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

Defined in Clash.XException

Methods

deepErrorX :: String -> (a0, a1, a2, a3, a4)

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

ensureSpine :: (a0, a1, a2, a3, a4) -> (a0, a1, a2, a3, a4)

rnfX :: (a0, a1, a2, a3, a4) -> ()

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

Defined in Clash.XException

Methods

deepErrorX :: String -> (a0, a1, a2, a3, a4, a5)

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

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

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

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

Defined in Clash.XException

Methods

deepErrorX :: String -> (a0, a1, a2, a3, a4, a5, a6)

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

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

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

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

Defined in Clash.XException

Methods

deepErrorX :: String -> (a0, a1, a2, a3, a4, a5, a6, a7)

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

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

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

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

Defined in Clash.XException

Methods

deepErrorX :: String -> (a0, a1, a2, a3, a4, a5, a6, a7, a8)

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

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

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

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

Defined in Clash.XException

Methods

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

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

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

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

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

Defined in Clash.XException

Methods

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

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

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

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

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

Defined in Clash.XException

Methods

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

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

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

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