Clash.Explicit.Prelude.Safe

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

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

Creating synchronous sequential circuits

mealy

Arguments

:: (KnownDomain dom, NFDataX s)

=> Clock dom

Clock to synchronize to

-> Reset dom

-> Enable dom

Global enable

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

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

-> s

Initial state

-> Signal dom i -> Signal dom o

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

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

import qualified Data.List as L

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

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

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

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

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

mealyB

Arguments

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

=> Clock dom

-> Reset dom

-> Enable dom

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

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

-> s

Initial state

-> Unbundled dom i -> Unbundled dom o

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

A version of mealy that does automatic Bundleing

Given a function f of type:

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

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

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

Using mealyB however we can write:

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

moore

Arguments

:: (KnownDomain dom, NFDataX s)

=> Clock dom

Clock to synchronize to

-> Reset dom

-> Enable dom

-> (s -> i -> s)

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

-> (s -> o)

Output function in moore machine form: state -> output

-> s

Initial state

-> Signal dom i -> Signal dom o

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

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

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

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

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

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

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

mooreB

Arguments

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

=> Clock dom

-> Reset dom

-> Enable dom

-> (s -> i -> s)

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

-> (s -> o)

Output function in moore machine form: state -> output

-> s

Initial state

-> Unbundled dom i -> Unbundled dom o

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

A version of moore that does automatic Bundleing

Given a functions t and o of types:

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

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

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

Using mooreB however we can write:

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

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

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

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

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

Synchronizer circuits for safe clock domain crossing

dualFlipFlopSynchronizer

Arguments

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

=> Clock dom1

Clock to which the incoming data is synchronized

-> Clock dom2

Clock to which the outgoing data is synchronized

-> Reset dom2

Reset for registers on the outgoing domain

-> Enable dom2

Enable for registers on the outgoing domain

-> a

Initial value of the two synchronization registers

-> Signal dom1 a

Incoming data

-> Signal dom2 a

Outgoing, synchronized, data

Synchronizer based on two sequentially connected flip-flops.

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

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

  [0111,1000]

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

  [0111,0111,0000,1000]

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

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

asyncFIFOSynchronizer

Arguments

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

=> SNat addrSize

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

-> Clock wdom

Clock to which the write port is synchronized

-> Clock rdom

Clock to which the read port is synchronized

-> Reset wdom

-> Reset rdom

-> Enable wdom

-> Enable rdom

-> Signal rdom Bool

Read request

-> Signal wdom (Maybe a)

Element to insert

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

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

Synchronizer implemented as a FIFO around an asynchronous RAM. Based on the design described in Clash.Tutorial, which is itself based on the design described in http://www.sunburst-design.com/papers/CummingsSNUG2002SJ_FIFO1.pdf.

NB: This synchronizer can be used for word-synchronization.

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

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

=> Clock dom

Clock to synchronize to

-> Enable dom

Global enable

-> Vec n a

ROM content

NB: must be a constant

-> Signal dom addr

Read address rd

-> Signal dom a

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

Additional helpful information:

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

romPow2

Arguments

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

=> Clock dom

Clock to synchronize to

-> Enable dom

Global enable

-> 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.Explicit.BlockRam for ideas on how to use ROMs and RAMs

RAM primitives with a combinational read port

asyncRam

Arguments

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

=> Clock wdom

Clock to which to synchronize the write port of the RAM

-> Clock rdom

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

-> Enable wdom

Global enable

-> SNat n

Size n of the RAM

-> Signal rdom addr

Read address r

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

(write address w, value to write)

-> Signal rdom a

Value of the RAM at address r

Create a RAM with space for n elements

• NB: Initial content of the RAM is undefined

Additional helpful information:

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

asyncRamPow2

Arguments

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

=> Clock wdom

Clock to which to synchronize the write port of the RAM

-> Clock rdom

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

-> Enable wdom

Global enable

-> Signal rdom (Unsigned n)

Read address r

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

(write address w, value to write)

-> Signal rdom a

Value of the RAM at address r

Create a RAM with space for 2^n elements

• NB: Initial content of the RAM is undefined

Additional helpful information:

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

BlockRAM primitives

blockRam

Arguments

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

=> Clock dom

Clock to synchronize to

-> Enable dom

Global enable

-> 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
  :: Clock  dom
  -> Enable  dom
  -> Signal dom (Unsigned 6)
  -> Signal dom (Maybe (Unsigned 6, Bit))
  -> Signal dom Bit
bram40 clk en = blockRam clk en (replicate d40 1)

Additional helpful information:

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

blockRamPow2

Arguments

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

=> Clock dom

Clock to synchronize to

-> Enable dom

Global enable

-> 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
  :: Clock dom
  -> Enable dom
  -> Signal dom (Unsigned 5)
  -> Signal dom (Maybe (Unsigned 5, Bit))
  -> Signal dom Bit
bram32 clk en = blockRamPow2 clk en (replicate d32 1)

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 rst (blockRamPow2 clk inits) rd wrM.

BlockRAM read/write conflict resolution

readNew

Arguments

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

=> Clock dom

-> Reset dom

-> Enable dom

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

The 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

Utility functions

isRising

Arguments

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

=> Clock dom

-> Reset dom

-> Enable dom

-> a

Starting value

-> Signal dom a

-> Signal dom Bool

Give a pulse when the Signal goes from minBound to maxBound

isFalling

Arguments

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

=> Clock dom

-> Reset dom

-> Enable dom

-> a

Starting value

-> Signal dom a

-> Signal dom Bool

Give a pulse when the Signal goes from maxBound to minBound

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

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

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

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

Exported modules

Synchronous signals

module Clash.Explicit.Signal

module Clash.Explicit.Signal.Delayed

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

Type classes

Clash

module Clash.Class.BitPack

module Clash.Class.Num

module Clash.Class.Resize

Other

module Control.Applicative

module Data.Bits

Exceptions

module Clash.XException

Named types

module Clash.NamedTypes

Haskell Prelude

module Clash.HaskellPrelude