Clash.Prelude

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

This package provides:

• Prelude library containing datatypes and functions for circuit design

To use the library:

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

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

Creating synchronous sequential circuits

mealy

Arguments

:: (HiddenClockResetEnable dom, NFDataX s)

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

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

-> s

Initial state

-> Signal dom i -> Signal dom o

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

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

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

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

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

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

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

mealyB

Arguments

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

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

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

-> s

Initial state

-> Unbundled dom i -> Unbundled dom o

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

A version of mealy that does automatic Bundleing

Given a function f of type:

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

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

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

Using mealyB however we can write:

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

(<^>)

Arguments

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

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

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

-> s

Initial state

-> Unbundled dom i -> Unbundled dom o

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

Infix version of mealyB

moore

Arguments

:: (HiddenClockResetEnable dom, NFDataX s)

=> (s -> i -> s)

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

-> (s -> o)

Output function in moore machine form: state -> output

-> s

Initial state

-> Signal dom i -> Signal dom o

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

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

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

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

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

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

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

mooreB

Arguments

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

=> (s -> i -> s)

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

-> (s -> o)

Output function in moore machine form: state -> output

-> s

Initial state

-> Unbundled dom i -> Unbundled dom o

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

A version of moore that does automatic Bundleing

Given a functions t and o of types:

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

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

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

Using mooreB however we can write:

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

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

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

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

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

ROMs

asyncRom

Arguments

:: (KnownNat n, Enum addr)

=> Vec n a

ROM content

NB: must be a constant

-> addr

Read address rd

-> a

The value of the ROM at address rd

An asynchronous/combinational ROM with space for n elements

Additional helpful information:

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

asyncRomPow2

Arguments

:: KnownNat n

=> Vec (2 ^ n) a

ROM content

NB: must be a constant

-> Unsigned n

Read address rd

-> a

The value of the ROM at address rd

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

Additional helpful information:

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

rom

Arguments

:: forall dom n m a. (NFDataX a, KnownNat n, KnownNat m, HiddenClock dom, HiddenEnable dom)

=> Vec n a

ROM content

NB: must be a constant

-> Signal dom (Unsigned m)

Read address rd

-> Signal dom a

The value of the ROM at address rd

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

• NB: Read value is delayed by 1 cycle
• NB: Initial output value is undefined

Additional helpful information:

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

romPow2

Arguments

:: forall dom n a. (KnownNat n, NFDataX a, HiddenClock dom, HiddenEnable dom)

=> Vec (2 ^ n) a

ROM content

NB: must be a constant

-> Signal dom (Unsigned n)

Read address rd

-> Signal dom a

The value of the ROM at address rd

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

• NB: Read value is delayed by 1 cycle
• NB: Initial output value is undefined

Additional helpful information:

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

ROMs initialized with a data file

asyncRomFile

Arguments

:: (KnownNat m, Enum addr)

=> SNat n

Size of the ROM

-> FilePath

File describing the content of the ROM

-> addr

Read address rd

-> BitVector m

The value of the ROM at address rd

An asynchronous/combinational ROM with space for n elements

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

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

Additional helpful information:

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

• When you notice that asyncRomFile is significantly slowing down your simulation, give it a monomorphic type signature. So instead of leaving the type to be inferred:

  myRomData = asyncRomFile d512 "memory.bin"
  

  or giving it a polymorphic type signature:

  myRomData :: Enum addr => addr -> BitVector 16
  myRomData = asyncRomFile d512 "memory.bin"
  

  you should give it a monomorphic type signature:

  myRomData :: Unsigned 9 -> BitVector 16
  myRomData = asyncRomFile d512 "memory.bin"
  

asyncRomFilePow2

Arguments

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

=> FilePath

File describing the content of the ROM

-> Unsigned n

Read address rd

-> BitVector m

The value of the ROM at address rd

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

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

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

Additional helpful information:

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

• When you notice that asyncRomFilePow2 is significantly slowing down your simulation, give it a monomorphic type signature. So instead of leaving the type to be inferred:

  myRomData = asyncRomFilePow2 "memory.bin"
  

  you should give it a monomorphic type signature:

  myRomData :: Unsigned 9 -> BitVector 16
  myRomData = asyncRomFilePow2 "memory.bin"
  

romFile

Arguments

:: (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom)

=> SNat n

Size of the ROM

-> FilePath

File describing the content of the ROM

-> Signal dom (Unsigned n)

Read address rd

-> Signal dom (BitVector m)

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

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

• NB: Read value is delayed by 1 cycle
• NB: Initial output value is undefined

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

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

Additional helpful information:

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

romFilePow2

Arguments

:: forall n m dom. (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom)

=> FilePath

File describing the content of the ROM

-> Signal dom (Unsigned n)

Read address rd

-> Signal dom (BitVector m)

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

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

• NB: Read value is delayed by 1 cycle
• NB: Initial output value is undefined

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

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

Additional helpful information:

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

RAM primitives with a combinational read port

asyncRam

Arguments

:: (Enum addr, HiddenClock dom, HiddenEnable dom, HasCallStack)

=> SNat n

Size n of the RAM

-> Signal dom addr

Read address r

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

(write address w, value to write)

-> Signal dom a

Value of the RAM at address r

Create a RAM with space for n elements.

• NB: Initial content of the RAM is undefined

Additional helpful information:

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

asyncRamPow2

Arguments

:: (KnownNat n, HiddenClock dom, HiddenEnable dom, HasCallStack)

=> Signal dom (Unsigned n)

Read address r

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

(write address w, value to write)

-> Signal dom a

Value of the RAM at address r

Create a RAM with space for 2^n elements

• NB: Initial content of the RAM is undefined

Additional helpful information:

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

BlockRAM primitives

blockRam

Arguments

:: (HasCallStack, HiddenClock dom, HiddenEnable dom, NFDataX a, Enum addr)

=> Vec n a

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

NB: MUST be a constant.

-> Signal dom addr

Read address r

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

(write address w, value to write)

-> Signal dom a

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

Create a blockRAM with space for n elements.

• NB: Read value is delayed by 1 cycle
• NB: Initial output value is undefined

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

Additional helpful information:

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

blockRamPow2

Arguments

:: (HasCallStack, HiddenClock dom, HiddenEnable dom, NFDataX a, KnownNat n)

=> Vec (2 ^ n) a

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, a))

(write address w, value to write)

-> Signal dom a

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

Create a blockRAM with space for 2^n elements

• NB: Read value is delayed by 1 cycle
• NB: Initial output value is undefined

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

Additional helpful information:

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

blockRamU

Arguments

:: forall n dom a r addr. (HasCallStack, HiddenClockResetEnable dom, NFDataX a, Enum addr, 1 <= n)

=> ResetStrategy r

Whether to clear BRAM on asserted reset (ClearOnReset) or not (NoClearOnReset). Reset needs to be asserted at least n cycles to clear the BRAM.

-> SNat n

Number of elements in BRAM

-> (Index n -> a)

If applicable (see first argument), reset BRAM using this function.

-> Signal dom addr

Read address r

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

(write address w, value to write)

-> Signal dom a

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

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

blockRam1

Arguments

:: forall n dom a r addr. (HasCallStack, HiddenClockResetEnable dom, NFDataX a, Enum addr, 1 <= n)

=> ResetStrategy r

Whether to clear BRAM on asserted reset (ClearOnReset) or not (NoClearOnReset). Reset needs to be asserted at least n cycles to clear the BRAM.

-> SNat n

Number of elements in BRAM

-> a

Initial content of the BRAM (replicated n times)

-> Signal dom addr

Read address r

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

(write address w, value to write)

-> Signal dom a

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

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

data ResetStrategy (r :: Bool) where

Constructors

ClearOnReset :: ResetStrategy 'True

NoClearOnReset :: ResetStrategy 'False

BlockRAM primitives initialized with a data file

blockRamFile

Arguments

:: (KnownNat m, Enum addr, HiddenClock dom, HiddenEnable dom, HasCallStack)

=> SNat n

Size of the blockRAM

-> FilePath

File describing the initial content of the blockRAM

-> Signal dom addr

Read address r

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

(write address w, value to write)

-> Signal dom (BitVector m)

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

Create a blockRAM with space for n elements

• NB: Read value is delayed by 1 cycle
• NB: Initial output value is undefined

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

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

Additional helpful information:

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

blockRamFilePow2

Arguments

:: forall dom n m. (KnownNat m, KnownNat n, HiddenClock dom, HiddenEnable dom, HasCallStack)

=> FilePath

File describing the initial content of the blockRAM

-> Signal dom (Unsigned n)

Read address r

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

(write address w, value to write)

-> Signal dom (BitVector m)

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

Create a blockRAM with space for 2^n elements

• NB: Read value is delayed by 1 cycle
• NB: Initial output value is undefined

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

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

Additional helpful information:

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

BlockRAM read/write conflict resolution

readNew

Arguments

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

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

The ram component

-> Signal dom addr

Read address r

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

(Write address w, value to write)

-> Signal dom a

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

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

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

Utility functions

window

Arguments

:: (HiddenClockResetEnable dom, KnownNat n, Default a, NFDataX a)

=> Signal dom a

Signal to create a window over

-> Vec (n + 1) (Signal dom a)

Window of at least size 1

Give a window over a Signal

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

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

windowD

Arguments

:: (HiddenClockResetEnable dom, KnownNat n, Default a, NFDataX a)

=> Signal dom a

Signal to create a window over

-> Vec (n + 1) (Signal dom a)

Window of at least size 1

Give a delayed window over a Signal

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

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

isRising

Arguments

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

=> a

Starting value

-> Signal dom a

-> Signal dom Bool

Give a pulse when the Signal goes from minBound to maxBound

isFalling

Arguments

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

=> a

Starting value

-> Signal dom a

-> Signal dom Bool

Give a pulse when the Signal goes from maxBound to minBound

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

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

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

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

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

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

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

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

To oscillate on an interval of 5 cycles:

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

To oscillate between True and False:

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

An alternative definition for the above could be:

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

Tracing

Simple

traceSignal1

Arguments

:: (BitPack a, NFDataX a, Typeable a)

=> String

Name of signal in the VCD output

-> Signal dom a

Signal to trace

-> Signal dom a

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

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

traceVecSignal1

Arguments

:: (KnownNat n, BitPack a, NFDataX a, Typeable a)

=> String

Name of signal in debugging output. Will be appended by _0, _1, ..., _n.

-> Signal dom (Vec (n + 1) a)

Signal to trace

-> Signal dom (Vec (n + 1) a)

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

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

Tracing in a multi-clock environment

traceSignal

Arguments

:: forall dom a. (KnownDomain dom, BitPack a, NFDataX a, Typeable a)

=> String

Name of signal in the VCD output

-> Signal dom a

Signal to trace

-> Signal dom a

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

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

traceVecSignal

Arguments

:: forall dom a n. (KnownDomain dom, KnownNat n, BitPack a, NFDataX a, Typeable a)

=> String

Name of signal in debugging output. Will be appended by _0, _1, ..., _n.

-> Signal dom (Vec (n + 1) a)

Signal to trace

-> Signal dom (Vec (n + 1) a)

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

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

VCD dump functions

dumpVCD

Arguments

:: NFDataX a

=> (Int, Int)

(offset, number of samples)

-> Signal dom a

(One of) the outputs of the circuit containing the traces

-> [String]

The names of the traces you definitely want to be dumped in the VCD file

-> IO (Either String Text)

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

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

For example:

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

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

Exported modules

Synchronous signals

module Clash.Signal

module Clash.Signal.Delayed

DataFlow interface

module Clash.Prelude.DataFlow

Datatypes

Bit vectors

module Clash.Sized.BitVector

module Clash.Prelude.BitIndex

module Clash.Prelude.BitReduction

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

module Clash.Sized.Vector

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

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

Defined in TextShow.Generic

Associated Types

type Rep ConType :: Type -> Type

Methods

from :: ConType -> Rep ConType x

to :: Rep ConType x -> ConType

Generic Options

Defined in TextShow.Options

Associated Types

type Rep Options :: Type -> Type

Methods

from :: Options -> Rep Options x

to :: Rep Options x -> Options

Generic GenTextMethods

Defined in TextShow.Options

Associated Types

type Rep GenTextMethods :: Type -> Type

Methods

from :: GenTextMethods -> Rep GenTextMethods x

to :: Rep GenTextMethods x -> GenTextMethods

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 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 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 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 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 [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 (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 (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 (FromGeneric a)

Defined in TextShow.Generic

Associated Types

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

Methods

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

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

Generic (FromStringShow a)

Defined in TextShow.FromStringTextShow

Associated Types

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

Methods

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

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

Generic (FromTextShow a)

Defined in TextShow.FromStringTextShow

Associated Types

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

Methods

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

to :: Rep (FromTextShow a) x -> FromTextShow 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 (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.Foldable

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

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 (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 (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 (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 (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 (FromGeneric1 f a)

Defined in TextShow.Generic

Associated Types

type Rep (FromGeneric1 f a) :: Type -> Type

Methods

from :: FromGeneric1 f a -> Rep (FromGeneric1 f a) x

to :: Rep (FromGeneric1 f a) x -> FromGeneric1 f a

Generic (FromStringShow1 f a)

Defined in TextShow.FromStringTextShow

Associated Types

type Rep (FromStringShow1 f a) :: Type -> Type

Methods

from :: FromStringShow1 f a -> Rep (FromStringShow1 f a) x

to :: Rep (FromStringShow1 f a) x -> FromStringShow1 f a

Generic (FromTextShow1 f a)

Defined in TextShow.FromStringTextShow

Associated Types

type Rep (FromTextShow1 f a) :: Type -> Type

Methods

from :: FromTextShow1 f a -> Rep (FromTextShow1 f a) x

to :: Rep (FromTextShow1 f a) x -> FromTextShow1 f a

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 (FromStringShow2 f a b)

Defined in TextShow.FromStringTextShow

Associated Types

type Rep (FromStringShow2 f a b) :: Type -> Type

Methods

from :: FromStringShow2 f a b -> Rep (FromStringShow2 f a b) x

to :: Rep (FromStringShow2 f a b) x -> FromStringShow2 f a b

Generic (FromTextShow2 f a b)

Defined in TextShow.FromStringTextShow

Associated Types

type Rep (FromTextShow2 f a b) :: Type -> Type

Methods

from :: FromTextShow2 f a b -> Rep (FromTextShow2 f a b) x

to :: Rep (FromTextShow2 f a b) x -> FromTextShow2 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 (FromTextShow1 f :: k -> Type)

Defined in TextShow.FromStringTextShow

Associated Types

type Rep1 (FromTextShow1 f) :: k -> Type

Methods

from1 :: forall (a :: k0). FromTextShow1 f a -> Rep1 (FromTextShow1 f) a

to1 :: forall (a :: k0). Rep1 (FromTextShow1 f) a -> FromTextShow1 f a

Generic1 (FromStringShow1 f :: k -> Type)

Defined in TextShow.FromStringTextShow

Associated Types

type Rep1 (FromStringShow1 f) :: k -> Type

Methods

from1 :: forall (a :: k0). FromStringShow1 f a -> Rep1 (FromStringShow1 f) a

to1 :: forall (a :: k0). Rep1 (FromStringShow1 f) a -> FromStringShow1 f a

Generic1 (FromGeneric1 f :: k -> Type)

Defined in TextShow.Generic

Associated Types

type Rep1 (FromGeneric1 f) :: k -> Type

Methods

from1 :: forall (a :: k0). FromGeneric1 f a -> Rep1 (FromGeneric1 f) a

to1 :: forall (a :: k0). Rep1 (FromGeneric1 f) a -> FromGeneric1 f 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

Generic1 (FromTextShow2 f a :: k1 -> Type)

Defined in TextShow.FromStringTextShow

Associated Types

type Rep1 (FromTextShow2 f a) :: k -> Type

Methods

from1 :: forall (a0 :: k). FromTextShow2 f a a0 -> Rep1 (FromTextShow2 f a) a0

to1 :: forall (a0 :: k). Rep1 (FromTextShow2 f a) a0 -> FromTextShow2 f a a0

Generic1 (FromStringShow2 f a :: k1 -> Type)

Defined in TextShow.FromStringTextShow

Associated Types

type Rep1 (FromStringShow2 f a) :: k -> Type

Methods

from1 :: forall (a0 :: k). FromStringShow2 f a a0 -> Rep1 (FromStringShow2 f a) a0

to1 :: forall (a0 :: k). Rep1 (FromStringShow2 f a) a0 -> FromStringShow2 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 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 FromGeneric

Defined in TextShow.Generic

Associated Types

type Rep1 FromGeneric :: k -> Type

Methods

from1 :: forall (a :: k). FromGeneric a -> Rep1 FromGeneric a

to1 :: forall (a :: k). Rep1 FromGeneric a -> FromGeneric a

Generic1 FromStringShow

Defined in TextShow.FromStringTextShow

Associated Types

type Rep1 FromStringShow :: k -> Type

Methods

from1 :: forall (a :: k). FromStringShow a -> Rep1 FromStringShow a

to1 :: forall (a :: k). Rep1 FromStringShow a -> FromStringShow a

Generic1 FromTextShow

Defined in TextShow.FromStringTextShow

Associated Types

type Rep1 FromTextShow :: k -> Type

Methods

from1 :: forall (a :: k). FromTextShow a -> Rep1 FromTextShow a

to1 :: forall (a :: k). Rep1 FromTextShow a -> FromTextShow 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.Foldable

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

Template Haskell

class Lift (t :: TYPE r) where

A Lift instance can have any of its values turned into a Template Haskell expression. This is needed when a value used within a Template Haskell quotation is bound outside the Oxford brackets ([| ... |] or [|| ... ||]) but not at the top level. As an example:

add1 :: Int -> Q (TExp Int)
add1 x = [|| x + 1 ||]

Template Haskell has no way of knowing what value x will take on at splice-time, so it requires the type of x to be an instance of Lift.

A Lift instance must satisfy $(lift x) ≡ x and $$(liftTyped x) ≡ x for all x, where $(...) and $$(...) are Template Haskell splices. It is additionally expected that lift x ≡ unTypeQ (liftTyped x).

Lift instances can be derived automatically by use of the -XDeriveLift GHC language extension:

{-# LANGUAGE DeriveLift #-}
module Foo where

import Language.Haskell.TH.Syntax

data Bar a = Bar1 a (Bar a) | Bar2 String
  deriving Lift

Levity-polymorphic since template-haskell-2.16.0.0.

Minimal complete definition

liftTyped

Methods

lift :: t -> Q Exp

Turn a value into a Template Haskell expression, suitable for use in a splice.

liftTyped :: t -> Q (TExp t)

Turn a value into a Template Haskell typed expression, suitable for use in a typed splice.

Since: template-haskell-2.16.0.0

Instances

Lift Bool

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Bool -> Q Exp

liftTyped :: Bool -> Q (TExp Bool)

Lift Char

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Char -> Q Exp

liftTyped :: Char -> Q (TExp Char)

Lift Double

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Double -> Q Exp

liftTyped :: Double -> Q (TExp Double)

Lift Float

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Float -> Q Exp

liftTyped :: Float -> Q (TExp Float)

Lift Int

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int -> Q Exp

liftTyped :: Int -> Q (TExp Int)

Lift Int8

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int8 -> Q Exp

liftTyped :: Int8 -> Q (TExp Int8)

Lift Int16

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int16 -> Q Exp

liftTyped :: Int16 -> Q (TExp Int16)

Lift Int32

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int32 -> Q Exp

liftTyped :: Int32 -> Q (TExp Int32)

Lift Int64

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int64 -> Q Exp

liftTyped :: Int64 -> Q (TExp Int64)

Lift Integer

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Integer -> Q Exp

liftTyped :: Integer -> Q (TExp Integer)

Lift Natural

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Natural -> Q Exp

liftTyped :: Natural -> Q (TExp Natural)

Lift Word

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word -> Q Exp

liftTyped :: Word -> Q (TExp Word)

Lift Word8

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word8 -> Q Exp

liftTyped :: Word8 -> Q (TExp Word8)

Lift Word16

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word16 -> Q Exp

liftTyped :: Word16 -> Q (TExp Word16)

Lift Word32

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word32 -> Q Exp

liftTyped :: Word32 -> Q (TExp Word32)

Lift Word64

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word64 -> Q Exp

liftTyped :: Word64 -> Q (TExp Word64)

Lift ()

Defined in Language.Haskell.TH.Syntax

Methods

lift :: () -> Q Exp

liftTyped :: () -> Q (TExp ())

Lift Void

Since: template-haskell-2.15.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Void -> Q Exp

liftTyped :: Void -> Q (TExp Void)

Lift Half

Defined in Numeric.Half

Methods

lift :: Half -> Q Exp

liftTyped :: Half -> Q (TExp Half)

Lift ConType

Defined in TextShow.Generic

Methods

lift :: ConType -> Q Exp

liftTyped :: ConType -> Q (TExp ConType)

Lift Options

Defined in TextShow.Options

Methods

lift :: Options -> Q Exp

liftTyped :: Options -> Q (TExp Options)

Lift GenTextMethods

Defined in TextShow.Options

Methods

lift :: GenTextMethods -> Q Exp

liftTyped :: GenTextMethods -> Q (TExp GenTextMethods)

Lift ConstrRepr

Defined in Clash.Annotations.BitRepresentation

Methods

lift :: ConstrRepr -> Q Exp

liftTyped :: ConstrRepr -> Q (TExp ConstrRepr)

Lift DataReprAnn

Defined in Clash.Annotations.BitRepresentation

Methods

lift :: DataReprAnn -> Q Exp

liftTyped :: DataReprAnn -> Q (TExp DataReprAnn)

Lift Bit

Defined in Clash.Sized.Internal.BitVector

Methods

lift :: Bit -> Q Exp

liftTyped :: Bit -> Q (TExp Bit)

Lift PortName

Defined in Clash.Annotations.TopEntity

Methods

lift :: PortName -> Q Exp

liftTyped :: PortName -> Q (TExp PortName)

Lift TopEntity

Defined in Clash.Annotations.TopEntity

Methods

lift :: TopEntity -> Q Exp

liftTyped :: TopEntity -> Q (TExp TopEntity)

Lift Int#

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int# -> Q Exp

liftTyped :: Int# -> Q (TExp Int#)

Lift Char#

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Char# -> Q Exp

liftTyped :: Char# -> Q (TExp Char#)

Lift Word#

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word# -> Q Exp

liftTyped :: Word# -> Q (TExp Word#)

Lift Addr#

Produces an Addr# literal from the NUL-terminated C-string starting at the given memory address.

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Addr# -> Q Exp

liftTyped :: Addr# -> Q (TExp Addr#)

Lift Float#

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Float# -> Q Exp

liftTyped :: Float# -> Q (TExp Float#)

Lift Double#

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Double# -> Q Exp

liftTyped :: Double# -> Q (TExp Double#)

Lift a => Lift ([a] :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: [a] -> Q Exp

liftTyped :: [a] -> Q (TExp [a])

Lift a => Lift (Maybe a :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Maybe a -> Q Exp

liftTyped :: Maybe a -> Q (TExp (Maybe a))

Integral a => Lift (Ratio a :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Ratio a -> Q Exp

liftTyped :: Ratio a -> Q (TExp (Ratio a))

Lift a => Lift (NonEmpty a :: Type)

Since: template-haskell-2.15.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: NonEmpty a -> Q Exp

liftTyped :: NonEmpty a -> Q (TExp (NonEmpty a))

Lift a => Lift (FromGeneric a :: Type)

Defined in TextShow.Generic

Methods

lift :: FromGeneric a -> Q Exp

liftTyped :: FromGeneric a -> Q (TExp (FromGeneric a))

Lift a => Lift (FromStringShow a :: Type)

Defined in TextShow.FromStringTextShow

Methods

lift :: FromStringShow a -> Q Exp

liftTyped :: FromStringShow a -> Q (TExp (FromStringShow a))

Lift a => Lift (FromTextShow a :: Type)

Defined in TextShow.FromStringTextShow

Methods

lift :: FromTextShow a -> Q Exp

liftTyped :: FromTextShow a -> Q (TExp (FromTextShow a))

KnownSymbol s => Lift (SSymbol s :: Type)

Defined in Clash.Promoted.Symbol

Methods

lift :: SSymbol s -> Q Exp

liftTyped :: SSymbol s -> Q (TExp (SSymbol s))

KnownNat n => Lift (BitVector n :: Type)

Defined in Clash.Sized.Internal.BitVector

Methods

lift :: BitVector n -> Q Exp

liftTyped :: BitVector n -> Q (TExp (BitVector n))

KnownNat n => Lift (Index n :: Type)

Defined in Clash.Sized.Internal.Index

Methods

lift :: Index n -> Q Exp

liftTyped :: Index n -> Q (TExp (Index n))

Lift (SNat n :: Type)

Defined in Clash.Promoted.Nat

Methods

lift :: SNat n -> Q Exp

liftTyped :: SNat n -> Q (TExp (SNat n))

KnownNat n => Lift (Unsigned n :: Type)

Defined in Clash.Sized.Internal.Unsigned

Methods

lift :: Unsigned n -> Q Exp

liftTyped :: Unsigned n -> Q (TExp (Unsigned n))

KnownNat n => Lift (Signed n :: Type)

Defined in Clash.Sized.Internal.Signed

Methods

lift :: Signed n -> Q Exp

liftTyped :: Signed n -> Q (TExp (Signed n))

(Lift a, Lift b) => Lift (Either a b :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Either a b -> Q Exp

liftTyped :: Either a b -> Q (TExp (Either a b))

(Lift a, Lift b) => Lift ((a, b) :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (a, b) -> Q Exp

liftTyped :: (a, b) -> Q (TExp (a, b))

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

Defined in Clash.Sized.Vector

Methods

lift :: Vec n a -> Q Exp

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

Lift a => Lift (Signal dom a :: Type)

Defined in Clash.Signal.Internal

Methods

lift :: Signal dom a -> Q Exp

liftTyped :: Signal dom a -> Q (TExp (Signal dom a))

Lift a => Lift (RTree d a :: Type)

Defined in Clash.Sized.RTree

Methods

lift :: RTree d a -> Q Exp

liftTyped :: RTree d a -> Q (TExp (RTree d a))

(Lift a, Lift b, Lift c) => Lift ((a, b, c) :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (a, b, c) -> Q Exp

liftTyped :: (a, b, c) -> Q (TExp (a, b, c))

Lift (f a) => Lift (FromGeneric1 f a :: Type)

Defined in TextShow.Generic

Methods

lift :: FromGeneric1 f a -> Q Exp

liftTyped :: FromGeneric1 f a -> Q (TExp (FromGeneric1 f a))

Lift (f a) => Lift (FromStringShow1 f a :: Type)

Defined in TextShow.FromStringTextShow

Methods

lift :: FromStringShow1 f a -> Q Exp

liftTyped :: FromStringShow1 f a -> Q (TExp (FromStringShow1 f a))

Lift (f a) => Lift (FromTextShow1 f a :: Type)

Defined in TextShow.FromStringTextShow

Methods

lift :: FromTextShow1 f a -> Q Exp

liftTyped :: FromTextShow1 f a -> Q (TExp (FromTextShow1 f a))

Lift a => Lift (DSignal dom delay a :: Type)

Defined in Clash.Signal.Delayed.Internal

Methods

lift :: DSignal dom delay a -> Q Exp

liftTyped :: DSignal dom delay a -> Q (TExp (DSignal dom delay a))

(Lift (rep (int + frac)), KnownNat frac, KnownNat int, Typeable rep) => Lift (Fixed rep int frac :: Type)

Defined in Clash.Sized.Fixed

Methods

lift :: Fixed rep int frac -> Q Exp

liftTyped :: Fixed rep int frac -> Q (TExp (Fixed rep int frac))

(Lift a, Lift b, Lift c, Lift d) => Lift ((a, b, c, d) :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (a, b, c, d) -> Q Exp

liftTyped :: (a, b, c, d) -> Q (TExp (a, b, c, d))

(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((a, b, c, d, e) :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (a, b, c, d, e) -> Q Exp

liftTyped :: (a, b, c, d, e) -> Q (TExp (a, b, c, d, e))

Lift (f a b) => Lift (FromStringShow2 f a b :: Type)

Defined in TextShow.FromStringTextShow

Methods

lift :: FromStringShow2 f a b -> Q Exp

liftTyped :: FromStringShow2 f a b -> Q (TExp (FromStringShow2 f a b))

Lift (f a b) => Lift (FromTextShow2 f a b :: Type)

Defined in TextShow.FromStringTextShow

Methods

lift :: FromTextShow2 f a b -> Q Exp

liftTyped :: FromTextShow2 f a b -> Q (TExp (FromTextShow2 f a b))

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((a, b, c, d, e, f) :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (a, b, c, d, e, f) -> Q Exp

liftTyped :: (a, b, c, d, e, f) -> Q (TExp (a, b, c, d, e, f))

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((a, b, c, d, e, f, g) :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (a, b, c, d, e, f, g) -> Q Exp

liftTyped :: (a, b, c, d, e, f, g) -> Q (TExp (a, b, c, d, e, f, g))

Lift (# #)

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# #) -> Q Exp

liftTyped :: (# #) -> Q (TExp (# #))

Lift a => Lift ((# a #) :: TYPE ('TupleRep '['LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a #) -> Q Exp

liftTyped :: (# a #) -> Q (TExp (# a #))

(Lift a, Lift b) => Lift ((# a, b #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a, b #) -> Q Exp

liftTyped :: (# a, b #) -> Q (TExp (# a, b #))

(Lift a, Lift b) => Lift ((# a | b #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a | b #) -> Q Exp

liftTyped :: (# a | b #) -> Q (TExp (# a | b #))

(Lift a, Lift b, Lift c) => Lift ((# a, b, c #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a, b, c #) -> Q Exp

liftTyped :: (# a, b, c #) -> Q (TExp (# a, b, c #))

(Lift a, Lift b, Lift c) => Lift ((# a | b | c #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a | b | c #) -> Q Exp

liftTyped :: (# a | b | c #) -> Q (TExp (# a | b | c #))

(Lift a, Lift b, Lift c, Lift d) => Lift ((# a, b, c, d #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a, b, c, d #) -> Q Exp

liftTyped :: (# a, b, c, d #) -> Q (TExp (# a, b, c, d #))

(Lift a, Lift b, Lift c, Lift d) => Lift ((# a | b | c | d #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a | b | c | d #) -> Q Exp

liftTyped :: (# a | b | c | d #) -> Q (TExp (# a | b | c | d #))

(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a, b, c, d, e #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a, b, c, d, e #) -> Q Exp

liftTyped :: (# a, b, c, d, e #) -> Q (TExp (# a, b, c, d, e #))

(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a | b | c | d | e #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a | b | c | d | e #) -> Q Exp

liftTyped :: (# a | b | c | d | e #) -> Q (TExp (# a | b | c | d | e #))

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a, b, c, d, e, f #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a, b, c, d, e, f #) -> Q Exp

liftTyped :: (# a, b, c, d, e, f #) -> Q (TExp (# a, b, c, d, e, f #))

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a | b | c | d | e | f #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a | b | c | d | e | f #) -> Q Exp

liftTyped :: (# a | b | c | d | e | f #) -> Q (TExp (# a | b | c | d | e | f #))

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a, b, c, d, e, f, g #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a, b, c, d, e, f, g #) -> Q Exp

liftTyped :: (# a, b, c, d, e, f, g #) -> Q (TExp (# a, b, c, d, e, f, g #))

(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a | b | c | d | e | f | g #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep]))

Since: template-haskell-2.16.0.0

Defined in Language.Haskell.TH.Syntax

Methods

lift :: (# a | b | c | d | e | f | g #) -> Q Exp

liftTyped :: (# a | b | c | d | e | f | g #) -> Q (TExp (# a | b | c | d | e | f | g #))

Type classes

Clash

autoReg :: (HasCallStack, HiddenClockResetEnable dom, AutoReg a) => a -> Signal dom a -> Signal dom a

Implicit version of autoReg

deriveAutoReg :: Name -> DecsQ

Automatically derives an AutoReg instance for a product type

Usage:

data Pair a b = MkPair { getA :: a, getB :: b } deriving (Generic, NFDataX)
data Tup3 a b c = MkTup3 { getAB :: Pair a b, getC :: c } deriving (Generic, NFDataX)
deriveAutoReg ''Pair
deriveAutoReg ''Tup3

NB: Because of the way template haskell works the order here matters, if you try to deriveAutoReg ''Tup3 before Pair it will complain about missing an instance AutoReg (Pair a b).

module Clash.Class.BitPack

module Clash.Class.Exp

module Clash.Class.Num

module Clash.Class.Parity

module Clash.Class.Resize

Other

module Control.Applicative

module Data.Bits

module Data.Default.Class

Exceptions

module Clash.XException

Named types

module Clash.NamedTypes

Hidden arguments

module Clash.Hidden

Magic

module Clash.Magic

Haskell Prelude

Clash.Prelude re-exports most of the Haskell Prelude with the exception of the following: (++), (!!), concat, drop, even, foldl, foldl1, foldr, foldr1, head, init, iterate, last, length, map, odd, repeat, replicate, reverse, scanl, scanr, splitAt, tail, take, unzip, unzip3, zip, zip3, zipWith, zipWith3.

It instead exports the identically named functions defined in terms of Vec at Clash.Sized.Vector. For the odd end even function a type class called Parity is available at Parity.

module Clash.HaskellPrelude