Documentation

Add (wrapping mod 2^n).

Bitwise and.

bitIndex a i == bitSlice a i i. The Finite argument must be known/literal (after inlining).

bitSlice a j i returns bits j (most significant) to i (least significant) from a (j >= i). Bits are numbered with the least significant bit at 0 (Verilog convention); the head of the Vec is the most significant bit. The Finite arguments must be known/literals (after inlining).

Interpret an Integer as a bit vector.

The String arguments must be literals (after inlining).

Unsigned division. Division by zero yields all-ones (2^n - 1), following the SMT-LIB convention implemented by the compiled RTL and the interpreter.

Equal.

The String and list arguments must be literals (after inlining).

Greater-than.

Greater-than or equal.

Logical and.

Logical not.

Logical or.

Shift left.

Less-than.

Less-than or equal.

Most significant bit.

Unsigned modulus. A zero divisor yields the dividend, following the SMT-LIB convention implemented by the compiled RTL and the interpreter.

Multiply (wrapping mod 2^n).

Produce integer associated with type-level natural.

Bitwise not.

Bitwise or.

Exponentiation.

Reduction and.

Reduction nand (NOT of the and-reduction, following the Verilog ~& operator).

Reduction nor (NOT of the or-reduction, following the Verilog ~| operator).

Reduction or.

Shift right.

Shift right, sign-extend.

Reduction xnor (NOT of the xor-reduction, following the Verilog ~^ operator).

Reduction xor.

Truncates or zero-pads most significant bits.

Subtract (wrapping mod 2^n).

Convert an Integer into a Finite n, throws an error if negative or >= n.

Concatenate vectors.

Turns a List literal into a Vec with fixed length. I.e.,

[x, y, z] :: Vec 3 a

Slice indexed from the end of the Vec.

Bitwise exclusive nor.

Bitwise exclusive or.

The unsigned value of a bit vector, as an Integer. Not a primitive: GHC-only simulation support backing ReWire.Bits.toInteger (Integer is a compile-time-literal-only type in the compiled fragment). It lives here because neither front end translates this module's bodies or chases its imports.

Addition of type-level naturals.

Since: base-4.7.0.0

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following:

Left identity

return a >>= k = k a

Right identity

m >>= return = m

Associativity

m >>= (\x -> k x >>= h) = (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

• pure = return

• m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

The above laws imply:

• fmap f xs  =  xs >>= return . f

• (>>) = (*>)

and that pure and (<*>) satisfy the applicative functor laws.

The instances of Monad for List, Maybe and IO defined in the Prelude satisfy these laws.

The class of monad transformers. For any monad m, the result t m should also be a monad, and lift should be a monad transformation from m to t m, i.e. it should satisfy the following laws:

• lift . return = return

• lift (m >>= f) = lift m >>= (lift . f)

Since 0.6.0.0 and for GHC 8.6 and later, the requirement that t m be a Monad is enforced by the implication constraint forall m. Monad m => Monad (t m) enabled by the QuantifiedConstraints extension.

Ambiguity error with GHC 9.0 to 9.2.2

(MonadTrans t, forall m. Monad m => Monad (t m)) => ...