Clash.Explicit.Prelude.Safe

This is the Safe API only of Clash.Explicit.Prelude

This module defines the explicitly clocked counterparts of the functions defined in Clash.Prelude.

Creating synchronous sequential circuits

mealy

Arguments

:: (KnownDomain dom, NFDataX s)

=> Clock dom

Clock to synchronize to

-> Reset dom

-> Enable dom

Global enable

-> (s -> i -> (s, o))

Transfer function in mealy machine form: state -> input -> (newstate,output)

-> s

Initial state

-> Signal dom i -> Signal dom o

Synchronous sequential function with input and output matching that of the mealy machine

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

import qualified Data.List as L

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

mac
  :: KnownDomain dom
  => Clock dom
  -> Reset dom
  -> Enable dom
  -> Signal dom (Int, Int)
  -> Signal dom Int
mac clk rst en = mealy clk rst en macT 0

>>> simulate (mac systemClockGen systemResetGen enableGen) [(0,0),(1,1),(2,2),(3,3),(4,4)]
[0,0,1,5,14...
...

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

dualMac
  :: KnownDomain dom
  => Clock dom
  -> Reset dom
  -> Enable dom
  -> (Signal dom Int, Signal dom Int)
  -> (Signal dom Int, Signal dom Int)
  -> Signal dom Int
dualMac clk rst en (a,b) (x,y) = s1 + s2
  where
    s1 = mealy clk rst en macT 0 (bundle (a,x))
    s2 = mealy clk rst en macT 0 (bundle (b,y))

mealyB

Arguments

:: (KnownDomain dom, NFDataX s, Bundle i, Bundle o)

=> Clock dom

-> Reset dom

-> Enable dom

-> (s -> i -> (s, o))

Transfer function in mealy machine form: state -> input -> (newstate,output)

-> s

Initial state

-> Unbundled dom i -> Unbundled dom o

Synchronous sequential function with input and output matching that of the mealy machine

A version of mealy that does automatic Bundleing

Given a function f of type:

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

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

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

Using mealyB however we can write:

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

moore

Arguments

:: (KnownDomain dom, NFDataX s)

=> Clock dom

Clock to synchronize to

-> Reset dom

-> Enable dom

-> (s -> i -> s)

Transfer function in moore machine form: state -> input -> newstate

-> (s -> o)

Output function in moore machine form: state -> output

-> s

Initial state

-> Signal dom i -> Signal dom o

Synchronous sequential function with input and output matching that of the moore machine

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

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

mac
  :: KnownDomain dom
  => Clock dom
  -> Reset dom
  -> Enable dom
  -> Signal dom (Int, Int)
  -> Signal dom Int
mac clk rst en = moore clk rst en macT id 0

>>> simulate (mac systemClockGen systemResetGen enableGen) [(0,0),(1,1),(2,2),(3,3),(4,4)]
[0,0,1,5,14...
...

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

dualMac
  :: KnownDomain dom
  => Clock dom
  -> Reset dom
  -> Enable dom
  -> (Signal dom Int, Signal dom Int)
  -> (Signal dom Int, Signal dom Int)
  -> Signal dom Int
dualMac clk rst en (a,b) (x,y) = s1 + s2
  where
    s1 = moore clk rst en macT id 0 (bundle (a,x))
    s2 = moore clk rst en macT id 0 (bundle (b,y))

mooreB

Arguments

:: (KnownDomain dom, NFDataX s, Bundle i, Bundle o)

=> Clock dom

-> Reset dom

-> Enable dom

-> (s -> i -> s)

Transfer function in moore machine form: state -> input -> newstate

-> (s -> o)

Output function in moore machine form: state -> output

-> s

Initial state

-> Unbundled dom i -> Unbundled dom o

Synchronous sequential function with input and output matching that of the moore machine

A version of moore that does automatic Bundleing

Given a functions t and o of types:

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

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

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

Using mooreB however we can write:

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

registerB :: (KnownDomain dom, NFDataX a, Bundle a) => Clock dom -> Reset dom -> Enable dom -> a -> Unbundled dom a -> Unbundled dom a

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

rP :: Clock dom -> Reset dom -> Enable dom
   -> (Signal dom Int, Signal dom Int)
   -> (Signal dom Int, Signal dom Int)
rP clk rst en = registerB clk rst en (8,8)

>>> simulateB (rP systemClockGen systemResetGen enableGen) [(1,1),(1,1),(2,2),(3,3)] :: [(Int,Int)]
[(8,8),(8,8),(1,1),(2,2),(3,3)...
...

Synchronizer circuits for safe clock domain crossing

dualFlipFlopSynchronizer

Arguments

:: (NFDataX a, KnownDomain dom1, KnownDomain dom2)

=> Clock dom1

Clock to which the incoming data is synchronized

-> Clock dom2

Clock to which the outgoing data is synchronized

-> Reset dom2

Reset for registers on the outgoing domain

-> Enable dom2

Enable for registers on the outgoing domain

-> a

Initial value of the two synchronization registers

-> Signal dom1 a

Incoming data

-> Signal dom2 a

Outgoing, synchronized, data

Synchronizer based on two sequentially connected flip-flops.

• NB: This synchronizer can be used for bit-synchronization.

• NB: Although this synchronizer does reduce metastability, it does not guarantee the proper synchronization of a whole word. For example, given that the output is sampled twice as fast as the input is running, and we have two samples in the input stream that look like:

  [0111,1000]

  But the circuit driving the input stream has a longer propagation delay on msb compared to the lsbs. What can happen is an output stream that looks like this:

  [0111,0111,0000,1000]

  Where the level-change of the msb was not captured, but the level change of the lsbs were.

  If you want to have safe word-synchronization use asyncFIFOSynchronizer.

asyncFIFOSynchronizer

Arguments

:: (KnownDomain wdom, KnownDomain rdom, 2 <= addrSize, NFDataX a)

=> SNat addrSize

Size of the internally used addresses, the FIFO contains 2^addrSize elements.

-> Clock wdom

Clock to which the write port is synchronized

-> Clock rdom

Clock to which the read port is synchronized

-> Reset wdom

-> Reset rdom

-> Enable wdom

-> Enable rdom

-> Signal rdom Bool

Read request

-> Signal wdom (Maybe a)

Element to insert

-> (Signal rdom a, Signal rdom Bool, Signal wdom Bool)

(Oldest element in the FIFO, empty flag, full flag)

Synchronizer implemented as a FIFO around a synchronous RAM. Based on the design described in Clash.Tutorial, which is itself based on the design described in http://www.sunburst-design.com/papers/CummingsSNUG2002SJ_FIFO1.pdf. However, this FIFO uses a synchronous dual-ported RAM which, unlike those designs using RAM with an asynchronous read port, is nearly guaranteed to actually synthesize into one of the dual-ported RAMs found on most FPGAs.

NB: This synchronizer can be used for word-synchronization. NB: This synchronizer will only work safely when you set up the proper bus skew and maximum delay constraints inside your synthesis tool for the clock domain crossings of the gray pointers.

ROMs

asyncRom

Arguments

:: (KnownNat n, Enum addr)

=> Vec n a

ROM content, also determines the size, n, of the ROM

NB: MUST be a constant

-> addr

Read address r

-> a

The value of the ROM at address r

An asynchronous/combinational ROM with space for n elements

See also:

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

asyncRomPow2

Arguments

:: KnownNat n

=> Vec (2 ^ n) a

ROM content

NB: MUST be a constant

-> Unsigned n

Read address r

-> a

The value of the ROM at address r

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

See also:

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

rom

Arguments

:: (KnownDomain dom, KnownNat n, NFDataX a, Enum addr)

=> Clock dom

Clock to synchronize to

-> Enable dom

Enable line

-> Vec n a

ROM content, also determines the size, n, of the ROM

NB: MUST be a constant

-> Signal dom addr

Read address r

-> Signal dom a

The value of the ROM at address r from the previous clock cycle

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

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

See also:

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

romPow2

Arguments

:: (KnownDomain dom, KnownNat n, NFDataX a)

=> Clock dom

Clock to synchronize to

-> Enable dom

Enable line

-> Vec (2 ^ n) a

ROM content

NB: MUST be a constant

-> Signal dom (Unsigned n)

Read address r

-> Signal dom a

The value of the ROM at address r from the previous clock cycle

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

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

See also:

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

ROMs defined by a MemBlob

asyncRomBlob

Arguments

:: Enum addr

=> MemBlob n m

ROM content, also determines the size, n, of the ROM

NB: MUST be a constant

-> addr

Read address r

-> BitVector m

The value of the ROM at address r

An asynchronous/combinational ROM with space for n elements

See also:

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

asyncRomBlobPow2

Arguments

:: KnownNat n

=> MemBlob (2 ^ n) m

ROM content, also determines the size, 2^n, of the ROM

NB: MUST be a constant

-> Unsigned n

Read address r

-> BitVector m

The value of the ROM at address r

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

See also:

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

romBlob

Arguments

:: forall dom addr m n. (KnownDomain dom, Enum addr)

=> Clock dom

Clock to synchronize to

-> Enable dom

Enable line

-> MemBlob n m

ROM content, also determines the size, n, of the ROM

NB: MUST be a constant

-> Signal dom addr

Read address r

-> Signal dom (BitVector m)

The value of the ROM at address r from the previous clock cycle

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

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

See also:

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

romBlobPow2

Arguments

:: forall dom m n. (KnownDomain dom, KnownNat n)

=> Clock dom

Clock to synchronize to

-> Enable dom

Enable line

-> MemBlob (2 ^ n) m

ROM content, also determines the size, 2^n, of the ROM

NB: MUST be a constant

-> Signal dom (Unsigned n)

Read address r

-> Signal dom (BitVector m)

The value of the ROM at address r from the previous clock cycle

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

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

See also:

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

RAM primitives with a combinational read port

asyncRam

Arguments

:: (Enum addr, HasCallStack, KnownDomain wdom, KnownDomain rdom, NFDataX a)

=> Clock wdom

Clock to which the write port of the RAM is synchronized

-> Clock rdom

Clock to which the read address signal, r, is synchronized

-> Enable wdom

Enable line for the write port

-> SNat n

Size n of the RAM

-> Signal rdom addr

Read address r

-> Signal wdom (Maybe (addr, a))

(write address w, value to write)

-> Signal rdom a

Value of the RAM at address r

Create a RAM with space for n elements

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

See also:

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

asyncRamPow2

Arguments

:: forall wdom rdom n a. (KnownNat n, HasCallStack, KnownDomain wdom, KnownDomain rdom, NFDataX a)

=> Clock wdom

Clock to which the write port of the RAM is synchronized

-> Clock rdom

Clock to which the read address signal, r, is synchronized

-> Enable wdom

Enable line for the write port

-> Signal rdom (Unsigned n)

Read address r

-> Signal wdom (Maybe (Unsigned n, a))

(write address w, value to write)

-> Signal rdom a

Value of the RAM at address r

Create a RAM with space for 2^n elements

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

See also:

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

Block RAM primitives

blockRam

Arguments

:: (KnownDomain dom, HasCallStack, NFDataX a, Enum addr)

=> Clock dom

Clock to synchronize to

-> Enable dom

Enable line

-> Vec n a

Initial content of the BRAM, also determines the size, n, of the BRAM

NB: MUST be a constant

-> Signal dom addr

Read address r

-> Signal dom (Maybe (addr, a))

(write address w, value to write)

-> Signal dom a

Value of the BRAM at address r from the previous clock cycle

Create a block RAM with space for n elements

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

See also:

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

Example

bram40
  :: Clock  dom
  -> Enable  dom
  -> Signal dom (Unsigned 6)
  -> Signal dom (Maybe (Unsigned 6, Bit))
  -> Signal dom Bit
bram40 clk en = blockRam clk en (replicate d40 1)

blockRamPow2

Arguments

:: (KnownDomain dom, HasCallStack, NFDataX a, KnownNat n)

=> Clock dom

Clock to synchronize to

-> Enable dom

Enable line

-> Vec (2 ^ n) a

Initial content of the BRAM

NB: MUST be a constant

-> Signal dom (Unsigned n)

Read address r

-> Signal dom (Maybe (Unsigned n, a))

(Write address w, value to write)

-> Signal dom a

Value of the BRAM at address r from the previous clock cycle

Create a block RAM with space for 2^n elements

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

See also:

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

Example

bram32
  :: Clock dom
  -> Enable dom
  -> Signal dom (Unsigned 5)
  -> Signal dom (Maybe (Unsigned 5, Bit))
  -> Signal dom Bit
bram32 clk en = blockRamPow2 clk en (replicate d32 1)

Block RAM primitives initialized with a MemBlob

blockRamBlob

Arguments

:: forall dom addr m n. (KnownDomain dom, Enum addr)

=> Clock dom

Clock to synchronize to

-> Enable dom

Enable line

-> MemBlob n m

Initial content of the BRAM, also determines the size, n, of the BRAM

NB: MUST be a constant

-> Signal dom addr

Read address r

-> Signal dom (Maybe (addr, BitVector m))

(write address w, value to write)

-> Signal dom (BitVector m)

Value of the BRAM at address r from the previous clock cycle

Create a block RAM with space for n elements

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

See also:

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

blockRamBlobPow2

Arguments

:: forall dom m n. (KnownDomain dom, KnownNat n)

=> Clock dom

Clock to synchronize to

-> Enable dom

Enable line

-> MemBlob (2 ^ n) m

Initial content of the BRAM, also determines the size, 2^n, of the BRAM

NB: MUST be a constant

-> Signal dom (Unsigned n)

Read address r

-> Signal dom (Maybe (Unsigned n, BitVector m))

(write address w, value to write)

-> Signal dom (BitVector m)

Value of the BRAM at address r from the previous clock cycle

Create a block RAM with space for 2^n elements

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

See also:

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

Creating and inspecting MemBlob

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

Efficient storage of memory content

It holds n words of BitVector m.

Instances

Show (MemBlob n m)

Defined in Clash.Explicit.BlockRam.Internal

Methods

showsPrec :: Int -> MemBlob n m -> ShowS

show :: MemBlob n m -> String

showList :: [MemBlob n m] -> ShowS

createMemBlob

Arguments

:: forall a f. (Foldable f, BitPack a)

=> String

Name of the binding to generate

-> Maybe Bit

Value to map don't care bits to. Nothing means throwing an error on don't care bits.

-> f a

The content for the MemBlob

-> DecsQ

Create a MemBlob binding from a list of values

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

Example

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

ram clk en = blockRamBlob clk en content

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

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

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

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

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

memBlobTH

Arguments

:: forall a f. (Foldable f, BitPack a)

=> Maybe Bit

Value to map don't care bits to. Nothing means throwing an error on don't care bits.

-> f a

The content for the MemBlob

-> ExpQ

Create a MemBlob from a list of values

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

Example

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

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

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

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

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

Convert a MemBlob back to a list

NB: Not synthesizable

Block RAM read/write conflict resolution

readNew

Arguments

:: (KnownDomain dom, NFDataX a, Eq addr)

=> Clock dom

-> Reset dom

-> Enable dom

-> (Signal dom addr -> Signal dom (Maybe (addr, a)) -> Signal dom a)

The BRAM component

-> Signal dom addr

Read address r

-> Signal dom (Maybe (addr, a))

(Write address w, value to write)

-> Signal dom a

Value of the BRAM at address r from the previous clock cycle

Create a read-after-write block RAM from a read-before-write one

True dual-port block RAM

trueDualPortBlockRam

Arguments

:: forall nAddrs domA domB a. (HasCallStack, KnownNat nAddrs, KnownDomain domA, KnownDomain domB, NFDataX a)

=> Clock domA

Clock for port A

-> Clock domB

Clock for port B

-> Signal domA (RamOp nAddrs a)

RAM operation for port A

-> Signal domB (RamOp nAddrs a)

RAM operation for port B

-> (Signal domA a, Signal domB a)

Outputs data on next cycle. When writing, the data written will be echoed. When reading, the read data is returned.

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

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

data RamOp n a

Port operation

Constructors

RamRead (Index n)

Read from address

RamWrite (Index n) a

Write data to address

RamNoOp

No operation

Instances

Show a => Show (RamOp n a)

Defined in Clash.Explicit.BlockRam

Methods

showsPrec :: Int -> RamOp n a -> ShowS

show :: RamOp n a -> String

showList :: [RamOp n a] -> ShowS

Generic (RamOp n a)

Defined in Clash.Explicit.BlockRam

Associated Types

type Rep (RamOp n a) :: Type -> Type

Methods

from :: RamOp n a -> Rep (RamOp n a) x

to :: Rep (RamOp n a) x -> RamOp n a

NFDataX a => NFDataX (RamOp n a)

Defined in Clash.Explicit.BlockRam

Methods

deepErrorX :: String -> RamOp n a

hasUndefined :: RamOp n a -> Bool

ensureSpine :: RamOp n a -> RamOp n a

rnfX :: RamOp n a -> ()

type Rep (RamOp n a)

Defined in Clash.Explicit.BlockRam

type Rep (RamOp n a) = D1 ('MetaData "RamOp" "Clash.Explicit.BlockRam" "clash-prelude-1.6.3-inplace" 'False) (C1 ('MetaCons "RamRead" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Index n))) :+: (C1 ('MetaCons "RamWrite" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Index n)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "RamNoOp" 'PrefixI 'False) (U1 :: Type -> Type)))

Utility functions

isRising

Arguments

:: (KnownDomain dom, NFDataX a, Bounded a, Eq a)

=> Clock dom

-> Reset dom

-> Enable dom

-> a

Starting value

-> Signal dom a

-> Signal dom Bool

Give a pulse when the Signal goes from minBound to maxBound

isFalling

Arguments

:: (KnownDomain dom, NFDataX a, Bounded a, Eq a)

=> Clock dom

-> Reset dom

-> Enable dom

-> a

Starting value

-> Signal dom a

-> Signal dom Bool

Give a pulse when the Signal goes from maxBound to minBound

riseEvery :: forall dom n. KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> SNat n -> Signal dom Bool

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

oscillate :: forall dom n. KnownDomain dom => Clock dom -> Reset dom -> Enable dom -> Bool -> SNat n -> Signal dom Bool

Oscillate a Bool for a given number of cycles, given the starting state.

Exported modules

Synchronous signals

module Clash.Explicit.Signal

module Clash.Explicit.Signal.Delayed

Datatypes

Bit vectors

module Clash.Sized.BitVector

Arbitrary-width numbers

module Clash.Sized.Signed

module Clash.Sized.Unsigned

module Clash.Sized.Index

Fixed point numbers

module Clash.Sized.Fixed

Fixed size vectors

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

Fixed size vectors.

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

Constructors

Nil :: Vec 0 a

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

Bundled Patterns

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

Add an element to the tail of a vector.

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

Can be used as a pattern:

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

Also in conjunctions with (:>):

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

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

Add an element to the head of a vector.

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

Can be used as a pattern:

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

Also in conjunctions with (:<):

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

Instances

Lift a => Lift (Vec n a :: Type)

Defined in Clash.Sized.Vector

Methods

lift :: Vec n a -> Q Exp

liftTyped :: Vec n a -> Q (TExp (Vec n a))

Functor (Vec n)

Defined in Clash.Sized.Vector

Methods

fmap :: (a -> b) -> Vec n a -> Vec n b

(<$) :: a -> Vec n b -> Vec n a

KnownNat n => Applicative (Vec n)

Defined in Clash.Sized.Vector

Methods

pure :: a -> Vec n a

(<*>) :: Vec n (a -> b) -> Vec n a -> Vec n b

liftA2 :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c

(*>) :: Vec n a -> Vec n b -> Vec n b

(<*) :: Vec n a -> Vec n b -> Vec n a

(KnownNat n, 1 <= n) => Foldable (Vec n)

Defined in Clash.Sized.Vector

Methods

fold :: Monoid m => Vec n m -> m

foldMap :: Monoid m => (a -> m) -> Vec n a -> m

foldMap' :: Monoid m => (a -> m) -> Vec n a -> m

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

foldr' :: (a -> b -> b) -> b -> Vec n a -> b

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

foldl' :: (b -> a -> b) -> b -> Vec n a -> b

foldr1 :: (a -> a -> a) -> Vec n a -> a

foldl1 :: (a -> a -> a) -> Vec n a -> a

toList :: Vec n a -> [a]

null :: Vec n a -> Bool

length :: Vec n a -> Int

elem :: Eq a => a -> Vec n a -> Bool

maximum :: Ord a => Vec n a -> a

minimum :: Ord a => Vec n a -> a

sum :: Num a => Vec n a -> a

product :: Num a => Vec n a -> a

(KnownNat n, 1 <= n) => Traversable (Vec n)

Defined in Clash.Sized.Vector

Methods

traverse :: Applicative f => (a -> f b) -> Vec n a -> f (Vec n b)

sequenceA :: Applicative f => Vec n (f a) -> f (Vec n a)

mapM :: Monad m => (a -> m b) -> Vec n a -> m (Vec n b)

sequence :: Monad m => Vec n (m a) -> m (Vec n a)

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

Defined in Clash.Sized.Vector

Methods

(==) :: Vec n a -> Vec n a -> Bool

(/=) :: Vec n a -> Vec n a -> Bool

(KnownNat n, Typeable a, Data a) => Data (Vec n a)

Defined in Clash.Sized.Vector

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vec n a -> c (Vec n a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vec n a)

toConstr :: Vec n a -> Constr

dataTypeOf :: Vec n a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vec n a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vec n a))

gmapT :: (forall b. Data b => b -> b) -> Vec n a -> Vec n a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vec n a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vec n a -> r

gmapQ :: (forall d. Data d => d -> u) -> Vec n a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vec n a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vec n a -> m (Vec n a)

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

Defined in Clash.Sized.Vector

Methods

compare :: Vec n a -> Vec n a -> Ordering

(<) :: Vec n a -> Vec n a -> Bool

(<=) :: Vec n a -> Vec n a -> Bool

(>) :: Vec n a -> Vec n a -> Bool

(>=) :: Vec n a -> Vec n a -> Bool

max :: Vec n a -> Vec n a -> Vec n a

min :: Vec n a -> Vec n a -> Vec n a

Show a => Show (Vec n a)

Defined in Clash.Sized.Vector

Methods

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

show :: Vec n a -> String

showList :: [Vec n a] -> ShowS

KnownNat n => Generic (Vec n a)

In many cases, this Generic instance only allows generic functions/instances over vectors of at least size 1, due to the n-1 in the Rep (Vec n a) definition.

We'll have to wait for things like https://ryanglscott.github.io/2018/02/11/how-to-derive-generic-for-some-gadts/ before we can work around this limitation

Defined in Clash.Sized.Vector

Associated Types

type Rep (Vec n a) :: Type -> Type

Methods

from :: Vec n a -> Rep (Vec n a) x

to :: Rep (Vec n a) x -> Vec n a

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

Defined in Clash.Sized.Vector

Methods

(<>) :: Vec n a -> Vec n a -> Vec n a

sconcat :: NonEmpty (Vec n a) -> Vec n a

stimes :: Integral b => b -> Vec n a -> Vec n a

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

Defined in Clash.Sized.Vector

Methods

mempty :: Vec n a

mappend :: Vec n a -> Vec n a -> Vec n a

mconcat :: [Vec n a] -> Vec n a

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

Defined in Clash.Sized.Vector

Methods

arbitrary :: Gen (Vec n a)

shrink :: Vec n a -> [Vec n a]

CoArbitrary a => CoArbitrary (Vec n a)

Defined in Clash.Sized.Vector

Methods

coarbitrary :: Vec n a -> Gen b -> Gen b

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

Defined in Clash.Sized.Vector

Methods

def :: Vec n a

NFData a => NFData (Vec n a)

Defined in Clash.Sized.Vector

Methods

rnf :: Vec n a -> ()

KnownNat n => Ixed (Vec n a)

Defined in Clash.Sized.Vector

Methods

ix :: Index (Vec n a) -> Traversal' (Vec n a) (IxValue (Vec n a))

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

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

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

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

Defined in Clash.Sized.Vector

Associated Types

type BitSize (Vec n a) :: Nat

Methods

pack :: Vec n a -> BitVector (BitSize (Vec n a))

unpack :: BitVector (BitSize (Vec n a)) -> Vec n a

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 n => Bundle (Vec n a)

Defined in Clash.Signal.Delayed.Bundle

Associated Types

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

Methods

bundle :: forall (dom :: Domain) (d :: Nat). Unbundled dom d (Vec n a) -> DSignal dom d (Vec n a)

unbundle :: forall (dom :: Domain) (d :: Nat). DSignal dom d (Vec n a) -> Unbundled dom d (Vec n a)

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

Defined in Clash.Class.AutoReg.Internal

Methods

autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Vec n a -> Signal dom (Vec n a) -> Signal dom (Vec n a)

(LockStep en a, KnownNat n) => LockStep (Vec n en) (Vec n a)

Defined in Clash.Prelude.DataFlow

Methods

lockStep :: forall (dom :: Domain). DataFlow dom (Vec n en) Bool (Vec n a) (Vec n a)

stepLock :: forall (dom :: Domain). DataFlow dom Bool (Vec n en) (Vec n a) (Vec n a)

type Unbundled t d (Vec n a)

Defined in Clash.Signal.Delayed.Bundle

type Unbundled t d (Vec n a) = Vec n (DSignal t d a)

type HasDomain dom (Vec n a)

Defined in Clash.Class.HasDomain.HasSpecificDomain

type HasDomain dom (Vec n a) = HasDomain dom a

type Unbundled t (Vec n a)

Defined in Clash.Signal.Bundle

type Unbundled t (Vec n a) = Vec n (Signal t a)

type TryDomain t (Vec n a)

Defined in Clash.Class.HasDomain.HasSingleDomain

type TryDomain t (Vec n a) = TryDomain t a

type Rep (Vec n a)

Defined in Clash.Sized.Vector

type Rep (Vec n a) = D1 ('MetaData "Vec" "Clash.Data.Vector" "clash-prelude" 'False) (C1 ('MetaCons "Nil" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Cons" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Vec (n - 1) a))))

type Index (Vec n a)

Defined in Clash.Sized.Vector

type Index (Vec n a) = Index n

type IxValue (Vec n a)

Defined in Clash.Sized.Vector

type IxValue (Vec n a) = a

type BitSize (Vec n a)

Defined in Clash.Sized.Vector

type BitSize (Vec n a) = n * BitSize a

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

and corresponds to the following circuit layout:

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

Convert a BitVector to a Vec of Bits.

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

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

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

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

Instances

type Apply (VCons a :: TyFun Nat Type -> Type) (l :: Nat)

Defined in Clash.Sized.Vector

type Apply (VCons a :: TyFun Nat Type -> Type) (l :: Nat) = Vec l a

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

singleton :: a -> Vec 1 a

Create a vector of one element

>>> singleton 5
5 :> Nil

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

Extract the first element of a vector

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

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

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

Extract the elements after the head of a vector

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

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

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

Extract the last element of a vector

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

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

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

Extract all the elements of a vector except the last element

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

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

shiftInAt0

Arguments

:: KnownNat n

=> Vec n a

The old vector

-> Vec m a

The elements to shift in at the head

-> (Vec n a, Vec m a)

(The new vector, shifted out elements)

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

• The new vector
• The shifted out elements

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

shiftInAtN

Arguments

:: KnownNat m

=> Vec n a

The old vector

-> Vec m a

The elements to shift in at the tail

-> (Vec n a, Vec m a)

(The new vector, shifted out elements)

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

• The new vector
• The shifted out elements

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

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

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

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

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

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

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

shiftOutFrom0

Arguments

:: (Default a, KnownNat m)

=> SNat m

m, the number of elements to shift out

-> Vec (m + n) a

The old vector

-> (Vec (m + n) a, Vec m a)

(The new vector, shifted out elements)

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

• The new vector
• The shifted out values

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

shiftOutFromN

Arguments

:: (Default a, KnownNat n)

=> SNat m

m, the number of elements to shift out

-> Vec (m + n) a

The old vector

-> (Vec (m + n) a, Vec m a)

(The new vector, shifted out elements)

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

• The new vector
• The shifted out values

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

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

Append two vectors.

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

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

Split a vector into two vectors at the given point.

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

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

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

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

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

Concatenate a vector of vectors.

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

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

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

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

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

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

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

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

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

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

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

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

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

reverse :: Vec n a -> Vec n a

The elements in a vector in reverse order.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Generate a vector of indices.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

zipWith3 :: (a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d

zipWith3 generalizes zip3 by zipping with the function given as the first argument, instead of a tupling function.

zipWith3 f (x1 :> x2 :> ... xn :> Nil) (y1 :> y2 :> ... :> yn :> Nil) (z1 :> z2 :> ... :> zn :> Nil) == (f x1 y1 z1 :> f x2 y2 z2 :> ... :> f xn yn zn :> Nil)

"zipWith3 f xs ys zs" corresponds to the following circuit layout:

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

zipWith4 :: (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e

zipWith5 :: (a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g

zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g -> Vec n h

foldr1 :: (a -> a -> a) -> Vec (n + 1) a -> a

foldr1 is a variant of foldr that has no starting value argument, and thus must be applied to non-empty vectors.

foldr1 f (x1 :> ... :> xn2 :> xn1 :> xn :> Nil) == x1 `f` (... (xn2 `f` (xn1 `f` xn))...)
foldr1 f (x1 :> Nil)                            == x1
foldr1 f Nil                                    == TYPE ERROR

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

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

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

foldl1 :: (a -> a -> a) -> Vec (n + 1) a -> a

foldl1 is a variant of foldl that has no starting value argument, and thus must be applied to non-empty vectors.

foldl1 f (x1 :> x2 :> x3 :> ... :> xn :> Nil) == (...((x1 `f` x2) `f` x3) `f`...) `f` xn
foldl1 f (x1 :> Nil)                          == x1
foldl1 f Nil                                  == TYPE ERROR

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

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

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

fold :: forall n a. (a -> a -> a) -> Vec (n + 1) a -> a

fold is a variant of foldr1 and foldl1, but instead of reducing from right to left, or left to right, it reduces a vector using a tree-like structure. The depth, or delay, of the structure produced by "fold f xs", is hence O(log_2(length xs)), and not O(length xs).

NB: The binary operator "f" in "fold f xs" must be associative.

fold f (x1 :> x2 :> ... :> xn1 :> xn :> Nil) == ((x1 `f` x2) `f` ...) `f` (... `f` (xn1 `f` xn))
fold f (x1 :> Nil)                           == x1
fold f Nil                                   == TYPE ERROR

>>> fold (+) (5 :> 4 :> 3 :> 2 :> 1 :> Nil)
15

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

scanl :: (b -> a -> b) -> b -> Vec n a -> Vec (n + 1) b

scanl is similar to foldl, but returns a vector of successive reduced values from the left:

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

>>> scanl (+) 0 (5 :> 4 :> 3 :> 2 :> Nil)
0 :> 5 :> 9 :> 12 :> 14 :> Nil

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

• NB:

  last (scanl f z xs) == foldl f z xs

• For a different trade-off between circuit size and logic depth for associative operators, see Clash.Sized.RTree

postscanl :: (b -> a -> b) -> b -> Vec n a -> Vec n b

postscanl is a variant of scanl where the first result is dropped:

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

>>> postscanl (+) 0 (5 :> 4 :> 3 :> 2 :> Nil)
5 :> 9 :> 12 :> 14 :> Nil

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

scanr :: (a -> b -> b) -> b -> Vec n a -> Vec (n + 1) b

scanr is similar to foldr, but returns a vector of successive reduced values from the right:

scanr f z (... :> xn1 :> xn :> Nil) == ... :> (xn1 `f` (xn `f` z)) :> (xn `f` z) :> z :> Nil

>>> scanr (+) 0 (5 :> 4 :> 3 :> 2 :> Nil)
14 :> 9 :> 5 :> 2 :> 0 :> Nil

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

• NB:

  head (scanr f z xs) == foldr f z xs

• For a different trade-off between circuit size and logic depth for associative operators, see Clash.Sized.RTree

postscanr :: (a -> b -> b) -> b -> Vec n a -> Vec n b

postscanr is a variant of scanr that where the last result is dropped:

postscanr f z (... :> xn1 :> xn :> Nil) == ... :> (xn1 `f` (xn `f` z)) :> (xn `f` z) :> Nil

>>> postscanr (+) 0 (5 :> 4 :> 3 :> 2 :> Nil)
14 :> 9 :> 5 :> 2 :> Nil

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

mapAccumL :: (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)

The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a vector, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new vector.

>>> mapAccumL (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
(10,1 :> 2 :> 4 :> 7 :> Nil)

"mapAccumL f acc xs" corresponds to the following circuit layout:

mapAccumR :: (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)

The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a vector, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new vector.

>>> mapAccumR (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
(10,10 :> 8 :> 5 :> 1 :> Nil)

"mapAccumR f acc xs" corresponds to the following circuit layout:

zip :: Vec n a -> Vec n b -> Vec n (a, b)

zip takes two vectors and returns a vector of corresponding pairs.

>>> zip (1:>2:>3:>4:>Nil) (4:>3:>2:>1:>Nil)
(1,4) :> (2,3) :> (3,2) :> (4,1) :> Nil

zip3 :: Vec n a -> Vec n b -> Vec n c -> Vec n (a, b, c)

zip3 takes three vectors and returns a vector of corresponding triplets.

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

zip4 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n (a, b, c, d)

zip4 takes four vectors and returns a list of quadruples, analogous to zip.

zip5 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n (a, b, c, d, e)

zip5 takes five vectors and returns a list of five-tuples, analogous to zip.

zip6 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n (a, b, c, d, e, f)

zip6 takes six vectors and returns a list of six-tuples, analogous to zip.

zip7 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n g -> Vec n (a, b, c, d, e, f, g)

zip7 takes seven vectors and returns a list of seven-tuples, analogous to zip.

unzip :: Vec n (a, b) -> (Vec n a, Vec n b)

unzip transforms a vector of pairs into a vector of first components and a vector of second components.

>>> unzip ((1,4):>(2,3):>(3,2):>(4,1):>Nil)
(1 :> 2 :> 3 :> 4 :> Nil,4 :> 3 :> 2 :> 1 :> Nil)

unzip3 :: Vec n (a, b, c) -> (Vec n a, Vec n b, Vec n c)

unzip3 transforms a vector of triplets into a vector of first components, a vector of second components, and a vector of third components.

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

unzip4 :: Vec n (a, b, c, d) -> (Vec n a, Vec n b, Vec n c, Vec n d)

unzip4 takes a vector of quadruples and returns four vectors, analogous to unzip.

unzip5 :: Vec n (a, b, c, d, e) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e)

unzip5 takes a vector of five-tuples and returns five vectors, analogous to unzip.

unzip6 :: Vec n (a, b, c, d, e, f) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e, Vec n f)

unzip6 takes a vector of six-tuples and returns six vectors, analogous to unzip.

unzip7 :: Vec n (a, b, c, d, e, f, g) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e, Vec n f, Vec n g)

unzip7 takes a vector of seven-tuples and returns seven vectors, analogous to unzip.

(!!) :: (KnownNat n, Enum i) => Vec n a -> i -> a

"xs !! n" returns the n'th element of xs.

NB: vector elements have an ASCENDING subscript starting from 0 and ending at length - 1.

>>> (1:>2:>3:>4:>5:>Nil) !! 4
5
>>> (1:>2:>3:>4:>5:>Nil) !! (length (1:>2:>3:>4:>5:>Nil) - 1)
5
>>> (1:>2:>3:>4:>5:>Nil) !! 1
2
>>> (1:>2:>3:>4:>5:>Nil) !! 14
*** Exception: Clash.Sized.Vector.(!!): index 14 is larger than maximum index 4
...

length :: KnownNat n => Vec n a -> Int

The length of a Vector as an Int value.

>>> length (6 :> 7 :> 8 :> Nil)
3

replace :: (KnownNat n, Enum i) => i -> a -> Vec n a -> Vec n a

"replace n a xs" returns the vector xs where the n'th element is replaced by a.

NB: vector elements have an ASCENDING subscript starting from 0 and ending at length - 1.

>>> replace 3 7 (1:>2:>3:>4:>5:>Nil)
1 :> 2 :> 3 :> 7 :> 5 :> Nil
>>> replace 0 7 (1:>2:>3:>4:>5:>Nil)
7 :> 2 :> 3 :> 4 :> 5 :> Nil
>>> replace 9 7 (1:>2:>3:>4:>5:>Nil)
1 :> 2 :> 3 :> 4 :> 5 :> *** Exception: Clash.Sized.Vector.replace: index 9 is larger than maximum index 4
...

take :: SNat m -> Vec (m + n) a -> Vec m a

"take n xs" returns the n-length prefix of xs.

>>> take (SNat :: SNat 3) (1:>2:>3:>4:>5:>Nil)
1 :> 2 :> 3 :> Nil
>>> take d3               (1:>2:>3:>4:>5:>Nil)
1 :> 2 :> 3 :> Nil
>>> take d0               (1:>2:>Nil)
Nil

# 1438 "srcClashSized/Vector.hs" >>> take d4 (1:>2:>Nil) BLANKLINE interactive:... • Couldn't match type ‘4 + n0’ with ‘2’ Expected type: Vec (4 + n0) a Actual type: Vec (1 + 1) a The type variable ‘n0’ is ambiguous • In the second argument of ‘take’, namely ‘(1 :> 2 :> Nil)’ In the expression: take d4 (1 :> 2 :> Nil) In an equation for ‘it’: it = take d4 (1 :> 2 :> Nil)

takeI :: KnownNat m => Vec (m + n) a -> Vec m a

"takeI xs" returns the prefix of xs as demanded by the context.

>>> takeI (1:>2:>3:>4:>5:>Nil) :: Vec 2 Int
1 :> 2 :> Nil

drop :: SNat m -> Vec (m + n) a -> Vec n a

"drop n xs" returns the suffix of xs after the first n elements.

>>> drop (SNat :: SNat 3) (1:>2:>3:>4:>5:>Nil)
4 :> 5 :> Nil
>>> drop d3               (1:>2:>3:>4:>5:>Nil)
4 :> 5 :> Nil
>>> drop d0               (1:>2:>Nil)
1 :> 2 :> Nil
>>> drop d4               (1:>2:>Nil)

<interactive>:...: error:
    • Couldn't match...type ‘4 + n0...
      The type variable ‘n0’ is ambiguous
    • In the first argument of ‘print’, namely ‘it’
      In a stmt of an interactive GHCi command: print it

dropI :: KnownNat m => Vec (m + n) a -> Vec n a

"dropI xs" returns the suffix of xs as demanded by the context.

>>> dropI (1:>2:>3:>4:>5:>Nil) :: Vec 2 Int
4 :> 5 :> Nil

at :: SNat m -> Vec (m + (n + 1)) a -> a

"at n xs" returns n'th element of xs

NB: vector elements have an ASCENDING subscript starting from 0 and ending at length - 1.

>>> at (SNat :: SNat 1) (1:>2:>3:>4:>5:>Nil)
2
>>> at d1               (1:>2:>3:>4:>5:>Nil)
2

select :: CmpNat (i + s) (s * n) ~ 'GT => SNat f -> SNat s -> SNat n -> Vec (f + i) a -> Vec n a

"select f s n xs" selects n elements with step-size s and offset f from xs.

>>> select (SNat :: SNat 1) (SNat :: SNat 2) (SNat :: SNat 3) (1:>2:>3:>4:>5:>6:>7:>8:>Nil)
2 :> 4 :> 6 :> Nil
>>> select d1 d2 d3 (1:>2:>3:>4:>5:>6:>7:>8:>Nil)
2 :> 4 :> 6 :> Nil

selectI :: (CmpNat (i + s) (s * n) ~ 'GT, KnownNat n) => SNat f -> SNat s -> Vec (f + i) a -> Vec n a

"selectI f s xs" selects as many elements as demanded by the context with step-size s and offset f from xs.

>>> selectI d1 d2 (1:>2:>3:>4:>5:>6:>7:>8:>Nil) :: Vec 2 Int
2 :> 4 :> Nil

replicate :: SNat n -> a -> Vec n a

"replicate n a" returns a vector that has n copies of a.

>>> replicate (SNat :: SNat 3) 6
6 :> 6 :> 6 :> Nil
>>> replicate d3 6
6 :> 6 :> 6 :> Nil

repeat :: KnownNat n => a -> Vec n a

"repeat a" creates a vector with as many copies of a as demanded by the context.

>>> repeat 6 :: Vec 5 Int
6 :> 6 :> 6 :> 6 :> 6 :> Nil

iterate :: SNat n -> (a -> a) -> a -> Vec n a

"iterate n f x" returns a vector starting with x followed by n repeated applications of f to x.

iterate (SNat :: SNat 4) f x == (x :> f x :> f (f x) :> f (f (f x)) :> Nil)
iterate d4 f x               == (x :> f x :> f (f x) :> f (f (f x)) :> Nil)

>>> iterate d4 (+1) 1
1 :> 2 :> 3 :> 4 :> Nil

"iterate n f z" corresponds to the following circuit layout:

iterateI :: forall n a. KnownNat n => (a -> a) -> a -> Vec n a

"iterate f x" returns a vector starting with x followed by n repeated applications of f to x, where n is determined by the context.

iterateI f x :: Vec 3 a == (x :> f x :> f (f x) :> Nil)

>>> iterateI (+1) 1 :: Vec 3 Int
1 :> 2 :> 3 :> Nil

"iterateI f z" corresponds to the following circuit layout:

unfoldr :: SNat n -> (s -> (a, s)) -> s -> Vec n a

"'unfoldr n f s" builds a vector of length n from a seed value s, where every element a is created by successive calls of f on s. Unlike unfoldr from Data.List the generating function f cannot dictate the length of the resulting vector, it must be statically known.

a simple use of unfoldr:

>>> unfoldr d10 (\s -> (s,s-1)) 10
10 :> 9 :> 8 :> 7 :> 6 :> 5 :> 4 :> 3 :> 2 :> 1 :> Nil

unfoldrI :: KnownNat n => (s -> (a, s)) -> s -> Vec n a

"'unfoldr f s" builds a vector from a seed value s, where every element a is created by successive calls of f on s; the length of the vector is inferred from the context. Unlike unfoldr from Data.List the generating function f cannot dictate the length of the resulting vector, it must be statically known.

a simple use of unfoldrI:

>>> unfoldrI (\s -> (s,s-1)) 10 :: Vec 10 Int
10 :> 9 :> 8 :> 7 :> 6 :> 5 :> 4 :> 3 :> 2 :> 1 :> Nil

generate :: SNat n -> (a -> a) -> a -> Vec n a

"generate n f x" returns a vector with n repeated applications of f to x.

generate (SNat :: SNat 4) f x == (f x :> f (f x) :> f (f (f x)) :> f (f (f (f x))) :> Nil)
generate d4 f x               == (f x :> f (f x) :> f (f (f x)) :> f (f (f (f x))) :> Nil)

>>> generate d4 (+1) 1
2 :> 3 :> 4 :> 5 :> Nil

"generate n f z" corresponds to the following circuit layout:

generateI :: KnownNat n => (a -> a) -> a -> Vec n a

"generateI f x" returns a vector with n repeated applications of f to x, where n is determined by the context.

generateI f x :: Vec 3 a == (f x :> f (f x) :> f (f (f x)) :> Nil)

>>> generateI (+1) 1 :: Vec 3 Int
2 :> 3 :> 4 :> Nil

"generateI f z" corresponds to the following circuit layout:

transpose :: KnownNat n => Vec m (Vec n a) -> Vec n (Vec m a)

Transpose a matrix: go from row-major to column-major

>>> let xss = (1:>2:>Nil):>(3:>4:>Nil):>(5:>6:>Nil):>Nil
>>> xss
(1 :> 2 :> Nil) :> (3 :> 4 :> Nil) :> (5 :> 6 :> Nil) :> Nil
>>> transpose xss
(1 :> 3 :> 5 :> Nil) :> (2 :> 4 :> 6 :> Nil) :> Nil

stencil1d

Arguments

:: KnownNat n

=> SNat (stX + 1)

Windows length stX, at least size 1

-> (Vec (stX + 1) a -> b)

The stencil (function)

-> Vec ((stX + n) + 1) a

-> Vec (n + 1) b

1-dimensional stencil computations

"stencil1d stX f xs", where xs has stX + n elements, applies the stencil computation f on: n + 1 overlapping (1D) windows of length stX, drawn from xs. The resulting vector has n + 1 elements.

>>> let xs = (1:>2:>3:>4:>5:>6:>Nil)
>>> :t xs
xs :: Num a => Vec 6 a
>>> :t stencil1d d2 sum xs
stencil1d d2 sum xs :: Num b => Vec 5 b
>>> stencil1d d2 sum xs
3 :> 5 :> 7 :> 9 :> 11 :> Nil

stencil2d

Arguments

:: (KnownNat n, KnownNat m)

=> SNat (stY + 1)

Window hight stY, at least size 1

-> SNat (stX + 1)

Window width stX, at least size 1

-> (Vec (stY + 1) (Vec (stX + 1) a) -> b)

The stencil (function)

-> Vec ((stY + m) + 1) (Vec ((stX + n) + 1) a)

-> Vec (m + 1) (Vec (n + 1) b)

2-dimensional stencil computations

"stencil2d stY stX f xss", where xss is a matrix of stY + m rows of stX + n elements, applies the stencil computation f on: (m + 1) * (n + 1) overlapping (2D) windows of stY rows of stX elements, drawn from xss. The result matrix has m + 1 rows of n + 1 elements.

>>> let xss = ((1:>2:>3:>4:>Nil):>(5:>6:>7:>8:>Nil):>(9:>10:>11:>12:>Nil):>(13:>14:>15:>16:>Nil):>Nil)
>>> :t xss
xss :: Num a => Vec 4 (Vec 4 a)
>>> :t stencil2d d2 d2 (sum . map sum) xss
stencil2d d2 d2 (sum . map sum) xss :: Num b => Vec 3 (Vec 3 b)
>>> stencil2d d2 d2 (sum . map sum) xss
(14 :> 18 :> 22 :> Nil) :> (30 :> 34 :> 38 :> Nil) :> (46 :> 50 :> 54 :> Nil) :> Nil

windows1d

Arguments

:: KnownNat n

=> SNat (stX + 1)

Length of the window, at least size 1

-> Vec ((stX + n) + 1) a

-> Vec (n + 1) (Vec (stX + 1) a)

"windows1d stX xs", where the vector xs has stX + n elements, returns a vector of n + 1 overlapping (1D) windows of xs of length stX.

>>> let xs = (1:>2:>3:>4:>5:>6:>Nil)
>>> :t xs
xs :: Num a => Vec 6 a
>>> :t windows1d d2 xs
windows1d d2 xs :: Num a => Vec 5 (Vec 2 a)
>>> windows1d d2 xs
(1 :> 2 :> Nil) :> (2 :> 3 :> Nil) :> (3 :> 4 :> Nil) :> (4 :> 5 :> Nil) :> (5 :> 6 :> Nil) :> Nil

windows2d

Arguments

:: (KnownNat n, KnownNat m)

=> SNat (stY + 1)

Window hight stY, at least size 1

-> SNat (stX + 1)

Window width stX, at least size 1

-> Vec ((stY + m) + 1) (Vec ((stX + n) + 1) a)

-> Vec (m + 1) (Vec (n + 1) (Vec (stY + 1) (Vec (stX + 1) a)))

"windows2d stY stX xss", where matrix xss has stY + m rows of stX + n, returns a matrix of m+1 rows of n+1 elements. The elements of this new matrix are the overlapping (2D) windows of xss, where every window has stY rows of stX elements.

>>> let xss = ((1:>2:>3:>4:>Nil):>(5:>6:>7:>8:>Nil):>(9:>10:>11:>12:>Nil):>(13:>14:>15:>16:>Nil):>Nil)
>>> :t xss
xss :: Num a => Vec 4 (Vec 4 a)
>>> :t windows2d d2 d2 xss
windows2d d2 d2 xss :: Num a => Vec 3 (Vec 3 (Vec 2 (Vec 2 a)))
>>> windows2d d2 d2 xss
(((1 :> 2 :> Nil) :> (5 :> 6 :> Nil) :> Nil) :> ((2 :> 3 :> Nil) :> (6 :> 7 :> Nil) :> Nil) :> ((3 :> 4 :> Nil) :> (7 :> 8 :> Nil) :> Nil) :> Nil) :> (((5 :> 6 :> Nil) :> (9 :> 10 :> Nil) :> Nil) :> ((6 :> 7 :> Nil) :> (10 :> 11 :> Nil) :> Nil) :> ((7 :> 8 :> Nil) :> (11 :> 12 :> Nil) :> Nil) :> Nil) :> (((9 :> 10 :> Nil) :> (13 :> 14 :> Nil) :> Nil) :> ((10 :> 11 :> Nil) :> (14 :> 15 :> Nil) :> Nil) :> ((11 :> 12 :> Nil) :> (15 :> 16 :> Nil) :> Nil) :> Nil) :> Nil

permute

Arguments

:: (Enum i, KnownNat n, KnownNat m)

=> (a -> a -> a)

Combination function, f

-> Vec n a

Default values, def

-> Vec m i

Index mapping, is

-> Vec (m + k) a

Vector to be permuted, xs

-> Vec n a

Forward permutation specified by an index mapping, ix. The result vector is initialized by the given defaults, def, and an further values that are permuted into the result are added to the current value using the given combination function, f.

The combination function must be associative and commutative.

backpermute

Arguments

:: (Enum i, KnownNat n)

=> Vec n a

Source vector, xs

-> Vec m i

Index mapping, is

-> Vec m a

Backwards permutation specified by an index mapping, is, from the destination vector specifying which element of the source vector xs to read.

"backpermute xs is" is equivalent to "map (xs !!) is".

For example:

>>> let input = 1:>9:>6:>4:>4:>2:>0:>1:>2:>Nil
>>> let from  = 1:>3:>7:>2:>5:>3:>Nil
>>> backpermute input from
9 :> 4 :> 1 :> 6 :> 2 :> 4 :> Nil

scatter

Arguments

:: (Enum i, KnownNat n, KnownNat m)

=> Vec n a

Default values, def

-> Vec m i

Index mapping, is

-> Vec (m + k) a

Vector to be scattered, xs

-> Vec n a

Copy elements from the source vector, xs, to the destination vector according to an index mapping is. This is a forward permute operation where a to vector encodes an input to output index mapping. Output elements for indices that are not mapped assume the value in the default vector def.

For example:

>>> let defVec = 0:>0:>0:>0:>0:>0:>0:>0:>0:>Nil
>>> let to = 1:>3:>7:>2:>5:>8:>Nil
>>> let input = 1:>9:>6:>4:>4:>2:>5:>Nil
>>> scatter defVec to input
0 :> 1 :> 4 :> 9 :> 0 :> 4 :> 0 :> 6 :> 2 :> Nil

NB: If the same index appears in the index mapping more than once, the latest mapping is chosen.

gather

Arguments

:: (Enum i, KnownNat n)

=> Vec n a

Source vector, xs

-> Vec m i

Index mapping, is

-> Vec m a

Backwards permutation specified by an index mapping, is, from the destination vector specifying which element of the source vector xs to read.

"gather xs is" is equivalent to "map (xs !!) is".

For example:

>>> let input = 1:>9:>6:>4:>4:>2:>0:>1:>2:>Nil
>>> let from  = 1:>3:>7:>2:>5:>3:>Nil
>>> gather input from
9 :> 4 :> 1 :> 6 :> 2 :> 4 :> Nil

interleave

Arguments

:: (KnownNat n, KnownNat d)

=> SNat d

Interleave step, d

-> Vec (n * d) a

-> Vec (d * n) a

"interleave d xs" creates a vector:

<x_0,x_d,x_(2d),...,x_1,x_(d+1),x_(2d+1),...,x_(d-1),x_(2d-1),x_(3d-1)>

>>> let xs = 1 :> 2 :> 3 :> 4 :> 5 :> 6 :> 7 :> 8 :> 9 :> Nil
>>> interleave d3 xs
1 :> 4 :> 7 :> 2 :> 5 :> 8 :> 3 :> 6 :> 9 :> Nil

rotateLeft :: (Enum i, KnownNat n) => Vec n a -> i -> Vec n a

Dynamically rotate a Vector to the left:

>>> let xs = 1 :> 2 :> 3 :> 4 :> Nil
>>> rotateLeft xs 1
2 :> 3 :> 4 :> 1 :> Nil
>>> rotateLeft xs 2
3 :> 4 :> 1 :> 2 :> Nil
>>> rotateLeft xs (-1)
4 :> 1 :> 2 :> 3 :> Nil

NB: use rotateLeftS if you want to rotate left by a static amount.

rotateRight :: (Enum i, KnownNat n) => Vec n a -> i -> Vec n a

Dynamically rotate a Vector to the right:

>>> let xs = 1 :> 2 :> 3 :> 4 :> Nil
>>> rotateRight xs 1
4 :> 1 :> 2 :> 3 :> Nil
>>> rotateRight xs 2
3 :> 4 :> 1 :> 2 :> Nil
>>> rotateRight xs (-1)
2 :> 3 :> 4 :> 1 :> Nil

NB: use rotateRightS if you want to rotate right by a static amount.

rotateLeftS :: KnownNat n => Vec n a -> SNat d -> Vec n a

Statically rotate a Vector to the left:

>>> let xs = 1 :> 2 :> 3 :> 4 :> Nil
>>> rotateLeftS xs d1
2 :> 3 :> 4 :> 1 :> Nil

NB: use rotateLeft if you want to rotate left by a dynamic amount.

rotateRightS :: KnownNat n => Vec n a -> SNat d -> Vec n a

Statically rotate a Vector to the right:

>>> let xs = 1 :> 2 :> 3 :> 4 :> Nil
>>> rotateRightS xs d1
4 :> 1 :> 2 :> 3 :> Nil

NB: use rotateRight if you want to rotate right by a dynamic amount.

toList :: Vec n a -> [a]

Convert a vector to a list.

>>> toList (1:>2:>3:>Nil)
[1,2,3]

NB: this function is not synthesizable

listToVecTH :: Lift a => [a] -> ExpQ

Create a vector literal from a list literal.

$(listToVecTH [1::Signed 8,2,3,4,5]) == (8:>2:>3:>4:>5:>Nil) :: Vec 5 (Signed 8)

>>> [1 :: Signed 8,2,3,4,5]
[1,2,3,4,5]
>>> $(listToVecTH [1::Signed 8,2,3,4,5])
1 :> 2 :> 3 :> 4 :> 5 :> Nil

asNatProxy :: Vec n a -> Proxy n

Vector as a Proxy for Nat

lengthS :: KnownNat n => Vec n a -> SNat n

Length of a Vector as an SNat value

lazyV :: KnownNat n => Vec n a -> Vec n a

What you should use when your vector functions are too strict in their arguments.

doctests setup

>>> let compareSwapL a b = if a < b then (a,b) else (b,a)
>>> :{
let sortVL :: (Ord a, KnownNat (n + 1)) => Vec ((n + 1) + 1) a -> Vec ((n + 1) + 1) a
    sortVL xs = map fst sorted :< (snd (last sorted))
      where
        lefts  = head xs :> map snd (init sorted)
        rights = tail xs
        sorted = zipWith compareSwapL (lazyV lefts) rights
:}

>>> :{
let sortV_flip xs = map fst sorted :< (snd (last sorted))
      where
        lefts  = head xs :> map snd (init sorted)
        rights = tail xs
        sorted = zipWith (flip compareSwapL) rights lefts
:}

Example usage

For example:

-- Bubble sort for 1 iteration
sortV xs = map fst sorted :< (snd (last sorted))
 where
   lefts  = head xs :> map snd (init sorted)
   rights = tail xs
   sorted = zipWith compareSwapL lefts rights

-- Compare and swap
compareSwapL a b = if a < b then (a,b)
                            else (b,a)

Will not terminate because zipWith is too strict in its second argument.

In this case, adding lazyV on zipWiths second argument:

sortVL xs = map fst sorted :< (snd (last sorted))
 where
   lefts  = head xs :> map snd (init sorted)
   rights = tail xs
   sorted = zipWith compareSwapL (lazyV lefts) rights

Results in a successful computation:

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

NB: There is also a solution using flip, but it slightly obfuscates the meaning of the code:

sortV_flip xs = map fst sorted :< (snd (last sorted))
 where
   lefts  = head xs :> map snd (init sorted)
   rights = tail xs
   sorted = zipWith (flip compareSwapL) rights lefts

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

dfold

Arguments

:: forall p k a. KnownNat k

=> Proxy (p :: TyFun Nat Type -> Type)

The motive

-> (forall l. SNat l -> a -> (p @@ l) -> p @@ (l + 1))

Function to fold.

NB: The SNat l is not the index (see (!!)) to the element a. SNat l is the number of elements that occur to the right of a.

-> (p @@ 0)

Initial element

-> Vec k a

Vector to fold over

-> p @@ k

A dependently typed fold.

doctests setup

>>> :seti -fplugin GHC.TypeLits.Normalise
>>> import Data.Singletons (Apply, Proxy (..), TyFun)
>>> data Append (m :: Nat) (a :: Type) (f :: TyFun Nat Type) :: Type
>>> type instance Apply (Append m a) l = Vec (l + m) a
>>> let append' xs ys = dfold (Proxy :: Proxy (Append m a)) (const (:>)) ys xs

Example usage

Using lists, we can define append (a.k.a. Data.List.++) in terms of Data.List.foldr:

>>> import qualified Data.List
>>> let append xs ys = Data.List.foldr (:) ys xs
>>> append [1,2] [3,4]
[1,2,3,4]

However, when we try to do the same for Vec, by defining append' in terms of Clash.Sized.Vector.foldr:

append' xs ys = foldr (:>) ys xs

we get a type error:

>>> let append' xs ys = foldr (:>) ys xs

<interactive>:...
    • Occurs check: cannot construct the infinite type: ... ~ ... + 1
      Expected type: a -> Vec ... a -> Vec ... a
        Actual type: a -> Vec ... a -> Vec (... + 1) a
    • In the first argument of ‘foldr’, namely ‘(:>)’
      In the expression: foldr (:>) ys xs
      In an equation for ‘append'’: append' xs ys = foldr (:>) ys xs
    • Relevant bindings include
        ys :: Vec ... a (bound at ...)
        append' :: Vec n a -> Vec ... a -> Vec ... a
          (bound at ...)

The reason is that the type of foldr is:

>>> :t foldr
foldr :: (a -> b -> b) -> b -> Vec n a -> b

While the type of (:>) is:

>>> :t (:>)
(:>) :: a -> Vec n a -> Vec (n + 1) a

We thus need a fold function that can handle the growing vector type: dfold. Compared to foldr, dfold takes an extra parameter, called the motive, that allows the folded function to have an argument and result type that depends on the current length of the vector. Using dfold, we can now correctly define append':

import Data.Singletons
import Data.Proxy

data Append (m :: Nat) (a :: Type) (f :: TyFun Nat Type) :: Type
type instance Apply (Append m a) l = Vec (l + m) a

append' xs ys = dfold (Proxy :: Proxy (Append m a)) (const (:>)) ys xs

We now see that append' has the appropriate type:

>>> :t append'
append' :: KnownNat k => Vec k a -> Vec m a -> Vec (k + m) a

And that it works:

>>> append' (1 :> 2 :> Nil) (3 :> 4 :> Nil)
1 :> 2 :> 3 :> 4 :> Nil

NB: "dfold m f z xs" creates a linear structure, which has a depth, or delay, of O(length xs). Look at dtfold for a dependently typed fold that produces a structure with a depth of O(log_2(length xs)).

dtfold

Arguments

:: forall p k a. KnownNat k

=> Proxy (p :: TyFun Nat Type -> Type)

The motive

-> (a -> p @@ 0)

Function to apply to every element

-> (forall l. SNat l -> (p @@ l) -> (p @@ l) -> p @@ (l + 1))

Function to combine results.

NB: The SNat l indicates the depth/height of the node in the tree that is created by applying this function. The leafs of the tree have depth/height 0, and the root of the tree has height k.

-> Vec (2 ^ k) a

Vector to fold over.

NB: Must have a length that is a power of 2.

-> p @@ k

A combination of dfold and fold: a dependently typed fold that reduces a vector in a tree-like structure.

doctests setup

>>> :seti -XUndecidableInstances
>>> import Data.Singletons (Apply, Proxy (..), TyFun)
>>> data IIndex (f :: TyFun Nat Type) :: Type
>>> type instance Apply IIndex l = Index ((2^l)+1)
>>> :{
let populationCount' :: (KnownNat k, KnownNat (2^k)) => BitVector (2^k) -> Index ((2^k)+1)
    populationCount' bv = dtfold (Proxy @IIndex)
                                 fromIntegral
                                 (\_ x y -> add x y)
                                 (bv2v bv)
:}

Example usage

As an example of when you might want to use dtfold we will build a population counter: a circuit that counts the number of bits set to '1' in a BitVector. Given a vector of n bits, we only need we need a data type that can represent the number n: Index (n+1). Index k has a range of [0 .. k-1] (using ceil(log2(k)) bits), hence we need Index n+1. As an initial attempt we will use sum, because it gives a nice (log2(n)) tree-structure of adders:

populationCount :: (KnownNat (n+1), KnownNat (n+2))
                => BitVector (n+1) -> Index (n+2)
populationCount = sum . map fromIntegral . bv2v

The "problem" with this description is that all adders have the same bit-width, i.e. all adders are of the type:

(+) :: Index (n+2) -> Index (n+2) -> Index (n+2).

This is a "problem" because we could have a more efficient structure: one where each layer of adders is precisely wide enough to count the number of bits at that layer. That is, at height d we want the adder to be of type:

Index ((2^d)+1) -> Index ((2^d)+1) -> Index ((2^(d+1))+1)

We have such an adder in the form of the add function, as defined in the instance ExtendingNum instance of Index. However, we cannot simply use fold to create a tree-structure of addes:

# 2277 "srcClashSized/Vector.hs" >>> :{ let populationCount' :: (KnownNat (n+1), KnownNat (n+2)) => BitVector (n+1) -> Index (n+2) populationCount' = fold add . map fromIntegral . bv2v :} BLANKLINE interactive:... • Couldn't match type ‘((n + 2) + (n + 2)) - 1’ with ‘n + 2’ Expected type: Index (n + 2) -> Index (n + 2) -> Index (n + 2) Actual type: Index (n + 2) -> Index (n + 2) -> AResult (Index (n + 2)) (Index (n + 2)) • In the first argument of ‘fold’, namely ‘add’ In the first argument of ‘(.)’, namely ‘fold add’ In the expression: fold add . map fromIntegral . bv2v • Relevant bindings include populationCount' :: BitVector (n + 1) -> Index (n + 2) (bound at ...)

because fold expects a function of type "a -> a -> a", i.e. a function where the arguments and result all have exactly the same type.

In order to accommodate the type of our add, where the result is larger than the arguments, we must use a dependently typed fold in the form of dtfold:

{-# LANGUAGE UndecidableInstances #-}
import Data.Singletons
import Data.Proxy

data IIndex (f :: TyFun Nat Type) :: Type
type instance Apply IIndex l = Index ((2^l)+1)

populationCount' :: (KnownNat k, KnownNat (2^k))
                 => BitVector (2^k) -> Index ((2^k)+1)
populationCount' bv = dtfold (Proxy @IIndex)
                             fromIntegral
                             (\_ x y -> add x y)
                             (bv2v bv)

And we can test that it works:

>>> :t populationCount' (7 :: BitVector 16)
populationCount' (7 :: BitVector 16) :: Index 17
>>> populationCount' (7 :: BitVector 16)
3

Some final remarks:

• By using dtfold instead of fold, we had to restrict our BitVector argument to have bit-width that is a power of 2.
• Even though our original populationCount function specified a structure where all adders had the same width. Most VHDL/(System)Verilog synthesis tools will create a more efficient circuit, i.e. one where the adders have an increasing bit-width for every layer, from the VHDL/(System)Verilog produced by the Clash compiler.

NB: The depth, or delay, of the structure produced by "dtfold m f g xs" is O(log_2(length xs)).

vfold :: forall k a b. KnownNat k => (forall l. SNat l -> a -> Vec l b -> Vec (l + 1) b) -> Vec k a -> Vec k b

Specialised version of dfold that builds a triangular computational structure.

doctests setup

>>> let compareSwap a b = if a > b then (a,b) else (b,a)
>>> let insert y xs = let (y',xs') = mapAccumL compareSwap y xs in xs' :< y'
>>> let insertionSort = vfold (const insert)

Example usage

compareSwap a b = if a > b then (a,b) else (b,a)
insert y xs     = let (y',xs') = mapAccumL compareSwap y xs in xs' :< y'
insertionSort   = vfold (const insert)

Builds a triangular structure of compare and swaps to sort a row.

>>> insertionSort (7 :> 3 :> 9 :> 1 :> Nil)
1 :> 3 :> 7 :> 9 :> Nil

The circuit layout of insertionSort, build using vfold, is:

smap :: forall k a b. KnownNat k => (forall l. SNat l -> a -> b) -> Vec k a -> Vec k b

Apply a function to every element of a vector and the element's position (as an SNat value) in the vector.

>>> let rotateMatrix = smap (flip rotateRightS)
>>> let xss = (1:>2:>3:>Nil):>(1:>2:>3:>Nil):>(1:>2:>3:>Nil):>Nil
>>> xss
(1 :> 2 :> 3 :> Nil) :> (1 :> 2 :> 3 :> Nil) :> (1 :> 2 :> 3 :> Nil) :> Nil
>>> rotateMatrix xss
(1 :> 2 :> 3 :> Nil) :> (3 :> 1 :> 2 :> Nil) :> (2 :> 3 :> 1 :> Nil) :> Nil

concatBitVector# :: forall n m. (KnownNat n, KnownNat m) => Vec n (BitVector m) -> BitVector (n * m)

unconcatBitVector# :: forall n m. (KnownNat n, KnownNat m) => BitVector (n * m) -> Vec n (BitVector m)

v2bv :: KnownNat n => Vec n Bit -> BitVector n

Convert a Vec of Bits to a BitVector.

>>> let x = (0:>0:>0:>1:>0:>0:>1:>0:>Nil) :: Vec 8 Bit
>>> x
0 :> 0 :> 0 :> 1 :> 0 :> 0 :> 1 :> 0 :> Nil
>>> v2bv x
0b0001_0010

seqV :: KnownNat n => Vec n a -> b -> b infixr 0

Evaluate all elements of a vector to WHNF, returning the second argument

forceV :: KnownNat n => Vec n a -> Vec n a

Evaluate all elements of a vector to WHNF

seqVX :: KnownNat n => Vec n a -> b -> b infixr 0

Evaluate all elements of a vector to WHNF, returning the second argument. Does not propagate XExceptions.

forceVX :: KnownNat n => Vec n a -> Vec n a

Evaluate all elements of a vector to WHNF. Does not propagate XExceptions.

Perfect depth trees

module Clash.Sized.RTree

Annotations

module Clash.Annotations.TopEntity

Generics type-classes

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Generic Bool

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep Bool :: Type -> Type

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Generic Ordering

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep Ordering :: Type -> Type

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Generic Exp

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Exp :: Type -> Type

Methods

from :: Exp -> Rep Exp x

to :: Rep Exp x -> Exp

Generic Match

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Match :: Type -> Type

Methods

from :: Match -> Rep Match x

to :: Rep Match x -> Match

Generic Clause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Clause :: Type -> Type

Methods

from :: Clause -> Rep Clause x

to :: Rep Clause x -> Clause

Generic Pat

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pat :: Type -> Type

Methods

from :: Pat -> Rep Pat x

to :: Rep Pat x -> Pat

Generic Type

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Type :: Type -> Type

Methods

from :: Type -> Rep Type x

to :: Rep Type x -> Type

Generic Dec

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Dec :: Type -> Type

Methods

from :: Dec -> Rep Dec x

to :: Rep Dec x -> Dec

Generic Name

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Name :: Type -> Type

Methods

from :: Name -> Rep Name x

to :: Rep Name x -> Name

Generic FunDep

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FunDep :: Type -> Type

Methods

from :: FunDep -> Rep FunDep x

to :: Rep FunDep x -> FunDep

Generic InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep InjectivityAnn :: Type -> Type

Methods

from :: InjectivityAnn -> Rep InjectivityAnn x

to :: Rep InjectivityAnn x -> InjectivityAnn

Generic Overlap

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Overlap :: Type -> Type

Methods

from :: Overlap -> Rep Overlap x

to :: Rep Overlap x -> Overlap

Generic ()

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep () :: Type -> Type

Methods

from :: () -> Rep () x

to :: Rep () x -> ()

Generic Version

Since: base-4.9.0.0

Defined in Data.Version

Associated Types

type Rep Version :: Type -> Type

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

Generic Void

Since: base-4.8.0.0

Defined in Data.Void

Associated Types

type Rep Void :: Type -> Type

Methods

from :: Void -> Rep Void x

to :: Rep Void x -> Void

Generic ExitCode

Defined in GHC.IO.Exception

Associated Types

type Rep ExitCode :: Type -> Type

Methods

from :: ExitCode -> Rep ExitCode x

to :: Rep ExitCode x -> ExitCode

Generic All

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep All :: Type -> Type

Methods

from :: All -> Rep All x

to :: Rep All x -> All

Generic Any

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep Any :: Type -> Type

Methods

from :: Any -> Rep Any x

to :: Rep Any x -> Any

Generic Fixity

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic Associativity

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep Associativity :: Type -> Type

Methods

from :: Associativity -> Rep Associativity x

to :: Rep Associativity x -> Associativity

Generic SourceUnpackedness

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic SourceStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic DecidedStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Extension

Defined in GHC.LanguageExtensions.Type

Associated Types

type Rep Extension :: Type -> Type

Methods

from :: Extension -> Rep Extension x

to :: Rep Extension x -> Extension

Generic ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type

Methods

from :: ForeignSrcLang -> Rep ForeignSrcLang x

to :: Rep ForeignSrcLang x -> ForeignSrcLang

Generic Half

Defined in Numeric.Half.Internal

Associated Types

type Rep Half :: Type -> Type

Methods

from :: Half -> Rep Half x

to :: Rep Half x -> Half

Generic Boxed

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Boxed :: Type -> Type

Methods

from :: Boxed -> Rep Boxed x

to :: Rep Boxed x -> Boxed

Generic Tool

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Tool :: Type -> Type

Methods

from :: Tool -> Rep Tool x

to :: Rep Tool x -> Tool

Generic SrcLoc

Defined in Language.Haskell.Exts.SrcLoc

Associated Types

type Rep SrcLoc :: Type -> Type

Methods

from :: SrcLoc -> Rep SrcLoc x

to :: Rep SrcLoc x -> SrcLoc

Generic SrcSpan

Defined in Language.Haskell.Exts.SrcLoc

Associated Types

type Rep SrcSpan :: Type -> Type

Methods

from :: SrcSpan -> Rep SrcSpan x

to :: Rep SrcSpan x -> SrcSpan

Generic SrcSpanInfo

Defined in Language.Haskell.Exts.SrcLoc

Associated Types

type Rep SrcSpanInfo :: Type -> Type

Methods

from :: SrcSpanInfo -> Rep SrcSpanInfo x

to :: Rep SrcSpanInfo x -> SrcSpanInfo

Generic Mode

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep Mode :: Type -> Type

Methods

from :: Mode -> Rep Mode x

to :: Rep Mode x -> Mode

Generic Style

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep Style :: Type -> Type

Methods

from :: Style -> Rep Style x

to :: Rep Style x -> Style

Generic Stmt

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Stmt :: Type -> Type

Methods

from :: Stmt -> Rep Stmt x

to :: Rep Stmt x -> Stmt

Generic ModName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModName :: Type -> Type

Methods

from :: ModName -> Rep ModName x

to :: Rep ModName x -> ModName

Generic Phases

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Phases :: Type -> Type

Methods

from :: Phases -> Rep Phases x

to :: Rep Phases x -> Phases

Generic RuleBndr

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleBndr :: Type -> Type

Methods

from :: RuleBndr -> Rep RuleBndr x

to :: Rep RuleBndr x -> RuleBndr

Generic Pragma

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pragma :: Type -> Type

Methods

from :: Pragma -> Rep Pragma x

to :: Rep Pragma x -> Pragma

Generic DerivClause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivClause :: Type -> Type

Methods

from :: DerivClause -> Rep DerivClause x

to :: Rep DerivClause x -> DerivClause

Generic Con

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Con :: Type -> Type

Methods

from :: Con -> Rep Con x

to :: Rep Con x -> Con

Generic DerivStrategy

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivStrategy :: Type -> Type

Methods

from :: DerivStrategy -> Rep DerivStrategy x

to :: Rep DerivStrategy x -> DerivStrategy

Generic TySynEqn

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TySynEqn :: Type -> Type

Methods

from :: TySynEqn -> Rep TySynEqn x

to :: Rep TySynEqn x -> TySynEqn

Generic TyVarBndr

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TyVarBndr :: Type -> Type

Methods

from :: TyVarBndr -> Rep TyVarBndr x

to :: Rep TyVarBndr x -> TyVarBndr

Generic Doc

Defined in Text.PrettyPrint.HughesPJ

Associated Types

type Rep Doc :: Type -> Type

Methods

from :: Doc -> Rep Doc x

to :: Rep Doc x -> Doc

Generic TextDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep TextDetails :: Type -> Type

Methods

from :: TextDetails -> Rep TextDetails x

to :: Rep TextDetails x -> TextDetails

Generic PkgName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PkgName :: Type -> Type

Methods

from :: PkgName -> Rep PkgName x

to :: Rep PkgName x -> PkgName

Generic Module

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Module :: Type -> Type

Methods

from :: Module -> Rep Module x

to :: Rep Module x -> Module

Generic OccName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep OccName :: Type -> Type

Methods

from :: OccName -> Rep OccName x

to :: Rep OccName x -> OccName

Generic NameFlavour

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameFlavour :: Type -> Type

Methods

from :: NameFlavour -> Rep NameFlavour x

to :: Rep NameFlavour x -> NameFlavour

Generic NameSpace

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameSpace :: Type -> Type

Methods

from :: NameSpace -> Rep NameSpace x

to :: Rep NameSpace x -> NameSpace

Generic Loc

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Loc :: Type -> Type

Methods

from :: Loc -> Rep Loc x

to :: Rep Loc x -> Loc

Generic Info

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Info :: Type -> Type

Methods

from :: Info -> Rep Info x

to :: Rep Info x -> Info

Generic ModuleInfo

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModuleInfo :: Type -> Type

Methods

from :: ModuleInfo -> Rep ModuleInfo x

to :: Rep ModuleInfo x -> ModuleInfo

Generic Fixity

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic FixityDirection

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FixityDirection :: Type -> Type

Methods

from :: FixityDirection -> Rep FixityDirection x

to :: Rep FixityDirection x -> FixityDirection

Generic Lit

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Lit :: Type -> Type

Methods

from :: Lit -> Rep Lit x

to :: Rep Lit x -> Lit

Generic Bytes

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bytes :: Type -> Type

Methods

from :: Bytes -> Rep Bytes x

to :: Rep Bytes x -> Bytes

Generic Body

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Body :: Type -> Type

Methods

from :: Body -> Rep Body x

to :: Rep Body x -> Body

Generic Guard

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Guard :: Type -> Type

Methods

from :: Guard -> Rep Guard x

to :: Rep Guard x -> Guard

Generic Range

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Range :: Type -> Type

Methods

from :: Range -> Rep Range x

to :: Rep Range x -> Range

Generic TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TypeFamilyHead :: Type -> Type

Methods

from :: TypeFamilyHead -> Rep TypeFamilyHead x

to :: Rep TypeFamilyHead x -> TypeFamilyHead

Generic Foreign

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Foreign :: Type -> Type

Methods

from :: Foreign -> Rep Foreign x

to :: Rep Foreign x -> Foreign

Generic Callconv

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Callconv :: Type -> Type

Methods

from :: Callconv -> Rep Callconv x

to :: Rep Callconv x -> Callconv

Generic Safety

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Safety :: Type -> Type

Methods

from :: Safety -> Rep Safety x

to :: Rep Safety x -> Safety

Generic Inline

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Inline :: Type -> Type

Methods

from :: Inline -> Rep Inline x

to :: Rep Inline x -> Inline

Generic RuleMatch

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleMatch :: Type -> Type

Methods

from :: RuleMatch -> Rep RuleMatch x

to :: Rep RuleMatch x -> RuleMatch

Generic AnnTarget

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnTarget :: Type -> Type

Methods

from :: AnnTarget -> Rep AnnTarget x

to :: Rep AnnTarget x -> AnnTarget

Generic SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic SourceStrictness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Bang

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bang :: Type -> Type

Methods

from :: Bang -> Rep Bang x

to :: Rep Bang x -> Bang

Generic PatSynDir

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynDir :: Type -> Type

Methods

from :: PatSynDir -> Rep PatSynDir x

to :: Rep PatSynDir x -> PatSynDir

Generic PatSynArgs

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynArgs :: Type -> Type

Methods

from :: PatSynArgs -> Rep PatSynArgs x

to :: Rep PatSynArgs x -> PatSynArgs

Generic FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FamilyResultSig :: Type -> Type

Methods

from :: FamilyResultSig -> Rep FamilyResultSig x

to :: Rep FamilyResultSig x -> FamilyResultSig

Generic TyLit

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TyLit :: Type -> Type

Methods

from :: TyLit -> Rep TyLit x

to :: Rep TyLit x -> TyLit

Generic Role

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Role :: Type -> Type

Methods

from :: Role -> Rep Role x

to :: Rep Role x -> Role

Generic AnnLookup

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnLookup :: Type -> Type

Methods

from :: AnnLookup -> Rep AnnLookup x

to :: Rep AnnLookup x -> AnnLookup

Generic DatatypeInfo

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep DatatypeInfo :: Type -> Type

Methods

from :: DatatypeInfo -> Rep DatatypeInfo x

to :: Rep DatatypeInfo x -> DatatypeInfo

Generic DatatypeVariant

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep DatatypeVariant :: Type -> Type

Methods

from :: DatatypeVariant -> Rep DatatypeVariant x

to :: Rep DatatypeVariant x -> DatatypeVariant

Generic ConstructorInfo

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep ConstructorInfo :: Type -> Type

Methods

from :: ConstructorInfo -> Rep ConstructorInfo x

to :: Rep ConstructorInfo x -> ConstructorInfo

Generic ConstructorVariant

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep ConstructorVariant :: Type -> Type

Methods

from :: ConstructorVariant -> Rep ConstructorVariant x

to :: Rep ConstructorVariant x -> ConstructorVariant

Generic FieldStrictness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep FieldStrictness :: Type -> Type

Methods

from :: FieldStrictness -> Rep FieldStrictness x

to :: Rep FieldStrictness x -> FieldStrictness

Generic Unpackedness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep Unpackedness :: Type -> Type

Methods

from :: Unpackedness -> Rep Unpackedness x

to :: Rep Unpackedness x -> Unpackedness

Generic Strictness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep Strictness :: Type -> Type

Methods

from :: Strictness -> Rep Strictness x

to :: Rep Strictness x -> Strictness

Generic Specificity

Defined in Language.Haskell.TH.Datatype.TyVarBndr

Associated Types

type Rep Specificity :: Type -> Type

Methods

from :: Specificity -> Rep Specificity x

to :: Rep Specificity x -> Specificity

Generic DTypeArg

Defined in Language.Haskell.TH.Desugar.Core

Associated Types

type Rep DTypeArg :: Type -> Type

Methods

from :: DTypeArg -> Rep DTypeArg x

to :: Rep DTypeArg x -> DTypeArg

Generic DFunArgs

Defined in Language.Haskell.TH.Desugar.Core

Associated Types

type Rep DFunArgs :: Type -> Type

Methods

from :: DFunArgs -> Rep DFunArgs x

to :: Rep DFunArgs x -> DFunArgs

Generic DVisFunArg

Defined in Language.Haskell.TH.Desugar.Core

Associated Types

type Rep DVisFunArg :: Type -> Type

Methods

from :: DVisFunArg -> Rep DVisFunArg x

to :: Rep DVisFunArg x -> DVisFunArg

Generic DExp

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DExp :: Type -> Type

Methods

from :: DExp -> Rep DExp x

to :: Rep DExp x -> DExp

Generic DPat

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DPat :: Type -> Type

Methods

from :: DPat -> Rep DPat x

to :: Rep DPat x -> DPat

Generic DType

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DType :: Type -> Type

Methods

from :: DType -> Rep DType x

to :: Rep DType x -> DType

Generic DTyVarBndr

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DTyVarBndr :: Type -> Type

Methods

from :: DTyVarBndr -> Rep DTyVarBndr x

to :: Rep DTyVarBndr x -> DTyVarBndr

Generic DMatch

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DMatch :: Type -> Type

Methods

from :: DMatch -> Rep DMatch x

to :: Rep DMatch x -> DMatch

Generic DClause

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DClause :: Type -> Type

Methods

from :: DClause -> Rep DClause x

to :: Rep DClause x -> DClause

Generic DLetDec

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DLetDec :: Type -> Type

Methods

from :: DLetDec -> Rep DLetDec x

to :: Rep DLetDec x -> DLetDec

Generic NewOrData

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep NewOrData :: Type -> Type

Methods

from :: NewOrData -> Rep NewOrData x

to :: Rep NewOrData x -> NewOrData

Generic DDec

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DDec :: Type -> Type

Methods

from :: DDec -> Rep DDec x

to :: Rep DDec x -> DDec

Generic DPatSynDir

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DPatSynDir :: Type -> Type

Methods

from :: DPatSynDir -> Rep DPatSynDir x

to :: Rep DPatSynDir x -> DPatSynDir

Generic DTypeFamilyHead

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DTypeFamilyHead :: Type -> Type

Methods

from :: DTypeFamilyHead -> Rep DTypeFamilyHead x

to :: Rep DTypeFamilyHead x -> DTypeFamilyHead

Generic DFamilyResultSig

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DFamilyResultSig :: Type -> Type

Methods

from :: DFamilyResultSig -> Rep DFamilyResultSig x

to :: Rep DFamilyResultSig x -> DFamilyResultSig

Generic DCon

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DCon :: Type -> Type

Methods

from :: DCon -> Rep DCon x

to :: Rep DCon x -> DCon

Generic DConFields

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DConFields :: Type -> Type

Methods

from :: DConFields -> Rep DConFields x

to :: Rep DConFields x -> DConFields

Generic DForeign

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DForeign :: Type -> Type

Methods

from :: DForeign -> Rep DForeign x

to :: Rep DForeign x -> DForeign

Generic DPragma

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DPragma :: Type -> Type

Methods

from :: DPragma -> Rep DPragma x

to :: Rep DPragma x -> DPragma

Generic DRuleBndr

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DRuleBndr :: Type -> Type

Methods

from :: DRuleBndr -> Rep DRuleBndr x

to :: Rep DRuleBndr x -> DRuleBndr

Generic DTySynEqn

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DTySynEqn :: Type -> Type

Methods

from :: DTySynEqn -> Rep DTySynEqn x

to :: Rep DTySynEqn x -> DTySynEqn

Generic DInfo

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DInfo :: Type -> Type

Methods

from :: DInfo -> Rep DInfo x

to :: Rep DInfo x -> DInfo

Generic DDerivClause

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DDerivClause :: Type -> Type

Methods

from :: DDerivClause -> Rep DDerivClause x

to :: Rep DDerivClause x -> DDerivClause

Generic DDerivStrategy

Defined in Language.Haskell.TH.Desugar.AST

Associated Types

type Rep DDerivStrategy :: Type -> Type

Methods

from :: DDerivStrategy -> Rep DDerivStrategy x

to :: Rep DDerivStrategy x -> DDerivStrategy

Generic ConstrRepr

Defined in Clash.Annotations.BitRepresentation

Associated Types

type Rep ConstrRepr :: Type -> Type

Methods

from :: ConstrRepr -> Rep ConstrRepr x

to :: Rep ConstrRepr x -> ConstrRepr

Generic DataReprAnn

Defined in Clash.Annotations.BitRepresentation

Associated Types

type Rep DataReprAnn :: Type -> Type

Methods

from :: DataReprAnn -> Rep DataReprAnn x

to :: Rep DataReprAnn x -> DataReprAnn

Generic ConstrRepr'

Defined in Clash.Annotations.BitRepresentation.Internal

Associated Types

type Rep ConstrRepr' :: Type -> Type

Methods

from :: ConstrRepr' -> Rep ConstrRepr' x

to :: Rep ConstrRepr' x -> ConstrRepr'

Generic DataRepr'

Defined in Clash.Annotations.BitRepresentation.Internal

Associated Types

type Rep DataRepr' :: Type -> Type

Methods

from :: DataRepr' -> Rep DataRepr' x

to :: Rep DataRepr' x -> DataRepr'

Generic Type'

Defined in Clash.Annotations.BitRepresentation.Internal

Associated Types

type Rep Type' :: Type -> Type

Methods

from :: Type' -> Rep Type' x

to :: Rep Type' x -> Type'

Generic PrimitiveWarning

Defined in Clash.Annotations.Primitive

Associated Types

type Rep PrimitiveWarning :: Type -> Type

Methods

from :: PrimitiveWarning -> Rep PrimitiveWarning x

to :: Rep PrimitiveWarning x -> PrimitiveWarning

Generic Primitive

Defined in Clash.Annotations.Primitive

Associated Types

type Rep Primitive :: Type -> Type

Methods

from :: Primitive -> Rep Primitive x

to :: Rep Primitive x -> Primitive

Generic HDL

Defined in Clash.Annotations.Primitive

Associated Types

type Rep HDL :: Type -> Type

Methods

from :: HDL -> Rep HDL x

to :: Rep HDL x -> HDL

Generic Bit

Defined in Clash.Sized.Internal.BitVector

Associated Types

type Rep Bit :: Type -> Type

Methods

from :: Bit -> Rep Bit x

to :: Rep Bit x -> Bit

Generic VDomainConfiguration

Defined in Clash.Signal.Internal

Associated Types

type Rep VDomainConfiguration :: Type -> Type

Methods

from :: VDomainConfiguration -> Rep VDomainConfiguration x

to :: Rep VDomainConfiguration x -> VDomainConfiguration

Generic InitBehavior

Defined in Clash.Signal.Internal

Associated Types

type Rep InitBehavior :: Type -> Type

Methods

from :: InitBehavior -> Rep InitBehavior x

to :: Rep InitBehavior x -> InitBehavior

Generic ResetPolarity

Defined in Clash.Signal.Internal

Associated Types

type Rep ResetPolarity :: Type -> Type

Methods

from :: ResetPolarity -> Rep ResetPolarity x

to :: Rep ResetPolarity x -> ResetPolarity

Generic ResetKind

Defined in Clash.Signal.Internal

Associated Types

type Rep ResetKind :: Type -> Type

Methods

from :: ResetKind -> Rep ResetKind x

to :: Rep ResetKind x -> ResetKind

Generic ActiveEdge

Defined in Clash.Signal.Internal

Associated Types

type Rep ActiveEdge :: Type -> Type

Methods

from :: ActiveEdge -> Rep ActiveEdge x

to :: Rep ActiveEdge x -> ActiveEdge

Generic PortName

Defined in Clash.Annotations.TopEntity

Associated Types

type Rep PortName :: Type -> Type

Methods

from :: PortName -> Rep PortName x

to :: Rep PortName x -> PortName

Generic TopEntity

Defined in Clash.Annotations.TopEntity

Associated Types

type Rep TopEntity :: Type -> Type

Methods

from :: TopEntity -> Rep TopEntity x

to :: Rep TopEntity x -> TopEntity

Generic RxReg

Defined in Clash.Examples.Internal

Associated Types

type Rep RxReg :: Type -> Type

Methods

from :: RxReg -> Rep RxReg x

to :: Rep RxReg x -> RxReg

Generic TxReg

Defined in Clash.Examples.Internal

Associated Types

type Rep TxReg :: Type -> Type

Methods

from :: TxReg -> Rep TxReg x

to :: Rep TxReg x -> TxReg

Generic [a]

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep [a] :: Type -> Type

Methods

from :: [a] -> Rep [a] x

to :: Rep [a] x -> [a]

Generic (Maybe a)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (Maybe a) :: Type -> Type

Methods

from :: Maybe a -> Rep (Maybe a) x

to :: Rep (Maybe a) x -> Maybe a

Generic (Par1 p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (Par1 p) :: Type -> Type

Methods

from :: Par1 p -> Rep (Par1 p) x

to :: Rep (Par1 p) x -> Par1 p

Generic (Solo a)

Defined in Data.Tuple.Solo

Associated Types

type Rep (Solo a) :: Type -> Type

Methods

from :: Solo a -> Rep (Solo a) x

to :: Rep (Solo a) x -> Solo a

Generic (Complex a)

Since: base-4.9.0.0

Defined in Data.Complex

Associated Types

type Rep (Complex a) :: Type -> Type

Methods

from :: Complex a -> Rep (Complex a) x

to :: Rep (Complex a) x -> Complex a

Generic (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Min a) :: Type -> Type

Methods

from :: Min a -> Rep (Min a) x

to :: Rep (Min a) x -> Min a

Generic (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Max a) :: Type -> Type

Methods

from :: Max a -> Rep (Max a) x

to :: Rep (Max a) x -> Max a

Generic (First a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (First a) :: Type -> Type

Methods

from :: First a -> Rep (First a) x

to :: Rep (First a) x -> First a

Generic (Last a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Last a) :: Type -> Type

Methods

from :: Last a -> Rep (Last a) x

to :: Rep (Last a) x -> Last a

Generic (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (WrappedMonoid m) :: Type -> Type

Methods

from :: WrappedMonoid m -> Rep (WrappedMonoid m) x

to :: Rep (WrappedMonoid m) x -> WrappedMonoid m

Generic (Option a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Option a) :: Type -> Type

Methods

from :: Option a -> Rep (Option a) x

to :: Rep (Option a) x -> Option a

Generic (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep (ZipList a) :: Type -> Type

Methods

from :: ZipList a -> Rep (ZipList a) x

to :: Rep (ZipList a) x -> ZipList a

Generic (Identity a)

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Associated Types

type Rep (Identity a) :: Type -> Type

Methods

from :: Identity a -> Rep (Identity a) x

to :: Rep (Identity a) x -> Identity a

Generic (First a)

Since: base-4.7.0.0

Defined in Data.Monoid

Associated Types

type Rep (First a) :: Type -> Type

Methods

from :: First a -> Rep (First a) x

to :: Rep (First a) x -> First a

Generic (Last a)

Since: base-4.7.0.0

Defined in Data.Monoid

Associated Types

type Rep (Last a) :: Type -> Type

Methods

from :: Last a -> Rep (Last a) x

to :: Rep (Last a) x -> Last a

Generic (Dual a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Dual a) :: Type -> Type

Methods

from :: Dual a -> Rep (Dual a) x

to :: Rep (Dual a) x -> Dual a

Generic (Endo a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Endo a) :: Type -> Type

Methods

from :: Endo a -> Rep (Endo a) x

to :: Rep (Endo a) x -> Endo a

Generic (Sum a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Sum a) :: Type -> Type

Methods

from :: Sum a -> Rep (Sum a) x

to :: Rep (Sum a) x -> Sum a

Generic (Product a)

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Product a) :: Type -> Type

Methods

from :: Product a -> Rep (Product a) x

to :: Rep (Product a) x -> Product a

Generic (Down a)

Since: base-4.12.0.0

Defined in GHC.Generics

Associated Types

type Rep (Down a) :: Type -> Type

Methods

from :: Down a -> Rep (Down a) x

to :: Rep (Down a) x -> Down a

Generic (NonEmpty a)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (NonEmpty a) :: Type -> Type

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x

to :: Rep (NonEmpty a) x -> NonEmpty a

Generic (Tree a)

Since: containers-0.5.8

Defined in Data.Tree

Associated Types

type Rep (Tree a) :: Type -> Type

Methods

from :: Tree a -> Rep (Tree a) x

to :: Rep (Tree a) x -> Tree a

Generic (FingerTree a)

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep (FingerTree a) :: Type -> Type

Methods

from :: FingerTree a -> Rep (FingerTree a) x

to :: Rep (FingerTree a) x -> FingerTree a

Generic (Digit a)

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep (Digit a) :: Type -> Type

Methods

from :: Digit a -> Rep (Digit a) x

to :: Rep (Digit a) x -> Digit a

Generic (Node a)

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep (Node a) :: Type -> Type

Methods

from :: Node a -> Rep (Node a) x

to :: Rep (Node a) x -> Node a

Generic (Elem a)

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep (Elem a) :: Type -> Type

Methods

from :: Elem a -> Rep (Elem a) x

to :: Rep (Elem a) x -> Elem a

Generic (ViewL a)

Since: containers-0.5.8

Defined in Data.Sequence.Internal

Associated Types

type Rep (ViewL a) :: Type -> Type

Methods

from :: ViewL a -> Rep (ViewL a) x

to :: Rep (ViewL a) x -> ViewL a

Generic (ViewR a)

Since: containers-0.5.8

Defined in Data.Sequence.Internal

Associated Types

type Rep (ViewR a) :: Type -> Type

Methods

from :: ViewR a -> Rep (ViewR a) x

to :: Rep (ViewR a) x -> ViewR a

Generic (Fix f)

Defined in Data.Fix

Associated Types

type Rep (Fix f) :: Type -> Type

Methods

from :: Fix f -> Rep (Fix f) x

to :: Rep (Fix f) x -> Fix f

Generic (ModuleName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModuleName l) :: Type -> Type

Methods

from :: ModuleName l -> Rep (ModuleName l) x

to :: Rep (ModuleName l) x -> ModuleName l

Generic (SpecialCon l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (SpecialCon l) :: Type -> Type

Methods

from :: SpecialCon l -> Rep (SpecialCon l) x

to :: Rep (SpecialCon l) x -> SpecialCon l

Generic (QName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QName l) :: Type -> Type

Methods

from :: QName l -> Rep (QName l) x

to :: Rep (QName l) x -> QName l

Generic (Name l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Name l) :: Type -> Type

Methods

from :: Name l -> Rep (Name l) x

to :: Rep (Name l) x -> Name l

Generic (IPName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (IPName l) :: Type -> Type

Methods

from :: IPName l -> Rep (IPName l) x

to :: Rep (IPName l) x -> IPName l

Generic (QOp l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QOp l) :: Type -> Type

Methods

from :: QOp l -> Rep (QOp l) x

to :: Rep (QOp l) x -> QOp l

Generic (Op l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Op l) :: Type -> Type

Methods

from :: Op l -> Rep (Op l) x

to :: Rep (Op l) x -> Op l

Generic (CName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (CName l) :: Type -> Type

Methods

from :: CName l -> Rep (CName l) x

to :: Rep (CName l) x -> CName l

Generic (Module l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Module l) :: Type -> Type

Methods

from :: Module l -> Rep (Module l) x

to :: Rep (Module l) x -> Module l

Generic (ModuleHead l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModuleHead l) :: Type -> Type

Methods

from :: ModuleHead l -> Rep (ModuleHead l) x

to :: Rep (ModuleHead l) x -> ModuleHead l

Generic (ExportSpecList l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ExportSpecList l) :: Type -> Type

Methods

from :: ExportSpecList l -> Rep (ExportSpecList l) x

to :: Rep (ExportSpecList l) x -> ExportSpecList l

Generic (ExportSpec l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ExportSpec l) :: Type -> Type

Methods

from :: ExportSpec l -> Rep (ExportSpec l) x

to :: Rep (ExportSpec l) x -> ExportSpec l

Generic (EWildcard l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (EWildcard l) :: Type -> Type

Methods

from :: EWildcard l -> Rep (EWildcard l) x

to :: Rep (EWildcard l) x -> EWildcard l

Generic (Namespace l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Namespace l) :: Type -> Type

Methods

from :: Namespace l -> Rep (Namespace l) x

to :: Rep (Namespace l) x -> Namespace l

Generic (ImportDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportDecl l) :: Type -> Type

Methods

from :: ImportDecl l -> Rep (ImportDecl l) x

to :: Rep (ImportDecl l) x -> ImportDecl l

Generic (ImportSpecList l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportSpecList l) :: Type -> Type

Methods

from :: ImportSpecList l -> Rep (ImportSpecList l) x

to :: Rep (ImportSpecList l) x -> ImportSpecList l

Generic (ImportSpec l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportSpec l) :: Type -> Type

Methods

from :: ImportSpec l -> Rep (ImportSpec l) x

to :: Rep (ImportSpec l) x -> ImportSpec l

Generic (Assoc l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Assoc l) :: Type -> Type

Methods

from :: Assoc l -> Rep (Assoc l) x

to :: Rep (Assoc l) x -> Assoc l

Generic (Decl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Decl l) :: Type -> Type

Methods

from :: Decl l -> Rep (Decl l) x

to :: Rep (Decl l) x -> Decl l

Generic (PatternSynDirection l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PatternSynDirection l) :: Type -> Type

Methods

from :: PatternSynDirection l -> Rep (PatternSynDirection l) x

to :: Rep (PatternSynDirection l) x -> PatternSynDirection l

Generic (TypeEqn l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (TypeEqn l) :: Type -> Type

Methods

from :: TypeEqn l -> Rep (TypeEqn l) x

to :: Rep (TypeEqn l) x -> TypeEqn l

Generic (Annotation l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Annotation l) :: Type -> Type

Methods

from :: Annotation l -> Rep (Annotation l) x

to :: Rep (Annotation l) x -> Annotation l

Generic (BooleanFormula l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (BooleanFormula l) :: Type -> Type

Methods

from :: BooleanFormula l -> Rep (BooleanFormula l) x

to :: Rep (BooleanFormula l) x -> BooleanFormula l

Generic (Role l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Role l) :: Type -> Type

Methods

from :: Role l -> Rep (Role l) x

to :: Rep (Role l) x -> Role l

Generic (DataOrNew l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DataOrNew l) :: Type -> Type

Methods

from :: DataOrNew l -> Rep (DataOrNew l) x

to :: Rep (DataOrNew l) x -> DataOrNew l

Generic (InjectivityInfo l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InjectivityInfo l) :: Type -> Type

Methods

from :: InjectivityInfo l -> Rep (InjectivityInfo l) x

to :: Rep (InjectivityInfo l) x -> InjectivityInfo l

Generic (ResultSig l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ResultSig l) :: Type -> Type

Methods

from :: ResultSig l -> Rep (ResultSig l) x

to :: Rep (ResultSig l) x -> ResultSig l

Generic (DeclHead l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DeclHead l) :: Type -> Type

Methods

from :: DeclHead l -> Rep (DeclHead l) x

to :: Rep (DeclHead l) x -> DeclHead l

Generic (InstRule l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstRule l) :: Type -> Type

Methods

from :: InstRule l -> Rep (InstRule l) x

to :: Rep (InstRule l) x -> InstRule l

Generic (InstHead l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstHead l) :: Type -> Type

Methods

from :: InstHead l -> Rep (InstHead l) x

to :: Rep (InstHead l) x -> InstHead l

Generic (Deriving l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Deriving l) :: Type -> Type

Methods

from :: Deriving l -> Rep (Deriving l) x

to :: Rep (Deriving l) x -> Deriving l

Generic (DerivStrategy l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DerivStrategy l) :: Type -> Type

Methods

from :: DerivStrategy l -> Rep (DerivStrategy l) x

to :: Rep (DerivStrategy l) x -> DerivStrategy l

Generic (Binds l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Binds l) :: Type -> Type

Methods

from :: Binds l -> Rep (Binds l) x

to :: Rep (Binds l) x -> Binds l

Generic (IPBind l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (IPBind l) :: Type -> Type

Methods

from :: IPBind l -> Rep (IPBind l) x

to :: Rep (IPBind l) x -> IPBind l

Generic (Match l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Match l) :: Type -> Type

Methods

from :: Match l -> Rep (Match l) x

to :: Rep (Match l) x -> Match l

Generic (QualConDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QualConDecl l) :: Type -> Type

Methods

from :: QualConDecl l -> Rep (QualConDecl l) x

to :: Rep (QualConDecl l) x -> QualConDecl l

Generic (ConDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ConDecl l) :: Type -> Type

Methods

from :: ConDecl l -> Rep (ConDecl l) x

to :: Rep (ConDecl l) x -> ConDecl l

Generic (FieldDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FieldDecl l) :: Type -> Type

Methods

from :: FieldDecl l -> Rep (FieldDecl l) x

to :: Rep (FieldDecl l) x -> FieldDecl l

Generic (GadtDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (GadtDecl l) :: Type -> Type

Methods

from :: GadtDecl l -> Rep (GadtDecl l) x

to :: Rep (GadtDecl l) x -> GadtDecl l

Generic (ClassDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ClassDecl l) :: Type -> Type

Methods

from :: ClassDecl l -> Rep (ClassDecl l) x

to :: Rep (ClassDecl l) x -> ClassDecl l

Generic (InstDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstDecl l) :: Type -> Type

Methods

from :: InstDecl l -> Rep (InstDecl l) x

to :: Rep (InstDecl l) x -> InstDecl l

Generic (BangType l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (BangType l) :: Type -> Type

Methods

from :: BangType l -> Rep (BangType l) x

to :: Rep (BangType l) x -> BangType l

Generic (Unpackedness l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Unpackedness l) :: Type -> Type

Methods

from :: Unpackedness l -> Rep (Unpackedness l) x

to :: Rep (Unpackedness l) x -> Unpackedness l

Generic (Rhs l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Rhs l) :: Type -> Type

Methods

from :: Rhs l -> Rep (Rhs l) x

to :: Rep (Rhs l) x -> Rhs l

Generic (GuardedRhs l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (GuardedRhs l) :: Type -> Type

Methods

from :: GuardedRhs l -> Rep (GuardedRhs l) x

to :: Rep (GuardedRhs l) x -> GuardedRhs l

Generic (Type l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Type l) :: Type -> Type

Methods

from :: Type l -> Rep (Type l) x

to :: Rep (Type l) x -> Type l

Generic (MaybePromotedName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (MaybePromotedName l) :: Type -> Type

Methods

from :: MaybePromotedName l -> Rep (MaybePromotedName l) x

to :: Rep (MaybePromotedName l) x -> MaybePromotedName l

Generic (Promoted l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Promoted l) :: Type -> Type

Methods

from :: Promoted l -> Rep (Promoted l) x

to :: Rep (Promoted l) x -> Promoted l

Generic (TyVarBind l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (TyVarBind l) :: Type -> Type

Methods

from :: TyVarBind l -> Rep (TyVarBind l) x

to :: Rep (TyVarBind l) x -> TyVarBind l

Generic (FunDep l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FunDep l) :: Type -> Type

Methods

from :: FunDep l -> Rep (FunDep l) x

to :: Rep (FunDep l) x -> FunDep l

Generic (Context l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Context l) :: Type -> Type

Methods

from :: Context l -> Rep (Context l) x

to :: Rep (Context l) x -> Context l

Generic (Asst l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Asst l) :: Type -> Type

Methods

from :: Asst l -> Rep (Asst l) x

to :: Rep (Asst l) x -> Asst l

Generic (Literal l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Literal l) :: Type -> Type

Methods

from :: Literal l -> Rep (Literal l) x

to :: Rep (Literal l) x -> Literal l

Generic (Sign l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Sign l) :: Type -> Type

Methods

from :: Sign l -> Rep (Sign l) x

to :: Rep (Sign l) x -> Sign l

Generic (Exp l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Exp l) :: Type -> Type

Methods

from :: Exp l -> Rep (Exp l) x

to :: Rep (Exp l) x -> Exp l

Generic (XName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (XName l) :: Type -> Type

Methods

from :: XName l -> Rep (XName l) x

to :: Rep (XName l) x -> XName l

Generic (XAttr l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (XAttr l) :: Type -> Type

Methods

from :: XAttr l -> Rep (XAttr l) x

to :: Rep (XAttr l) x -> XAttr l

Generic (Bracket l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Bracket l) :: Type -> Type

Methods

from :: Bracket l -> Rep (Bracket l) x

to :: Rep (Bracket l) x -> Bracket l

Generic (Splice l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Splice l) :: Type -> Type

Methods

from :: Splice l -> Rep (Splice l) x

to :: Rep (Splice l) x -> Splice l

Generic (Safety l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Safety l) :: Type -> Type

Methods

from :: Safety l -> Rep (Safety l) x

to :: Rep (Safety l) x -> Safety l

Generic (CallConv l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (CallConv l) :: Type -> Type

Methods

from :: CallConv l -> Rep (CallConv l) x

to :: Rep (CallConv l) x -> CallConv l

Generic (ModulePragma l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModulePragma l) :: Type -> Type

Methods

from :: ModulePragma l -> Rep (ModulePragma l) x

to :: Rep (ModulePragma l) x -> ModulePragma l

Generic (Overlap l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Overlap l) :: Type -> Type

Methods

from :: Overlap l -> Rep (Overlap l) x

to :: Rep (Overlap l) x -> Overlap l

Generic (Activation l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Activation l) :: Type -> Type

Methods

from :: Activation l -> Rep (Activation l) x

to :: Rep (Activation l) x -> Activation l

Generic (Rule l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Rule l) :: Type -> Type

Methods

from :: Rule l -> Rep (Rule l) x

to :: Rep (Rule l) x -> Rule l

Generic (RuleVar l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RuleVar l) :: Type -> Type

Methods

from :: RuleVar l -> Rep (RuleVar l) x

to :: Rep (RuleVar l) x -> RuleVar l

Generic (WarningText l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (WarningText l) :: Type -> Type

Methods

from :: WarningText l -> Rep (WarningText l) x

to :: Rep (WarningText l) x -> WarningText l

Generic (Pat l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Pat l) :: Type -> Type

Methods

from :: Pat l -> Rep (Pat l) x

to :: Rep (Pat l) x -> Pat l

Generic (PXAttr l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PXAttr l) :: Type -> Type

Methods

from :: PXAttr l -> Rep (PXAttr l) x

to :: Rep (PXAttr l) x -> PXAttr l

Generic (RPatOp l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RPatOp l) :: Type -> Type

Methods

from :: RPatOp l -> Rep (RPatOp l) x

to :: Rep (RPatOp l) x -> RPatOp l

Generic (RPat l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RPat l) :: Type -> Type

Methods

from :: RPat l -> Rep (RPat l) x

to :: Rep (RPat l) x -> RPat l

Generic (PatField l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PatField l) :: Type -> Type

Methods

from :: PatField l -> Rep (PatField l) x

to :: Rep (PatField l) x -> PatField l

Generic (Stmt l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Stmt l) :: Type -> Type

Methods

from :: Stmt l -> Rep (Stmt l) x

to :: Rep (Stmt l) x -> Stmt l

Generic (QualStmt l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QualStmt l) :: Type -> Type

Methods

from :: QualStmt l -> Rep (QualStmt l) x

to :: Rep (QualStmt l) x -> QualStmt l

Generic (FieldUpdate l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FieldUpdate l) :: Type -> Type

Methods

from :: FieldUpdate l -> Rep (FieldUpdate l) x

to :: Rep (FieldUpdate l) x -> FieldUpdate l

Generic (Alt l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Alt l) :: Type -> Type

Methods

from :: Alt l -> Rep (Alt l) x

to :: Rep (Alt l) x -> Alt l

Generic (Loc a)

Defined in Language.Haskell.Exts.SrcLoc

Associated Types

type Rep (Loc a) :: Type -> Type

Methods

from :: Loc a -> Rep (Loc a) x

to :: Rep (Loc a) x -> Loc a

Generic (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep (Doc a) :: Type -> Type

Methods

from :: Doc a -> Rep (Doc a) x

to :: Rep (Doc a) x -> Doc a

Generic (Maybe a)

Defined in Data.Strict.Maybe

Associated Types

type Rep (Maybe a) :: Type -> Type

Methods

from :: Maybe a -> Rep (Maybe a) x

to :: Rep (Maybe a) x -> Maybe a

Generic (PrimitiveGuard a)

Defined in Clash.Annotations.Primitive

Associated Types

type Rep (PrimitiveGuard a) :: Type -> Type

Methods

from :: PrimitiveGuard a -> Rep (PrimitiveGuard a) x

to :: Rep (PrimitiveGuard a) x -> PrimitiveGuard a

Generic (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Associated Types

type Rep (BitVector n) :: Type -> Type

Methods

from :: BitVector n -> Rep (BitVector n) x

to :: Rep (BitVector n) x -> BitVector n

Generic (Index n)

Defined in Clash.Sized.Internal.Index

Associated Types

type Rep (Index n) :: Type -> Type

Methods

from :: Index n -> Rep (Index n) x

to :: Rep (Index n) x -> Index n

Generic (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Associated Types

type Rep (Unsigned n) :: Type -> Type

Methods

from :: Unsigned n -> Rep (Unsigned n) x

to :: Rep (Unsigned n) x -> Unsigned n

Generic (Signed n)

Defined in Clash.Sized.Internal.Signed

Associated Types

type Rep (Signed n) :: Type -> Type

Methods

from :: Signed n -> Rep (Signed n) x

to :: Rep (Signed n) x -> Signed n

Generic (Overflowing a)

Defined in Clash.Num.Overflowing

Associated Types

type Rep (Overflowing a) :: Type -> Type

Methods

from :: Overflowing a -> Rep (Overflowing a) x

to :: Rep (Overflowing a) x -> Overflowing a

Generic (Either a b)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (Either a b) :: Type -> Type

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Generic (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (V1 p) :: Type -> Type

Methods

from :: V1 p -> Rep (V1 p) x

to :: Rep (V1 p) x -> V1 p

Generic (U1 p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (U1 p) :: Type -> Type

Methods

from :: U1 p -> Rep (U1 p) x

to :: Rep (U1 p) x -> U1 p

Generic (a, b)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b) :: Type -> Type

Methods

from :: (a, b) -> Rep (a, b) x

to :: Rep (a, b) x -> (a, b)

Generic (Arg a b)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep (Arg a b) :: Type -> Type

Methods

from :: Arg a b -> Rep (Arg a b) x

to :: Rep (Arg a b) x -> Arg a b

Generic (WrappedMonad m a)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep (WrappedMonad m a) :: Type -> Type

Methods

from :: WrappedMonad m a -> Rep (WrappedMonad m a) x

to :: Rep (WrappedMonad m a) x -> WrappedMonad m a

Generic (Proxy t)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (Proxy t) :: Type -> Type

Methods

from :: Proxy t -> Rep (Proxy t) x

to :: Rep (Proxy t) x -> Proxy t

Generic (Cofree f a)

Defined in Control.Comonad.Cofree

Associated Types

type Rep (Cofree f a) :: Type -> Type

Methods

from :: Cofree f a -> Rep (Cofree f a) x

to :: Rep (Cofree f a) x -> Cofree f a

Generic (Free f a)

Defined in Control.Monad.Free

Associated Types

type Rep (Free f a) :: Type -> Type

Methods

from :: Free f a -> Rep (Free f a) x

to :: Rep (Free f a) x -> Free f a

Generic (ListF a b)

Defined in Data.Functor.Base

Associated Types

type Rep (ListF a b) :: Type -> Type

Methods

from :: ListF a b -> Rep (ListF a b) x

to :: Rep (ListF a b) x -> ListF a b

Generic (NonEmptyF a b)

Defined in Data.Functor.Base

Associated Types

type Rep (NonEmptyF a b) :: Type -> Type

Methods

from :: NonEmptyF a b -> Rep (NonEmptyF a b) x

to :: Rep (NonEmptyF a b) x -> NonEmptyF a b

Generic (TreeF a b)

Defined in Data.Functor.Base

Associated Types

type Rep (TreeF a b) :: Type -> Type

Methods

from :: TreeF a b -> Rep (TreeF a b) x

to :: Rep (TreeF a b) x -> TreeF a b

Generic (Pair a b)

Defined in Data.Strict.Tuple

Associated Types

type Rep (Pair a b) :: Type -> Type

Methods

from :: Pair a b -> Rep (Pair a b) x

to :: Rep (Pair a b) x -> Pair a b

Generic (These a b)

Defined in Data.Strict.These

Associated Types

type Rep (These a b) :: Type -> Type

Methods

from :: These a b -> Rep (These a b) x

to :: Rep (These a b) x -> These a b

Generic (Either a b)

Defined in Data.Strict.Either

Associated Types

type Rep (Either a b) :: Type -> Type

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Generic (These a b)

Defined in Data.These

Associated Types

type Rep (These a b) :: Type -> Type

Methods

from :: These a b -> Rep (These a b) x

to :: Rep (These a b) x -> These a b

KnownNat n => Generic (Vec n a)

In many cases, this Generic instance only allows generic functions/instances over vectors of at least size 1, due to the n-1 in the Rep (Vec n a) definition.

We'll have to wait for things like https://ryanglscott.github.io/2018/02/11/how-to-derive-generic-for-some-gadts/ before we can work around this limitation

Defined in Clash.Sized.Vector

Associated Types

type Rep (Vec n a) :: Type -> Type

Methods

from :: Vec n a -> Rep (Vec n a) x

to :: Rep (Vec n a) x -> Vec n a

Generic (RamOp n a)

Defined in Clash.Explicit.BlockRam

Associated Types

type Rep (RamOp n a) :: Type -> Type

Methods

from :: RamOp n a -> Rep (RamOp n a) x

to :: Rep (RamOp n a) x -> RamOp n a

Generic (Rec1 f p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (Rec1 f p) :: Type -> Type

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x

to :: Rep (Rec1 f p) x -> Rec1 f p

Generic (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Generic (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Char p) :: Type -> Type

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

Generic (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: Type -> Type

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

Generic (URec Float p)

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: Type -> Type

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

Generic (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Int p) :: Type -> Type

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

Generic (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep (URec Word p) :: Type -> Type

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

Generic (a, b, c)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c) :: Type -> Type

Methods

from :: (a, b, c) -> Rep (a, b, c) x

to :: Rep (a, b, c) x -> (a, b, c)

Generic (Kleisli m a b)

Since: base-4.14.0.0

Defined in Control.Arrow

Associated Types

type Rep (Kleisli m a b) :: Type -> Type

Methods

from :: Kleisli m a b -> Rep (Kleisli m a b) x

to :: Rep (Kleisli m a b) x -> Kleisli m a b

Generic (WrappedArrow a b c)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep (WrappedArrow a b c) :: Type -> Type

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c

Generic (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Associated Types

type Rep (Const a b) :: Type -> Type

Methods

from :: Const a b -> Rep (Const a b) x

to :: Rep (Const a b) x -> Const a b

Generic (Ap f a)

Since: base-4.12.0.0

Defined in Data.Monoid

Associated Types

type Rep (Ap f a) :: Type -> Type

Methods

from :: Ap f a -> Rep (Ap f a) x

to :: Rep (Ap f a) x -> Ap f a

Generic (Alt f a)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Alt f a) :: Type -> Type

Methods

from :: Alt f a -> Rep (Alt f a) x

to :: Rep (Alt f a) x -> Alt f a

Generic (Join p a)

Defined in Data.Bifunctor.Join

Associated Types

type Rep (Join p a) :: Type -> Type

Methods

from :: Join p a -> Rep (Join p a) x

to :: Rep (Join p a) x -> Join p a

Generic (Fix p a)

Defined in Data.Bifunctor.Fix

Associated Types

type Rep (Fix p a) :: Type -> Type

Methods

from :: Fix p a -> Rep (Fix p a) x

to :: Rep (Fix p a) x -> Fix p a

Generic (FreeF f a b)

Defined in Control.Monad.Trans.Free

Associated Types

type Rep (FreeF f a b) :: Type -> Type

Methods

from :: FreeF f a b -> Rep (FreeF f a b) x

to :: Rep (FreeF f a b) x -> FreeF f a b

Generic (CofreeF f a b)

Defined in Control.Comonad.Trans.Cofree

Associated Types

type Rep (CofreeF f a b) :: Type -> Type

Methods

from :: CofreeF f a b -> Rep (CofreeF f a b) x

to :: Rep (CofreeF f a b) x -> CofreeF f a b

Generic (Tagged s b)

Defined in Data.Tagged

Associated Types

type Rep (Tagged s b) :: Type -> Type

Methods

from :: Tagged s b -> Rep (Tagged s b) x

to :: Rep (Tagged s b) x -> Tagged s b

Generic (K1 i c p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (K1 i c p) :: Type -> Type

Methods

from :: K1 i c p -> Rep (K1 i c p) x

to :: Rep (K1 i c p) x -> K1 i c p

Generic ((f :+: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep ((f :+: g) p) :: Type -> Type

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x

to :: Rep ((f :+: g) p) x -> (f :+: g) p

Generic ((f :*: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep ((f :*: g) p) :: Type -> Type

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x

to :: Rep ((f :*: g) p) x -> (f :*: g) p

Generic (a, b, c, d)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d) :: Type -> Type

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x

to :: Rep (a, b, c, d) x -> (a, b, c, d)

Generic (Product f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Associated Types

type Rep (Product f g a) :: Type -> Type

Methods

from :: Product f g a -> Rep (Product f g a) x

to :: Rep (Product f g a) x -> Product f g a

Generic (Sum f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Associated Types

type Rep (Sum f g a) :: Type -> Type

Methods

from :: Sum f g a -> Rep (Sum f g a) x

to :: Rep (Sum f g a) x -> Sum f g a

Generic (M1 i c f p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep (M1 i c f p) :: Type -> Type

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x

to :: Rep (M1 i c f p) x -> M1 i c f p

Generic ((f :.: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Associated Types

type Rep ((f :.: g) p) :: Type -> Type

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x

to :: Rep ((f :.: g) p) x -> (f :.: g) p

Generic (a, b, c, d, e)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e) :: Type -> Type

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e)

Generic (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Associated Types

type Rep (Compose f g a) :: Type -> Type

Methods

from :: Compose f g a -> Rep (Compose f g a) x

to :: Rep (Compose f g a) x -> Compose f g a

Generic (WrappedBifunctor p a b)

Defined in Data.Bifunctor.Wrapped

Associated Types

type Rep (WrappedBifunctor p a b) :: Type -> Type

Methods

from :: WrappedBifunctor p a b -> Rep (WrappedBifunctor p a b) x

to :: Rep (WrappedBifunctor p a b) x -> WrappedBifunctor p a b

Generic (Joker g a b)

Defined in Data.Bifunctor.Joker

Associated Types

type Rep (Joker g a b) :: Type -> Type

Methods

from :: Joker g a b -> Rep (Joker g a b) x

to :: Rep (Joker g a b) x -> Joker g a b

Generic (Flip p a b)

Defined in Data.Bifunctor.Flip

Associated Types

type Rep (Flip p a b) :: Type -> Type

Methods

from :: Flip p a b -> Rep (Flip p a b) x

to :: Rep (Flip p a b) x -> Flip p a b

Generic (Clown f a b)

Defined in Data.Bifunctor.Clown

Associated Types

type Rep (Clown f a b) :: Type -> Type

Methods

from :: Clown f a b -> Rep (Clown f a b) x

to :: Rep (Clown f a b) x -> Clown f a b

Generic (a, b, c, d, e, f)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f) :: Type -> Type

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f)

Generic (Sum p q a b)

Defined in Data.Bifunctor.Sum

Associated Types

type Rep (Sum p q a b) :: Type -> Type

Methods

from :: Sum p q a b -> Rep (Sum p q a b) x

to :: Rep (Sum p q a b) x -> Sum p q a b

Generic (Product f g a b)

Defined in Data.Bifunctor.Product

Associated Types

type Rep (Product f g a b) :: Type -> Type

Methods

from :: Product f g a b -> Rep (Product f g a b) x

to :: Rep (Product f g a b) x -> Product f g a b

Generic (a, b, c, d, e, f, g)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g)

Generic (Tannen f p a b)

Defined in Data.Bifunctor.Tannen

Associated Types

type Rep (Tannen f p a b) :: Type -> Type

Methods

from :: Tannen f p a b -> Rep (Tannen f p a b) x

to :: Rep (Tannen f p a b) x -> Tannen f p a b

Generic (Biff p f g a b)

Defined in Data.Bifunctor.Biff

Associated Types

type Rep (Biff p f g a b) :: Type -> Type

Methods

from :: Biff p f g a b -> Rep (Biff p f g a b) x

to :: Rep (Biff p f g a b) x -> Biff p f g a b

class Generic1 (f :: k -> Type)

Representable types of kind * -> * (or kind k -> *, when PolyKinds is enabled). This class is derivable in GHC with the DeriveGeneric flag on.

A Generic1 instance must satisfy the following laws:

from1 . to1 ≡ id
to1 . from1 ≡ id

Minimal complete definition

from1, to1

Instances

Generic1 (V1 :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 V1 :: k -> Type

Methods

from1 :: forall (a :: k0). V1 a -> Rep1 V1 a

to1 :: forall (a :: k0). Rep1 V1 a -> V1 a

Generic1 (U1 :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 U1 :: k -> Type

Methods

from1 :: forall (a :: k0). U1 a -> Rep1 U1 a

to1 :: forall (a :: k0). Rep1 U1 a -> U1 a

Generic1 (Proxy :: k -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 Proxy :: k -> Type

Methods

from1 :: forall (a :: k0). Proxy a -> Rep1 Proxy a

to1 :: forall (a :: k0). Rep1 Proxy a -> Proxy a

Generic1 (Alt f :: k -> Type)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep1 (Alt f) :: k -> Type

Methods

from1 :: forall (a :: k0). Alt f a -> Rep1 (Alt f) a

to1 :: forall (a :: k0). Rep1 (Alt f) a -> Alt f a

Generic1 (Ap f :: k -> Type)

Since: base-4.12.0.0

Defined in Data.Monoid

Associated Types

type Rep1 (Ap f) :: k -> Type

Methods

from1 :: forall (a :: k0). Ap f a -> Rep1 (Ap f) a

to1 :: forall (a :: k0). Rep1 (Ap f) a -> Ap f a

Generic1 (Const a :: k -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Associated Types

type Rep1 (Const a) :: k -> Type

Methods

from1 :: forall (a0 :: k0). Const a a0 -> Rep1 (Const a) a0

to1 :: forall (a0 :: k0). Rep1 (Const a) a0 -> Const a a0

Generic1 (URec (Ptr ()) :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec (Ptr ())) :: k -> Type

Methods

from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a

to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a

Generic1 (URec Char :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Char) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a

to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a

Generic1 (URec Double :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Double) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a

to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a

Generic1 (URec Float :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Float) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a

to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a

Generic1 (URec Int :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Int) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a

to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a

Generic1 (URec Word :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (URec Word) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a

to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a

Generic1 (Rec1 f :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (Rec1 f) :: k -> Type

Methods

from1 :: forall (a :: k0). Rec1 f a -> Rep1 (Rec1 f) a

to1 :: forall (a :: k0). Rep1 (Rec1 f) a -> Rec1 f a

Generic1 (Sum f g :: k -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Associated Types

type Rep1 (Sum f g) :: k -> Type

Methods

from1 :: forall (a :: k0). Sum f g a -> Rep1 (Sum f g) a

to1 :: forall (a :: k0). Rep1 (Sum f g) a -> Sum f g a

Generic1 (Product f g :: k -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Associated Types

type Rep1 (Product f g) :: k -> Type

Methods

from1 :: forall (a :: k0). Product f g a -> Rep1 (Product f g) a

to1 :: forall (a :: k0). Rep1 (Product f g) a -> Product f g a

Generic1 (K1 i c :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (K1 i c) :: k -> Type

Methods

from1 :: forall (a :: k0). K1 i c a -> Rep1 (K1 i c) a

to1 :: forall (a :: k0). Rep1 (K1 i c) a -> K1 i c a

Generic1 (f :+: g :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (f :+: g) :: k -> Type

Methods

from1 :: forall (a :: k0). (f :+: g) a -> Rep1 (f :+: g) a

to1 :: forall (a :: k0). Rep1 (f :+: g) a -> (f :+: g) a

Generic1 (f :*: g :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (f :*: g) :: k -> Type

Methods

from1 :: forall (a :: k0). (f :*: g) a -> Rep1 (f :*: g) a

to1 :: forall (a :: k0). Rep1 (f :*: g) a -> (f :*: g) a

Generic1 (WrappedBifunctor p a :: k1 -> Type)

Defined in Data.Bifunctor.Wrapped

Associated Types

type Rep1 (WrappedBifunctor p a) :: k -> Type

Methods

from1 :: forall (a0 :: k). WrappedBifunctor p a a0 -> Rep1 (WrappedBifunctor p a) a0

to1 :: forall (a0 :: k). Rep1 (WrappedBifunctor p a) a0 -> WrappedBifunctor p a a0

Generic1 (Joker g a :: k1 -> Type)

Defined in Data.Bifunctor.Joker

Associated Types

type Rep1 (Joker g a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Joker g a a0 -> Rep1 (Joker g a) a0

to1 :: forall (a0 :: k). Rep1 (Joker g a) a0 -> Joker g a a0

Generic1 (Clown f a :: k1 -> Type)

Defined in Data.Bifunctor.Clown

Associated Types

type Rep1 (Clown f a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Clown f a a0 -> Rep1 (Clown f a) a0

to1 :: forall (a0 :: k). Rep1 (Clown f a) a0 -> Clown f a a0

Functor f => Generic1 (Compose f g :: k -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Associated Types

type Rep1 (Compose f g) :: k -> Type

Methods

from1 :: forall (a :: k0). Compose f g a -> Rep1 (Compose f g) a

to1 :: forall (a :: k0). Rep1 (Compose f g) a -> Compose f g a

Generic1 (M1 i c f :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (M1 i c f) :: k -> Type

Methods

from1 :: forall (a :: k0). M1 i c f a -> Rep1 (M1 i c f) a

to1 :: forall (a :: k0). Rep1 (M1 i c f) a -> M1 i c f a

Functor f => Generic1 (f :.: g :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (f :.: g) :: k -> Type

Methods

from1 :: forall (a :: k0). (f :.: g) a -> Rep1 (f :.: g) a

to1 :: forall (a :: k0). Rep1 (f :.: g) a -> (f :.: g) a

Generic1 (Sum p q a :: k1 -> Type)

Defined in Data.Bifunctor.Sum

Associated Types

type Rep1 (Sum p q a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Sum p q a a0 -> Rep1 (Sum p q a) a0

to1 :: forall (a0 :: k). Rep1 (Sum p q a) a0 -> Sum p q a a0

Generic1 (Product f g a :: k1 -> Type)

Defined in Data.Bifunctor.Product

Associated Types

type Rep1 (Product f g a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Product f g a a0 -> Rep1 (Product f g a) a0

to1 :: forall (a0 :: k). Rep1 (Product f g a) a0 -> Product f g a a0

Functor f => Generic1 (Tannen f p a :: k2 -> Type)

Defined in Data.Bifunctor.Tannen

Associated Types

type Rep1 (Tannen f p a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Tannen f p a a0 -> Rep1 (Tannen f p a) a0

to1 :: forall (a0 :: k). Rep1 (Tannen f p a) a0 -> Tannen f p a a0

Functor (p (f a)) => Generic1 (Biff p f g a :: k3 -> Type)

Defined in Data.Bifunctor.Biff

Associated Types

type Rep1 (Biff p f g a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Biff p f g a a0 -> Rep1 (Biff p f g a) a0

to1 :: forall (a0 :: k). Rep1 (Biff p f g a) a0 -> Biff p f g a a0

Generic1 []

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 [] :: k -> Type

Methods

from1 :: forall (a :: k). [a] -> Rep1 [] a

to1 :: forall (a :: k). Rep1 [] a -> [a]

Generic1 Maybe

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 Maybe :: k -> Type

Methods

from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a

to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a

Generic1 Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type Rep1 Par1 :: k -> Type

Methods

from1 :: forall (a :: k). Par1 a -> Rep1 Par1 a

to1 :: forall (a :: k). Rep1 Par1 a -> Par1 a

Generic1 Solo

Defined in Data.Tuple.Solo

Associated Types

type Rep1 Solo :: k -> Type

Methods

from1 :: forall (a :: k). Solo a -> Rep1 Solo a

to1 :: forall (a :: k). Rep1 Solo a -> Solo a

Generic1 Complex

Since: base-4.9.0.0

Defined in Data.Complex

Associated Types

type Rep1 Complex :: k -> Type

Methods

from1 :: forall (a :: k). Complex a -> Rep1 Complex a

to1 :: forall (a :: k). Rep1 Complex a -> Complex a

Generic1 Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep1 Min :: k -> Type

Methods

from1 :: forall (a :: k). Min a -> Rep1 Min a

to1 :: forall (a :: k). Rep1 Min a -> Min a

Generic1 Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep1 Max :: k -> Type

Methods

from1 :: forall (a :: k). Max a -> Rep1 Max a

to1 :: forall (a :: k). Rep1 Max a -> Max a

Generic1 First

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep1 First :: k -> Type

Methods

from1 :: forall (a :: k). First a -> Rep1 First a

to1 :: forall (a :: k). Rep1 First a -> First a

Generic1 Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep1 Last :: k -> Type

Methods

from1 :: forall (a :: k). Last a -> Rep1 Last a

to1 :: forall (a :: k). Rep1 Last a -> Last a

Generic1 WrappedMonoid

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep1 WrappedMonoid :: k -> Type

Methods

from1 :: forall (a :: k). WrappedMonoid a -> Rep1 WrappedMonoid a

to1 :: forall (a :: k). Rep1 WrappedMonoid a -> WrappedMonoid a

Generic1 Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep1 Option :: k -> Type

Methods

from1 :: forall (a :: k). Option a -> Rep1 Option a

to1 :: forall (a :: k). Rep1 Option a -> Option a

Generic1 ZipList

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep1 ZipList :: k -> Type

Methods

from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a

to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a

Generic1 Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Associated Types

type Rep1 Identity :: k -> Type

Methods

from1 :: forall (a :: k). Identity a -> Rep1 Identity a

to1 :: forall (a :: k). Rep1 Identity a -> Identity a

Generic1 First

Since: base-4.7.0.0

Defined in Data.Monoid

Associated Types

type Rep1 First :: k -> Type

Methods

from1 :: forall (a :: k). First a -> Rep1 First a

to1 :: forall (a :: k). Rep1 First a -> First a

Generic1 Last

Since: base-4.7.0.0

Defined in Data.Monoid

Associated Types

type Rep1 Last :: k -> Type

Methods

from1 :: forall (a :: k). Last a -> Rep1 Last a

to1 :: forall (a :: k). Rep1 Last a -> Last a

Generic1 Dual

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep1 Dual :: k -> Type

Methods

from1 :: forall (a :: k). Dual a -> Rep1 Dual a

to1 :: forall (a :: k). Rep1 Dual a -> Dual a

Generic1 Sum

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep1 Sum :: k -> Type

Methods

from1 :: forall (a :: k). Sum a -> Rep1 Sum a

to1 :: forall (a :: k). Rep1 Sum a -> Sum a

Generic1 Product

Since: base-4.7.0.0

Defined in Data.Semigroup.Internal

Associated Types

type Rep1 Product :: k -> Type

Methods

from1 :: forall (a :: k). Product a -> Rep1 Product a

to1 :: forall (a :: k). Rep1 Product a -> Product a

Generic1 Down

Since: base-4.12.0.0

Defined in GHC.Generics

Associated Types

type Rep1 Down :: k -> Type

Methods

from1 :: forall (a :: k). Down a -> Rep1 Down a

to1 :: forall (a :: k). Rep1 Down a -> Down a

Generic1 NonEmpty

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 NonEmpty :: k -> Type

Methods

from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a

to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a

Generic1 Tree

Since: containers-0.5.8

Defined in Data.Tree

Associated Types

type Rep1 Tree :: k -> Type

Methods

from1 :: forall (a :: k). Tree a -> Rep1 Tree a

to1 :: forall (a :: k). Rep1 Tree a -> Tree a

Generic1 FingerTree

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep1 FingerTree :: k -> Type

Methods

from1 :: forall (a :: k). FingerTree a -> Rep1 FingerTree a

to1 :: forall (a :: k). Rep1 FingerTree a -> FingerTree a

Generic1 Digit

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep1 Digit :: k -> Type

Methods

from1 :: forall (a :: k). Digit a -> Rep1 Digit a

to1 :: forall (a :: k). Rep1 Digit a -> Digit a

Generic1 Node

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep1 Node :: k -> Type

Methods

from1 :: forall (a :: k). Node a -> Rep1 Node a

to1 :: forall (a :: k). Rep1 Node a -> Node a

Generic1 Elem

Since: containers-0.6.1

Defined in Data.Sequence.Internal

Associated Types

type Rep1 Elem :: k -> Type

Methods

from1 :: forall (a :: k). Elem a -> Rep1 Elem a

to1 :: forall (a :: k). Rep1 Elem a -> Elem a

Generic1 ViewL

Since: containers-0.5.8

Defined in Data.Sequence.Internal

Associated Types

type Rep1 ViewL :: k -> Type

Methods

from1 :: forall (a :: k). ViewL a -> Rep1 ViewL a

to1 :: forall (a :: k). Rep1 ViewL a -> ViewL a

Generic1 ViewR

Since: containers-0.5.8

Defined in Data.Sequence.Internal

Associated Types

type Rep1 ViewR :: k -> Type

Methods

from1 :: forall (a :: k). ViewR a -> Rep1 ViewR a

to1 :: forall (a :: k). Rep1 ViewR a -> ViewR a

Generic1 Maybe

Defined in Data.Strict.Maybe

Associated Types

type Rep1 Maybe :: k -> Type

Methods

from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a

to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a

Generic1 (Either a :: Type -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 (Either a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Either a a0 -> Rep1 (Either a) a0

to1 :: forall (a0 :: k). Rep1 (Either a) a0 -> Either a a0

Generic1 ((,) a :: Type -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 ((,) a) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, a0) -> Rep1 ((,) a) a0

to1 :: forall (a0 :: k). Rep1 ((,) a) a0 -> (a, a0)

Generic1 (Arg a :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Semigroup

Associated Types

type Rep1 (Arg a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Arg a a0 -> Rep1 (Arg a) a0

to1 :: forall (a0 :: k). Rep1 (Arg a) a0 -> Arg a a0

Generic1 (WrappedMonad m :: Type -> Type)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep1 (WrappedMonad m) :: k -> Type

Methods

from1 :: forall (a :: k). WrappedMonad m a -> Rep1 (WrappedMonad m) a

to1 :: forall (a :: k). Rep1 (WrappedMonad m) a -> WrappedMonad m a

Functor f => Generic1 (Cofree f :: Type -> Type)

Defined in Control.Comonad.Cofree

Associated Types

type Rep1 (Cofree f) :: k -> Type

Methods

from1 :: forall (a :: k). Cofree f a -> Rep1 (Cofree f) a

to1 :: forall (a :: k). Rep1 (Cofree f) a -> Cofree f a

Functor f => Generic1 (Free f :: Type -> Type)

Defined in Control.Monad.Free

Associated Types

type Rep1 (Free f) :: k -> Type

Methods

from1 :: forall (a :: k). Free f a -> Rep1 (Free f) a

to1 :: forall (a :: k). Rep1 (Free f) a -> Free f a

Generic1 (ListF a :: Type -> Type)

Defined in Data.Functor.Base

Associated Types

type Rep1 (ListF a) :: k -> Type

Methods

from1 :: forall (a0 :: k). ListF a a0 -> Rep1 (ListF a) a0

to1 :: forall (a0 :: k). Rep1 (ListF a) a0 -> ListF a a0

Generic1 (NonEmptyF a :: Type -> Type)

Defined in Data.Functor.Base

Associated Types

type Rep1 (NonEmptyF a) :: k -> Type

Methods

from1 :: forall (a0 :: k). NonEmptyF a a0 -> Rep1 (NonEmptyF a) a0

to1 :: forall (a0 :: k). Rep1 (NonEmptyF a) a0 -> NonEmptyF a a0

Generic1 (TreeF a :: Type -> Type)

Defined in Data.Functor.Base

Associated Types

type Rep1 (TreeF a) :: k -> Type

Methods

from1 :: forall (a0 :: k). TreeF a a0 -> Rep1 (TreeF a) a0

to1 :: forall (a0 :: k). Rep1 (TreeF a) a0 -> TreeF a a0

Generic1 (Pair a :: Type -> Type)

Defined in Data.Strict.Tuple

Associated Types

type Rep1 (Pair a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Pair a a0 -> Rep1 (Pair a) a0

to1 :: forall (a0 :: k). Rep1 (Pair a) a0 -> Pair a a0

Generic1 (These a :: Type -> Type)

Defined in Data.Strict.These

Associated Types

type Rep1 (These a) :: k -> Type

Methods

from1 :: forall (a0 :: k). These a a0 -> Rep1 (These a) a0

to1 :: forall (a0 :: k). Rep1 (These a) a0 -> These a a0

Generic1 (Either a :: Type -> Type)

Defined in Data.Strict.Either

Associated Types

type Rep1 (Either a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Either a a0 -> Rep1 (Either a) a0

to1 :: forall (a0 :: k). Rep1 (Either a) a0 -> Either a a0

Generic1 (These a :: Type -> Type)

Defined in Data.These

Associated Types

type Rep1 (These a) :: k -> Type

Methods

from1 :: forall (a0 :: k). These a a0 -> Rep1 (These a) a0

to1 :: forall (a0 :: k). Rep1 (These a) a0 -> These a a0

Generic1 ((,,) a b :: Type -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 ((,,) a b) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, a0) -> Rep1 ((,,) a b) a0

to1 :: forall (a0 :: k). Rep1 ((,,) a b) a0 -> (a, b, a0)

Generic1 (Kleisli m a :: Type -> Type)

Since: base-4.14.0.0

Defined in Control.Arrow

Associated Types

type Rep1 (Kleisli m a) :: k -> Type

Methods

from1 :: forall (a0 :: k). Kleisli m a a0 -> Rep1 (Kleisli m a) a0

to1 :: forall (a0 :: k). Rep1 (Kleisli m a) a0 -> Kleisli m a a0

Generic1 (WrappedArrow a b :: Type -> Type)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep1 (WrappedArrow a b) :: k -> Type

Methods

from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0

to1 :: forall (a0 :: k). Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0

Generic1 (FreeF f a :: Type -> Type)

Defined in Control.Monad.Trans.Free

Associated Types

type Rep1 (FreeF f a) :: k -> Type

Methods

from1 :: forall (a0 :: k). FreeF f a a0 -> Rep1 (FreeF f a) a0

to1 :: forall (a0 :: k). Rep1 (FreeF f a) a0 -> FreeF f a a0

Generic1 (CofreeF f a :: Type -> Type)

Defined in Control.Comonad.Trans.Cofree

Associated Types

type Rep1 (CofreeF f a) :: k -> Type

Methods

from1 :: forall (a0 :: k). CofreeF f a a0 -> Rep1 (CofreeF f a) a0

to1 :: forall (a0 :: k). Rep1 (CofreeF f a) a0 -> CofreeF f a a0

Generic1 (Tagged s :: Type -> Type)

Defined in Data.Tagged

Associated Types

type Rep1 (Tagged s) :: k -> Type

Methods

from1 :: forall (a :: k). Tagged s a -> Rep1 (Tagged s) a

to1 :: forall (a :: k). Rep1 (Tagged s) a -> Tagged s a

Generic1 ((,,,) a b c :: Type -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,) a b c) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, a0) -> Rep1 ((,,,) a b c) a0

to1 :: forall (a0 :: k). Rep1 ((,,,) a b c) a0 -> (a, b, c, a0)

Generic1 ((,,,,) a b c d :: Type -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,) a b c d) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, a0) -> Rep1 ((,,,,) a b c d) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,) a b c d) a0 -> (a, b, c, d, a0)

Generic1 ((,,,,,) a b c d e :: Type -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,) a b c d e) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, a0) -> Rep1 ((,,,,,) a b c d e) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,,) a b c d e) a0 -> (a, b, c, d, e, a0)

Generic1 ((,,,,,,) a b c d e f :: Type -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

Associated Types

type Rep1 ((,,,,,,) a b c d e f) :: k -> Type

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, a0) -> Rep1 ((,,,,,,) a b c d e f) a0

to1 :: forall (a0 :: k). Rep1 ((,,,,,,) a b c d e f) a0 -> (a, b, c, d, e, f, a0)

Type-level natural numbers

module GHC.TypeLits

module GHC.TypeLits.Extra

module Clash.Promoted.Nat

module Clash.Promoted.Nat.Literals

module Clash.Promoted.Nat.TH

Type-level strings

module Clash.Promoted.Symbol

Type classes

Clash

module Clash.Class.BitPack

module Clash.Class.Num

module Clash.Class.Resize

Other

module Control.Applicative

module Data.Bits

Exceptions

module Clash.XException

Named types

module Clash.NamedTypes

Haskell Prelude

Clash.Explicit.Prelude.Safe re-exports most of the Haskell Prelude with the exception of those functions that the Clash API defines to work on Vec from Clash.Sized.Vector instead of on lists as the Haskell Prelude does. In addition, for the odd and even functions a type class called Parity is available at Clash.Class.Parity.

module Clash.HaskellPrelude