Clash.Explicit.Prelude

This module defines the explicitly clocked counterparts of the functions defined in Clash.Prelude. Take a look at Clash.Signal.Explicit to see how you can make multi-clock designs.

Creating synchronous sequential circuits

mealy

Arguments

:: Clock dom gated

Clock to synchronize to

-> Reset dom synchronous

-> (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
  :: Clock domain Source
  -> Reset domain Asynchronous
  -> Signal domain (Int, Int)
  -> Signal domain Int
mac clk rst = mealy clk rst macT 0

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

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

dualMac
  :: Clock domain gated -> Reset domain synchronous
  -> (Signal domain Int, Signal domain Int)
  -> (Signal domain Int, Signal domain Int)
  -> Signal domain Int
dualMac clk rst (a,b) (x,y) = s1 + s2
  where
    s1 = mealy clk rst mac 0 (bundle (a,x))
    s2 = mealy clk rst mac 0 (bundle (b,y))

mealyB

Arguments

:: (Bundle i, Bundle o)

=> Clock dom gated

-> Reset dom synchronous

-> (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 a b c = (b1,b2,i2)
  where
    (i1,b1) = unbundle (mealy clk rst f 0 (bundle (a,b)))
    (i2,b2) = unbundle (mealy clk rst f 3 (bundle (i1,c)))

Using mealyB' however we can write:

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

moore

Arguments

:: Clock domain gated

Clock to synchronize to

-> Reset domain synchronous

-> (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 domain i -> Signal domain 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
  :: Clock mac Source
  -> Reset mac Asynchronous
  -> Signal mac (Int, Int)
  -> Signal mac Int
mac clk rst = moore clk rst macT id 0

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

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

dualMac
  :: Clock domain gated
  -> Reset domain synchronous
  -> (Signal domain Int, Signal domain Int)
  -> (Signal domain Int, Signal domain Int)
  -> Signal domain Int
dualMac clk rst (a,b) (x,y) = s1 + s2
  where
    s1 = moore clk rst mac id 0 (bundle (a,x))
    s2 = moore clk rst mac id 0 (bundle (b,y))

mooreB

Arguments

:: (Bundle i, Bundle o)

=> Clock domain gated

-> Reset domain synchronous

-> (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 domain i -> Unbundled domain 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 a b c = (b1,b2,i2)
  where
    (i1,b1) = unbundle (moore clk rst t o 0 (bundle (a,b)))
    (i2,b2) = unbundle (moore clk rst t o 3 (bundle (i1,c)))

Using mooreB' however we can write:

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

registerB :: Bundle a => Clock domain gated -> Reset domain synchronous -> a -> Unbundled domain a -> Unbundled domain a

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

rP :: Clock domain gated -> Reset domain synchronous
   -> (Signal domain Int, Signal domain Int)
   -> (Signal domain Int, Signal domain Int)
rP clk rst = registerB clk rst (8,8)

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

Synchronizer circuits for safe clock domain crossings

dualFlipFlopSynchronizer

Arguments

:: Clock domain1 gated1

Clock to which the incoming data is synchronised

-> Clock domain2 gated2

Clock to which the outgoing data is synchronised

-> Reset domain2 synchronous

Reset for registers on the outgoing domain

-> a

Initial value of the two synchronisation registers

-> Signal domain1 a

Incoming data

-> Signal domain2 a

Outgoing, synchronised, data

Synchroniser based on two sequentially connected flip-flops.

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

• NB: Although this synchroniser does reduce metastability, it does not guarantee the proper synchronisation 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-synchronisation use asyncFIFOSynchronizer.

asyncFIFOSynchronizer

Arguments

:: 2 <= addrSize

=> SNat addrSize

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

-> Clock wdomain wgated

Clock to which the write port is synchronised

-> Clock rdomain rgated

Clock to which the read port is synchronised

-> Reset wdomain synchronous

-> Reset rdomain synchronous

-> Signal rdomain Bool

Read request

-> Signal wdomain (Maybe a)

Element to insert

-> (Signal rdomain a, Signal rdomain Bool, Signal wdomain Bool)

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

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

:: (KnownNat n, Enum addr)

=> Clock domain gated

Clock to synchronize to

-> Vec n a

ROM content

NB: must be a constant

-> Signal domain addr

Read address rd

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

:: KnownNat n

=> Clock domain gated

Clock to synchronize to

-> Vec (2 ^ n) a

ROM content

NB: must be a constant

-> Signal domain (Unsigned n)

Read address rd

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

ROMs initialised with a data file

asyncRomFile

Arguments

:: (KnownNat m, Enum addr)

=> SNat n

Size of the ROM

-> FilePath

File describing the content of the ROM

-> addr

Read address rd

-> BitVector m

The value of the ROM at address rd

An asynchronous/combinational ROM with space for n elements

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

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

Additional helpful information:

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

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

  myRomData = asyncRomFile d512 "memory.bin"
  

  or giving it a polymorphic type signature:

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

  you should give it a monomorphic type signature:

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

asyncRomFilePow2

Arguments

:: (KnownNat m, KnownNat n)

=> FilePath

File describing the content of the ROM

-> Unsigned n

Read address rd

-> BitVector m

The value of the ROM at address rd

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

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

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

Additional helpful information:

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

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

  myRomData = asyncRomFilePow2 "memory.bin"
  

  you should give it a monomorphic type signature:

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

romFile

Arguments

:: (KnownNat m, Enum addr)

=> Clock domain gated

Clock to synchronize to

-> SNat n

Size of the ROM

-> FilePath

File describing the content of the ROM

-> Signal domain addr

Read address rd

-> Signal domain (BitVector m)

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

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

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

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

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

Additional helpful information:

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

romFilePow2

Arguments

:: (KnownNat m, KnownNat n)

=> Clock domain gated

Clock to synchronize to

-> FilePath

File describing the content of the ROM

-> Signal domain (Unsigned n)

Read address rd

-> Signal domain (BitVector m)

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

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

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

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

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

Additional helpful information:

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

RAM primitives with a combinational read port

asyncRam

Arguments

:: (Enum addr, HasCallStack)

=> Clock wdom wgated

Clock to which to synchronise the write port of the RAM

-> Clock rdom rgated

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

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

:: (KnownNat n, HasCallStack)

=> Clock wdom wgated

Clock to which to synchronise the write port of the RAM

-> Clock rdom rgated

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

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

:: HasCallStack

=> Enum addr

=> Clock dom gated

Clock to synchronize to

-> 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  domain gated
       -> Signal domain (Unsigned 6)
       -> Signal domain (Maybe (Unsigned 6, Bit))
       -> Signal domain Bit
bram40 clk = blockRam clk (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

:: (KnownNat n, HasCallStack)

=> Clock dom gated

Clock to synchronize to

-> 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 :: Signal domain (Unsigned 5)
       -> Signal domain (Maybe (Unsigned 5, Bit))
       -> Signal domain Bit
bram32 clk = blockRamPow2 clk (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 primitives initialised with a data file

blockRamFile

Arguments

:: (KnownNat m, Enum addr, HasCallStack)

=> Clock dom gated

Clock to synchronize to

-> SNat n

Size of the blockRAM

-> FilePath

File describing the initial content of the blockRAM

-> Signal dom addr

Read address r

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

(write address w, value to write)

-> Signal dom (BitVector m)

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

Create a blockRAM with space for n elements

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

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

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

Additional helpful information:

• See Clash.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 (blockRamFile' clk size file) rd wrM.
• See Clash.Explicit.BlockRam.File for more information on how to instantiate a Block RAM with the contents of a data file.
• See Clash.Sized.Fixed for ideas on how to create your own data files.

blockRamFilePow2

Arguments

:: (KnownNat m, KnownNat n, HasCallStack)

=> Clock dom gated

Clock to synchronize to

-> FilePath

File describing the initial content of the blockRAM

-> Signal dom (Unsigned n)

Read address r

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

(write address w, value to write)

-> Signal dom (BitVector m)

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

Create a blockRAM with space for 2^n elements

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

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

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

Additional helpful information:

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

BlockRAM read/write conflict resolution

readNew

Arguments

:: Eq addr

=> Reset domain synchronous

-> Clock domain gated

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

The ram component

-> Signal domain addr

Read address r

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

(Write address w, value to write)

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

window

Arguments

:: (KnownNat n, Default a)

=> Clock domain gated

Clock to which the incoming signal is synchronized

-> Reset domain synchronous

-> Signal domain a

Signal to create a window over

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

Window of at least size 1

Give a window over a Signal

@ window4

windowD

Arguments

:: (KnownNat n, Default a)

=> Clock domain gated

Clock to which the incoming signal is synchronized

-> Reset domain synchronous

-> Signal domain a

Signal to create a window over

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

Window of at least size 1

Give a delayed window over a Signal

windowD3 :: Clock domain gated -> Reset domain synchronous
         -> Signal domain Int -> Vec 3 (Signal domain Int)
windowD3 = windowD

>>> simulateB (windowD3 systemClockGen systemResetGen) [1::Int,2,3,4] :: [Vec 3 Int]
[<0,0,0>,<1,0,0>,<2,1,0>,<3,2,1>,<4,3,2>...
...

isRising

Arguments

:: (Bounded a, Eq a)

=> Clock domain gated

-> Reset domain synchronous

-> a

Starting value

-> Signal domain a

-> Signal domain Bool

Give a pulse when the Signal goes from minBound to maxBound

isFalling

Arguments

:: (Bounded a, Eq a)

=> Clock domain gated

-> Reset domain synchronous

-> a

Starting value

-> Signal domain a

-> Signal domain Bool

Give a pulse when the Signal goes from maxBound to minBound

Testbench functions

assert

Arguments

:: (Eq a, ShowX a)

=> Clock domain gated

-> Reset domain synchronous

-> String

Additional message

-> Signal domain a

Checked value

-> Signal domain a

Expected value

-> Signal domain b

Return value

-> Signal domain b

Compares the first two Signals for equality and logs a warning when they are not equal. The second Signal is considered the expected value. This function simply returns the third Signal' unaltered as its result. This function is used by outputVerifier.

NB: This function can be used in synthesizable designs.

stimuliGenerator

Arguments

:: KnownNat l

=> Clock domain gated

Clock to which to synchronize the output signal

-> Reset domain synchronous

-> Vec l a

Samples to generate

-> Signal domain a

Signal of given samples

To be used as one of the functions to create the "magical" testInput value, which the CλaSH compiler looks for to create the stimulus generator for the generated VHDL testbench.

Example:

testInput
  :: Clock domain gated -> Reset domain synchronous
  -> Signal domain Int
testInput clk rst = stimuliGenerator clk rst $(listToVecTH [(1::Int),3..21])

>>> sampleN 13 (testInput systemClockGen systemResetGen)
[1,3,5,7,9,11,13,15,17,19,21,21,21]

outputVerifier

Arguments

:: (KnownNat l, Eq a, ShowX a)

=> Clock domain gated

Clock to which the input signal is synchronized to

-> Reset domain synchronous

-> Vec l a

Samples to compare with

-> Signal domain a

Signal to verify

-> Signal domain Bool

Indicator that all samples are verified

To be used as one of the functions to generate the "magical" expectedOutput function, which the CλaSH compiler looks for to create the signal verifier for the generated VHDL testbench.

Example:

expectedOutput
  :: Clock domain gated -> Reset domain synchronous
  -> Signal domain Int -> Signal domain Bool
expectedOutput clk rst = outputVerifier clk rst $(listToVecTH ([70,99,2,3,4,5,7,8,9,10]::[Int]))

>>> import qualified Data.List as List
>>> sampleN 12 (expectedOutput systemClockGen systemResetGen (fromList ([0..10] List.++ [10,10,10])))

cycle(system10000): 0, outputVerifier
expected value: 70, not equal to actual value: 0
[False
cycle(system10000): 1, outputVerifier
expected value: 99, not equal to actual value: 1
,False,False,False,False,False
cycle(system10000): 6, outputVerifier
expected value: 7, not equal to actual value: 6
,False
cycle(system10000): 7, outputVerifier
expected value: 8, not equal to actual value: 7
,False
cycle(system10000): 8, outputVerifier
expected value: 9, not equal to actual value: 8
,False
cycle(system10000): 9, outputVerifier
expected value: 10, not equal to actual value: 9
,False,True,True]

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

Type-level natural numbers

module GHC.TypeLits

module Clash.Promoted.Nat

module Clash.Promoted.Nat.Literals

module Clash.Promoted.Nat.TH

Type-level strings

module Clash.Promoted.Symbol

Template Haskell

class Lift t where

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

add1 :: Int -> Q Exp
add1 x = [| x + 1 |]

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

A Lift instance must satisfy $(lift x) ≡ x for all x, where $(...) is a Template Haskell splice.

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

{-# LANGUAGE DeriveLift #-}
module Foo where

import Language.Haskell.TH.Syntax

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

Methods

lift :: t -> Q Exp

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

Instances

Lift Bool

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Bool -> Q Exp

Lift Char

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Char -> Q Exp

Lift Double

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Double -> Q Exp

Lift Float

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Float -> Q Exp

Lift Int

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int -> Q Exp

Lift Int8

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int8 -> Q Exp

Lift Int16

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int16 -> Q Exp

Lift Int32

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int32 -> Q Exp

Lift Int64

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int64 -> Q Exp

Lift Integer

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Integer -> Q Exp

Lift Natural

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Natural -> Q Exp

Lift Word

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word -> Q Exp

Lift Word8

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word8 -> Q Exp

Lift Word16

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word16 -> Q Exp

Lift Word32

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word32 -> Q Exp

Lift Word64

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word64 -> Q Exp

Lift ()

Defined in Language.Haskell.TH.Syntax

Methods

lift :: () -> Q Exp

Lift PortName

Defined in Clash.Annotations.TopEntity

Methods

lift :: PortName -> Q Exp

Lift TopEntity

Defined in Clash.Annotations.TopEntity

Methods

lift :: TopEntity -> Q Exp

Lift Bit

Defined in Clash.Sized.Internal.BitVector

Methods

lift :: Bit -> Q Exp

Lift Half

Defined in Numeric.Half

Methods

lift :: Half -> Q Exp

Lift a => Lift [a]

Defined in Language.Haskell.TH.Syntax

Methods

lift :: [a] -> Q Exp

Lift a => Lift (Maybe a)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Maybe a -> Q Exp

Integral a => Lift (Ratio a)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Ratio a -> Q Exp

KnownNat n => Lift (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

lift :: BitVector n -> Q Exp

KnownNat n => Lift (Index n)

Defined in Clash.Sized.Internal.Index

Methods

lift :: Index n -> Q Exp

Lift (SNat n)

Defined in Clash.Promoted.Nat

Methods

lift :: SNat n -> Q Exp

KnownNat n => Lift (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

lift :: Unsigned n -> Q Exp

KnownNat n => Lift (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

lift :: Signed n -> Q Exp

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

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Either a b -> Q Exp

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

Defined in Language.Haskell.TH.Syntax

Methods

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

Lift a => Lift (Vec n a)

Defined in Clash.Sized.Vector

Methods

lift :: Vec n a -> Q Exp

Lift a => Lift (Signal domain a)

Defined in Clash.Signal.Internal

Methods

lift :: Signal domain a -> Q Exp

Lift a => Lift (RTree d a)

Defined in Clash.Sized.RTree

Methods

lift :: RTree d a -> Q Exp

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

Defined in Language.Haskell.TH.Syntax

Methods

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

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

Defined in Clash.Sized.Fixed

Methods

lift :: Fixed rep int frac -> Q Exp

Lift a => Lift (DSignal domain delay a)

Defined in Clash.Explicit.Signal.Delayed

Methods

lift :: DSignal domain delay a -> Q Exp

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

Defined in Language.Haskell.TH.Syntax

Methods

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

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

Defined in Language.Haskell.TH.Syntax

Methods

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

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

Defined in Language.Haskell.TH.Syntax

Methods

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

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

Defined in Language.Haskell.TH.Syntax

Methods

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

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

undefined :: HasCallStack => a

Named types

module Clash.NamedTypes

Haskell Prelude

seq :: a -> b -> b

The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness.

A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.

filter :: (a -> Bool) -> [a] -> [a]

filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

filter p xs = [ x | x <- xs, p x]

print :: Show a => a -> IO ()

The print function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class Show; print converts values to strings for output using the show operation and adds a newline.

For example, a program to print the first 20 integers and their powers of 2 could be written as:

main = print ([(n, 2^n) | n <- [0..19]])

fst :: (a, b) -> a

Extract the first component of a pair.

snd :: (a, b) -> b

Extract the second component of a pair.

otherwise :: Bool

otherwise is defined as the value True. It helps to make guards more readable. eg.

 f x | x < 0     = ...
     | otherwise = ...

($) :: (a -> b) -> a -> b infixr 0

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs.

fromIntegral :: (Integral a, Num b) => a -> b

general coercion from integral types

realToFrac :: (Real a, Fractional b) => a -> b

general coercion to fractional types

class Bounded a where

The Bounded class is used to name the upper and lower limits of a type. Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.

The Bounded class may be derived for any enumeration type; minBound is the first constructor listed in the data declaration and maxBound is the last. Bounded may also be derived for single-constructor datatypes whose constituent types are in Bounded.

Minimal complete definition

minBound, maxBound

Methods

minBound :: a

maxBound :: a

Instances

Bounded Bool

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Bool

maxBound :: Bool

Bounded Char

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Char

maxBound :: Char

Bounded Int

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Int

maxBound :: Int

Bounded Int8

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int8

maxBound :: Int8

Bounded Int16

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int16

maxBound :: Int16

Bounded Int32

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int32

maxBound :: Int32

Bounded Int64

Since: base-2.1

Defined in GHC.Int

Methods

minBound :: Int64

maxBound :: Int64

Bounded Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Ordering

maxBound :: Ordering

Bounded Word

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Word

maxBound :: Word

Bounded Word8

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word8

maxBound :: Word8

Bounded Word16

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word16

maxBound :: Word16

Bounded Word32

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word32

maxBound :: Word32

Bounded Word64

Since: base-2.1

Defined in GHC.Word

Methods

minBound :: Word64

maxBound :: Word64

Bounded VecCount

Since: base-4.10.0.0

Defined in GHC.Enum

Methods

minBound :: VecCount

maxBound :: VecCount

Bounded VecElem

Since: base-4.10.0.0

Defined in GHC.Enum

Methods

minBound :: VecElem

maxBound :: VecElem

Bounded ()

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: ()

maxBound :: ()

Bounded All

Defined in Data.Semigroup.Internal

Methods

minBound :: All

maxBound :: All

Bounded Any

Defined in Data.Semigroup.Internal

Methods

minBound :: Any

maxBound :: Any

Bounded Associativity

Defined in GHC.Generics

Methods

minBound :: Associativity

maxBound :: Associativity

Bounded SourceUnpackedness

Defined in GHC.Generics

Methods

minBound :: SourceUnpackedness

maxBound :: SourceUnpackedness

Bounded SourceStrictness

Defined in GHC.Generics

Methods

minBound :: SourceStrictness

maxBound :: SourceStrictness

Bounded DecidedStrictness

Defined in GHC.Generics

Methods

minBound :: DecidedStrictness

maxBound :: DecidedStrictness

Bounded CChar

Defined in Foreign.C.Types

Methods

minBound :: CChar

maxBound :: CChar

Bounded CSChar

Defined in Foreign.C.Types

Methods

minBound :: CSChar

maxBound :: CSChar

Bounded CUChar

Defined in Foreign.C.Types

Methods

minBound :: CUChar

maxBound :: CUChar

Bounded CShort

Defined in Foreign.C.Types

Methods

minBound :: CShort

maxBound :: CShort

Bounded CUShort

Defined in Foreign.C.Types

Methods

minBound :: CUShort

maxBound :: CUShort

Bounded CInt

Defined in Foreign.C.Types

Methods

minBound :: CInt

maxBound :: CInt

Bounded CUInt

Defined in Foreign.C.Types

Methods

minBound :: CUInt

maxBound :: CUInt

Bounded CLong

Defined in Foreign.C.Types

Methods

minBound :: CLong

maxBound :: CLong

Bounded CULong

Defined in Foreign.C.Types

Methods

minBound :: CULong

maxBound :: CULong

Bounded CLLong

Defined in Foreign.C.Types

Methods

minBound :: CLLong

maxBound :: CLLong

Bounded CULLong

Defined in Foreign.C.Types

Methods

minBound :: CULLong

maxBound :: CULLong

Bounded CBool

Defined in Foreign.C.Types

Methods

minBound :: CBool

maxBound :: CBool

Bounded CPtrdiff

Defined in Foreign.C.Types

Methods

minBound :: CPtrdiff

maxBound :: CPtrdiff

Bounded CSize

Defined in Foreign.C.Types

Methods

minBound :: CSize

maxBound :: CSize

Bounded CWchar

Defined in Foreign.C.Types

Methods

minBound :: CWchar

maxBound :: CWchar

Bounded CSigAtomic

Defined in Foreign.C.Types

Methods

minBound :: CSigAtomic

maxBound :: CSigAtomic

Bounded CIntPtr

Defined in Foreign.C.Types

Methods

minBound :: CIntPtr

maxBound :: CIntPtr

Bounded CUIntPtr

Defined in Foreign.C.Types

Methods

minBound :: CUIntPtr

maxBound :: CUIntPtr

Bounded CIntMax

Defined in Foreign.C.Types

Methods

minBound :: CIntMax

maxBound :: CIntMax

Bounded CUIntMax

Defined in Foreign.C.Types

Methods

minBound :: CUIntMax

maxBound :: CUIntMax

Bounded GeneralCategory

Defined in GHC.Unicode

Methods

minBound :: GeneralCategory

maxBound :: GeneralCategory

Bounded Bit

Defined in Clash.Sized.Internal.BitVector

Methods

minBound :: Bit

maxBound :: Bit

a :=> (Bounded (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a)

() :=> (Bounded Bool)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Bool

() :=> (Bounded Char)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Char

() :=> (Bounded Int)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Int

() :=> (Bounded Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Ordering

() :=> (Bounded Word)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Word

() :=> (Bounded ())

Defined in Data.Constraint

Methods

ins :: () :- Bounded ()

Class () (Bounded a)

Defined in Data.Constraint

Methods

cls :: Bounded a :- ()

Bounded a => Bounded (Min a)

Defined in Data.Semigroup

Methods

minBound :: Min a

maxBound :: Min a

Bounded a => Bounded (Max a)

Defined in Data.Semigroup

Methods

minBound :: Max a

maxBound :: Max a

Bounded a => Bounded (First a)

Defined in Data.Semigroup

Methods

minBound :: First a

maxBound :: First a

Bounded a => Bounded (Last a)

Defined in Data.Semigroup

Methods

minBound :: Last a

maxBound :: Last a

Bounded m => Bounded (WrappedMonoid m)

Defined in Data.Semigroup

Methods

minBound :: WrappedMonoid m

maxBound :: WrappedMonoid m

Bounded a => Bounded (Identity a)

Defined in Data.Functor.Identity

Methods

minBound :: Identity a

maxBound :: Identity a

Bounded a => Bounded (Dual a)

Defined in Data.Semigroup.Internal

Methods

minBound :: Dual a

maxBound :: Dual a

Bounded a => Bounded (Sum a)

Defined in Data.Semigroup.Internal

Methods

minBound :: Sum a

maxBound :: Sum a

Bounded a => Bounded (Product a)

Defined in Data.Semigroup.Internal

Methods

minBound :: Product a

maxBound :: Product a

KnownNat n => Bounded (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

minBound :: BitVector n

maxBound :: BitVector n

KnownNat n => Bounded (Index n)

Defined in Clash.Sized.Internal.Index

Methods

minBound :: Index n

maxBound :: Index n

(Ord a, Num a) => Bounded (Bounds a)

Defined in Test.QuickCheck.Arbitrary

Methods

minBound :: Bounds a

maxBound :: Bounds a

KnownNat n => Bounded (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

minBound :: Unsigned n

maxBound :: Unsigned n

KnownNat n => Bounded (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

minBound :: Signed n

maxBound :: Signed n

a => Bounded (Dict a)

Defined in Data.Constraint

Methods

minBound :: Dict a

maxBound :: Dict a

(Bounded a) :=> (Bounded (Identity a))

Defined in Data.Constraint

Methods

ins :: Bounded a :- Bounded (Identity a)

(Bounded a) :=> (Bounded (Const a b))

Defined in Data.Constraint

Methods

ins :: Bounded a :- Bounded (Const a b)

(Bounded a, Bounded b) => Bounded (a, b)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b)

maxBound :: (a, b)

Bounded (Proxy t)

Defined in Data.Proxy

Methods

minBound :: Proxy t

maxBound :: Proxy t

(Bounded a, Bounded b) :=> (Bounded (a, b))

Defined in Data.Constraint

Methods

ins :: (Bounded a, Bounded b) :- Bounded (a, b)

(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c)

maxBound :: (a, b, c)

Bounded a => Bounded (Const a b)

Defined in Data.Functor.Const

Methods

minBound :: Const a b

maxBound :: Const a b

a ~ b => Bounded (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

minBound :: a :~: b

maxBound :: a :~: b

Bounded b => Bounded (Tagged s b)

Defined in Data.Tagged

Methods

minBound :: Tagged s b

maxBound :: Tagged s b

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

Defined in Clash.Sized.Fixed

Methods

minBound :: Fixed rep int frac

maxBound :: Fixed rep int frac

(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d)

maxBound :: (a, b, c, d)

a ~~ b => Bounded (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

minBound :: a :~~: b

maxBound :: a :~~: b

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e)

maxBound :: (a, b, c, d, e)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f)

maxBound :: (a, b, c, d, e, f)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g)

maxBound :: (a, b, c, d, e, f, g)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h)

maxBound :: (a, b, c, d, e, f, g, h)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i)

maxBound :: (a, b, c, d, e, f, g, h, i)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j)

maxBound :: (a, b, c, d, e, f, g, h, i, j)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Enum a where

Class Enum defines operations on sequentially ordered types.

The enumFrom... methods are used in Haskell's translation of arithmetic sequences.

Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details.

For any type that is an instance of class Bounded as well as Enum, the following should hold:

• The calls succ maxBound and pred minBound should result in a runtime error.
• fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.
• enumFrom and enumFromThen should be defined with an implicit bound, thus:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a

the successor of a value. For numeric types, succ adds 1.

pred :: a -> a

the predecessor of a value. For numeric types, pred subtracts 1.

toEnum :: Int -> a

Convert from an Int.

fromEnum :: a -> Int

Convert to an Int. It is implementation-dependent what fromEnum returns when applied to a value that is too large to fit in an Int.

enumFrom :: a -> [a]

Used in Haskell's translation of [n..].

enumFromThen :: a -> a -> [a]

Used in Haskell's translation of [n,n'..].

enumFromTo :: a -> a -> [a]

Used in Haskell's translation of [n..m].

enumFromThenTo :: a -> a -> a -> [a]

Used in Haskell's translation of [n,n'..m].

Instances

Enum Bool

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Bool -> Bool

pred :: Bool -> Bool

toEnum :: Int -> Bool

fromEnum :: Bool -> Int

enumFrom :: Bool -> [Bool]

enumFromThen :: Bool -> Bool -> [Bool]

enumFromTo :: Bool -> Bool -> [Bool]

enumFromThenTo :: Bool -> Bool -> Bool -> [Bool]

Enum Char

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Enum Int

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

Enum Int8

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int8 -> Int8

pred :: Int8 -> Int8

toEnum :: Int -> Int8

fromEnum :: Int8 -> Int

enumFrom :: Int8 -> [Int8]

enumFromThen :: Int8 -> Int8 -> [Int8]

enumFromTo :: Int8 -> Int8 -> [Int8]

enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8]

Enum Int16

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int16 -> Int16

pred :: Int16 -> Int16

toEnum :: Int -> Int16

fromEnum :: Int16 -> Int

enumFrom :: Int16 -> [Int16]

enumFromThen :: Int16 -> Int16 -> [Int16]

enumFromTo :: Int16 -> Int16 -> [Int16]

enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16]

Enum Int32

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int32 -> Int32

pred :: Int32 -> Int32

toEnum :: Int -> Int32

fromEnum :: Int32 -> Int

enumFrom :: Int32 -> [Int32]

enumFromThen :: Int32 -> Int32 -> [Int32]

enumFromTo :: Int32 -> Int32 -> [Int32]

enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32]

Enum Int64

Since: base-2.1

Defined in GHC.Int

Methods

succ :: Int64 -> Int64

pred :: Int64 -> Int64

toEnum :: Int -> Int64

fromEnum :: Int64 -> Int

enumFrom :: Int64 -> [Int64]

enumFromThen :: Int64 -> Int64 -> [Int64]

enumFromTo :: Int64 -> Int64 -> [Int64]

enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64]

Enum Integer

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Integer -> Integer

pred :: Integer -> Integer

toEnum :: Int -> Integer

fromEnum :: Integer -> Int

enumFrom :: Integer -> [Integer]

enumFromThen :: Integer -> Integer -> [Integer]

enumFromTo :: Integer -> Integer -> [Integer]

enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]

Enum Natural

Since: base-4.8.0.0

Defined in GHC.Natural

Methods

succ :: Natural -> Natural

pred :: Natural -> Natural

toEnum :: Int -> Natural

fromEnum :: Natural -> Int

enumFrom :: Natural -> [Natural]

enumFromThen :: Natural -> Natural -> [Natural]

enumFromTo :: Natural -> Natural -> [Natural]

enumFromThenTo :: Natural -> Natural -> Natural -> [Natural]

Enum Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Ordering -> Ordering

pred :: Ordering -> Ordering

toEnum :: Int -> Ordering

fromEnum :: Ordering -> Int

enumFrom :: Ordering -> [Ordering]

enumFromThen :: Ordering -> Ordering -> [Ordering]

enumFromTo :: Ordering -> Ordering -> [Ordering]

enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering]

Enum Word

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Word -> Word

pred :: Word -> Word

toEnum :: Int -> Word

fromEnum :: Word -> Int

enumFrom :: Word -> [Word]

enumFromThen :: Word -> Word -> [Word]

enumFromTo :: Word -> Word -> [Word]

enumFromThenTo :: Word -> Word -> Word -> [Word]

Enum Word8

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word8 -> Word8

pred :: Word8 -> Word8

toEnum :: Int -> Word8

fromEnum :: Word8 -> Int

enumFrom :: Word8 -> [Word8]

enumFromThen :: Word8 -> Word8 -> [Word8]

enumFromTo :: Word8 -> Word8 -> [Word8]

enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8]

Enum Word16

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word16 -> Word16

pred :: Word16 -> Word16

toEnum :: Int -> Word16

fromEnum :: Word16 -> Int

enumFrom :: Word16 -> [Word16]

enumFromThen :: Word16 -> Word16 -> [Word16]

enumFromTo :: Word16 -> Word16 -> [Word16]

enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16]

Enum Word32

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word32 -> Word32

pred :: Word32 -> Word32

toEnum :: Int -> Word32

fromEnum :: Word32 -> Int

enumFrom :: Word32 -> [Word32]

enumFromThen :: Word32 -> Word32 -> [Word32]

enumFromTo :: Word32 -> Word32 -> [Word32]

enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32]

Enum Word64

Since: base-2.1

Defined in GHC.Word

Methods

succ :: Word64 -> Word64

pred :: Word64 -> Word64

toEnum :: Int -> Word64

fromEnum :: Word64 -> Int

enumFrom :: Word64 -> [Word64]

enumFromThen :: Word64 -> Word64 -> [Word64]

enumFromTo :: Word64 -> Word64 -> [Word64]

enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64]

Enum VecCount

Since: base-4.10.0.0

Defined in GHC.Enum

Methods

succ :: VecCount -> VecCount

pred :: VecCount -> VecCount

toEnum :: Int -> VecCount

fromEnum :: VecCount -> Int

enumFrom :: VecCount -> [VecCount]

enumFromThen :: VecCount -> VecCount -> [VecCount]

enumFromTo :: VecCount -> VecCount -> [VecCount]

enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount]

Enum VecElem

Since: base-4.10.0.0

Defined in GHC.Enum

Methods

succ :: VecElem -> VecElem

pred :: VecElem -> VecElem

toEnum :: Int -> VecElem

fromEnum :: VecElem -> Int

enumFrom :: VecElem -> [VecElem]

enumFromThen :: VecElem -> VecElem -> [VecElem]

enumFromTo :: VecElem -> VecElem -> [VecElem]

enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem]

Enum ()

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: () -> ()

pred :: () -> ()

toEnum :: Int -> ()

fromEnum :: () -> Int

enumFrom :: () -> [()]

enumFromThen :: () -> () -> [()]

enumFromTo :: () -> () -> [()]

enumFromThenTo :: () -> () -> () -> [()]

Enum Associativity

Defined in GHC.Generics

Methods

succ :: Associativity -> Associativity

pred :: Associativity -> Associativity

toEnum :: Int -> Associativity

fromEnum :: Associativity -> Int

enumFrom :: Associativity -> [Associativity]

enumFromThen :: Associativity -> Associativity -> [Associativity]

enumFromTo :: Associativity -> Associativity -> [Associativity]

enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity]

Enum SourceUnpackedness

Defined in GHC.Generics

Methods

succ :: SourceUnpackedness -> SourceUnpackedness

pred :: SourceUnpackedness -> SourceUnpackedness

toEnum :: Int -> SourceUnpackedness

fromEnum :: SourceUnpackedness -> Int

enumFrom :: SourceUnpackedness -> [SourceUnpackedness]

enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]

enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]

enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]

Enum SourceStrictness

Defined in GHC.Generics

Methods

succ :: SourceStrictness -> SourceStrictness

pred :: SourceStrictness -> SourceStrictness

toEnum :: Int -> SourceStrictness

fromEnum :: SourceStrictness -> Int

enumFrom :: SourceStrictness -> [SourceStrictness]

enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness]

enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness]

enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness]

Enum DecidedStrictness

Defined in GHC.Generics

Methods

succ :: DecidedStrictness -> DecidedStrictness

pred :: DecidedStrictness -> DecidedStrictness

toEnum :: Int -> DecidedStrictness

fromEnum :: DecidedStrictness -> Int

enumFrom :: DecidedStrictness -> [DecidedStrictness]

enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]

enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]

enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]

Enum CChar

Defined in Foreign.C.Types

Methods

succ :: CChar -> CChar

pred :: CChar -> CChar

toEnum :: Int -> CChar

fromEnum :: CChar -> Int

enumFrom :: CChar -> [CChar]

enumFromThen :: CChar -> CChar -> [CChar]

enumFromTo :: CChar -> CChar -> [CChar]

enumFromThenTo :: CChar -> CChar -> CChar -> [CChar]

Enum CSChar

Defined in Foreign.C.Types

Methods

succ :: CSChar -> CSChar

pred :: CSChar -> CSChar

toEnum :: Int -> CSChar

fromEnum :: CSChar -> Int

enumFrom :: CSChar -> [CSChar]

enumFromThen :: CSChar -> CSChar -> [CSChar]

enumFromTo :: CSChar -> CSChar -> [CSChar]

enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar]

Enum CUChar

Defined in Foreign.C.Types

Methods

succ :: CUChar -> CUChar

pred :: CUChar -> CUChar

toEnum :: Int -> CUChar

fromEnum :: CUChar -> Int

enumFrom :: CUChar -> [CUChar]

enumFromThen :: CUChar -> CUChar -> [CUChar]

enumFromTo :: CUChar -> CUChar -> [CUChar]

enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar]

Enum CShort

Defined in Foreign.C.Types

Methods

succ :: CShort -> CShort

pred :: CShort -> CShort

toEnum :: Int -> CShort

fromEnum :: CShort -> Int

enumFrom :: CShort -> [CShort]

enumFromThen :: CShort -> CShort -> [CShort]

enumFromTo :: CShort -> CShort -> [CShort]

enumFromThenTo :: CShort -> CShort -> CShort -> [CShort]

Enum CUShort

Defined in Foreign.C.Types

Methods

succ :: CUShort -> CUShort

pred :: CUShort -> CUShort

toEnum :: Int -> CUShort

fromEnum :: CUShort -> Int

enumFrom :: CUShort -> [CUShort]

enumFromThen :: CUShort -> CUShort -> [CUShort]

enumFromTo :: CUShort -> CUShort -> [CUShort]

enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort]

Enum CInt

Defined in Foreign.C.Types

Methods

succ :: CInt -> CInt

pred :: CInt -> CInt

toEnum :: Int -> CInt

fromEnum :: CInt -> Int

enumFrom :: CInt -> [CInt]

enumFromThen :: CInt -> CInt -> [CInt]

enumFromTo :: CInt -> CInt -> [CInt]

enumFromThenTo :: CInt -> CInt -> CInt -> [CInt]

Enum CUInt

Defined in Foreign.C.Types

Methods

succ :: CUInt -> CUInt

pred :: CUInt -> CUInt

toEnum :: Int -> CUInt

fromEnum :: CUInt -> Int

enumFrom :: CUInt -> [CUInt]

enumFromThen :: CUInt -> CUInt -> [CUInt]

enumFromTo :: CUInt -> CUInt -> [CUInt]

enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt]

Enum CLong

Defined in Foreign.C.Types

Methods

succ :: CLong -> CLong

pred :: CLong -> CLong

toEnum :: Int -> CLong

fromEnum :: CLong -> Int

enumFrom :: CLong -> [CLong]

enumFromThen :: CLong -> CLong -> [CLong]

enumFromTo :: CLong -> CLong -> [CLong]

enumFromThenTo :: CLong -> CLong -> CLong -> [CLong]

Enum CULong

Defined in Foreign.C.Types

Methods

succ :: CULong -> CULong

pred :: CULong -> CULong

toEnum :: Int -> CULong

fromEnum :: CULong -> Int

enumFrom :: CULong -> [CULong]

enumFromThen :: CULong -> CULong -> [CULong]

enumFromTo :: CULong -> CULong -> [CULong]

enumFromThenTo :: CULong -> CULong -> CULong -> [CULong]

Enum CLLong

Defined in Foreign.C.Types

Methods

succ :: CLLong -> CLLong

pred :: CLLong -> CLLong

toEnum :: Int -> CLLong

fromEnum :: CLLong -> Int

enumFrom :: CLLong -> [CLLong]

enumFromThen :: CLLong -> CLLong -> [CLLong]

enumFromTo :: CLLong -> CLLong -> [CLLong]

enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong]

Enum CULLong

Defined in Foreign.C.Types

Methods

succ :: CULLong -> CULLong

pred :: CULLong -> CULLong

toEnum :: Int -> CULLong

fromEnum :: CULLong -> Int

enumFrom :: CULLong -> [CULLong]

enumFromThen :: CULLong -> CULLong -> [CULLong]

enumFromTo :: CULLong -> CULLong -> [CULLong]

enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong]

Enum CBool

Defined in Foreign.C.Types

Methods

succ :: CBool -> CBool

pred :: CBool -> CBool

toEnum :: Int -> CBool

fromEnum :: CBool -> Int

enumFrom :: CBool -> [CBool]

enumFromThen :: CBool -> CBool -> [CBool]

enumFromTo :: CBool -> CBool -> [CBool]

enumFromThenTo :: CBool -> CBool -> CBool -> [CBool]

Enum CFloat

Defined in Foreign.C.Types

Methods

succ :: CFloat -> CFloat

pred :: CFloat -> CFloat

toEnum :: Int -> CFloat

fromEnum :: CFloat -> Int

enumFrom :: CFloat -> [CFloat]

enumFromThen :: CFloat -> CFloat -> [CFloat]

enumFromTo :: CFloat -> CFloat -> [CFloat]

enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat]

Enum CDouble

Defined in Foreign.C.Types

Methods

succ :: CDouble -> CDouble

pred :: CDouble -> CDouble

toEnum :: Int -> CDouble

fromEnum :: CDouble -> Int

enumFrom :: CDouble -> [CDouble]

enumFromThen :: CDouble -> CDouble -> [CDouble]

enumFromTo :: CDouble -> CDouble -> [CDouble]

enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble]

Enum CPtrdiff

Defined in Foreign.C.Types

Methods

succ :: CPtrdiff -> CPtrdiff

pred :: CPtrdiff -> CPtrdiff

toEnum :: Int -> CPtrdiff

fromEnum :: CPtrdiff -> Int

enumFrom :: CPtrdiff -> [CPtrdiff]

enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff]

enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff]

enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff]

Enum CSize

Defined in Foreign.C.Types

Methods

succ :: CSize -> CSize

pred :: CSize -> CSize

toEnum :: Int -> CSize

fromEnum :: CSize -> Int

enumFrom :: CSize -> [CSize]

enumFromThen :: CSize -> CSize -> [CSize]

enumFromTo :: CSize -> CSize -> [CSize]

enumFromThenTo :: CSize -> CSize -> CSize -> [CSize]

Enum CWchar

Defined in Foreign.C.Types

Methods

succ :: CWchar -> CWchar

pred :: CWchar -> CWchar

toEnum :: Int -> CWchar

fromEnum :: CWchar -> Int

enumFrom :: CWchar -> [CWchar]

enumFromThen :: CWchar -> CWchar -> [CWchar]

enumFromTo :: CWchar -> CWchar -> [CWchar]

enumFromThenTo :: CWchar -> CWchar -> CWchar -> [CWchar]

Enum CSigAtomic

Defined in Foreign.C.Types

Methods

succ :: CSigAtomic -> CSigAtomic

pred :: CSigAtomic -> CSigAtomic

toEnum :: Int -> CSigAtomic

fromEnum :: CSigAtomic -> Int

enumFrom :: CSigAtomic -> [CSigAtomic]

enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic]

enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic]

enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic]

Enum CClock

Defined in Foreign.C.Types

Methods

succ :: CClock -> CClock

pred :: CClock -> CClock

toEnum :: Int -> CClock

fromEnum :: CClock -> Int

enumFrom :: CClock -> [CClock]

enumFromThen :: CClock -> CClock -> [CClock]

enumFromTo :: CClock -> CClock -> [CClock]

enumFromThenTo :: CClock -> CClock -> CClock -> [CClock]

Enum CTime

Defined in Foreign.C.Types

Methods

succ :: CTime -> CTime

pred :: CTime -> CTime

toEnum :: Int -> CTime

fromEnum :: CTime -> Int

enumFrom :: CTime -> [CTime]

enumFromThen :: CTime -> CTime -> [CTime]

enumFromTo :: CTime -> CTime -> [CTime]

enumFromThenTo :: CTime -> CTime -> CTime -> [CTime]

Enum CUSeconds

Defined in Foreign.C.Types

Methods

succ :: CUSeconds -> CUSeconds

pred :: CUSeconds -> CUSeconds

toEnum :: Int -> CUSeconds

fromEnum :: CUSeconds -> Int

enumFrom :: CUSeconds -> [CUSeconds]

enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds]

enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds]

enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds]

Enum CSUSeconds

Defined in Foreign.C.Types

Methods

succ :: CSUSeconds -> CSUSeconds

pred :: CSUSeconds -> CSUSeconds

toEnum :: Int -> CSUSeconds

fromEnum :: CSUSeconds -> Int

enumFrom :: CSUSeconds -> [CSUSeconds]

enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds]

enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds]

enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds]

Enum CIntPtr

Defined in Foreign.C.Types

Methods

succ :: CIntPtr -> CIntPtr

pred :: CIntPtr -> CIntPtr

toEnum :: Int -> CIntPtr

fromEnum :: CIntPtr -> Int

enumFrom :: CIntPtr -> [CIntPtr]

enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr]

enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr]

enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr]

Enum CUIntPtr

Defined in Foreign.C.Types

Methods

succ :: CUIntPtr -> CUIntPtr

pred :: CUIntPtr -> CUIntPtr

toEnum :: Int -> CUIntPtr

fromEnum :: CUIntPtr -> Int

enumFrom :: CUIntPtr -> [CUIntPtr]

enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr]

enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr]

enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr]

Enum CIntMax

Defined in Foreign.C.Types

Methods

succ :: CIntMax -> CIntMax

pred :: CIntMax -> CIntMax

toEnum :: Int -> CIntMax

fromEnum :: CIntMax -> Int

enumFrom :: CIntMax -> [CIntMax]

enumFromThen :: CIntMax -> CIntMax -> [CIntMax]

enumFromTo :: CIntMax -> CIntMax -> [CIntMax]

enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax]

Enum CUIntMax

Defined in Foreign.C.Types

Methods

succ :: CUIntMax -> CUIntMax

pred :: CUIntMax -> CUIntMax

toEnum :: Int -> CUIntMax

fromEnum :: CUIntMax -> Int

enumFrom :: CUIntMax -> [CUIntMax]

enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax]

enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax]

enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax]

Enum GeneralCategory

Defined in GHC.Unicode

Methods

succ :: GeneralCategory -> GeneralCategory

pred :: GeneralCategory -> GeneralCategory

toEnum :: Int -> GeneralCategory

fromEnum :: GeneralCategory -> Int

enumFrom :: GeneralCategory -> [GeneralCategory]

enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory]

enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory]

enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory]

Enum Extension

Defined in GHC.LanguageExtensions.Type

Methods

succ :: Extension -> Extension

pred :: Extension -> Extension

toEnum :: Int -> Extension

fromEnum :: Extension -> Int

enumFrom :: Extension -> [Extension]

enumFromThen :: Extension -> Extension -> [Extension]

enumFromTo :: Extension -> Extension -> [Extension]

enumFromThenTo :: Extension -> Extension -> Extension -> [Extension]

Enum Day

Defined in Data.Time.Calendar.Days

Methods

succ :: Day -> Day

pred :: Day -> Day

toEnum :: Int -> Day

fromEnum :: Day -> Int

enumFrom :: Day -> [Day]

enumFromThen :: Day -> Day -> [Day]

enumFromTo :: Day -> Day -> [Day]

enumFromThenTo :: Day -> Day -> Day -> [Day]

Enum Bit

Defined in Clash.Sized.Internal.BitVector

Methods

succ :: Bit -> Bit

pred :: Bit -> Bit

toEnum :: Int -> Bit

fromEnum :: Bit -> Int

enumFrom :: Bit -> [Bit]

enumFromThen :: Bit -> Bit -> [Bit]

enumFromTo :: Bit -> Bit -> [Bit]

enumFromThenTo :: Bit -> Bit -> Bit -> [Bit]

a :=> (Enum (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a)

() :=> (Enum Bool)

Defined in Data.Constraint

Methods

ins :: () :- Enum Bool

() :=> (Enum Char)

Defined in Data.Constraint

Methods

ins :: () :- Enum Char

() :=> (Enum Double)

Defined in Data.Constraint

Methods

ins :: () :- Enum Double

() :=> (Enum Float)

Defined in Data.Constraint

Methods

ins :: () :- Enum Float

() :=> (Enum Int)

Defined in Data.Constraint

Methods

ins :: () :- Enum Int

() :=> (Enum Integer)

Defined in Data.Constraint

Methods

ins :: () :- Enum Integer

() :=> (Enum Natural)

Defined in Data.Constraint

Methods

ins :: () :- Enum Natural

() :=> (Enum Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Enum Ordering

() :=> (Enum Word)

Defined in Data.Constraint

Methods

ins :: () :- Enum Word

() :=> (Enum ())

Defined in Data.Constraint

Methods

ins :: () :- Enum ()

Class () (Enum a)

Defined in Data.Constraint

Methods

cls :: Enum a :- ()

Integral a => Enum (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

succ :: Ratio a -> Ratio a

pred :: Ratio a -> Ratio a

toEnum :: Int -> Ratio a

fromEnum :: Ratio a -> Int

enumFrom :: Ratio a -> [Ratio a]

enumFromThen :: Ratio a -> Ratio a -> [Ratio a]

enumFromTo :: Ratio a -> Ratio a -> [Ratio a]

enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a]

Enum (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

succ :: Fixed a -> Fixed a

pred :: Fixed a -> Fixed a

toEnum :: Int -> Fixed a

fromEnum :: Fixed a -> Int

enumFrom :: Fixed a -> [Fixed a]

enumFromThen :: Fixed a -> Fixed a -> [Fixed a]

enumFromTo :: Fixed a -> Fixed a -> [Fixed a]

enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a]

Enum a => Enum (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: Min a -> Min a

pred :: Min a -> Min a

toEnum :: Int -> Min a

fromEnum :: Min a -> Int

enumFrom :: Min a -> [Min a]

enumFromThen :: Min a -> Min a -> [Min a]

enumFromTo :: Min a -> Min a -> [Min a]

enumFromThenTo :: Min a -> Min a -> Min a -> [Min a]

Enum a => Enum (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: Max a -> Max a

pred :: Max a -> Max a

toEnum :: Int -> Max a

fromEnum :: Max a -> Int

enumFrom :: Max a -> [Max a]

enumFromThen :: Max a -> Max a -> [Max a]

enumFromTo :: Max a -> Max a -> [Max a]

enumFromThenTo :: Max a -> Max a -> Max a -> [Max a]

Enum a => Enum (First a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: First a -> First a

pred :: First a -> First a

toEnum :: Int -> First a

fromEnum :: First a -> Int

enumFrom :: First a -> [First a]

enumFromThen :: First a -> First a -> [First a]

enumFromTo :: First a -> First a -> [First a]

enumFromThenTo :: First a -> First a -> First a -> [First a]

Enum a => Enum (Last a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: Last a -> Last a

pred :: Last a -> Last a

toEnum :: Int -> Last a

fromEnum :: Last a -> Int

enumFrom :: Last a -> [Last a]

enumFromThen :: Last a -> Last a -> [Last a]

enumFromTo :: Last a -> Last a -> [Last a]

enumFromThenTo :: Last a -> Last a -> Last a -> [Last a]

Enum a => Enum (WrappedMonoid a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

succ :: WrappedMonoid a -> WrappedMonoid a

pred :: WrappedMonoid a -> WrappedMonoid a

toEnum :: Int -> WrappedMonoid a

fromEnum :: WrappedMonoid a -> Int

enumFrom :: WrappedMonoid a -> [WrappedMonoid a]

enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]

enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]

enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]

Enum a => Enum (Identity a)

Defined in Data.Functor.Identity

Methods

succ :: Identity a -> Identity a

pred :: Identity a -> Identity a

toEnum :: Int -> Identity a

fromEnum :: Identity a -> Int

enumFrom :: Identity a -> [Identity a]

enumFromThen :: Identity a -> Identity a -> [Identity a]

enumFromTo :: Identity a -> Identity a -> [Identity a]

enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a]

KnownNat n => Enum (BitVector n)

The functions: enumFrom, enumFromThen, enumFromTo, and enumFromThenTo, are not synthesisable.

Defined in Clash.Sized.Internal.BitVector

Methods

succ :: BitVector n -> BitVector n

pred :: BitVector n -> BitVector n

toEnum :: Int -> BitVector n

fromEnum :: BitVector n -> Int

enumFrom :: BitVector n -> [BitVector n]

enumFromThen :: BitVector n -> BitVector n -> [BitVector n]

enumFromTo :: BitVector n -> BitVector n -> [BitVector n]

enumFromThenTo :: BitVector n -> BitVector n -> BitVector n -> [BitVector n]

KnownNat n => Enum (Index n)

The functions: enumFrom, enumFromThen, enumFromTo, and enumFromThenTo, are not synthesisable.

Defined in Clash.Sized.Internal.Index

Methods

succ :: Index n -> Index n

pred :: Index n -> Index n

toEnum :: Int -> Index n

fromEnum :: Index n -> Int

enumFrom :: Index n -> [Index n]

enumFromThen :: Index n -> Index n -> [Index n]

enumFromTo :: Index n -> Index n -> [Index n]

enumFromThenTo :: Index n -> Index n -> Index n -> [Index n]

Enum a => Enum (Bounds a)

Defined in Test.QuickCheck.Arbitrary

Methods

succ :: Bounds a -> Bounds a

pred :: Bounds a -> Bounds a

toEnum :: Int -> Bounds a

fromEnum :: Bounds a -> Int

enumFrom :: Bounds a -> [Bounds a]

enumFromThen :: Bounds a -> Bounds a -> [Bounds a]

enumFromTo :: Bounds a -> Bounds a -> [Bounds a]

enumFromThenTo :: Bounds a -> Bounds a -> Bounds a -> [Bounds a]

KnownNat n => Enum (Unsigned n)

The functions: enumFrom, enumFromThen, enumFromTo, and enumFromThenTo, are not synthesisable.

Defined in Clash.Sized.Internal.Unsigned

Methods

succ :: Unsigned n -> Unsigned n

pred :: Unsigned n -> Unsigned n

toEnum :: Int -> Unsigned n

fromEnum :: Unsigned n -> Int

enumFrom :: Unsigned n -> [Unsigned n]

enumFromThen :: Unsigned n -> Unsigned n -> [Unsigned n]

enumFromTo :: Unsigned n -> Unsigned n -> [Unsigned n]

enumFromThenTo :: Unsigned n -> Unsigned n -> Unsigned n -> [Unsigned n]

KnownNat n => Enum (Signed n)

The functions: enumFrom, enumFromThen, enumFromTo, and enumFromThenTo, are not synthesisable.

Defined in Clash.Sized.Internal.Signed

Methods

succ :: Signed n -> Signed n

pred :: Signed n -> Signed n

toEnum :: Int -> Signed n

fromEnum :: Signed n -> Int

enumFrom :: Signed n -> [Signed n]

enumFromThen :: Signed n -> Signed n -> [Signed n]

enumFromTo :: Signed n -> Signed n -> [Signed n]

enumFromThenTo :: Signed n -> Signed n -> Signed n -> [Signed n]

a => Enum (Dict a)

Defined in Data.Constraint

Methods

succ :: Dict a -> Dict a

pred :: Dict a -> Dict a

toEnum :: Int -> Dict a

fromEnum :: Dict a -> Int

enumFrom :: Dict a -> [Dict a]

enumFromThen :: Dict a -> Dict a -> [Dict a]

enumFromTo :: Dict a -> Dict a -> [Dict a]

enumFromThenTo :: Dict a -> Dict a -> Dict a -> [Dict a]

(Enum a) :=> (Enum (Identity a))

Defined in Data.Constraint

Methods

ins :: Enum a :- Enum (Identity a)

(Enum a) :=> (Enum (Const a b))

Defined in Data.Constraint

Methods

ins :: Enum a :- Enum (Const a b)

(Integral a) :=> (Enum (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Enum (Ratio a)

Enum (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

succ :: Proxy s -> Proxy s

pred :: Proxy s -> Proxy s

toEnum :: Int -> Proxy s

fromEnum :: Proxy s -> Int

enumFrom :: Proxy s -> [Proxy s]

enumFromThen :: Proxy s -> Proxy s -> [Proxy s]

enumFromTo :: Proxy s -> Proxy s -> [Proxy s]

enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s]

Class (Real a, Enum a) (Integral a)

Defined in Data.Constraint

Methods

cls :: Integral a :- (Real a, Enum a)

Enum a => Enum (Const a b)

Defined in Data.Functor.Const

Methods

succ :: Const a b -> Const a b

pred :: Const a b -> Const a b

toEnum :: Int -> Const a b

fromEnum :: Const a b -> Int

enumFrom :: Const a b -> [Const a b]

enumFromThen :: Const a b -> Const a b -> [Const a b]

enumFromTo :: Const a b -> Const a b -> [Const a b]

enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b]

Enum (f a) => Enum (Alt f a)

Defined in Data.Semigroup.Internal

Methods

succ :: Alt f a -> Alt f a

pred :: Alt f a -> Alt f a

toEnum :: Int -> Alt f a

fromEnum :: Alt f a -> Int

enumFrom :: Alt f a -> [Alt f a]

enumFromThen :: Alt f a -> Alt f a -> [Alt f a]

enumFromTo :: Alt f a -> Alt f a -> [Alt f a]

enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a]

a ~ b => Enum (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

succ :: (a :~: b) -> a :~: b

pred :: (a :~: b) -> a :~: b

toEnum :: Int -> a :~: b

fromEnum :: (a :~: b) -> Int

enumFrom :: (a :~: b) -> [a :~: b]

enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b]

enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b]

enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b]

Enum a => Enum (Tagged s a)

Defined in Data.Tagged

Methods

succ :: Tagged s a -> Tagged s a

pred :: Tagged s a -> Tagged s a

toEnum :: Int -> Tagged s a

fromEnum :: Tagged s a -> Int

enumFrom :: Tagged s a -> [Tagged s a]

enumFromThen :: Tagged s a -> Tagged s a -> [Tagged s a]

enumFromTo :: Tagged s a -> Tagged s a -> [Tagged s a]

enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [Tagged s a]

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

Defined in Clash.Sized.Fixed

Methods

succ :: Fixed rep int frac -> Fixed rep int frac

pred :: Fixed rep int frac -> Fixed rep int frac

toEnum :: Int -> Fixed rep int frac

fromEnum :: Fixed rep int frac -> Int

enumFrom :: Fixed rep int frac -> [Fixed rep int frac]

enumFromThen :: Fixed rep int frac -> Fixed rep int frac -> [Fixed rep int frac]

enumFromTo :: Fixed rep int frac -> Fixed rep int frac -> [Fixed rep int frac]

enumFromThenTo :: Fixed rep int frac -> Fixed rep int frac -> Fixed rep int frac -> [Fixed rep int frac]

a ~~ b => Enum (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

succ :: (a :~~: b) -> a :~~: b

pred :: (a :~~: b) -> a :~~: b

toEnum :: Int -> a :~~: b

fromEnum :: (a :~~: b) -> Int

enumFrom :: (a :~~: b) -> [a :~~: b]

enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b]

enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b]

enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b]

class Eq a where

The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq.

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

(==) :: a -> a -> Bool infix 4

(/=) :: a -> a -> Bool infix 4

Instances

Eq Bool

Defined in GHC.Classes

Methods

(==) :: Bool -> Bool -> Bool

(/=) :: Bool -> Bool -> Bool

Eq Char

Defined in GHC.Classes

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Eq Double

Defined in GHC.Classes

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Eq Float

Defined in GHC.Classes

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Eq Int

Defined in GHC.Classes

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Eq Int8

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int8 -> Int8 -> Bool

(/=) :: Int8 -> Int8 -> Bool

Eq Int16

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int16 -> Int16 -> Bool

(/=) :: Int16 -> Int16 -> Bool

Eq Int32

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int32 -> Int32 -> Bool

(/=) :: Int32 -> Int32 -> Bool

Eq Int64

Since: base-2.1

Defined in GHC.Int

Methods

(==) :: Int64 -> Int64 -> Bool

(/=) :: Int64 -> Int64 -> Bool

Eq Integer

Defined in GHC.Integer.Type

Methods

(==) :: Integer -> Integer -> Bool

(/=) :: Integer -> Integer -> Bool

Eq Natural

Defined in GHC.Natural

Methods

(==) :: Natural -> Natural -> Bool

(/=) :: Natural -> Natural -> Bool

Eq Ordering

Defined in GHC.Classes

Methods

(==) :: Ordering -> Ordering -> Bool

(/=) :: Ordering -> Ordering -> Bool

Eq Word

Defined in GHC.Classes

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Eq Word8

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word8 -> Word8 -> Bool

(/=) :: Word8 -> Word8 -> Bool

Eq Word16

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word16 -> Word16 -> Bool

(/=) :: Word16 -> Word16 -> Bool

Eq Word32

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word32 -> Word32 -> Bool

(/=) :: Word32 -> Word32 -> Bool

Eq Word64

Since: base-2.1

Defined in GHC.Word

Methods

(==) :: Word64 -> Word64 -> Bool

(/=) :: Word64 -> Word64 -> Bool

Eq SomeTypeRep

Defined in Data.Typeable.Internal

Methods

(==) :: SomeTypeRep -> SomeTypeRep -> Bool

(/=) :: SomeTypeRep -> SomeTypeRep -> Bool

Eq Exp

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Exp -> Exp -> Bool

(/=) :: Exp -> Exp -> Bool

Eq Match

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Match -> Match -> Bool

(/=) :: Match -> Match -> Bool

Eq Clause

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Clause -> Clause -> Bool

(/=) :: Clause -> Clause -> Bool

Eq Pat

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Pat -> Pat -> Bool

(/=) :: Pat -> Pat -> Bool

Eq Type

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Type -> Type -> Bool

(/=) :: Type -> Type -> Bool

Eq Dec

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Dec -> Dec -> Bool

(/=) :: Dec -> Dec -> Bool

Eq Name

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Name -> Name -> Bool

(/=) :: Name -> Name -> Bool

Eq FunDep

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: FunDep -> FunDep -> Bool

(/=) :: FunDep -> FunDep -> Bool

Eq InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: InjectivityAnn -> InjectivityAnn -> Bool

(/=) :: InjectivityAnn -> InjectivityAnn -> Bool

Eq Overlap

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Overlap -> Overlap -> Bool

(/=) :: Overlap -> Overlap -> Bool

Eq DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: DerivStrategy -> DerivStrategy -> Bool

(/=) :: DerivStrategy -> DerivStrategy -> Bool

Eq ()

Defined in GHC.Classes

Methods

(==) :: () -> () -> Bool

(/=) :: () -> () -> Bool

Eq TyCon

Defined in GHC.Classes

Methods

(==) :: TyCon -> TyCon -> Bool

(/=) :: TyCon -> TyCon -> Bool

Eq Module

Defined in GHC.Classes

Methods

(==) :: Module -> Module -> Bool

(/=) :: Module -> Module -> Bool

Eq TrName

Defined in GHC.Classes

Methods

(==) :: TrName -> TrName -> Bool

(/=) :: TrName -> TrName -> Bool

Eq BigNat

Defined in GHC.Integer.Type

Methods

(==) :: BigNat -> BigNat -> Bool

(/=) :: BigNat -> BigNat -> Bool

Eq Void

Since: base-4.8.0.0

Defined in Data.Void

Methods

(==) :: Void -> Void -> Bool

(/=) :: Void -> Void -> Bool

Eq SpecConstrAnnotation

Defined in GHC.Exts

Methods

(==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool

(/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool

Eq Constr

Equality of constructors

Since: base-4.0.0.0

Defined in Data.Data

Methods

(==) :: Constr -> Constr -> Bool

(/=) :: Constr -> Constr -> Bool

Eq DataRep

Defined in Data.Data

Methods

(==) :: DataRep -> DataRep -> Bool

(/=) :: DataRep -> DataRep -> Bool

Eq ConstrRep

Defined in Data.Data

Methods

(==) :: ConstrRep -> ConstrRep -> Bool

(/=) :: ConstrRep -> ConstrRep -> Bool

Eq Fixity

Defined in Data.Data

Methods

(==) :: Fixity -> Fixity -> Bool

(/=) :: Fixity -> Fixity -> Bool

Eq Unique

Defined in Data.Unique

Methods

(==) :: Unique -> Unique -> Bool

(/=) :: Unique -> Unique -> Bool

Eq Version

Since: base-2.1

Defined in Data.Version

Methods

(==) :: Version -> Version -> Bool

(/=) :: Version -> Version -> Bool

Eq ThreadId

Since: base-4.2.0.0

Defined in GHC.Conc.Sync

Methods

(==) :: ThreadId -> ThreadId -> Bool

(/=) :: ThreadId -> ThreadId -> Bool

Eq BlockReason

Defined in GHC.Conc.Sync

Methods

(==) :: BlockReason -> BlockReason -> Bool

(/=) :: BlockReason -> BlockReason -> Bool

Eq ThreadStatus

Defined in GHC.Conc.Sync

Methods

(==) :: ThreadStatus -> ThreadStatus -> Bool

(/=) :: ThreadStatus -> ThreadStatus -> Bool

Eq AsyncException

Defined in GHC.IO.Exception

Methods

(==) :: AsyncException -> AsyncException -> Bool

(/=) :: AsyncException -> AsyncException -> Bool

Eq ArrayException

Defined in GHC.IO.Exception

Methods

(==) :: ArrayException -> ArrayException -> Bool

(/=) :: ArrayException -> ArrayException -> Bool

Eq ExitCode

Defined in GHC.IO.Exception

Methods

(==) :: ExitCode -> ExitCode -> Bool

(/=) :: ExitCode -> ExitCode -> Bool

Eq IOErrorType

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

(==) :: IOErrorType -> IOErrorType -> Bool

(/=) :: IOErrorType -> IOErrorType -> Bool

Eq MaskingState

Defined in GHC.IO

Methods

(==) :: MaskingState -> MaskingState -> Bool

(/=) :: MaskingState -> MaskingState -> Bool

Eq IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

(==) :: IOException -> IOException -> Bool

(/=) :: IOException -> IOException -> Bool

Eq ErrorCall

Defined in GHC.Exception

Methods

(==) :: ErrorCall -> ErrorCall -> Bool

(/=) :: ErrorCall -> ErrorCall -> Bool

Eq ArithException

Defined in GHC.Exception

Methods

(==) :: ArithException -> ArithException -> Bool

(/=) :: ArithException -> ArithException -> Bool

Eq All

Defined in Data.Semigroup.Internal

Methods

(==) :: All -> All -> Bool

(/=) :: All -> All -> Bool

Eq Any

Defined in Data.Semigroup.Internal

Methods

(==) :: Any -> Any -> Bool

(/=) :: Any -> Any -> Bool

Eq Fixity

Defined in GHC.Generics

Methods

(==) :: Fixity -> Fixity -> Bool

(/=) :: Fixity -> Fixity -> Bool

Eq Associativity

Defined in GHC.Generics

Methods

(==) :: Associativity -> Associativity -> Bool

(/=) :: Associativity -> Associativity -> Bool

Eq SourceUnpackedness

Defined in GHC.Generics

Methods

(==) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

Eq SourceStrictness

Defined in GHC.Generics

Methods

(==) :: SourceStrictness -> SourceStrictness -> Bool

(/=) :: SourceStrictness -> SourceStrictness -> Bool

Eq DecidedStrictness

Defined in GHC.Generics

Methods

(==) :: DecidedStrictness -> DecidedStrictness -> Bool

(/=) :: DecidedStrictness -> DecidedStrictness -> Bool

Eq SomeSymbol

Since: base-4.7.0.0

Defined in GHC.TypeLits

Methods

(==) :: SomeSymbol -> SomeSymbol -> Bool

(/=) :: SomeSymbol -> SomeSymbol -> Bool

Eq SomeNat

Since: base-4.7.0.0

Defined in GHC.TypeNats

Methods

(==) :: SomeNat -> SomeNat -> Bool

(/=) :: SomeNat -> SomeNat -> Bool

Eq CChar

Defined in Foreign.C.Types

Methods

(==) :: CChar -> CChar -> Bool

(/=) :: CChar -> CChar -> Bool

Eq CSChar

Defined in Foreign.C.Types

Methods

(==) :: CSChar -> CSChar -> Bool

(/=) :: CSChar -> CSChar -> Bool

Eq CUChar

Defined in Foreign.C.Types

Methods

(==) :: CUChar -> CUChar -> Bool

(/=) :: CUChar -> CUChar -> Bool

Eq CShort

Defined in Foreign.C.Types

Methods

(==) :: CShort -> CShort -> Bool

(/=) :: CShort -> CShort -> Bool

Eq CUShort

Defined in Foreign.C.Types

Methods

(==) :: CUShort -> CUShort -> Bool

(/=) :: CUShort -> CUShort -> Bool

Eq CInt

Defined in Foreign.C.Types

Methods

(==) :: CInt -> CInt -> Bool

(/=) :: CInt -> CInt -> Bool

Eq CUInt

Defined in Foreign.C.Types

Methods

(==) :: CUInt -> CUInt -> Bool

(/=) :: CUInt -> CUInt -> Bool

Eq CLong

Defined in Foreign.C.Types

Methods

(==) :: CLong -> CLong -> Bool

(/=) :: CLong -> CLong -> Bool

Eq CULong

Defined in Foreign.C.Types

Methods

(==) :: CULong -> CULong -> Bool

(/=) :: CULong -> CULong -> Bool

Eq CLLong

Defined in Foreign.C.Types

Methods

(==) :: CLLong -> CLLong -> Bool

(/=) :: CLLong -> CLLong -> Bool

Eq CULLong

Defined in Foreign.C.Types

Methods

(==) :: CULLong -> CULLong -> Bool

(/=) :: CULLong -> CULLong -> Bool

Eq CBool

Defined in Foreign.C.Types

Methods

(==) :: CBool -> CBool -> Bool

(/=) :: CBool -> CBool -> Bool

Eq CFloat

Defined in Foreign.C.Types

Methods

(==) :: CFloat -> CFloat -> Bool

(/=) :: CFloat -> CFloat -> Bool

Eq CDouble

Defined in Foreign.C.Types

Methods

(==) :: CDouble -> CDouble -> Bool

(/=) :: CDouble -> CDouble -> Bool

Eq CPtrdiff

Defined in Foreign.C.Types

Methods

(==) :: CPtrdiff -> CPtrdiff -> Bool

(/=) :: CPtrdiff -> CPtrdiff -> Bool

Eq CSize

Defined in Foreign.C.Types

Methods

(==) :: CSize -> CSize -> Bool

(/=) :: CSize -> CSize -> Bool

Eq CWchar

Defined in Foreign.C.Types

Methods

(==) :: CWchar -> CWchar -> Bool

(/=) :: CWchar -> CWchar -> Bool

Eq CSigAtomic

Defined in Foreign.C.Types

Methods

(==) :: CSigAtomic -> CSigAtomic -> Bool

(/=) :: CSigAtomic -> CSigAtomic -> Bool

Eq CClock

Defined in Foreign.C.Types

Methods

(==) :: CClock -> CClock -> Bool

(/=) :: CClock -> CClock -> Bool

Eq CTime

Defined in Foreign.C.Types

Methods

(==) :: CTime -> CTime -> Bool

(/=) :: CTime -> CTime -> Bool

Eq CUSeconds

Defined in Foreign.C.Types

Methods

(==) :: CUSeconds -> CUSeconds -> Bool

(/=) :: CUSeconds -> CUSeconds -> Bool

Eq CSUSeconds

Defined in Foreign.C.Types

Methods

(==) :: CSUSeconds -> CSUSeconds -> Bool

(/=) :: CSUSeconds -> CSUSeconds -> Bool

Eq CIntPtr

Defined in Foreign.C.Types

Methods

(==) :: CIntPtr -> CIntPtr -> Bool

(/=) :: CIntPtr -> CIntPtr -> Bool

Eq CUIntPtr

Defined in Foreign.C.Types

Methods

(==) :: CUIntPtr -> CUIntPtr -> Bool

(/=) :: CUIntPtr -> CUIntPtr -> Bool

Eq CIntMax

Defined in Foreign.C.Types

Methods

(==) :: CIntMax -> CIntMax -> Bool

(/=) :: CIntMax -> CIntMax -> Bool

Eq CUIntMax

Defined in Foreign.C.Types

Methods

(==) :: CUIntMax -> CUIntMax -> Bool

(/=) :: CUIntMax -> CUIntMax -> Bool

Eq Fingerprint

Defined in GHC.Fingerprint.Type

Methods

(==) :: Fingerprint -> Fingerprint -> Bool

(/=) :: Fingerprint -> Fingerprint -> Bool

Eq Lexeme

Defined in Text.Read.Lex

Methods

(==) :: Lexeme -> Lexeme -> Bool

(/=) :: Lexeme -> Lexeme -> Bool

Eq Number

Defined in Text.Read.Lex

Methods

(==) :: Number -> Number -> Bool

(/=) :: Number -> Number -> Bool

Eq GeneralCategory

Defined in GHC.Unicode

Methods

(==) :: GeneralCategory -> GeneralCategory -> Bool

(/=) :: GeneralCategory -> GeneralCategory -> Bool

Eq SrcLoc

Defined in GHC.Stack.Types

Methods

(==) :: SrcLoc -> SrcLoc -> Bool

(/=) :: SrcLoc -> SrcLoc -> Bool

Eq ByteString

Defined in Data.ByteString.Lazy.Internal

Methods

(==) :: ByteString -> ByteString -> Bool

(/=) :: ByteString -> ByteString -> Bool

Eq ByteString

Defined in Data.ByteString.Internal

Methods

(==) :: ByteString -> ByteString -> Bool

(/=) :: ByteString -> ByteString -> Bool

Eq IntSet

Defined in Data.IntSet.Internal

Methods

(==) :: IntSet -> IntSet -> Bool

(/=) :: IntSet -> IntSet -> Bool

Eq TyVarBndr

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: TyVarBndr -> TyVarBndr -> Bool

(/=) :: TyVarBndr -> TyVarBndr -> Bool

Eq Extension

Defined in GHC.LanguageExtensions.Type

Methods

(==) :: Extension -> Extension -> Bool

(/=) :: Extension -> Extension -> Bool

Eq ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

(==) :: ForeignSrcLang -> ForeignSrcLang -> Bool

(/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool

Eq Doc

Defined in Text.PrettyPrint.HughesPJ

Methods

(==) :: Doc -> Doc -> Bool

(/=) :: Doc -> Doc -> Bool

Eq TextDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

(==) :: TextDetails -> TextDetails -> Bool

(/=) :: TextDetails -> TextDetails -> Bool

Eq Style

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

(==) :: Style -> Style -> Bool

(/=) :: Style -> Style -> Bool

Eq Mode

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

(==) :: Mode -> Mode -> Bool

(/=) :: Mode -> Mode -> Bool

Eq ModName

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: ModName -> ModName -> Bool

(/=) :: ModName -> ModName -> Bool

Eq PkgName

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: PkgName -> PkgName -> Bool

(/=) :: PkgName -> PkgName -> Bool

Eq Module

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Module -> Module -> Bool

(/=) :: Module -> Module -> Bool

Eq OccName

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: OccName -> OccName -> Bool

(/=) :: OccName -> OccName -> Bool

Eq NameFlavour

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: NameFlavour -> NameFlavour -> Bool

(/=) :: NameFlavour -> NameFlavour -> Bool

Eq NameSpace

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: NameSpace -> NameSpace -> Bool

(/=) :: NameSpace -> NameSpace -> Bool

Eq Loc

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Loc -> Loc -> Bool

(/=) :: Loc -> Loc -> Bool

Eq Info

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Info -> Info -> Bool

(/=) :: Info -> Info -> Bool

Eq ModuleInfo

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: ModuleInfo -> ModuleInfo -> Bool

(/=) :: ModuleInfo -> ModuleInfo -> Bool

Eq Fixity

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Fixity -> Fixity -> Bool

(/=) :: Fixity -> Fixity -> Bool

Eq FixityDirection

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: FixityDirection -> FixityDirection -> Bool

(/=) :: FixityDirection -> FixityDirection -> Bool

Eq Lit

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Lit -> Lit -> Bool

(/=) :: Lit -> Lit -> Bool

Eq Body

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Body -> Body -> Bool

(/=) :: Body -> Body -> Bool

Eq Guard

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Guard -> Guard -> Bool

(/=) :: Guard -> Guard -> Bool

Eq Stmt

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Stmt -> Stmt -> Bool

(/=) :: Stmt -> Stmt -> Bool

Eq Range

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Range -> Range -> Bool

(/=) :: Range -> Range -> Bool

Eq DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: DerivClause -> DerivClause -> Bool

(/=) :: DerivClause -> DerivClause -> Bool

Eq TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool

Eq TySynEqn

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: TySynEqn -> TySynEqn -> Bool

(/=) :: TySynEqn -> TySynEqn -> Bool

Eq Foreign

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Foreign -> Foreign -> Bool

(/=) :: Foreign -> Foreign -> Bool

Eq Callconv

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Callconv -> Callconv -> Bool

(/=) :: Callconv -> Callconv -> Bool

Eq Safety

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Safety -> Safety -> Bool

(/=) :: Safety -> Safety -> Bool

Eq Pragma

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Pragma -> Pragma -> Bool

(/=) :: Pragma -> Pragma -> Bool

Eq Inline

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Inline -> Inline -> Bool

(/=) :: Inline -> Inline -> Bool

Eq RuleMatch

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: RuleMatch -> RuleMatch -> Bool

(/=) :: RuleMatch -> RuleMatch -> Bool

Eq Phases

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Phases -> Phases -> Bool

(/=) :: Phases -> Phases -> Bool

Eq RuleBndr

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: RuleBndr -> RuleBndr -> Bool

(/=) :: RuleBndr -> RuleBndr -> Bool

Eq AnnTarget

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: AnnTarget -> AnnTarget -> Bool

(/=) :: AnnTarget -> AnnTarget -> Bool

Eq SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

Eq SourceStrictness

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: SourceStrictness -> SourceStrictness -> Bool

(/=) :: SourceStrictness -> SourceStrictness -> Bool

Eq DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: DecidedStrictness -> DecidedStrictness -> Bool

(/=) :: DecidedStrictness -> DecidedStrictness -> Bool

Eq Con

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Con -> Con -> Bool

(/=) :: Con -> Con -> Bool

Eq Bang

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Bang -> Bang -> Bool

(/=) :: Bang -> Bang -> Bool

Eq PatSynDir

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: PatSynDir -> PatSynDir -> Bool

(/=) :: PatSynDir -> PatSynDir -> Bool

Eq PatSynArgs

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: PatSynArgs -> PatSynArgs -> Bool

(/=) :: PatSynArgs -> PatSynArgs -> Bool

Eq FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: FamilyResultSig -> FamilyResultSig -> Bool

(/=) :: FamilyResultSig -> FamilyResultSig -> Bool

Eq TyLit

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: TyLit -> TyLit -> Bool

(/=) :: TyLit -> TyLit -> Bool

Eq Role

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: Role -> Role -> Bool

(/=) :: Role -> Role -> Bool

Eq AnnLookup

Defined in Language.Haskell.TH.Syntax

Methods

(==) :: AnnLookup -> AnnLookup -> Bool

(/=) :: AnnLookup -> AnnLookup -> Bool

Eq LocalTime

Defined in Data.Time.LocalTime.Internal.LocalTime

Methods

(==) :: LocalTime -> LocalTime -> Bool

(/=) :: LocalTime -> LocalTime -> Bool

Eq UniversalTime

Defined in Data.Time.Clock.Internal.UniversalTime

Methods

(==) :: UniversalTime -> UniversalTime -> Bool

(/=) :: UniversalTime -> UniversalTime -> Bool

Eq UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

(==) :: UTCTime -> UTCTime -> Bool

(/=) :: UTCTime -> UTCTime -> Bool

Eq Day

Defined in Data.Time.Calendar.Days

Methods

(==) :: Day -> Day -> Bool

(/=) :: Day -> Day -> Bool

Eq HDL

Defined in Clash.Annotations.Primitive

Methods

(==) :: HDL -> HDL -> Bool

(/=) :: HDL -> HDL -> Bool

Eq SaturationMode

Defined in Clash.Class.Num

Methods

(==) :: SaturationMode -> SaturationMode -> Bool

(/=) :: SaturationMode -> SaturationMode -> Bool

Eq Bit

Defined in Clash.Sized.Internal.BitVector

Methods

(==) :: Bit -> Bit -> Bool

(/=) :: Bit -> Bit -> Bool

Eq DefName

Defined in Control.Lens.Internal.FieldTH

Methods

(==) :: DefName -> DefName -> Bool

(/=) :: DefName -> DefName -> Bool

Eq TimeLocale

Defined in System.Locale

Methods

(==) :: TimeLocale -> TimeLocale -> Bool

(/=) :: TimeLocale -> TimeLocale -> Bool

Eq ByteArray

Defined in Data.Primitive.ByteArray

Methods

(==) :: ByteArray -> ByteArray -> Bool

(/=) :: ByteArray -> ByteArray -> Bool

Eq Addr

Defined in Data.Primitive.Types

Methods

(==) :: Addr -> Addr -> Bool

(/=) :: Addr -> Addr -> Bool

Eq ConstructorInfo

Defined in Language.Haskell.TH.Datatype

Methods

(==) :: ConstructorInfo -> ConstructorInfo -> Bool

(/=) :: ConstructorInfo -> ConstructorInfo -> Bool

Eq ConstructorVariant

Defined in Language.Haskell.TH.Datatype

Methods

(==) :: ConstructorVariant -> ConstructorVariant -> Bool

(/=) :: ConstructorVariant -> ConstructorVariant -> Bool

Eq DatatypeInfo

Defined in Language.Haskell.TH.Datatype

Methods

(==) :: DatatypeInfo -> DatatypeInfo -> Bool

(/=) :: DatatypeInfo -> DatatypeInfo -> Bool

Eq DatatypeVariant

Defined in Language.Haskell.TH.Datatype

Methods

(==) :: DatatypeVariant -> DatatypeVariant -> Bool

(/=) :: DatatypeVariant -> DatatypeVariant -> Bool

Eq FieldStrictness

Defined in Language.Haskell.TH.Datatype

Methods

(==) :: FieldStrictness -> FieldStrictness -> Bool

(/=) :: FieldStrictness -> FieldStrictness -> Bool

Eq Strictness

Defined in Language.Haskell.TH.Datatype

Methods

(==) :: Strictness -> Strictness -> Bool

(/=) :: Strictness -> Strictness -> Bool

Eq Unpackedness

Defined in Language.Haskell.TH.Datatype

Methods

(==) :: Unpackedness -> Unpackedness -> Bool

(/=) :: Unpackedness -> Unpackedness -> Bool

Eq Half

Defined in Numeric.Half

Methods

(==) :: Half -> Half -> Bool

(/=) :: Half -> Half -> Bool

Eq ResetKind

Defined in Clash.Signal.Internal

Methods

(==) :: ResetKind -> ResetKind -> Bool

(/=) :: ResetKind -> ResetKind -> Bool

Eq ClockKind

Defined in Clash.Signal.Internal

Methods

(==) :: ClockKind -> ClockKind -> Bool

(/=) :: ClockKind -> ClockKind -> Bool

Eq NewOrData

Defined in Language.Haskell.TH.Desugar.Core

Methods

(==) :: NewOrData -> NewOrData -> Bool

(/=) :: NewOrData -> NewOrData -> Bool

() :=> (Eq Bool)

Defined in Data.Constraint

Methods

ins :: () :- Eq Bool

() :=> (Eq Double)

Defined in Data.Constraint

Methods

ins :: () :- Eq Double

() :=> (Eq Float)

Defined in Data.Constraint

Methods

ins :: () :- Eq Float

() :=> (Eq Int)

Defined in Data.Constraint

Methods

ins :: () :- Eq Int

() :=> (Eq Integer)

Defined in Data.Constraint

Methods

ins :: () :- Eq Integer

() :=> (Eq Natural)

Defined in Data.Constraint

Methods

ins :: () :- Eq Natural

() :=> (Eq Word)

Defined in Data.Constraint

Methods

ins :: () :- Eq Word

() :=> (Eq ())

Defined in Data.Constraint

Methods

ins :: () :- Eq ()

() :=> (Eq (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Eq (a :- b)

() :=> (Eq (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Eq (Dict a)

Class () (Eq a)

Defined in Data.Constraint

Methods

cls :: Eq a :- ()

Eq a => Eq [a]

Defined in GHC.Classes

Methods

(==) :: [a] -> [a] -> Bool

(/=) :: [a] -> [a] -> Bool

Eq a => Eq (Maybe a)

Defined in GHC.Base

Methods

(==) :: Maybe a -> Maybe a -> Bool

(/=) :: Maybe a -> Maybe a -> Bool

Eq a => Eq (Ratio a)

Defined in GHC.Real

Methods

(==) :: Ratio a -> Ratio a -> Bool

(/=) :: Ratio a -> Ratio a -> Bool

Eq (Ptr a)

Defined in GHC.Ptr

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Eq (FunPtr a)

Defined in GHC.Ptr

Methods

(==) :: FunPtr a -> FunPtr a -> Bool

(/=) :: FunPtr a -> FunPtr a -> Bool

Eq p => Eq (Par1 p)

Defined in GHC.Generics

Methods

(==) :: Par1 p -> Par1 p -> Bool

(/=) :: Par1 p -> Par1 p -> Bool

Eq a => Eq (Complex a)

Defined in Data.Complex

Methods

(==) :: Complex a -> Complex a -> Bool

(/=) :: Complex a -> Complex a -> Bool

Eq (Fixed a)

Defined in Data.Fixed

Methods

(==) :: Fixed a -> Fixed a -> Bool

(/=) :: Fixed a -> Fixed a -> Bool

Eq a => Eq (Min a)

Defined in Data.Semigroup

Methods

(==) :: Min a -> Min a -> Bool

(/=) :: Min a -> Min a -> Bool

Eq a => Eq (Max a)

Defined in Data.Semigroup

Methods

(==) :: Max a -> Max a -> Bool

(/=) :: Max a -> Max a -> Bool

Eq a => Eq (First a)

Defined in Data.Semigroup

Methods

(==) :: First a -> First a -> Bool

(/=) :: First a -> First a -> Bool

Eq a => Eq (Last a)

Defined in Data.Semigroup

Methods

(==) :: Last a -> Last a -> Bool

(/=) :: Last a -> Last a -> Bool

Eq m => Eq (WrappedMonoid m)

Defined in Data.Semigroup

Methods

(==) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool

Eq a => Eq (Option a)

Defined in Data.Semigroup

Methods

(==) :: Option a -> Option a -> Bool

(/=) :: Option a -> Option a -> Bool

Eq (StableName a)

Since: base-2.1

Defined in System.Mem.StableName

Methods

(==) :: StableName a -> StableName a -> Bool

(/=) :: StableName a -> StableName a -> Bool

Eq a => Eq (ZipList a)

Defined in Control.Applicative

Methods

(==) :: ZipList a -> ZipList a -> Bool

(/=) :: ZipList a -> ZipList a -> Bool

Eq a => Eq (Identity a)

Defined in Data.Functor.Identity

Methods

(==) :: Identity a -> Identity a -> Bool

(/=) :: Identity a -> Identity a -> Bool

Eq (TVar a)

Since: base-4.8.0.0

Defined in GHC.Conc.Sync

Methods

(==) :: TVar a -> TVar a -> Bool

(/=) :: TVar a -> TVar a -> Bool

Eq (IORef a)

Pointer equality.

Since: base-4.1.0.0

Defined in GHC.IORef

Methods

(==) :: IORef a -> IORef a -> Bool

(/=) :: IORef a -> IORef a -> Bool

Eq a => Eq (First a)

Defined in Data.Monoid

Methods

(==) :: First a -> First a -> Bool

(/=) :: First a -> First a -> Bool

Eq a => Eq (Last a)

Defined in Data.Monoid

Methods

(==) :: Last a -> Last a -> Bool

(/=) :: Last a -> Last a -> Bool

Eq a => Eq (Dual a)

Defined in Data.Semigroup.Internal

Methods

(==) :: Dual a -> Dual a -> Bool

(/=) :: Dual a -> Dual a -> Bool

Eq a => Eq (Sum a)

Defined in Data.Semigroup.Internal

Methods

(==) :: Sum a -> Sum a -> Bool

(/=) :: Sum a -> Sum a -> Bool

Eq a => Eq (Product a)

Defined in Data.Semigroup.Internal

Methods

(==) :: Product a -> Product a -> Bool

(/=) :: Product a -> Product a -> Bool

Eq a => Eq (Down a)

Defined in Data.Ord

Methods

(==) :: Down a -> Down a -> Bool

(/=) :: Down a -> Down a -> Bool

Eq (MVar a)

Since: base-4.1.0.0

Defined in GHC.MVar

Methods

(==) :: MVar a -> MVar a -> Bool

(/=) :: MVar a -> MVar a -> Bool

Eq a => Eq (NonEmpty a)

Defined in GHC.Base

Methods

(==) :: NonEmpty a -> NonEmpty a -> Bool

(/=) :: NonEmpty a -> NonEmpty a -> Bool

Eq a => Eq (IntMap a)

Defined in Data.IntMap.Internal

Methods

(==) :: IntMap a -> IntMap a -> Bool

(/=) :: IntMap a -> IntMap a -> Bool

Eq a => Eq (Tree a)

Defined in Data.Tree

Methods

(==) :: Tree a -> Tree a -> Bool

(/=) :: Tree a -> Tree a -> Bool

Eq a => Eq (Seq a)

Defined in Data.Sequence.Internal

Methods

(==) :: Seq a -> Seq a -> Bool

(/=) :: Seq a -> Seq a -> Bool

Eq a => Eq (ViewL a)

Defined in Data.Sequence.Internal

Methods

(==) :: ViewL a -> ViewL a -> Bool

(/=) :: ViewL a -> ViewL a -> Bool

Eq a => Eq (ViewR a)

Defined in Data.Sequence.Internal

Methods

(==) :: ViewR a -> ViewR a -> Bool

(/=) :: ViewR a -> ViewR a -> Bool

Eq a => Eq (Set a)

Defined in Data.Set.Internal

Methods

(==) :: Set a -> Set a -> Bool

(/=) :: Set a -> Set a -> Bool

Eq (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

(==) :: Doc a -> Doc a -> Bool

(/=) :: Doc a -> Doc a -> Bool

Eq a => Eq (AnnotDetails a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

(==) :: AnnotDetails a -> AnnotDetails a -> Bool

(/=) :: AnnotDetails a -> AnnotDetails a -> Bool

Eq a => Eq (Span a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

(==) :: Span a -> Span a -> Bool

(/=) :: Span a -> Span a -> Bool

Eq (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

(==) :: BitVector n -> BitVector n -> Bool

(/=) :: BitVector n -> BitVector n -> Bool

Eq (Index n)

Defined in Clash.Sized.Internal.Index

Methods

(==) :: Index n -> Index n -> Bool

(/=) :: Index n -> Index n -> Bool

Eq a => Eq (Bounds a)

Defined in Test.QuickCheck.Arbitrary

Methods

(==) :: Bounds a -> Bounds a -> Bool

(/=) :: Bounds a -> Bounds a -> Bool

Eq a => Eq (DList a)

Defined in Data.DList

Methods

(==) :: DList a -> DList a -> Bool

(/=) :: DList a -> DList a -> Bool

Eq a => Eq (HashSet a)

Defined in Data.HashSet

Methods

(==) :: HashSet a -> HashSet a -> Bool

(/=) :: HashSet a -> HashSet a -> Bool

(Storable a, Eq a) => Eq (Vector a)

Defined in Data.Vector.Storable

Methods

(==) :: Vector a -> Vector a -> Bool

(/=) :: Vector a -> Vector a -> Bool

(Prim a, Eq a) => Eq (Vector a)

Defined in Data.Vector.Primitive

Methods

(==) :: Vector a -> Vector a -> Bool

(/=) :: Vector a -> Vector a -> Bool

Eq a => Eq (Vector a)

Defined in Data.Vector

Methods

(==) :: Vector a -> Vector a -> Bool

(/=) :: Vector a -> Vector a -> Bool

Eq a => Eq (Array a)

Defined in Data.Primitive.Array

Methods

(==) :: Array a -> Array a -> Bool

(/=) :: Array a -> Array a -> Bool

(Eq a, Prim a) => Eq (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

(==) :: PrimArray a -> PrimArray a -> Bool

(/=) :: PrimArray a -> PrimArray a -> Bool

Eq a => Eq (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

(==) :: SmallArray a -> SmallArray a -> Bool

(/=) :: SmallArray a -> SmallArray a -> Bool

(Eq a, PrimUnlifted a) => Eq (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

(==) :: UnliftedArray a -> UnliftedArray a -> Bool

(/=) :: UnliftedArray a -> UnliftedArray a -> Bool

Eq (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

(==) :: Unsigned n -> Unsigned n -> Bool

(/=) :: Unsigned n -> Unsigned n -> Bool

Eq (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

(==) :: Signed n -> Signed n -> Bool

(/=) :: Signed n -> Signed n -> Bool

Eq (Dict a)

Defined in Data.Constraint

Methods

(==) :: Dict a -> Dict a -> Bool

(/=) :: Dict a -> Dict a -> Bool

(Eq a) :=> (Eq [a])

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq [a]

(Eq a) :=> (Eq (Maybe a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Maybe a)

(Eq a) :=> (Eq (Complex a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Complex a)

(Eq a) :=> (Eq (Ratio a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Ratio a)

(Eq a) :=> (Eq (Identity a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Identity a)

(Eq a) :=> (Eq (Const a b))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Const a b)

Class (Eq a) (Ord a)

Defined in Data.Constraint

Methods

cls :: Ord a :- Eq a

Class (Eq a) (Bits a)

Defined in Data.Constraint

Methods

cls :: Bits a :- Eq a

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

Defined in Data.Either

Methods

(==) :: Either a b -> Either a b -> Bool

(/=) :: Either a b -> Either a b -> Bool

Eq (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: V1 p -> V1 p -> Bool

(/=) :: V1 p -> V1 p -> Bool

Eq (U1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: U1 p -> U1 p -> Bool

(/=) :: U1 p -> U1 p -> Bool

Eq (TypeRep a)

Since: base-2.1

Defined in Data.Typeable.Internal

Methods

(==) :: TypeRep a -> TypeRep a -> Bool

(/=) :: TypeRep a -> TypeRep a -> Bool

(Eq a, Eq b) => Eq (a, b)

Defined in GHC.Classes

Methods

(==) :: (a, b) -> (a, b) -> Bool

(/=) :: (a, b) -> (a, b) -> Bool

(Ix i, Eq e) => Eq (Array i e)

Since: base-2.1

Defined in GHC.Arr

Methods

(==) :: Array i e -> Array i e -> Bool

(/=) :: Array i e -> Array i e -> Bool

Eq a => Eq (Arg a b)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(==) :: Arg a b -> Arg a b -> Bool

(/=) :: Arg a b -> Arg a b -> Bool

Eq (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

(==) :: Proxy s -> Proxy s -> Bool

(/=) :: Proxy s -> Proxy s -> Bool

Eq (STRef s a)

Pointer equality.

Since: base-2.1

Defined in GHC.STRef

Methods

(==) :: STRef s a -> STRef s a -> Bool

(/=) :: STRef s a -> STRef s a -> Bool

(Eq k, Eq a) => Eq (Map k a)

Defined in Data.Map.Internal

Methods

(==) :: Map k a -> Map k a -> Bool

(/=) :: Map k a -> Map k a -> Bool

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

Defined in Clash.Sized.Vector

Methods

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

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

(Eq i, Eq a) => Eq (Level i a)

Defined in Control.Lens.Internal.Level

Methods

(==) :: Level i a -> Level i a -> Bool

(/=) :: Level i a -> Level i a -> Bool

(Eq1 f, Eq a) => Eq (Cofree f a)

Defined in Control.Comonad.Cofree

Methods

(==) :: Cofree f a -> Cofree f a -> Bool

(/=) :: Cofree f a -> Cofree f a -> Bool

(Eq1 f, Eq a) => Eq (Free f a)

Defined in Control.Monad.Free

Methods

(==) :: Free f a -> Free f a -> Bool

(/=) :: Free f a -> Free f a -> Bool

(Eq1 f, Eq a) => Eq (Yoneda f a)

Defined in Data.Functor.Yoneda

Methods

(==) :: Yoneda f a -> Yoneda f a -> Bool

(/=) :: Yoneda f a -> Yoneda f a -> Bool

(Eq k, Eq v) => Eq (HashMap k v)

Defined in Data.HashMap.Base

Methods

(==) :: HashMap k v -> HashMap k v -> Bool

(/=) :: HashMap k v -> HashMap k v -> Bool

Eq (MutableArray s a)

Defined in Data.Primitive.Array

Methods

(==) :: MutableArray s a -> MutableArray s a -> Bool

(/=) :: MutableArray s a -> MutableArray s a -> Bool

Eq (SmallMutableArray s a)

Defined in Data.Primitive.SmallArray

Methods

(==) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool

(/=) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool

Eq (MutableUnliftedArray s a)

Defined in Data.Primitive.UnliftedArray

Methods

(==) :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool

(/=) :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool

(Eq k, Eq v) => Eq (Leaf k v)

Defined in Data.HashMap.Base

Methods

(==) :: Leaf k v -> Leaf k v -> Bool

(/=) :: Leaf k v -> Leaf k v -> Bool

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

Defined in Clash.Sized.RTree

Methods

(==) :: RTree d a -> RTree d a -> Bool

(/=) :: RTree d a -> RTree d a -> Bool

Eq (a :- b)

Defined in Data.Constraint

Methods

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

(/=) :: (a :- b) -> (a :- b) -> Bool

(Eq a, Eq b) :=> (Eq (a, b))

Defined in Data.Constraint

Methods

ins :: (Eq a, Eq b) :- Eq (a, b)

(Eq a, Eq b) :=> (Eq (Either a b))

Defined in Data.Constraint

Methods

ins :: (Eq a, Eq b) :- Eq (Either a b)

Eq (f p) => Eq (Rec1 f p)

Defined in GHC.Generics

Methods

(==) :: Rec1 f p -> Rec1 f p -> Bool

(/=) :: Rec1 f p -> Rec1 f p -> Bool

Eq (URec (Ptr ()) p)

Defined in GHC.Generics

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

Eq (URec Char p)

Defined in GHC.Generics

Methods

(==) :: URec Char p -> URec Char p -> Bool

(/=) :: URec Char p -> URec Char p -> Bool

Eq (URec Double p)

Defined in GHC.Generics

Methods

(==) :: URec Double p -> URec Double p -> Bool

(/=) :: URec Double p -> URec Double p -> Bool

Eq (URec Float p)

Defined in GHC.Generics

Methods

(==) :: URec Float p -> URec Float p -> Bool

(/=) :: URec Float p -> URec Float p -> Bool

Eq (URec Int p)

Defined in GHC.Generics

Methods

(==) :: URec Int p -> URec Int p -> Bool

(/=) :: URec Int p -> URec Int p -> Bool

Eq (URec Word p)

Defined in GHC.Generics

Methods

(==) :: URec Word p -> URec Word p -> Bool

(/=) :: URec Word p -> URec Word p -> Bool

(Eq a, Eq b, Eq c) => Eq (a, b, c)

Defined in GHC.Classes

Methods

(==) :: (a, b, c) -> (a, b, c) -> Bool

(/=) :: (a, b, c) -> (a, b, c) -> Bool

Eq (STArray s i e)

Since: base-2.1

Defined in GHC.Arr

Methods

(==) :: STArray s i e -> STArray s i e -> Bool

(/=) :: STArray s i e -> STArray s i e -> Bool

Eq a => Eq (Const a b)

Defined in Data.Functor.Const

Methods

(==) :: Const a b -> Const a b -> Bool

(/=) :: Const a b -> Const a b -> Bool

Eq (f a) => Eq (Alt f a)

Defined in Data.Semigroup.Internal

Methods

(==) :: Alt f a -> Alt f a -> Bool

(/=) :: Alt f a -> Alt f a -> Bool

Eq (a :~: b)

Defined in Data.Type.Equality

Methods

(==) :: (a :~: b) -> (a :~: b) -> Bool

(/=) :: (a :~: b) -> (a :~: b) -> Bool

(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a)

Defined in Control.Monad.Trans.Error

Methods

(==) :: ErrorT e m a -> ErrorT e m a -> Bool

(/=) :: ErrorT e m a -> ErrorT e m a -> Bool

Eq a => Eq (Constant a b)

Defined in Data.Functor.Constant

Methods

(==) :: Constant a b -> Constant a b -> Bool

(/=) :: Constant a b -> Constant a b -> Bool

Eq b => Eq (Tagged s b)

Defined in Data.Tagged

Methods

(==) :: Tagged s b -> Tagged s b -> Bool

(/=) :: Tagged s b -> Tagged s b -> Bool

Eq (p (Fix p a) a) => Eq (Fix p a)

Defined in Data.Bifunctor.Fix

Methods

(==) :: Fix p a -> Fix p a -> Bool

(/=) :: Fix p a -> Fix p a -> Bool

Eq (p a a) => Eq (Join p a)

Defined in Data.Bifunctor.Join

Methods

(==) :: Join p a -> Join p a -> Bool

(/=) :: Join p a -> Join p a -> Bool

(Eq a, Eq (f b)) => Eq (CofreeF f a b)

Defined in Control.Comonad.Trans.Cofree

Methods

(==) :: CofreeF f a b -> CofreeF f a b -> Bool

(/=) :: CofreeF f a b -> CofreeF f a b -> Bool

Eq (w (CofreeF f a (CofreeT f w a))) => Eq (CofreeT f w a)

Defined in Control.Comonad.Trans.Cofree

Methods

(==) :: CofreeT f w a -> CofreeT f w a -> Bool

(/=) :: CofreeT f w a -> CofreeT f w a -> Bool

(Eq1 f, Eq1 m, Eq a) => Eq (FreeT f m a)

Defined in Control.Monad.Trans.Free

Methods

(==) :: FreeT f m a -> FreeT f m a -> Bool

(/=) :: FreeT f m a -> FreeT f m a -> Bool

(Eq a, Eq (f b)) => Eq (FreeF f a b)

Defined in Control.Monad.Trans.Free

Methods

(==) :: FreeF f a b -> FreeF f a b -> Bool

(/=) :: FreeF f a b -> FreeF f a b -> Bool

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

Defined in Clash.Sized.Fixed

Methods

(==) :: Fixed rep int frac -> Fixed rep int frac -> Bool

(/=) :: Fixed rep int frac -> Fixed rep int frac -> Bool

Eq c => Eq (K1 i c p)

Defined in GHC.Generics

Methods

(==) :: K1 i c p -> K1 i c p -> Bool

(/=) :: K1 i c p -> K1 i c p -> Bool

(Eq (f p), Eq (g p)) => Eq ((f :+: g) p)

Defined in GHC.Generics

Methods

(==) :: (f :+: g) p -> (f :+: g) p -> Bool

(/=) :: (f :+: g) p -> (f :+: g) p -> Bool

(Eq (f p), Eq (g p)) => Eq ((f :*: g) p)

Defined in GHC.Generics

Methods

(==) :: (f :*: g) p -> (f :*: g) p -> Bool

(/=) :: (f :*: g) p -> (f :*: g) p -> Bool

(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(Eq1 f, Eq1 g, Eq a) => Eq (Product f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

(==) :: Product f g a -> Product f g a -> Bool

(/=) :: Product f g a -> Product f g a -> Bool

(Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

(==) :: Sum f g a -> Sum f g a -> Bool

(/=) :: Sum f g a -> Sum f g a -> Bool

Eq (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

(==) :: (a :~~: b) -> (a :~~: b) -> Bool

(/=) :: (a :~~: b) -> (a :~~: b) -> Bool

Eq (f p) => Eq (M1 i c f p)

Defined in GHC.Generics

Methods

(==) :: M1 i c f p -> M1 i c f p -> Bool

(/=) :: M1 i c f p -> M1 i c f p -> Bool

Eq (f (g p)) => Eq ((f :.: g) p)

Defined in GHC.Generics

Methods

(==) :: (f :.: g) p -> (f :.: g) p -> Bool

(/=) :: (f :.: g) p -> (f :.: g) p -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

(==) :: Compose f g a -> Compose f g a -> Bool

(/=) :: Compose f g a -> Compose f g a -> Bool

Eq (f a) => Eq (Clown f a b)

Defined in Data.Bifunctor.Clown

Methods

(==) :: Clown f a b -> Clown f a b -> Bool

(/=) :: Clown f a b -> Clown f a b -> Bool

Eq (p b a) => Eq (Flip p a b)

Defined in Data.Bifunctor.Flip

Methods

(==) :: Flip p a b -> Flip p a b -> Bool

(/=) :: Flip p a b -> Flip p a b -> Bool

Eq (g b) => Eq (Joker g a b)

Defined in Data.Bifunctor.Joker

Methods

(==) :: Joker g a b -> Joker g a b -> Bool

(/=) :: Joker g a b -> Joker g a b -> Bool

Eq (p a b) => Eq (WrappedBifunctor p a b)

Defined in Data.Bifunctor.Wrapped

Methods

(==) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

(/=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(/=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(Eq (f a b), Eq (g a b)) => Eq (Product f g a b)

Defined in Data.Bifunctor.Product

Methods

(==) :: Product f g a b -> Product f g a b -> Bool

(/=) :: Product f g a b -> Product f g a b -> Bool

(Eq (p a b), Eq (q a b)) => Eq (Sum p q a b)

Defined in Data.Bifunctor.Sum

Methods

(==) :: Sum p q a b -> Sum p q a b -> Bool

(/=) :: Sum p q a b -> Sum p q a b -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(/=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

Eq (f (p a b)) => Eq (Tannen f p a b)

Defined in Data.Bifunctor.Tannen

Methods

(==) :: Tannen f p a b -> Tannen f p a b -> Bool

(/=) :: Tannen f p a b -> Tannen f p a b -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(/=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

Eq (p (f a) (g b)) => Eq (Biff p f g a b)

Defined in Data.Bifunctor.Biff

Methods

(==) :: Biff p f g a b -> Biff p f g a b -> Bool

(/=) :: Biff p f g a b -> Biff p f g a b -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in GHC.Classes

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

class Fractional a => Floating a where

Trigonometric and hyperbolic functions and related functions.

Minimal complete definition

pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh

Methods

pi :: a

exp :: a -> a

log :: a -> a

sqrt :: a -> a

(**) :: a -> a -> a infixr 8

logBase :: a -> a -> a

sin :: a -> a

cos :: a -> a

tan :: a -> a

asin :: a -> a

acos :: a -> a

atan :: a -> a

sinh :: a -> a

cosh :: a -> a

tanh :: a -> a

asinh :: a -> a

acosh :: a -> a

atanh :: a -> a

Instances

Floating Double

Since: base-2.1

Defined in GHC.Float

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

Floating Float

Since: base-2.1

Defined in GHC.Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

Floating CFloat

Defined in Foreign.C.Types

Methods

pi :: CFloat

exp :: CFloat -> CFloat

log :: CFloat -> CFloat

sqrt :: CFloat -> CFloat

(**) :: CFloat -> CFloat -> CFloat

logBase :: CFloat -> CFloat -> CFloat

sin :: CFloat -> CFloat

cos :: CFloat -> CFloat

tan :: CFloat -> CFloat

asin :: CFloat -> CFloat

acos :: CFloat -> CFloat

atan :: CFloat -> CFloat

sinh :: CFloat -> CFloat

cosh :: CFloat -> CFloat

tanh :: CFloat -> CFloat

asinh :: CFloat -> CFloat

acosh :: CFloat -> CFloat

atanh :: CFloat -> CFloat

log1p :: CFloat -> CFloat

expm1 :: CFloat -> CFloat

log1pexp :: CFloat -> CFloat

log1mexp :: CFloat -> CFloat

Floating CDouble

Defined in Foreign.C.Types

Methods

pi :: CDouble

exp :: CDouble -> CDouble

log :: CDouble -> CDouble

sqrt :: CDouble -> CDouble

(**) :: CDouble -> CDouble -> CDouble

logBase :: CDouble -> CDouble -> CDouble

sin :: CDouble -> CDouble

cos :: CDouble -> CDouble

tan :: CDouble -> CDouble

asin :: CDouble -> CDouble

acos :: CDouble -> CDouble

atan :: CDouble -> CDouble

sinh :: CDouble -> CDouble

cosh :: CDouble -> CDouble

tanh :: CDouble -> CDouble

asinh :: CDouble -> CDouble

acosh :: CDouble -> CDouble

atanh :: CDouble -> CDouble

log1p :: CDouble -> CDouble

expm1 :: CDouble -> CDouble

log1pexp :: CDouble -> CDouble

log1mexp :: CDouble -> CDouble

Floating Half

Defined in Numeric.Half

Methods

pi :: Half

exp :: Half -> Half

log :: Half -> Half

sqrt :: Half -> Half

(**) :: Half -> Half -> Half

logBase :: Half -> Half -> Half

sin :: Half -> Half

cos :: Half -> Half

tan :: Half -> Half

asin :: Half -> Half

acos :: Half -> Half

atan :: Half -> Half

sinh :: Half -> Half

cosh :: Half -> Half

tanh :: Half -> Half

asinh :: Half -> Half

acosh :: Half -> Half

atanh :: Half -> Half

log1p :: Half -> Half

expm1 :: Half -> Half

log1pexp :: Half -> Half

log1mexp :: Half -> Half

() :=> (Floating Double)

Defined in Data.Constraint

Methods

ins :: () :- Floating Double

() :=> (Floating Float)

Defined in Data.Constraint

Methods

ins :: () :- Floating Float

RealFloat a => Floating (Complex a)

Since: base-2.1

Defined in Data.Complex

Methods

pi :: Complex a

exp :: Complex a -> Complex a

log :: Complex a -> Complex a

sqrt :: Complex a -> Complex a

(**) :: Complex a -> Complex a -> Complex a

logBase :: Complex a -> Complex a -> Complex a

sin :: Complex a -> Complex a

cos :: Complex a -> Complex a

tan :: Complex a -> Complex a

asin :: Complex a -> Complex a

acos :: Complex a -> Complex a

atan :: Complex a -> Complex a

sinh :: Complex a -> Complex a

cosh :: Complex a -> Complex a

tanh :: Complex a -> Complex a

asinh :: Complex a -> Complex a

acosh :: Complex a -> Complex a

atanh :: Complex a -> Complex a

log1p :: Complex a -> Complex a

expm1 :: Complex a -> Complex a

log1pexp :: Complex a -> Complex a

log1mexp :: Complex a -> Complex a

Floating a => Floating (Identity a)

Defined in Data.Functor.Identity

Methods

pi :: Identity a

exp :: Identity a -> Identity a

log :: Identity a -> Identity a

sqrt :: Identity a -> Identity a

(**) :: Identity a -> Identity a -> Identity a

logBase :: Identity a -> Identity a -> Identity a

sin :: Identity a -> Identity a

cos :: Identity a -> Identity a

tan :: Identity a -> Identity a

asin :: Identity a -> Identity a

acos :: Identity a -> Identity a

atan :: Identity a -> Identity a

sinh :: Identity a -> Identity a

cosh :: Identity a -> Identity a

tanh :: Identity a -> Identity a

asinh :: Identity a -> Identity a

acosh :: Identity a -> Identity a

atanh :: Identity a -> Identity a

log1p :: Identity a -> Identity a

expm1 :: Identity a -> Identity a

log1pexp :: Identity a -> Identity a

log1mexp :: Identity a -> Identity a

(Floating a) :=> (Floating (Identity a))

Defined in Data.Constraint

Methods

ins :: Floating a :- Floating (Identity a)

(Floating a) :=> (Floating (Const a b))

Defined in Data.Constraint

Methods

ins :: Floating a :- Floating (Const a b)

(RealFloat a) :=> (Floating (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Floating (Complex a)

Class (Fractional a) (Floating a)

Defined in Data.Constraint

Methods

cls :: Floating a :- Fractional a

Floating a => Floating (Op a b)

Defined in Data.Functor.Contravariant

Methods

pi :: Op a b

exp :: Op a b -> Op a b

log :: Op a b -> Op a b

sqrt :: Op a b -> Op a b

(**) :: Op a b -> Op a b -> Op a b

logBase :: Op a b -> Op a b -> Op a b

sin :: Op a b -> Op a b

cos :: Op a b -> Op a b

tan :: Op a b -> Op a b

asin :: Op a b -> Op a b

acos :: Op a b -> Op a b

atan :: Op a b -> Op a b

sinh :: Op a b -> Op a b

cosh :: Op a b -> Op a b

tanh :: Op a b -> Op a b

asinh :: Op a b -> Op a b

acosh :: Op a b -> Op a b

atanh :: Op a b -> Op a b

log1p :: Op a b -> Op a b

expm1 :: Op a b -> Op a b

log1pexp :: Op a b -> Op a b

log1mexp :: Op a b -> Op a b

Class (RealFrac a, Floating a) (RealFloat a)

Defined in Data.Constraint

Methods

cls :: RealFloat a :- (RealFrac a, Floating a)

Floating a => Floating (Const a b)

Defined in Data.Functor.Const

Methods

pi :: Const a b

exp :: Const a b -> Const a b

log :: Const a b -> Const a b

sqrt :: Const a b -> Const a b

(**) :: Const a b -> Const a b -> Const a b

logBase :: Const a b -> Const a b -> Const a b

sin :: Const a b -> Const a b

cos :: Const a b -> Const a b

tan :: Const a b -> Const a b

asin :: Const a b -> Const a b

acos :: Const a b -> Const a b

atan :: Const a b -> Const a b

sinh :: Const a b -> Const a b

cosh :: Const a b -> Const a b

tanh :: Const a b -> Const a b

asinh :: Const a b -> Const a b

acosh :: Const a b -> Const a b

atanh :: Const a b -> Const a b

log1p :: Const a b -> Const a b

expm1 :: Const a b -> Const a b

log1pexp :: Const a b -> Const a b

log1mexp :: Const a b -> Const a b

Floating a => Floating (Tagged s a)

Defined in Data.Tagged

Methods

pi :: Tagged s a

exp :: Tagged s a -> Tagged s a

log :: Tagged s a -> Tagged s a

sqrt :: Tagged s a -> Tagged s a

(**) :: Tagged s a -> Tagged s a -> Tagged s a

logBase :: Tagged s a -> Tagged s a -> Tagged s a

sin :: Tagged s a -> Tagged s a

cos :: Tagged s a -> Tagged s a

tan :: Tagged s a -> Tagged s a

asin :: Tagged s a -> Tagged s a

acos :: Tagged s a -> Tagged s a

atan :: Tagged s a -> Tagged s a

sinh :: Tagged s a -> Tagged s a

cosh :: Tagged s a -> Tagged s a

tanh :: Tagged s a -> Tagged s a

asinh :: Tagged s a -> Tagged s a

acosh :: Tagged s a -> Tagged s a

atanh :: Tagged s a -> Tagged s a

log1p :: Tagged s a -> Tagged s a

expm1 :: Tagged s a -> Tagged s a

log1pexp :: Tagged s a -> Tagged s a

log1mexp :: Tagged s a -> Tagged s a

class Num a => Fractional a where

Fractional numbers, supporting real division.

Minimal complete definition

fromRational, (recip | (/))

Methods

(/) :: a -> a -> a infixl 7

fractional division

recip :: a -> a

reciprocal fraction

fromRational :: Rational -> a

Conversion from a Rational (that is Ratio Integer). A floating literal stands for an application of fromRational to a value of type Rational, so such literals have type (Fractional a) => a.

Instances

Fractional CFloat

Defined in Foreign.C.Types

Methods

(/) :: CFloat -> CFloat -> CFloat

recip :: CFloat -> CFloat

fromRational :: Rational -> CFloat

Fractional CDouble

Defined in Foreign.C.Types

Methods

(/) :: CDouble -> CDouble -> CDouble

recip :: CDouble -> CDouble

fromRational :: Rational -> CDouble

Fractional Half

Defined in Numeric.Half

Methods

(/) :: Half -> Half -> Half

recip :: Half -> Half

fromRational :: Rational -> Half

() :=> (Fractional Double)

Defined in Data.Constraint

Methods

ins :: () :- Fractional Double

() :=> (Fractional Float)

Defined in Data.Constraint

Methods

ins :: () :- Fractional Float

Integral a => Fractional (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

(/) :: Ratio a -> Ratio a -> Ratio a

recip :: Ratio a -> Ratio a

fromRational :: Rational -> Ratio a

RealFloat a => Fractional (Complex a)

Since: base-2.1

Defined in Data.Complex

Methods

(/) :: Complex a -> Complex a -> Complex a

recip :: Complex a -> Complex a

fromRational :: Rational -> Complex a

HasResolution a => Fractional (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

(/) :: Fixed a -> Fixed a -> Fixed a

recip :: Fixed a -> Fixed a

fromRational :: Rational -> Fixed a

Fractional a => Fractional (Identity a)

Defined in Data.Functor.Identity

Methods

(/) :: Identity a -> Identity a -> Identity a

recip :: Identity a -> Identity a

fromRational :: Rational -> Identity a

(Fractional a) :=> (Fractional (Identity a))

Defined in Data.Constraint

Methods

ins :: Fractional a :- Fractional (Identity a)

(Fractional a) :=> (Fractional (Const a b))

Defined in Data.Constraint

Methods

ins :: Fractional a :- Fractional (Const a b)

(Integral a) :=> (Fractional (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Fractional (Ratio a)

(RealFloat a) :=> (Fractional (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Fractional (Complex a)

Class (Fractional a) (Floating a)

Defined in Data.Constraint

Methods

cls :: Floating a :- Fractional a

Class (Num a) (Fractional a)

Defined in Data.Constraint

Methods

cls :: Fractional a :- Num a

Fractional a => Fractional (Op a b)

Defined in Data.Functor.Contravariant

Methods

(/) :: Op a b -> Op a b -> Op a b

recip :: Op a b -> Op a b

fromRational :: Rational -> Op a b

Fractional a => Fractional (Signal domain a)

Defined in Clash.Signal.Internal

Methods

(/) :: Signal domain a -> Signal domain a -> Signal domain a

recip :: Signal domain a -> Signal domain a

fromRational :: Rational -> Signal domain a

Class (Real a, Fractional a) (RealFrac a)

Defined in Data.Constraint

Methods

cls :: RealFrac a :- (Real a, Fractional a)

Fractional a => Fractional (Const a b)

Defined in Data.Functor.Const

Methods

(/) :: Const a b -> Const a b -> Const a b

recip :: Const a b -> Const a b

fromRational :: Rational -> Const a b

Fractional a => Fractional (Tagged s a)

Defined in Data.Tagged

Methods

(/) :: Tagged s a -> Tagged s a -> Tagged s a

recip :: Tagged s a -> Tagged s a

fromRational :: Rational -> Tagged s a

FracFixedC rep int frac => Fractional (Fixed rep int frac)

The operators of this instance saturate on overflow, and use truncation as the rounding method.

When used in a polymorphic setting, use the following Constraint synonyms for less verbose type signatures:

• FracFixedC frac rep size for: Fixed frac rep size
• FracSFixedC int frac for: SFixed int frac
• FracUFixedC int frac for: UFixed int frac

Defined in Clash.Sized.Fixed

Methods

(/) :: Fixed rep int frac -> Fixed rep int frac -> Fixed rep int frac

recip :: Fixed rep int frac -> Fixed rep int frac

fromRational :: Rational -> Fixed rep int frac

Fractional a => Fractional (DSignal domain delay a)

Defined in Clash.Explicit.Signal.Delayed

Methods

(/) :: DSignal domain delay a -> DSignal domain delay a -> DSignal domain delay a

recip :: DSignal domain delay a -> DSignal domain delay a

fromRational :: Rational -> DSignal domain delay a

class (Real a, Enum a) => Integral a where

Integral numbers, supporting integer division.

Minimal complete definition

quotRem, toInteger

Methods

quot :: a -> a -> a infixl 7

integer division truncated toward zero

rem :: a -> a -> a infixl 7

integer remainder, satisfying

(x `quot` y)*y + (x `rem` y) == x

div :: a -> a -> a infixl 7

integer division truncated toward negative infinity

mod :: a -> a -> a infixl 7

integer modulus, satisfying

(x `div` y)*y + (x `mod` y) == x

quotRem :: a -> a -> (a, a)

simultaneous quot and rem

divMod :: a -> a -> (a, a)

simultaneous div and mod

toInteger :: a -> Integer

conversion to Integer

Instances

Integral Int

Since: base-2.0.1

Defined in GHC.Real

Methods

quot :: Int -> Int -> Int

rem :: Int -> Int -> Int

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

quotRem :: Int -> Int -> (Int, Int)

divMod :: Int -> Int -> (Int, Int)

toInteger :: Int -> Integer

Integral Int8

Since: base-2.1

Defined in GHC.Int

Methods

quot :: Int8 -> Int8 -> Int8

rem :: Int8 -> Int8 -> Int8

div :: Int8 -> Int8 -> Int8

mod :: Int8 -> Int8 -> Int8

quotRem :: Int8 -> Int8 -> (Int8, Int8)

divMod :: Int8 -> Int8 -> (Int8, Int8)

toInteger :: Int8 -> Integer

Integral Int16

Since: base-2.1

Defined in GHC.Int

Methods

quot :: Int16 -> Int16 -> Int16

rem :: Int16 -> Int16 -> Int16

div :: Int16 -> Int16 -> Int16

mod :: Int16 -> Int16 -> Int16

quotRem :: Int16 -> Int16 -> (Int16, Int16)

divMod :: Int16 -> Int16 -> (Int16, Int16)

toInteger :: Int16 -> Integer

Integral Int32

Since: base-2.1

Defined in GHC.Int

Methods

quot :: Int32 -> Int32 -> Int32

rem :: Int32 -> Int32 -> Int32

div :: Int32 -> Int32 -> Int32

mod :: Int32 -> Int32 -> Int32

quotRem :: Int32 -> Int32 -> (Int32, Int32)

divMod :: Int32 -> Int32 -> (Int32, Int32)

toInteger :: Int32 -> Integer

Integral Int64

Since: base-2.1

Defined in GHC.Int

Methods

quot :: Int64 -> Int64 -> Int64

rem :: Int64 -> Int64 -> Int64

div :: Int64 -> Int64 -> Int64

mod :: Int64 -> Int64 -> Int64

quotRem :: Int64 -> Int64 -> (Int64, Int64)

divMod :: Int64 -> Int64 -> (Int64, Int64)

toInteger :: Int64 -> Integer

Integral Integer

Since: base-2.0.1

Defined in GHC.Real

Methods

quot :: Integer -> Integer -> Integer

rem :: Integer -> Integer -> Integer

div :: Integer -> Integer -> Integer

mod :: Integer -> Integer -> Integer

quotRem :: Integer -> Integer -> (Integer, Integer)

divMod :: Integer -> Integer -> (Integer, Integer)

toInteger :: Integer -> Integer

Integral Natural

Since: base-4.8.0.0

Defined in GHC.Natural

Methods

quot :: Natural -> Natural -> Natural

rem :: Natural -> Natural -> Natural

div :: Natural -> Natural -> Natural

mod :: Natural -> Natural -> Natural

quotRem :: Natural -> Natural -> (Natural, Natural)

divMod :: Natural -> Natural -> (Natural, Natural)

toInteger :: Natural -> Integer

Integral Word

Since: base-2.1

Defined in GHC.Real

Methods

quot :: Word -> Word -> Word

rem :: Word -> Word -> Word

div :: Word -> Word -> Word

mod :: Word -> Word -> Word

quotRem :: Word -> Word -> (Word, Word)

divMod :: Word -> Word -> (Word, Word)

toInteger :: Word -> Integer

Integral Word8

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word8 -> Word8 -> Word8

rem :: Word8 -> Word8 -> Word8

div :: Word8 -> Word8 -> Word8

mod :: Word8 -> Word8 -> Word8

quotRem :: Word8 -> Word8 -> (Word8, Word8)

divMod :: Word8 -> Word8 -> (Word8, Word8)

toInteger :: Word8 -> Integer

Integral Word16

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word16 -> Word16 -> Word16

rem :: Word16 -> Word16 -> Word16

div :: Word16 -> Word16 -> Word16

mod :: Word16 -> Word16 -> Word16

quotRem :: Word16 -> Word16 -> (Word16, Word16)

divMod :: Word16 -> Word16 -> (Word16, Word16)

toInteger :: Word16 -> Integer

Integral Word32

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word32 -> Word32 -> Word32

rem :: Word32 -> Word32 -> Word32

div :: Word32 -> Word32 -> Word32

mod :: Word32 -> Word32 -> Word32

quotRem :: Word32 -> Word32 -> (Word32, Word32)

divMod :: Word32 -> Word32 -> (Word32, Word32)

toInteger :: Word32 -> Integer

Integral Word64

Since: base-2.1

Defined in GHC.Word

Methods

quot :: Word64 -> Word64 -> Word64

rem :: Word64 -> Word64 -> Word64

div :: Word64 -> Word64 -> Word64

mod :: Word64 -> Word64 -> Word64

quotRem :: Word64 -> Word64 -> (Word64, Word64)

divMod :: Word64 -> Word64 -> (Word64, Word64)

toInteger :: Word64 -> Integer

Integral CChar

Defined in Foreign.C.Types

Methods

quot :: CChar -> CChar -> CChar

rem :: CChar -> CChar -> CChar

div :: CChar -> CChar -> CChar

mod :: CChar -> CChar -> CChar

quotRem :: CChar -> CChar -> (CChar, CChar)

divMod :: CChar -> CChar -> (CChar, CChar)

toInteger :: CChar -> Integer

Integral CSChar

Defined in Foreign.C.Types

Methods

quot :: CSChar -> CSChar -> CSChar

rem :: CSChar -> CSChar -> CSChar

div :: CSChar -> CSChar -> CSChar

mod :: CSChar -> CSChar -> CSChar

quotRem :: CSChar -> CSChar -> (CSChar, CSChar)

divMod :: CSChar -> CSChar -> (CSChar, CSChar)

toInteger :: CSChar -> Integer

Integral CUChar

Defined in Foreign.C.Types

Methods

quot :: CUChar -> CUChar -> CUChar

rem :: CUChar -> CUChar -> CUChar

div :: CUChar -> CUChar -> CUChar

mod :: CUChar -> CUChar -> CUChar

quotRem :: CUChar -> CUChar -> (CUChar, CUChar)

divMod :: CUChar -> CUChar -> (CUChar, CUChar)

toInteger :: CUChar -> Integer

Integral CShort

Defined in Foreign.C.Types

Methods

quot :: CShort -> CShort -> CShort

rem :: CShort -> CShort -> CShort

div :: CShort -> CShort -> CShort

mod :: CShort -> CShort -> CShort

quotRem :: CShort -> CShort -> (CShort, CShort)

divMod :: CShort -> CShort -> (CShort, CShort)

toInteger :: CShort -> Integer

Integral CUShort

Defined in Foreign.C.Types

Methods

quot :: CUShort -> CUShort -> CUShort

rem :: CUShort -> CUShort -> CUShort

div :: CUShort -> CUShort -> CUShort

mod :: CUShort -> CUShort -> CUShort

quotRem :: CUShort -> CUShort -> (CUShort, CUShort)

divMod :: CUShort -> CUShort -> (CUShort, CUShort)

toInteger :: CUShort -> Integer

Integral CInt

Defined in Foreign.C.Types

Methods

quot :: CInt -> CInt -> CInt

rem :: CInt -> CInt -> CInt

div :: CInt -> CInt -> CInt

mod :: CInt -> CInt -> CInt

quotRem :: CInt -> CInt -> (CInt, CInt)

divMod :: CInt -> CInt -> (CInt, CInt)

toInteger :: CInt -> Integer

Integral CUInt

Defined in Foreign.C.Types

Methods

quot :: CUInt -> CUInt -> CUInt

rem :: CUInt -> CUInt -> CUInt

div :: CUInt -> CUInt -> CUInt

mod :: CUInt -> CUInt -> CUInt

quotRem :: CUInt -> CUInt -> (CUInt, CUInt)

divMod :: CUInt -> CUInt -> (CUInt, CUInt)

toInteger :: CUInt -> Integer

Integral CLong

Defined in Foreign.C.Types

Methods

quot :: CLong -> CLong -> CLong

rem :: CLong -> CLong -> CLong

div :: CLong -> CLong -> CLong

mod :: CLong -> CLong -> CLong

quotRem :: CLong -> CLong -> (CLong, CLong)

divMod :: CLong -> CLong -> (CLong, CLong)

toInteger :: CLong -> Integer

Integral CULong

Defined in Foreign.C.Types

Methods

quot :: CULong -> CULong -> CULong

rem :: CULong -> CULong -> CULong

div :: CULong -> CULong -> CULong

mod :: CULong -> CULong -> CULong

quotRem :: CULong -> CULong -> (CULong, CULong)

divMod :: CULong -> CULong -> (CULong, CULong)

toInteger :: CULong -> Integer

Integral CLLong

Defined in Foreign.C.Types

Methods

quot :: CLLong -> CLLong -> CLLong

rem :: CLLong -> CLLong -> CLLong

div :: CLLong -> CLLong -> CLLong

mod :: CLLong -> CLLong -> CLLong

quotRem :: CLLong -> CLLong -> (CLLong, CLLong)

divMod :: CLLong -> CLLong -> (CLLong, CLLong)

toInteger :: CLLong -> Integer

Integral CULLong

Defined in Foreign.C.Types

Methods

quot :: CULLong -> CULLong -> CULLong

rem :: CULLong -> CULLong -> CULLong

div :: CULLong -> CULLong -> CULLong

mod :: CULLong -> CULLong -> CULLong

quotRem :: CULLong -> CULLong -> (CULLong, CULLong)

divMod :: CULLong -> CULLong -> (CULLong, CULLong)

toInteger :: CULLong -> Integer

Integral CBool

Defined in Foreign.C.Types

Methods

quot :: CBool -> CBool -> CBool

rem :: CBool -> CBool -> CBool

div :: CBool -> CBool -> CBool

mod :: CBool -> CBool -> CBool

quotRem :: CBool -> CBool -> (CBool, CBool)

divMod :: CBool -> CBool -> (CBool, CBool)

toInteger :: CBool -> Integer

Integral CPtrdiff

Defined in Foreign.C.Types

Methods

quot :: CPtrdiff -> CPtrdiff -> CPtrdiff

rem :: CPtrdiff -> CPtrdiff -> CPtrdiff

div :: CPtrdiff -> CPtrdiff -> CPtrdiff

mod :: CPtrdiff -> CPtrdiff -> CPtrdiff

quotRem :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff)

divMod :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff)

toInteger :: CPtrdiff -> Integer

Integral CSize

Defined in Foreign.C.Types

Methods

quot :: CSize -> CSize -> CSize

rem :: CSize -> CSize -> CSize

div :: CSize -> CSize -> CSize

mod :: CSize -> CSize -> CSize

quotRem :: CSize -> CSize -> (CSize, CSize)

divMod :: CSize -> CSize -> (CSize, CSize)

toInteger :: CSize -> Integer

Integral CWchar

Defined in Foreign.C.Types

Methods

quot :: CWchar -> CWchar -> CWchar

rem :: CWchar -> CWchar -> CWchar

div :: CWchar -> CWchar -> CWchar

mod :: CWchar -> CWchar -> CWchar

quotRem :: CWchar -> CWchar -> (CWchar, CWchar)

divMod :: CWchar -> CWchar -> (CWchar, CWchar)

toInteger :: CWchar -> Integer

Integral CSigAtomic

Defined in Foreign.C.Types

Methods

quot :: CSigAtomic -> CSigAtomic -> CSigAtomic

rem :: CSigAtomic -> CSigAtomic -> CSigAtomic

div :: CSigAtomic -> CSigAtomic -> CSigAtomic

mod :: CSigAtomic -> CSigAtomic -> CSigAtomic

quotRem :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic)

divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic)

toInteger :: CSigAtomic -> Integer

Integral CIntPtr

Defined in Foreign.C.Types

Methods

quot :: CIntPtr -> CIntPtr -> CIntPtr

rem :: CIntPtr -> CIntPtr -> CIntPtr

div :: CIntPtr -> CIntPtr -> CIntPtr

mod :: CIntPtr -> CIntPtr -> CIntPtr

quotRem :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr)

divMod :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr)

toInteger :: CIntPtr -> Integer

Integral CUIntPtr

Defined in Foreign.C.Types

Methods

quot :: CUIntPtr -> CUIntPtr -> CUIntPtr

rem :: CUIntPtr -> CUIntPtr -> CUIntPtr

div :: CUIntPtr -> CUIntPtr -> CUIntPtr

mod :: CUIntPtr -> CUIntPtr -> CUIntPtr

quotRem :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr)

divMod :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr)

toInteger :: CUIntPtr -> Integer

Integral CIntMax

Defined in Foreign.C.Types

Methods

quot :: CIntMax -> CIntMax -> CIntMax

rem :: CIntMax -> CIntMax -> CIntMax

div :: CIntMax -> CIntMax -> CIntMax

mod :: CIntMax -> CIntMax -> CIntMax

quotRem :: CIntMax -> CIntMax -> (CIntMax, CIntMax)

divMod :: CIntMax -> CIntMax -> (CIntMax, CIntMax)

toInteger :: CIntMax -> Integer

Integral CUIntMax

Defined in Foreign.C.Types

Methods

quot :: CUIntMax -> CUIntMax -> CUIntMax

rem :: CUIntMax -> CUIntMax -> CUIntMax

div :: CUIntMax -> CUIntMax -> CUIntMax

mod :: CUIntMax -> CUIntMax -> CUIntMax

quotRem :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax)

divMod :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax)

toInteger :: CUIntMax -> Integer

Integral Bit

Defined in Clash.Sized.Internal.BitVector

Methods

quot :: Bit -> Bit -> Bit

rem :: Bit -> Bit -> Bit

div :: Bit -> Bit -> Bit

mod :: Bit -> Bit -> Bit

quotRem :: Bit -> Bit -> (Bit, Bit)

divMod :: Bit -> Bit -> (Bit, Bit)

toInteger :: Bit -> Integer

() :=> (Integral Int)

Defined in Data.Constraint

Methods

ins :: () :- Integral Int

() :=> (Integral Integer)

Defined in Data.Constraint

Methods

ins :: () :- Integral Integer

() :=> (Integral Natural)

Defined in Data.Constraint

Methods

ins :: () :- Integral Natural

() :=> (Integral Word)

Defined in Data.Constraint

Methods

ins :: () :- Integral Word

Integral a => Integral (Identity a)

Defined in Data.Functor.Identity

Methods

quot :: Identity a -> Identity a -> Identity a

rem :: Identity a -> Identity a -> Identity a

div :: Identity a -> Identity a -> Identity a

mod :: Identity a -> Identity a -> Identity a

quotRem :: Identity a -> Identity a -> (Identity a, Identity a)

divMod :: Identity a -> Identity a -> (Identity a, Identity a)

toInteger :: Identity a -> Integer

KnownNat n => Integral (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

quot :: BitVector n -> BitVector n -> BitVector n

rem :: BitVector n -> BitVector n -> BitVector n

div :: BitVector n -> BitVector n -> BitVector n

mod :: BitVector n -> BitVector n -> BitVector n

quotRem :: BitVector n -> BitVector n -> (BitVector n, BitVector n)

divMod :: BitVector n -> BitVector n -> (BitVector n, BitVector n)

toInteger :: BitVector n -> Integer

KnownNat n => Integral (Index n)

Defined in Clash.Sized.Internal.Index

Methods

quot :: Index n -> Index n -> Index n

rem :: Index n -> Index n -> Index n

div :: Index n -> Index n -> Index n

mod :: Index n -> Index n -> Index n

quotRem :: Index n -> Index n -> (Index n, Index n)

divMod :: Index n -> Index n -> (Index n, Index n)

toInteger :: Index n -> Integer

(Num a, Real a, Enum a) => Integral (Bounds a)

Defined in Test.QuickCheck.Arbitrary

Methods

quot :: Bounds a -> Bounds a -> Bounds a

rem :: Bounds a -> Bounds a -> Bounds a

div :: Bounds a -> Bounds a -> Bounds a

mod :: Bounds a -> Bounds a -> Bounds a

quotRem :: Bounds a -> Bounds a -> (Bounds a, Bounds a)

divMod :: Bounds a -> Bounds a -> (Bounds a, Bounds a)

toInteger :: Bounds a -> Integer

KnownNat n => Integral (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

quot :: Unsigned n -> Unsigned n -> Unsigned n

rem :: Unsigned n -> Unsigned n -> Unsigned n

div :: Unsigned n -> Unsigned n -> Unsigned n

mod :: Unsigned n -> Unsigned n -> Unsigned n

quotRem :: Unsigned n -> Unsigned n -> (Unsigned n, Unsigned n)

divMod :: Unsigned n -> Unsigned n -> (Unsigned n, Unsigned n)

toInteger :: Unsigned n -> Integer

KnownNat n => Integral (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

quot :: Signed n -> Signed n -> Signed n

rem :: Signed n -> Signed n -> Signed n

div :: Signed n -> Signed n -> Signed n

mod :: Signed n -> Signed n -> Signed n

quotRem :: Signed n -> Signed n -> (Signed n, Signed n)

divMod :: Signed n -> Signed n -> (Signed n, Signed n)

toInteger :: Signed n -> Integer

(Integral a) :=> (RealFrac (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- RealFrac (Ratio a)

(Integral a) :=> (Real (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Real (Ratio a)

(Integral a) :=> (Ord (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Ord (Ratio a)

(Integral a) :=> (Num (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Num (Ratio a)

(Integral a) :=> (Integral (Identity a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Integral (Identity a)

(Integral a) :=> (Integral (Const a b))

Defined in Data.Constraint

Methods

ins :: Integral a :- Integral (Const a b)

(Integral a) :=> (Fractional (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Fractional (Ratio a)

(Integral a) :=> (Enum (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Enum (Ratio a)

(Integral a, Show a) :=> (Show (Ratio a))

Defined in Data.Constraint

Methods

ins :: (Integral a, Show a) :- Show (Ratio a)

(Integral a, Read a) :=> (Read (Ratio a))

Defined in Data.Constraint

Methods

ins :: (Integral a, Read a) :- Read (Ratio a)

Class (Real a, Enum a) (Integral a)

Defined in Data.Constraint

Methods

cls :: Integral a :- (Real a, Enum a)

Integral a => Integral (Const a b)

Defined in Data.Functor.Const

Methods

quot :: Const a b -> Const a b -> Const a b

rem :: Const a b -> Const a b -> Const a b

div :: Const a b -> Const a b -> Const a b

mod :: Const a b -> Const a b -> Const a b

quotRem :: Const a b -> Const a b -> (Const a b, Const a b)

divMod :: Const a b -> Const a b -> (Const a b, Const a b)

toInteger :: Const a b -> Integer

Integral a => Integral (Tagged s a)

Defined in Data.Tagged

Methods

quot :: Tagged s a -> Tagged s a -> Tagged s a

rem :: Tagged s a -> Tagged s a -> Tagged s a

div :: Tagged s a -> Tagged s a -> Tagged s a

mod :: Tagged s a -> Tagged s a -> Tagged s a

quotRem :: Tagged s a -> Tagged s a -> (Tagged s a, Tagged s a)

divMod :: Tagged s a -> Tagged s a -> (Tagged s a, Tagged s a)

toInteger :: Tagged s a -> Integer

class Applicative m => Monad (m :: * -> *) where

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

Instances of Monad should satisfy the following laws:

• return a >>= k  =  k a

• m >>= return  =  m

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

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

• pure = return

• (<*>) = ap

The above laws imply:

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

• (>>) = (*>)

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

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

Minimal complete definition

(>>=)

Methods

(>>=) :: m a -> (a -> m b) -> m b infixl 1

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

(>>) :: m a -> m b -> m b infixl 1

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

return :: a -> m a

Inject a value into the monadic type.

fail :: String -> m a

Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a do expression.

As part of the MonadFail proposal (MFP), this function is moved to its own class MonadFail (see Control.Monad.Fail for more details). The definition here will be removed in a future release.

Instances

Monad []

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: [a] -> (a -> [b]) -> [b]

(>>) :: [a] -> [b] -> [b]

return :: a -> [a]

fail :: String -> [a]

Monad Maybe

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b

(>>) :: Maybe a -> Maybe b -> Maybe b

return :: a -> Maybe a

fail :: String -> Maybe a

Monad IO

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b

(>>) :: IO a -> IO b -> IO b

return :: a -> IO a

fail :: String -> IO a

Monad Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b

(>>) :: Par1 a -> Par1 b -> Par1 b

return :: a -> Par1 a

fail :: String -> Par1 a

Monad Q

Defined in Language.Haskell.TH.Syntax

Methods

(>>=) :: Q a -> (a -> Q b) -> Q b

(>>) :: Q a -> Q b -> Q b

return :: a -> Q a

fail :: String -> Q a

Monad Complex

Since: base-4.9.0.0

Defined in Data.Complex

Methods

(>>=) :: Complex a -> (a -> Complex b) -> Complex b

(>>) :: Complex a -> Complex b -> Complex b

return :: a -> Complex a

fail :: String -> Complex a

Monad Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(>>=) :: Min a -> (a -> Min b) -> Min b

(>>) :: Min a -> Min b -> Min b

return :: a -> Min a

fail :: String -> Min a

Monad Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(>>=) :: Max a -> (a -> Max b) -> Max b

(>>) :: Max a -> Max b -> Max b

return :: a -> Max a

fail :: String -> Max a

Monad First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(>>=) :: First a -> (a -> First b) -> First b

(>>) :: First a -> First b -> First b

return :: a -> First a

fail :: String -> First a

Monad Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b

(>>) :: Last a -> Last b -> Last b

return :: a -> Last a

fail :: String -> Last a

Monad Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(>>=) :: Option a -> (a -> Option b) -> Option b

(>>) :: Option a -> Option b -> Option b

return :: a -> Option a

fail :: String -> Option a

Monad Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

(>>=) :: Identity a -> (a -> Identity b) -> Identity b

(>>) :: Identity a -> Identity b -> Identity b

return :: a -> Identity a

fail :: String -> Identity a

Monad STM

Since: base-4.3.0.0

Defined in GHC.Conc.Sync

Methods

(>>=) :: STM a -> (a -> STM b) -> STM b

(>>) :: STM a -> STM b -> STM b

return :: a -> STM a

fail :: String -> STM a

Monad First

Defined in Data.Monoid

Methods

(>>=) :: First a -> (a -> First b) -> First b

(>>) :: First a -> First b -> First b

return :: a -> First a

fail :: String -> First a

Monad Last

Defined in Data.Monoid

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b

(>>) :: Last a -> Last b -> Last b

return :: a -> Last a

fail :: String -> Last a

Monad Dual

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

(>>=) :: Dual a -> (a -> Dual b) -> Dual b

(>>) :: Dual a -> Dual b -> Dual b

return :: a -> Dual a

fail :: String -> Dual a

Monad Sum

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

(>>=) :: Sum a -> (a -> Sum b) -> Sum b

(>>) :: Sum a -> Sum b -> Sum b

return :: a -> Sum a

fail :: String -> Sum a

Monad Product

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

(>>=) :: Product a -> (a -> Product b) -> Product b

(>>) :: Product a -> Product b -> Product b

return :: a -> Product a

fail :: String -> Product a

Monad Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(>>=) :: Down a -> (a -> Down b) -> Down b

(>>) :: Down a -> Down b -> Down b

return :: a -> Down a

fail :: String -> Down a

Monad ReadPrec

Since: base-2.1

Defined in Text.ParserCombinators.ReadPrec

Methods

(>>=) :: ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b

(>>) :: ReadPrec a -> ReadPrec b -> ReadPrec b

return :: a -> ReadPrec a

fail :: String -> ReadPrec a

Monad ReadP

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

(>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b

(>>) :: ReadP a -> ReadP b -> ReadP b

return :: a -> ReadP a

fail :: String -> ReadP a

Monad NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b

(>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

return :: a -> NonEmpty a

fail :: String -> NonEmpty a

Monad Tree

Defined in Data.Tree

Methods

(>>=) :: Tree a -> (a -> Tree b) -> Tree b

(>>) :: Tree a -> Tree b -> Tree b

return :: a -> Tree a

fail :: String -> Tree a

Monad Seq

Defined in Data.Sequence.Internal

Methods

(>>=) :: Seq a -> (a -> Seq b) -> Seq b

(>>) :: Seq a -> Seq b -> Seq b

return :: a -> Seq a

fail :: String -> Seq a

Monad P

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

(>>=) :: P a -> (a -> P b) -> P b

(>>) :: P a -> P b -> P b

return :: a -> P a

fail :: String -> P a

Monad Gen

Defined in Test.QuickCheck.Gen

Methods

(>>=) :: Gen a -> (a -> Gen b) -> Gen b

(>>) :: Gen a -> Gen b -> Gen b

return :: a -> Gen a

fail :: String -> Gen a

Monad Id

Defined in Data.Vector.Fusion.Util

Methods

(>>=) :: Id a -> (a -> Id b) -> Id b

(>>) :: Id a -> Id b -> Id b

return :: a -> Id a

fail :: String -> Id a

Monad Box

Defined in Data.Vector.Fusion.Util

Methods

(>>=) :: Box a -> (a -> Box b) -> Box b

(>>) :: Box a -> Box b -> Box b

return :: a -> Box a

fail :: String -> Box a

Monad DList

Defined in Data.DList

Methods

(>>=) :: DList a -> (a -> DList b) -> DList b

(>>) :: DList a -> DList b -> DList b

return :: a -> DList a

fail :: String -> DList a

Monad Vector

Defined in Data.Vector

Methods

(>>=) :: Vector a -> (a -> Vector b) -> Vector b

(>>) :: Vector a -> Vector b -> Vector b

return :: a -> Vector a

fail :: String -> Vector a

Monad Array

Defined in Data.Primitive.Array

Methods

(>>=) :: Array a -> (a -> Array b) -> Array b

(>>) :: Array a -> Array b -> Array b

return :: a -> Array a

fail :: String -> Array a

Monad SmallArray

Defined in Data.Primitive.SmallArray

Methods

(>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b

(>>) :: SmallArray a -> SmallArray b -> SmallArray b

return :: a -> SmallArray a

fail :: String -> SmallArray a

Monad Rose

Defined in Test.QuickCheck.Property

Methods

(>>=) :: Rose a -> (a -> Rose b) -> Rose b

(>>) :: Rose a -> Rose b -> Rose b

return :: a -> Rose a

fail :: String -> Rose a

() :=> (Monad ((->) a :: * -> *))

Defined in Data.Constraint

Methods

ins :: () :- Monad ((->) a)

() :=> (Monad [])

Defined in Data.Constraint

Methods

ins :: () :- Monad []

() :=> (Monad IO)

Defined in Data.Constraint

Methods

ins :: () :- Monad IO

() :=> (Monad (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Monad (Either a)

() :=> (Monad Identity)

Defined in Data.Constraint

Methods

ins :: () :- Monad Identity

Monad (Either e)

Since: base-4.4.0.0

Defined in Data.Either

Methods

(>>=) :: Either e a -> (a -> Either e b) -> Either e b

(>>) :: Either e a -> Either e b -> Either e b

return :: a -> Either e a

fail :: String -> Either e a

Monad (U1 :: * -> *)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(>>=) :: U1 a -> (a -> U1 b) -> U1 b

(>>) :: U1 a -> U1 b -> U1 b

return :: a -> U1 a

fail :: String -> U1 a

Monoid a => Monad ((,) a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b)

(>>) :: (a, a0) -> (a, b) -> (a, b)

return :: a0 -> (a, a0)

fail :: String -> (a, a0)

Monad (ST s)

Since: base-2.1

Defined in GHC.ST

Methods

(>>=) :: ST s a -> (a -> ST s b) -> ST s b

(>>) :: ST s a -> ST s b -> ST s b

return :: a -> ST s a

fail :: String -> ST s a

Monad m => Monad (WrappedMonad m)

Defined in Control.Applicative

Methods

(>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b

(>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

return :: a -> WrappedMonad m a

fail :: String -> WrappedMonad m a

ArrowApply a => Monad (ArrowMonad a)

Since: base-2.1

Defined in Control.Arrow

Methods

(>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b

(>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b

return :: a0 -> ArrowMonad a a0

fail :: String -> ArrowMonad a a0

Monad (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

(>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b

(>>) :: Proxy a -> Proxy b -> Proxy b

return :: a -> Proxy a

fail :: String -> Proxy a

Monad (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

(>>=) :: ReifiedFold s a -> (a -> ReifiedFold s b) -> ReifiedFold s b

(>>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b

return :: a -> ReifiedFold s a

fail :: String -> ReifiedFold s a

Monad (ReifiedGetter s)

Defined in Control.Lens.Reified

Methods

(>>=) :: ReifiedGetter s a -> (a -> ReifiedGetter s b) -> ReifiedGetter s b

(>>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b

return :: a -> ReifiedGetter s a

fail :: String -> ReifiedGetter s a

Representable f => Monad (Co f)

Defined in Data.Functor.Rep

Methods

(>>=) :: Co f a -> (a -> Co f b) -> Co f b

(>>) :: Co f a -> Co f b -> Co f b

return :: a -> Co f a

fail :: String -> Co f a

Alternative f => Monad (Cofree f)

Defined in Control.Comonad.Cofree

Methods

(>>=) :: Cofree f a -> (a -> Cofree f b) -> Cofree f b

(>>) :: Cofree f a -> Cofree f b -> Cofree f b

return :: a -> Cofree f a

fail :: String -> Cofree f a

Functor f => Monad (Free f)

Defined in Control.Monad.Free

Methods

(>>=) :: Free f a -> (a -> Free f b) -> Free f b

(>>) :: Free f a -> Free f b -> Free f b

return :: a -> Free f a

fail :: String -> Free f a

Monad m => Monad (Yoneda m)

Defined in Data.Functor.Yoneda

Methods

(>>=) :: Yoneda m a -> (a -> Yoneda m b) -> Yoneda m b

(>>) :: Yoneda m a -> Yoneda m b -> Yoneda m b

return :: a -> Yoneda m a

fail :: String -> Yoneda m a

(Monad (Rep p), Representable p) => Monad (Prep p)

Defined in Data.Profunctor.Rep

Methods

(>>=) :: Prep p a -> (a -> Prep p b) -> Prep p b

(>>) :: Prep p a -> Prep p b -> Prep p b

return :: a -> Prep p a

fail :: String -> Prep p a

(Monad m) :=> (Functor (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Functor (WrappedMonad m)

(Monad m) :=> (Applicative (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Applicative (WrappedMonad m)

Class (Applicative f) (Monad f)

Defined in Data.Constraint

Methods

cls :: Monad f :- Applicative f

Monad f => Monad (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b

(>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

return :: a -> Rec1 f a

fail :: String -> Rec1 f a

Monad f => Monad (Alt f)

Defined in Data.Semigroup.Internal

Methods

(>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b

(>>) :: Alt f a -> Alt f b -> Alt f b

return :: a -> Alt f a

fail :: String -> Alt f a

(Applicative f, Monad f) => Monad (WhenMissing f x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)).

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

(>>=) :: WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b

(>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b

return :: a -> WhenMissing f x a

fail :: String -> WhenMissing f x a

(Monad m, Error e) => Monad (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

(>>=) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b

(>>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b

return :: a -> ErrorT e m a

fail :: String -> ErrorT e m a

Monad m => Monad (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

(>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b

(>>) :: StateT s m a -> StateT s m b -> StateT s m b

return :: a -> StateT s m a

fail :: String -> StateT s m a

Monad (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

(>>=) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b

(>>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b

return :: a0 -> Indexed i a a0

fail :: String -> Indexed i a a0

Monad (Tagged s)

Defined in Data.Tagged

Methods

(>>=) :: Tagged s a -> (a -> Tagged s b) -> Tagged s b

(>>) :: Tagged s a -> Tagged s b -> Tagged s b

return :: a -> Tagged s a

fail :: String -> Tagged s a

(Alternative f, Monad w) => Monad (CofreeT f w)

Defined in Control.Comonad.Trans.Cofree

Methods

(>>=) :: CofreeT f w a -> (a -> CofreeT f w b) -> CofreeT f w b

(>>) :: CofreeT f w a -> CofreeT f w b -> CofreeT f w b

return :: a -> CofreeT f w a

fail :: String -> CofreeT f w a

(Functor f, Monad m) => Monad (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

(>>=) :: FreeT f m a -> (a -> FreeT f m b) -> FreeT f m b

(>>) :: FreeT f m a -> FreeT f m b -> FreeT f m b

return :: a -> FreeT f m a

fail :: String -> FreeT f m a

Class (Monad f, Alternative f) (MonadPlus f)

Defined in Data.Constraint

Methods

cls :: MonadPlus f :- (Monad f, Alternative f)

Monad ((->) r :: * -> *)

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b

(>>) :: (r -> a) -> (r -> b) -> r -> b

return :: a -> r -> a

fail :: String -> r -> a

(Monad f, Monad g) => Monad (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b

(>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

return :: a -> (f :*: g) a

fail :: String -> (f :*: g) a

(Monad f, Monad g) => Monad (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

(>>=) :: Product f g a -> (a -> Product f g b) -> Product f g b

(>>) :: Product f g a -> Product f g b -> Product f g b

return :: a -> Product f g a

fail :: String -> Product f g a

(Monad f, Applicative f) => Monad (WhenMatched f x y)

Equivalent to ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

(>>=) :: WhenMatched f x y a -> (a -> WhenMatched f x y b) -> WhenMatched f x y b

(>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b

return :: a -> WhenMatched f x y a

fail :: String -> WhenMatched f x y a

(Applicative f, Monad f) => Monad (WhenMissing f k x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)) .

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

(>>=) :: WhenMissing f k x a -> (a -> WhenMissing f k x b) -> WhenMissing f k x b

(>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b

return :: a -> WhenMissing f k x a

fail :: String -> WhenMissing f k x a

Monad f => Monad (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b

(>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b

return :: a -> M1 i c f a

fail :: String -> M1 i c f a

(Monad f, Applicative f) => Monad (WhenMatched f k x y)

Equivalent to ReaderT k (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

(>>=) :: WhenMatched f k x y a -> (a -> WhenMatched f k x y b) -> WhenMatched f k x y b

(>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b

return :: a -> WhenMatched f k x y a

fail :: String -> WhenMatched f k x y a

class Functor (f :: * -> *) where

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Maybe and IO satisfy these laws.

Minimal complete definition

fmap

Methods

fmap :: (a -> b) -> f a -> f b

(<$) :: a -> f b -> f a infixl 4

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Instances

Functor []

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> [a] -> [b]

(<$) :: a -> [b] -> [a]

Functor Maybe

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b

(<$) :: a -> Maybe b -> Maybe a

Functor IO

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> IO a -> IO b

(<$) :: a -> IO b -> IO a

Functor Par1

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> Par1 a -> Par1 b

(<$) :: a -> Par1 b -> Par1 a

Functor Q

Defined in Language.Haskell.TH.Syntax

Methods

fmap :: (a -> b) -> Q a -> Q b

(<$) :: a -> Q b -> Q a

Functor Complex

Defined in Data.Complex

Methods

fmap :: (a -> b) -> Complex a -> Complex b

(<$) :: a -> Complex b -> Complex a

Functor Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> Min a -> Min b

(<$) :: a -> Min b -> Min a

Functor Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> Max a -> Max b

(<$) :: a -> Max b -> Max a

Functor First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> First a -> First b

(<$) :: a -> First b -> First a

Functor Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> Last a -> Last b

(<$) :: a -> Last b -> Last a

Functor Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a -> b) -> Option a -> Option b

(<$) :: a -> Option b -> Option a

Functor ZipList

Defined in Control.Applicative

Methods

fmap :: (a -> b) -> ZipList a -> ZipList b

(<$) :: a -> ZipList b -> ZipList a

Functor Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

fmap :: (a -> b) -> Identity a -> Identity b

(<$) :: a -> Identity b -> Identity a

Functor Handler

Since: base-4.6.0.0

Defined in Control.Exception

Methods

fmap :: (a -> b) -> Handler a -> Handler b

(<$) :: a -> Handler b -> Handler a

Functor STM

Since: base-4.3.0.0

Defined in GHC.Conc.Sync

Methods

fmap :: (a -> b) -> STM a -> STM b

(<$) :: a -> STM b -> STM a

Functor First

Defined in Data.Monoid

Methods

fmap :: (a -> b) -> First a -> First b

(<$) :: a -> First b -> First a

Functor Last

Defined in Data.Monoid

Methods

fmap :: (a -> b) -> Last a -> Last b

(<$) :: a -> Last b -> Last a

Functor Dual

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

fmap :: (a -> b) -> Dual a -> Dual b

(<$) :: a -> Dual b -> Dual a

Functor Sum

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

fmap :: (a -> b) -> Sum a -> Sum b

(<$) :: a -> Sum b -> Sum a

Functor Product

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

fmap :: (a -> b) -> Product a -> Product b

(<$) :: a -> Product b -> Product a

Functor Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

fmap :: (a -> b) -> Down a -> Down b

(<$) :: a -> Down b -> Down a

Functor ReadPrec

Since: base-2.1

Defined in Text.ParserCombinators.ReadPrec

Methods

fmap :: (a -> b) -> ReadPrec a -> ReadPrec b

(<$) :: a -> ReadPrec b -> ReadPrec a

Functor ReadP

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

fmap :: (a -> b) -> ReadP a -> ReadP b

(<$) :: a -> ReadP b -> ReadP a

Functor NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

fmap :: (a -> b) -> NonEmpty a -> NonEmpty b

(<$) :: a -> NonEmpty b -> NonEmpty a

Functor IntMap

Defined in Data.IntMap.Internal

Methods

fmap :: (a -> b) -> IntMap a -> IntMap b

(<$) :: a -> IntMap b -> IntMap a

Functor Tree

Defined in Data.Tree

Methods

fmap :: (a -> b) -> Tree a -> Tree b

(<$) :: a -> Tree b -> Tree a

Functor Seq

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Seq a -> Seq b

(<$) :: a -> Seq b -> Seq a

Functor FingerTree

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> FingerTree a -> FingerTree b

(<$) :: a -> FingerTree b -> FingerTree a

Functor Digit

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Digit a -> Digit b

(<$) :: a -> Digit b -> Digit a

Functor Node

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Node a -> Node b

(<$) :: a -> Node b -> Node a

Functor Elem

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Elem a -> Elem b

(<$) :: a -> Elem b -> Elem a

Functor ViewL

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewL a -> ViewL b

(<$) :: a -> ViewL b -> ViewL a

Functor ViewR

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewR a -> ViewR b

(<$) :: a -> ViewR b -> ViewR a

Functor Doc

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

fmap :: (a -> b) -> Doc a -> Doc b

(<$) :: a -> Doc b -> Doc a

Functor AnnotDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b

(<$) :: a -> AnnotDetails b -> AnnotDetails a

Functor Span

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

fmap :: (a -> b) -> Span a -> Span b

(<$) :: a -> Span b -> Span a

Functor P

Defined in Text.ParserCombinators.ReadP

Methods

fmap :: (a -> b) -> P a -> P b

(<$) :: a -> P b -> P a

Functor Gen

Defined in Test.QuickCheck.Gen

Methods

fmap :: (a -> b) -> Gen a -> Gen b

(<$) :: a -> Gen b -> Gen a

Functor Id

Defined in Data.Vector.Fusion.Util

Methods

fmap :: (a -> b) -> Id a -> Id b

(<$) :: a -> Id b -> Id a

Functor Box

Defined in Data.Vector.Fusion.Util

Methods

fmap :: (a -> b) -> Box a -> Box b

(<$) :: a -> Box b -> Box a

Functor DList

Defined in Data.DList

Methods

fmap :: (a -> b) -> DList a -> DList b

(<$) :: a -> DList b -> DList a

Functor Vector

Defined in Data.Vector

Methods

fmap :: (a -> b) -> Vector a -> Vector b

(<$) :: a -> Vector b -> Vector a

Functor Array

Defined in Data.Primitive.Array

Methods

fmap :: (a -> b) -> Array a -> Array b

(<$) :: a -> Array b -> Array a

Functor SmallArray

Defined in Data.Primitive.SmallArray

Methods

fmap :: (a -> b) -> SmallArray a -> SmallArray b

(<$) :: a -> SmallArray b -> SmallArray a

Functor Rose

Defined in Test.QuickCheck.Property

Methods

fmap :: (a -> b) -> Rose a -> Rose b

(<$) :: a -> Rose b -> Rose a

() :=> (Functor ((->) a :: * -> *))

Defined in Data.Constraint

Methods

ins :: () :- Functor ((->) a)

() :=> (Functor [])

Defined in Data.Constraint

Methods

ins :: () :- Functor []

() :=> (Functor Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Functor Maybe

() :=> (Functor IO)

Defined in Data.Constraint

Methods

ins :: () :- Functor IO

() :=> (Functor (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Either a)

() :=> (Functor ((,) a))

Defined in Data.Constraint

Methods

ins :: () :- Functor ((,) a)

() :=> (Functor Identity)

Defined in Data.Constraint

Methods

ins :: () :- Functor Identity

() :=> (Functor (Const a :: * -> *))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Const a)

Class () (Functor f)

Defined in Data.Constraint

Methods

cls :: Functor f :- ()

Functor (Either a)

Since: base-3.0

Defined in Data.Either

Methods

fmap :: (a0 -> b) -> Either a a0 -> Either a b

(<$) :: a0 -> Either a b -> Either a a0

Functor (V1 :: * -> *)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> V1 a -> V1 b

(<$) :: a -> V1 b -> V1 a

Functor (U1 :: * -> *)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> U1 a -> U1 b

(<$) :: a -> U1 b -> U1 a

Functor ((,) a)

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a0 -> b) -> (a, a0) -> (a, b)

(<$) :: a0 -> (a, b) -> (a, a0)

Functor (ST s)

Since: base-2.1

Defined in GHC.ST

Methods

fmap :: (a -> b) -> ST s a -> ST s b

(<$) :: a -> ST s b -> ST s a

Functor (Array i)

Since: base-2.1

Defined in GHC.Arr

Methods

fmap :: (a -> b) -> Array i a -> Array i b

(<$) :: a -> Array i b -> Array i a

Functor (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a0 -> b) -> Arg a a0 -> Arg a b

(<$) :: a0 -> Arg a b -> Arg a a0

Monad m => Functor (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b

(<$) :: a -> WrappedMonad m b -> WrappedMonad m a

Arrow a => Functor (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

(<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0

Functor (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

fmap :: (a -> b) -> Proxy a -> Proxy b

(<$) :: a -> Proxy b -> Proxy a

Functor (Map k)

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> Map k a -> Map k b

(<$) :: a -> Map k b -> Map k a

Functor (Vec n)

Defined in Clash.Sized.Vector

Methods

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

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

Functor (Level i)

Defined in Control.Lens.Internal.Level

Methods

fmap :: (a -> b) -> Level i a -> Level i b

(<$) :: a -> Level i b -> Level i a

Functor (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

fmap :: (a -> b) -> ReifiedFold s a -> ReifiedFold s b

(<$) :: a -> ReifiedFold s b -> ReifiedFold s a

Functor (ReifiedGetter s)

Defined in Control.Lens.Reified

Methods

fmap :: (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b

(<$) :: a -> ReifiedGetter s b -> ReifiedGetter s a

Functor f => Functor (Co f)

Defined in Data.Functor.Rep

Methods

fmap :: (a -> b) -> Co f a -> Co f b

(<$) :: a -> Co f b -> Co f a

Functor f => Functor (Cofree f)

Defined in Control.Comonad.Cofree

Methods

fmap :: (a -> b) -> Cofree f a -> Cofree f b

(<$) :: a -> Cofree f b -> Cofree f a

Functor f => Functor (Free f)

Defined in Control.Monad.Free

Methods

fmap :: (a -> b) -> Free f a -> Free f b

(<$) :: a -> Free f b -> Free f a

Functor (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

fmap :: (a -> b) -> Yoneda f a -> Yoneda f b

(<$) :: a -> Yoneda f b -> Yoneda f a

Functor (HashMap k)

Defined in Data.HashMap.Base

Methods

fmap :: (a -> b) -> HashMap k a -> HashMap k b

(<$) :: a -> HashMap k b -> HashMap k a

Functor f => Functor (Indexing f)

Defined in Control.Lens.Internal.Indexed

Methods

fmap :: (a -> b) -> Indexing f a -> Indexing f b

(<$) :: a -> Indexing f b -> Indexing f a

Functor f => Functor (Indexing64 f)

Defined in Control.Lens.Internal.Indexed

Methods

fmap :: (a -> b) -> Indexing64 f a -> Indexing64 f b

(<$) :: a -> Indexing64 f b -> Indexing64 f a

Profunctor p => Functor (Coprep p)

Defined in Data.Profunctor.Rep

Methods

fmap :: (a -> b) -> Coprep p a -> Coprep p b

(<$) :: a -> Coprep p b -> Coprep p a

Profunctor p => Functor (Prep p)

Defined in Data.Profunctor.Rep

Methods

fmap :: (a -> b) -> Prep p a -> Prep p b

(<$) :: a -> Prep p b -> Prep p a

Functor (Signal domain)

Defined in Clash.Signal.Internal

Methods

fmap :: (a -> b) -> Signal domain a -> Signal domain b

(<$) :: a -> Signal domain b -> Signal domain a

KnownNat d => Functor (RTree d)

Defined in Clash.Sized.RTree

Methods

fmap :: (a -> b) -> RTree d a -> RTree d b

(<$) :: a -> RTree d b -> RTree d a

(Monad m) :=> (Functor (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Functor (WrappedMonad m)

Class (Functor f) (Applicative f)

Defined in Data.Constraint

Methods

cls :: Applicative f :- Functor f

Functor f => Functor (Rec1 f)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> Rec1 f a -> Rec1 f b

(<$) :: a -> Rec1 f b -> Rec1 f a

Functor (URec Char :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Functor (URec Double :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Functor (URec Float :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Functor (URec Int :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Functor (URec Word :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Functor (URec (Ptr ()) :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Arrow a => Functor (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

(<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

Functor (Const m :: * -> *)

Since: base-2.1

Defined in Data.Functor.Const

Methods

fmap :: (a -> b) -> Const m a -> Const m b

(<$) :: a -> Const m b -> Const m a

Functor f => Functor (Alt f)

Defined in Data.Semigroup.Internal

Methods

fmap :: (a -> b) -> Alt f a -> Alt f b

(<$) :: a -> Alt f b -> Alt f a

(Applicative f, Monad f) => Functor (WhenMissing f x)

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

fmap :: (a -> b) -> WhenMissing f x a -> WhenMissing f x b

(<$) :: a -> WhenMissing f x b -> WhenMissing f x a

Functor m => Functor (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

fmap :: (a -> b) -> ErrorT e m a -> ErrorT e m b

(<$) :: a -> ErrorT e m b -> ErrorT e m a

Functor m => Functor (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

fmap :: (a -> b) -> StateT s m a -> StateT s m b

(<$) :: a -> StateT s m b -> StateT s m a

Functor (Constant a :: * -> *)

Defined in Data.Functor.Constant

Methods

fmap :: (a0 -> b) -> Constant a a0 -> Constant a b

(<$) :: a0 -> Constant a b -> Constant a a0

Functor (Context a b)

Defined in Control.Lens.Internal.Context

Methods

fmap :: (a0 -> b0) -> Context a b a0 -> Context a b b0

(<$) :: a0 -> Context a b b0 -> Context a b a0

Functor (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

fmap :: (a0 -> b) -> Indexed i a a0 -> Indexed i a b

(<$) :: a0 -> Indexed i a b -> Indexed i a a0

Functor (ReifiedIndexedFold i s)

Defined in Control.Lens.Reified

Methods

fmap :: (a -> b) -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s b

(<$) :: a -> ReifiedIndexedFold i s b -> ReifiedIndexedFold i s a

Functor (ReifiedIndexedGetter i s)

Defined in Control.Lens.Reified

Methods

fmap :: (a -> b) -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b

(<$) :: a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s a

Monad m => Functor (Bundle m v)

Defined in Data.Vector.Fusion.Bundle.Monadic

Methods

fmap :: (a -> b) -> Bundle m v a -> Bundle m v b

(<$) :: a -> Bundle m v b -> Bundle m v a

Functor (Tagged s)

Defined in Data.Tagged

Methods

fmap :: (a -> b) -> Tagged s a -> Tagged s b

(<$) :: a -> Tagged s b -> Tagged s a

Bifunctor p => Functor (Fix p)

Defined in Data.Bifunctor.Fix

Methods

fmap :: (a -> b) -> Fix p a -> Fix p b

(<$) :: a -> Fix p b -> Fix p a

Bifunctor p => Functor (Join p)

Defined in Data.Bifunctor.Join

Methods

fmap :: (a -> b) -> Join p a -> Join p b

(<$) :: a -> Join p b -> Join p a

Functor f => Functor (CofreeF f a)

Defined in Control.Comonad.Trans.Cofree

Methods

fmap :: (a0 -> b) -> CofreeF f a a0 -> CofreeF f a b

(<$) :: a0 -> CofreeF f a b -> CofreeF f a a0

(Functor f, Functor w) => Functor (CofreeT f w)

Defined in Control.Comonad.Trans.Cofree

Methods

fmap :: (a -> b) -> CofreeT f w a -> CofreeT f w b

(<$) :: a -> CofreeT f w b -> CofreeT f w a

(Functor f, Monad m) => Functor (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

fmap :: (a -> b) -> FreeT f m a -> FreeT f m b

(<$) :: a -> FreeT f m b -> FreeT f m a

Functor f => Functor (FreeF f a)

Defined in Control.Monad.Trans.Free

Methods

fmap :: (a0 -> b) -> FreeF f a a0 -> FreeF f a b

(<$) :: a0 -> FreeF f a b -> FreeF f a a0

Functor (Day f g)

Defined in Data.Functor.Day

Methods

fmap :: (a -> b) -> Day f g a -> Day f g b

(<$) :: a -> Day f g b -> Day f g a

Functor (DSignal domain delay)

Defined in Clash.Explicit.Signal.Delayed

Methods

fmap :: (a -> b) -> DSignal domain delay a -> DSignal domain delay b

(<$) :: a -> DSignal domain delay b -> DSignal domain delay a

Functor (Flows i b)

Defined in Control.Lens.Internal.Level

Methods

fmap :: (a -> b0) -> Flows i b a -> Flows i b b0

(<$) :: a -> Flows i b b0 -> Flows i b a

Functor (Mafic a b)

Defined in Control.Lens.Internal.Magma

Methods

fmap :: (a0 -> b0) -> Mafic a b a0 -> Mafic a b b0

(<$) :: a0 -> Mafic a b b0 -> Mafic a b a0

Functor (Holes t m)

Defined in Control.Lens.Traversal

Methods

fmap :: (a -> b) -> Holes t m a -> Holes t m b

(<$) :: a -> Holes t m b -> Holes t m a

Functor (CotambaraSum p a)

Defined in Data.Profunctor.Choice

Methods

fmap :: (a0 -> b) -> CotambaraSum p a a0 -> CotambaraSum p a b

(<$) :: a0 -> CotambaraSum p a b -> CotambaraSum p a a0

Profunctor p => Functor (TambaraSum p a)

Defined in Data.Profunctor.Choice

Methods

fmap :: (a0 -> b) -> TambaraSum p a a0 -> TambaraSum p a b

(<$) :: a0 -> TambaraSum p a b -> TambaraSum p a a0

Functor ((->) r :: * -> *)

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> (r -> a) -> r -> b

(<$) :: a -> (r -> b) -> r -> a

Functor (K1 i c :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> K1 i c a -> K1 i c b

(<$) :: a -> K1 i c b -> K1 i c a

(Functor f, Functor g) => Functor (f :+: g)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b

(<$) :: a -> (f :+: g) b -> (f :+: g) a

(Functor f, Functor g) => Functor (f :*: g)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :*: g) a -> (f :*: g) b

(<$) :: a -> (f :*: g) b -> (f :*: g) a

(Functor f, Functor g) => Functor (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

fmap :: (a -> b) -> Product f g a -> Product f g b

(<$) :: a -> Product f g b -> Product f g a

(Functor f, Functor g) => Functor (Sum f g)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

fmap :: (a -> b) -> Sum f g a -> Sum f g b

(<$) :: a -> Sum f g b -> Sum f g a

Functor f => Functor (WhenMatched f x y)

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

fmap :: (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b

(<$) :: a -> WhenMatched f x y b -> WhenMatched f x y a

(Applicative f, Monad f) => Functor (WhenMissing f k x)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b

(<$) :: a -> WhenMissing f k x b -> WhenMissing f k x a

Functor (Bazaar p a b)

Defined in Control.Lens.Internal.Bazaar

Methods

fmap :: (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0

(<$) :: a0 -> Bazaar p a b b0 -> Bazaar p a b a0

Functor (Bazaar1 p a b)

Defined in Control.Lens.Internal.Bazaar

Methods

fmap :: (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0

(<$) :: a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0

Functor (Magma i t b)

Defined in Control.Lens.Internal.Magma

Methods

fmap :: (a -> b0) -> Magma i t b a -> Magma i t b b0

(<$) :: a -> Magma i t b b0 -> Magma i t b a

Profunctor p => Functor (Procompose p q a)

Defined in Data.Profunctor.Composition

Methods

fmap :: (a0 -> b) -> Procompose p q a a0 -> Procompose p q a b

(<$) :: a0 -> Procompose p q a b -> Procompose p q a a0

Functor (Exchange a b s)

Defined in Control.Lens.Internal.Iso

Methods

fmap :: (a0 -> b0) -> Exchange a b s a0 -> Exchange a b s b0

(<$) :: a0 -> Exchange a b s b0 -> Exchange a b s a0

Profunctor p => Functor (Rift p q a)

Defined in Data.Profunctor.Composition

Methods

fmap :: (a0 -> b) -> Rift p q a a0 -> Rift p q a b

(<$) :: a0 -> Rift p q a b -> Rift p q a a0

Functor (Pretext p a b)

Defined in Control.Lens.Internal.Context

Methods

fmap :: (a0 -> b0) -> Pretext p a b a0 -> Pretext p a b b0

(<$) :: a0 -> Pretext p a b b0 -> Pretext p a b a0

Functor (Molten i a b)

Defined in Control.Lens.Internal.Magma

Methods

fmap :: (a0 -> b0) -> Molten i a b a0 -> Molten i a b b0

(<$) :: a0 -> Molten i a b b0 -> Molten i a b a0

Functor f => Functor (M1 i c f)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> M1 i c f a -> M1 i c f b

(<$) :: a -> M1 i c f b -> M1 i c f a

(Functor f, Functor g) => Functor (f :.: g)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b

(<$) :: a -> (f :.: g) b -> (f :.: g) a

(Functor f, Functor g) => Functor (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

fmap :: (a -> b) -> Compose f g a -> Compose f g b

(<$) :: a -> Compose f g b -> Compose f g a

Functor f => Functor (WhenMatched f k x y)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

(<$) :: a -> WhenMatched f k x y b -> WhenMatched f k x y a

Reifies s (ReifiedApplicative f) => Functor (ReflectedApplicative f s)

Defined in Data.Reflection

Methods

fmap :: (a -> b) -> ReflectedApplicative f s a -> ReflectedApplicative f s b

(<$) :: a -> ReflectedApplicative f s b -> ReflectedApplicative f s a

Functor (Clown f a :: * -> *)

Defined in Data.Bifunctor.Clown

Methods

fmap :: (a0 -> b) -> Clown f a a0 -> Clown f a b

(<$) :: a0 -> Clown f a b -> Clown f a a0

Bifunctor p => Functor (Flip p a)

Defined in Data.Bifunctor.Flip

Methods

fmap :: (a0 -> b) -> Flip p a a0 -> Flip p a b

(<$) :: a0 -> Flip p a b -> Flip p a a0

Functor g => Functor (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

fmap :: (a0 -> b) -> Joker g a a0 -> Joker g a b

(<$) :: a0 -> Joker g a b -> Joker g a a0

Bifunctor p => Functor (WrappedBifunctor p a)

Defined in Data.Bifunctor.Wrapped

Methods

fmap :: (a0 -> b) -> WrappedBifunctor p a a0 -> WrappedBifunctor p a b

(<$) :: a0 -> WrappedBifunctor p a b -> WrappedBifunctor p a a0

Functor (BazaarT p g a b)

Defined in Control.Lens.Internal.Bazaar

Methods

fmap :: (a0 -> b0) -> BazaarT p g a b a0 -> BazaarT p g a b b0

(<$) :: a0 -> BazaarT p g a b b0 -> BazaarT p g a b a0

Functor (BazaarT1 p g a b)

Defined in Control.Lens.Internal.Bazaar

Methods

fmap :: (a0 -> b0) -> BazaarT1 p g a b a0 -> BazaarT1 p g a b b0

(<$) :: a0 -> BazaarT1 p g a b b0 -> BazaarT1 p g a b a0

Functor (PretextT p g a b)

Defined in Control.Lens.Internal.Context

Methods

fmap :: (a0 -> b0) -> PretextT p g a b a0 -> PretextT p g a b b0

(<$) :: a0 -> PretextT p g a b b0 -> PretextT p g a b a0

Functor (TakingWhile p f a b)

Defined in Control.Lens.Internal.Magma

Methods

fmap :: (a0 -> b0) -> TakingWhile p f a b a0 -> TakingWhile p f a b b0

(<$) :: a0 -> TakingWhile p f a b b0 -> TakingWhile p f a b a0

(Functor f, Bifunctor p) => Functor (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

fmap :: (a0 -> b) -> Tannen f p a a0 -> Tannen f p a b

(<$) :: a0 -> Tannen f p a b -> Tannen f p a a0

(Bifunctor p, Functor g) => Functor (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

fmap :: (a0 -> b) -> Biff p f g a a0 -> Biff p f g a b

(<$) :: a0 -> Biff p f g a b -> Biff p f g a a0

class Num a where

Basic numeric class.

Minimal complete definition

(+), (*), abs, signum, fromInteger, (negate | (-))

Methods

(+) :: a -> a -> a infixl 6

(-) :: a -> a -> a infixl 6

(*) :: a -> a -> a infixl 7

negate :: a -> a

Unary negation.

abs :: a -> a

Absolute value.

signum :: a -> a

Sign of a number. The functions abs and signum should satisfy the law:

abs x * signum x == x

For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

fromInteger :: Integer -> a

Conversion from an Integer. An integer literal represents the application of the function fromInteger to the appropriate value of type Integer, so such literals have type (Num a) => a.

Instances

Num Int

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Num Int8

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int8 -> Int8 -> Int8

(-) :: Int8 -> Int8 -> Int8

(*) :: Int8 -> Int8 -> Int8

negate :: Int8 -> Int8

abs :: Int8 -> Int8

signum :: Int8 -> Int8

fromInteger :: Integer -> Int8

Num Int16

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int16 -> Int16 -> Int16

(-) :: Int16 -> Int16 -> Int16

(*) :: Int16 -> Int16 -> Int16

negate :: Int16 -> Int16

abs :: Int16 -> Int16

signum :: Int16 -> Int16

fromInteger :: Integer -> Int16

Num Int32

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int32 -> Int32 -> Int32

(-) :: Int32 -> Int32 -> Int32

(*) :: Int32 -> Int32 -> Int32

negate :: Int32 -> Int32

abs :: Int32 -> Int32

signum :: Int32 -> Int32

fromInteger :: Integer -> Int32

Num Int64

Since: base-2.1

Defined in GHC.Int

Methods

(+) :: Int64 -> Int64 -> Int64

(-) :: Int64 -> Int64 -> Int64

(*) :: Int64 -> Int64 -> Int64

negate :: Int64 -> Int64

abs :: Int64 -> Int64

signum :: Int64 -> Int64

fromInteger :: Integer -> Int64

Num Integer

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

(*) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

abs :: Integer -> Integer

signum :: Integer -> Integer

fromInteger :: Integer -> Integer

Num Natural

Since: base-4.8.0.0

Defined in GHC.Natural

Methods

(+) :: Natural -> Natural -> Natural

(-) :: Natural -> Natural -> Natural

(*) :: Natural -> Natural -> Natural

negate :: Natural -> Natural

abs :: Natural -> Natural

signum :: Natural -> Natural

fromInteger :: Integer -> Natural

Num Word

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Word -> Word -> Word

(-) :: Word -> Word -> Word

(*) :: Word -> Word -> Word

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Num Word8

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word8 -> Word8 -> Word8

(-) :: Word8 -> Word8 -> Word8

(*) :: Word8 -> Word8 -> Word8

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Num Word16

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word16 -> Word16 -> Word16

(-) :: Word16 -> Word16 -> Word16

(*) :: Word16 -> Word16 -> Word16

negate :: Word16 -> Word16

abs :: Word16 -> Word16

signum :: Word16 -> Word16

fromInteger :: Integer -> Word16

Num Word32

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word32 -> Word32 -> Word32

(-) :: Word32 -> Word32 -> Word32

(*) :: Word32 -> Word32 -> Word32

negate :: Word32 -> Word32

abs :: Word32 -> Word32

signum :: Word32 -> Word32

fromInteger :: Integer -> Word32

Num Word64

Since: base-2.1

Defined in GHC.Word

Methods

(+) :: Word64 -> Word64 -> Word64

(-) :: Word64 -> Word64 -> Word64

(*) :: Word64 -> Word64 -> Word64

negate :: Word64 -> Word64

abs :: Word64 -> Word64

signum :: Word64 -> Word64

fromInteger :: Integer -> Word64

Num CChar

Defined in Foreign.C.Types

Methods

(+) :: CChar -> CChar -> CChar

(-) :: CChar -> CChar -> CChar

(*) :: CChar -> CChar -> CChar

negate :: CChar -> CChar

abs :: CChar -> CChar

signum :: CChar -> CChar

fromInteger :: Integer -> CChar

Num CSChar

Defined in Foreign.C.Types

Methods

(+) :: CSChar -> CSChar -> CSChar

(-) :: CSChar -> CSChar -> CSChar

(*) :: CSChar -> CSChar -> CSChar

negate :: CSChar -> CSChar

abs :: CSChar -> CSChar

signum :: CSChar -> CSChar

fromInteger :: Integer -> CSChar

Num CUChar

Defined in Foreign.C.Types

Methods

(+) :: CUChar -> CUChar -> CUChar

(-) :: CUChar -> CUChar -> CUChar

(*) :: CUChar -> CUChar -> CUChar

negate :: CUChar -> CUChar

abs :: CUChar -> CUChar

signum :: CUChar -> CUChar

fromInteger :: Integer -> CUChar

Num CShort

Defined in Foreign.C.Types

Methods

(+) :: CShort -> CShort -> CShort

(-) :: CShort -> CShort -> CShort

(*) :: CShort -> CShort -> CShort

negate :: CShort -> CShort

abs :: CShort -> CShort

signum :: CShort -> CShort

fromInteger :: Integer -> CShort

Num CUShort

Defined in Foreign.C.Types

Methods

(+) :: CUShort -> CUShort -> CUShort

(-) :: CUShort -> CUShort -> CUShort

(*) :: CUShort -> CUShort -> CUShort

negate :: CUShort -> CUShort

abs :: CUShort -> CUShort

signum :: CUShort -> CUShort

fromInteger :: Integer -> CUShort

Num CInt

Defined in Foreign.C.Types

Methods

(+) :: CInt -> CInt -> CInt

(-) :: CInt -> CInt -> CInt

(*) :: CInt -> CInt -> CInt

negate :: CInt -> CInt

abs :: CInt -> CInt

signum :: CInt -> CInt

fromInteger :: Integer -> CInt

Num CUInt

Defined in Foreign.C.Types

Methods

(+) :: CUInt -> CUInt -> CUInt

(-) :: CUInt -> CUInt -> CUInt

(*) :: CUInt -> CUInt -> CUInt

negate :: CUInt -> CUInt

abs :: CUInt -> CUInt

signum :: CUInt -> CUInt

fromInteger :: Integer -> CUInt

Num CLong

Defined in Foreign.C.Types

Methods

(+) :: CLong -> CLong -> CLong

(-) :: CLong -> CLong -> CLong

(*) :: CLong -> CLong -> CLong

negate :: CLong -> CLong

abs :: CLong -> CLong

signum :: CLong -> CLong

fromInteger :: Integer -> CLong

Num CULong

Defined in Foreign.C.Types

Methods

(+) :: CULong -> CULong -> CULong

(-) :: CULong -> CULong -> CULong

(*) :: CULong -> CULong -> CULong

negate :: CULong -> CULong

abs :: CULong -> CULong

signum :: CULong -> CULong

fromInteger :: Integer -> CULong

Num CLLong

Defined in Foreign.C.Types

Methods

(+) :: CLLong -> CLLong -> CLLong

(-) :: CLLong -> CLLong -> CLLong

(*) :: CLLong -> CLLong -> CLLong

negate :: CLLong -> CLLong

abs :: CLLong -> CLLong

signum :: CLLong -> CLLong

fromInteger :: Integer -> CLLong

Num CULLong

Defined in Foreign.C.Types

Methods

(+) :: CULLong -> CULLong -> CULLong

(-) :: CULLong -> CULLong -> CULLong

(*) :: CULLong -> CULLong -> CULLong

negate :: CULLong -> CULLong

abs :: CULLong -> CULLong

signum :: CULLong -> CULLong

fromInteger :: Integer -> CULLong

Num CBool

Defined in Foreign.C.Types

Methods

(+) :: CBool -> CBool -> CBool

(-) :: CBool -> CBool -> CBool

(*) :: CBool -> CBool -> CBool

negate :: CBool -> CBool

abs :: CBool -> CBool

signum :: CBool -> CBool

fromInteger :: Integer -> CBool

Num CFloat

Defined in Foreign.C.Types

Methods

(+) :: CFloat -> CFloat -> CFloat

(-) :: CFloat -> CFloat -> CFloat

(*) :: CFloat -> CFloat -> CFloat

negate :: CFloat -> CFloat

abs :: CFloat -> CFloat

signum :: CFloat -> CFloat

fromInteger :: Integer -> CFloat

Num CDouble

Defined in Foreign.C.Types

Methods

(+) :: CDouble -> CDouble -> CDouble

(-) :: CDouble -> CDouble -> CDouble

(*) :: CDouble -> CDouble -> CDouble

negate :: CDouble -> CDouble

abs :: CDouble -> CDouble

signum :: CDouble -> CDouble

fromInteger :: Integer -> CDouble

Num CPtrdiff

Defined in Foreign.C.Types

Methods

(+) :: CPtrdiff -> CPtrdiff -> CPtrdiff

(-) :: CPtrdiff -> CPtrdiff -> CPtrdiff

(*) :: CPtrdiff -> CPtrdiff -> CPtrdiff

negate :: CPtrdiff -> CPtrdiff

abs :: CPtrdiff -> CPtrdiff

signum :: CPtrdiff -> CPtrdiff

fromInteger :: Integer -> CPtrdiff

Num CSize

Defined in Foreign.C.Types

Methods

(+) :: CSize -> CSize -> CSize

(-) :: CSize -> CSize -> CSize

(*) :: CSize -> CSize -> CSize

negate :: CSize -> CSize

abs :: CSize -> CSize

signum :: CSize -> CSize

fromInteger :: Integer -> CSize

Num CWchar

Defined in Foreign.C.Types

Methods

(+) :: CWchar -> CWchar -> CWchar

(-) :: CWchar -> CWchar -> CWchar

(*) :: CWchar -> CWchar -> CWchar

negate :: CWchar -> CWchar

abs :: CWchar -> CWchar

signum :: CWchar -> CWchar

fromInteger :: Integer -> CWchar

Num CSigAtomic

Defined in Foreign.C.Types

Methods

(+) :: CSigAtomic -> CSigAtomic -> CSigAtomic

(-) :: CSigAtomic -> CSigAtomic -> CSigAtomic

(*) :: CSigAtomic -> CSigAtomic -> CSigAtomic

negate :: CSigAtomic -> CSigAtomic

abs :: CSigAtomic -> CSigAtomic

signum :: CSigAtomic -> CSigAtomic

fromInteger :: Integer -> CSigAtomic

Num CClock

Defined in Foreign.C.Types

Methods

(+) :: CClock -> CClock -> CClock

(-) :: CClock -> CClock -> CClock

(*) :: CClock -> CClock -> CClock

negate :: CClock -> CClock

abs :: CClock -> CClock

signum :: CClock -> CClock

fromInteger :: Integer -> CClock

Num CTime

Defined in Foreign.C.Types

Methods

(+) :: CTime -> CTime -> CTime

(-) :: CTime -> CTime -> CTime

(*) :: CTime -> CTime -> CTime

negate :: CTime -> CTime

abs :: CTime -> CTime

signum :: CTime -> CTime

fromInteger :: Integer -> CTime

Num CUSeconds

Defined in Foreign.C.Types

Methods

(+) :: CUSeconds -> CUSeconds -> CUSeconds

(-) :: CUSeconds -> CUSeconds -> CUSeconds

(*) :: CUSeconds -> CUSeconds -> CUSeconds

negate :: CUSeconds -> CUSeconds

abs :: CUSeconds -> CUSeconds

signum :: CUSeconds -> CUSeconds

fromInteger :: Integer -> CUSeconds

Num CSUSeconds

Defined in Foreign.C.Types

Methods

(+) :: CSUSeconds -> CSUSeconds -> CSUSeconds

(-) :: CSUSeconds -> CSUSeconds -> CSUSeconds

(*) :: CSUSeconds -> CSUSeconds -> CSUSeconds

negate :: CSUSeconds -> CSUSeconds

abs :: CSUSeconds -> CSUSeconds

signum :: CSUSeconds -> CSUSeconds

fromInteger :: Integer -> CSUSeconds

Num CIntPtr

Defined in Foreign.C.Types

Methods

(+) :: CIntPtr -> CIntPtr -> CIntPtr

(-) :: CIntPtr -> CIntPtr -> CIntPtr

(*) :: CIntPtr -> CIntPtr -> CIntPtr

negate :: CIntPtr -> CIntPtr

abs :: CIntPtr -> CIntPtr

signum :: CIntPtr -> CIntPtr

fromInteger :: Integer -> CIntPtr

Num CUIntPtr

Defined in Foreign.C.Types

Methods

(+) :: CUIntPtr -> CUIntPtr -> CUIntPtr

(-) :: CUIntPtr -> CUIntPtr -> CUIntPtr

(*) :: CUIntPtr -> CUIntPtr -> CUIntPtr

negate :: CUIntPtr -> CUIntPtr

abs :: CUIntPtr -> CUIntPtr

signum :: CUIntPtr -> CUIntPtr

fromInteger :: Integer -> CUIntPtr

Num CIntMax

Defined in Foreign.C.Types

Methods

(+) :: CIntMax -> CIntMax -> CIntMax

(-) :: CIntMax -> CIntMax -> CIntMax

(*) :: CIntMax -> CIntMax -> CIntMax

negate :: CIntMax -> CIntMax

abs :: CIntMax -> CIntMax

signum :: CIntMax -> CIntMax

fromInteger :: Integer -> CIntMax

Num CUIntMax

Defined in Foreign.C.Types

Methods

(+) :: CUIntMax -> CUIntMax -> CUIntMax

(-) :: CUIntMax -> CUIntMax -> CUIntMax

(*) :: CUIntMax -> CUIntMax -> CUIntMax

negate :: CUIntMax -> CUIntMax

abs :: CUIntMax -> CUIntMax

signum :: CUIntMax -> CUIntMax

fromInteger :: Integer -> CUIntMax

Num Bit

Defined in Clash.Sized.Internal.BitVector

Methods

(+) :: Bit -> Bit -> Bit

(-) :: Bit -> Bit -> Bit

(*) :: Bit -> Bit -> Bit

negate :: Bit -> Bit

abs :: Bit -> Bit

signum :: Bit -> Bit

fromInteger :: Integer -> Bit

Num Half

Defined in Numeric.Half

Methods

(+) :: Half -> Half -> Half

(-) :: Half -> Half -> Half

(*) :: Half -> Half -> Half

negate :: Half -> Half

abs :: Half -> Half

signum :: Half -> Half

fromInteger :: Integer -> Half

() :=> (Num Double)

Defined in Data.Constraint

Methods

ins :: () :- Num Double

() :=> (Num Float)

Defined in Data.Constraint

Methods

ins :: () :- Num Float

() :=> (Num Int)

Defined in Data.Constraint

Methods

ins :: () :- Num Int

() :=> (Num Integer)

Defined in Data.Constraint

Methods

ins :: () :- Num Integer

() :=> (Num Natural)

Defined in Data.Constraint

Methods

ins :: () :- Num Natural

() :=> (Num Word)

Defined in Data.Constraint

Methods

ins :: () :- Num Word

Class () (Num a)

Defined in Data.Constraint

Methods

cls :: Num a :- ()

Integral a => Num (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

(+) :: Ratio a -> Ratio a -> Ratio a

(-) :: Ratio a -> Ratio a -> Ratio a

(*) :: Ratio a -> Ratio a -> Ratio a

negate :: Ratio a -> Ratio a

abs :: Ratio a -> Ratio a

signum :: Ratio a -> Ratio a

fromInteger :: Integer -> Ratio a

RealFloat a => Num (Complex a)

Since: base-2.1

Defined in Data.Complex

Methods

(+) :: Complex a -> Complex a -> Complex a

(-) :: Complex a -> Complex a -> Complex a

(*) :: Complex a -> Complex a -> Complex a

negate :: Complex a -> Complex a

abs :: Complex a -> Complex a

signum :: Complex a -> Complex a

fromInteger :: Integer -> Complex a

HasResolution a => Num (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

(+) :: Fixed a -> Fixed a -> Fixed a

(-) :: Fixed a -> Fixed a -> Fixed a

(*) :: Fixed a -> Fixed a -> Fixed a

negate :: Fixed a -> Fixed a

abs :: Fixed a -> Fixed a

signum :: Fixed a -> Fixed a

fromInteger :: Integer -> Fixed a

Num a => Num (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(+) :: Min a -> Min a -> Min a

(-) :: Min a -> Min a -> Min a

(*) :: Min a -> Min a -> Min a

negate :: Min a -> Min a

abs :: Min a -> Min a

signum :: Min a -> Min a

fromInteger :: Integer -> Min a

Num a => Num (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(+) :: Max a -> Max a -> Max a

(-) :: Max a -> Max a -> Max a

(*) :: Max a -> Max a -> Max a

negate :: Max a -> Max a

abs :: Max a -> Max a

signum :: Max a -> Max a

fromInteger :: Integer -> Max a

Num a => Num (Identity a)

Defined in Data.Functor.Identity

Methods

(+) :: Identity a -> Identity a -> Identity a

(-) :: Identity a -> Identity a -> Identity a

(*) :: Identity a -> Identity a -> Identity a

negate :: Identity a -> Identity a

abs :: Identity a -> Identity a

signum :: Identity a -> Identity a

fromInteger :: Integer -> Identity a

Num a => Num (Sum a)

Defined in Data.Semigroup.Internal

Methods

(+) :: Sum a -> Sum a -> Sum a

(-) :: Sum a -> Sum a -> Sum a

(*) :: Sum a -> Sum a -> Sum a

negate :: Sum a -> Sum a

abs :: Sum a -> Sum a

signum :: Sum a -> Sum a

fromInteger :: Integer -> Sum a

Num a => Num (Product a)

Defined in Data.Semigroup.Internal

Methods

(+) :: Product a -> Product a -> Product a

(-) :: Product a -> Product a -> Product a

(*) :: Product a -> Product a -> Product a

negate :: Product a -> Product a

abs :: Product a -> Product a

signum :: Product a -> Product a

fromInteger :: Integer -> Product a

Num a => Num (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(+) :: Down a -> Down a -> Down a

(-) :: Down a -> Down a -> Down a

(*) :: Down a -> Down a -> Down a

negate :: Down a -> Down a

abs :: Down a -> Down a

signum :: Down a -> Down a

fromInteger :: Integer -> Down a

KnownNat n => Num (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

(+) :: BitVector n -> BitVector n -> BitVector n

(-) :: BitVector n -> BitVector n -> BitVector n

(*) :: BitVector n -> BitVector n -> BitVector n

negate :: BitVector n -> BitVector n

abs :: BitVector n -> BitVector n

signum :: BitVector n -> BitVector n

fromInteger :: Integer -> BitVector n

KnownNat n => Num (Index n)

Operators report an error on overflow and underflow

Defined in Clash.Sized.Internal.Index

Methods

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

(-) :: Index n -> Index n -> Index n

(*) :: Index n -> Index n -> Index n

negate :: Index n -> Index n

abs :: Index n -> Index n

signum :: Index n -> Index n

fromInteger :: Integer -> Index n

Num a => Num (Bounds a)

Defined in Test.QuickCheck.Arbitrary

Methods

(+) :: Bounds a -> Bounds a -> Bounds a

(-) :: Bounds a -> Bounds a -> Bounds a

(*) :: Bounds a -> Bounds a -> Bounds a

negate :: Bounds a -> Bounds a

abs :: Bounds a -> Bounds a

signum :: Bounds a -> Bounds a

fromInteger :: Integer -> Bounds a

KnownNat n => Num (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

(+) :: Unsigned n -> Unsigned n -> Unsigned n

(-) :: Unsigned n -> Unsigned n -> Unsigned n

(*) :: Unsigned n -> Unsigned n -> Unsigned n

negate :: Unsigned n -> Unsigned n

abs :: Unsigned n -> Unsigned n

signum :: Unsigned n -> Unsigned n

fromInteger :: Integer -> Unsigned n

KnownNat n => Num (Signed n)

Operators do wrap-around on overflow

Defined in Clash.Sized.Internal.Signed

Methods

(+) :: Signed n -> Signed n -> Signed n

(-) :: Signed n -> Signed n -> Signed n

(*) :: Signed n -> Signed n -> Signed n

negate :: Signed n -> Signed n

abs :: Signed n -> Signed n

signum :: Signed n -> Signed n

fromInteger :: Integer -> Signed n

(Integral a) :=> (Num (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Num (Ratio a)

(Num a) :=> (Num (Identity a))

Defined in Data.Constraint

Methods

ins :: Num a :- Num (Identity a)

(Num a) :=> (Num (Const a b))

Defined in Data.Constraint

Methods

ins :: Num a :- Num (Const a b)

(RealFloat a) :=> (Num (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Num (Complex a)

Class (Num a) (Fractional a)

Defined in Data.Constraint

Methods

cls :: Fractional a :- Num a

Num a => Num (Op a b)

Defined in Data.Functor.Contravariant

Methods

(+) :: Op a b -> Op a b -> Op a b

(-) :: Op a b -> Op a b -> Op a b

(*) :: Op a b -> Op a b -> Op a b

negate :: Op a b -> Op a b

abs :: Op a b -> Op a b

signum :: Op a b -> Op a b

fromInteger :: Integer -> Op a b

Num a => Num (Signal domain a)

Defined in Clash.Signal.Internal

Methods

(+) :: Signal domain a -> Signal domain a -> Signal domain a

(-) :: Signal domain a -> Signal domain a -> Signal domain a

(*) :: Signal domain a -> Signal domain a -> Signal domain a

negate :: Signal domain a -> Signal domain a

abs :: Signal domain a -> Signal domain a

signum :: Signal domain a -> Signal domain a

fromInteger :: Integer -> Signal domain a

Class (Num a, Ord a) (Real a)

Defined in Data.Constraint

Methods

cls :: Real a :- (Num a, Ord a)

Num a => Num (Const a b)

Defined in Data.Functor.Const

Methods

(+) :: Const a b -> Const a b -> Const a b

(-) :: Const a b -> Const a b -> Const a b

(*) :: Const a b -> Const a b -> Const a b

negate :: Const a b -> Const a b

abs :: Const a b -> Const a b

signum :: Const a b -> Const a b

fromInteger :: Integer -> Const a b

Num (f a) => Num (Alt f a)

Defined in Data.Semigroup.Internal

Methods

(+) :: Alt f a -> Alt f a -> Alt f a

(-) :: Alt f a -> Alt f a -> Alt f a

(*) :: Alt f a -> Alt f a -> Alt f a

negate :: Alt f a -> Alt f a

abs :: Alt f a -> Alt f a

signum :: Alt f a -> Alt f a

fromInteger :: Integer -> Alt f a

Num a => Num (Tagged s a)

Defined in Data.Tagged

Methods

(+) :: Tagged s a -> Tagged s a -> Tagged s a

(-) :: Tagged s a -> Tagged s a -> Tagged s a

(*) :: Tagged s a -> Tagged s a -> Tagged s a

negate :: Tagged s a -> Tagged s a

abs :: Tagged s a -> Tagged s a

signum :: Tagged s a -> Tagged s a

fromInteger :: Integer -> Tagged s a

NumFixedC rep int frac => Num (Fixed rep int frac)

The operators of this instance saturate on overflow, and use truncation as the rounding method.

When used in a polymorphic setting, use the following Constraint synonyms for less verbose type signatures:

• NumFixedC frac rep size for: Fixed frac rep size
• NumSFixedC int frac for: SFixed int frac
• NumUFixedC int frac for: UFixed int frac

Defined in Clash.Sized.Fixed

Methods

(+) :: Fixed rep int frac -> Fixed rep int frac -> Fixed rep int frac

(-) :: Fixed rep int frac -> Fixed rep int frac -> Fixed rep int frac

(*) :: Fixed rep int frac -> Fixed rep int frac -> Fixed rep int frac

negate :: Fixed rep int frac -> Fixed rep int frac

abs :: Fixed rep int frac -> Fixed rep int frac

signum :: Fixed rep int frac -> Fixed rep int frac

fromInteger :: Integer -> Fixed rep int frac

Num a => Num (DSignal domain delay a)

Defined in Clash.Explicit.Signal.Delayed

Methods

(+) :: DSignal domain delay a -> DSignal domain delay a -> DSignal domain delay a

(-) :: DSignal domain delay a -> DSignal domain delay a -> DSignal domain delay a

(*) :: DSignal domain delay a -> DSignal domain delay a -> DSignal domain delay a

negate :: DSignal domain delay a -> DSignal domain delay a

abs :: DSignal domain delay a -> DSignal domain delay a

signum :: DSignal domain delay a -> DSignal domain delay a

fromInteger :: Integer -> DSignal domain delay a

class Eq a => Ord a where

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord. The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects.

Minimal complete definition: either compare or <=. Using compare can be more efficient for complex types.

Minimal complete definition

compare | (<=)

Methods

compare :: a -> a -> Ordering

(<) :: a -> a -> Bool infix 4

(<=) :: a -> a -> Bool infix 4

(>) :: a -> a -> Bool infix 4

(>=) :: a -> a -> Bool infix 4

max :: a -> a -> a

min :: a -> a -> a

Instances

Ord Bool

Defined in GHC.Classes

Methods

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

(<=) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

Ord Char

Defined in GHC.Classes

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Ord Double

Defined in GHC.Classes

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

Ord Float

Defined in GHC.Classes

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Ord Int

Defined in GHC.Classes

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Ord Int8

Since: base-2.1

Defined in GHC.Int

Methods

compare :: Int8 -> Int8 -> Ordering

(<) :: Int8 -> Int8 -> Bool

(<=) :: Int8 -> Int8 -> Bool

(>) :: Int8 -> Int8 -> Bool

(>=) :: Int8 -> Int8 -> Bool

max :: Int8 -> Int8 -> Int8

min :: Int8 -> Int8 -> Int8

Ord Int16

Since: base-2.1

Defined in GHC.Int

Methods

compare :: Int16 -> Int16 -> Ordering

(<) :: Int16 -> Int16 -> Bool

(<=) :: Int16 -> Int16 -> Bool

(>) :: Int16 -> Int16 -> Bool

(>=) :: Int16 -> Int16 -> Bool

max :: Int16 -> Int16 -> Int16

min :: Int16 -> Int16 -> Int16

Ord Int32

Since: base-2.1

Defined in GHC.Int

Methods

compare :: Int32 -> Int32 -> Ordering

(<) :: Int32 -> Int32 -> Bool

(<=) :: Int32 -> Int32 -> Bool

(>) :: Int32 -> Int32 -> Bool

(>=) :: Int32 -> Int32 -> Bool

max :: Int32 -> Int32 -> Int32

min :: Int32 -> Int32 -> Int32

Ord Int64

Since: base-2.1

Defined in GHC.Int

Methods

compare :: Int64 -> Int64 -> Ordering

(<) :: Int64 -> Int64 -> Bool

(<=) :: Int64 -> Int64 -> Bool

(>) :: Int64 -> Int64 -> Bool

(>=) :: Int64 -> Int64 -> Bool

max :: Int64 -> Int64 -> Int64

min :: Int64 -> Int64 -> Int64

Ord Integer

Defined in GHC.Integer.Type

Methods

compare :: Integer -> Integer -> Ordering

(<) :: Integer -> Integer -> Bool

(<=) :: Integer -> Integer -> Bool

(>) :: Integer -> Integer -> Bool

(>=) :: Integer -> Integer -> Bool

max :: Integer -> Integer -> Integer

min :: Integer -> Integer -> Integer

Ord Natural

Defined in GHC.Natural

Methods

compare :: Natural -> Natural -> Ordering

(<) :: Natural -> Natural -> Bool

(<=) :: Natural -> Natural -> Bool

(>) :: Natural -> Natural -> Bool

(>=) :: Natural -> Natural -> Bool

max :: Natural -> Natural -> Natural

min :: Natural -> Natural -> Natural

Ord Ordering

Defined in GHC.Classes

Methods

compare :: Ordering -> Ordering -> Ordering

(<) :: Ordering -> Ordering -> Bool

(<=) :: Ordering -> Ordering -> Bool

(>) :: Ordering -> Ordering -> Bool

(>=) :: Ordering -> Ordering -> Bool

max :: Ordering -> Ordering -> Ordering

min :: Ordering -> Ordering -> Ordering

Ord Word

Defined in GHC.Classes

Methods

compare :: Word -> Word -> Ordering

(<) :: Word -> Word -> Bool

(<=) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(>=) :: Word -> Word -> Bool

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Ord Word8

Since: base-2.1

Defined in GHC.Word

Methods

compare :: Word8 -> Word8 -> Ordering

(<) :: Word8 -> Word8 -> Bool

(<=) :: Word8 -> Word8 -> Bool

(>) :: Word8 -> Word8 -> Bool

(>=) :: Word8 -> Word8 -> Bool

max :: Word8 -> Word8 -> Word8

min :: Word8 -> Word8 -> Word8

Ord Word16

Since: base-2.1

Defined in GHC.Word

Methods

compare :: Word16 -> Word16 -> Ordering

(<) :: Word16 -> Word16 -> Bool

(<=) :: Word16 -> Word16 -> Bool

(>) :: Word16 -> Word16 -> Bool

(>=) :: Word16 -> Word16 -> Bool

max :: Word16 -> Word16 -> Word16

min :: Word16 -> Word16 -> Word16

Ord Word32

Since: base-2.1

Defined in GHC.Word

Methods

compare :: Word32 -> Word32 -> Ordering

(<) :: Word32 -> Word32 -> Bool

(<=) :: Word32 -> Word32 -> Bool

(>) :: Word32 -> Word32 -> Bool

(>=) :: Word32 -> Word32 -> Bool

max :: Word32 -> Word32 -> Word32

min :: Word32 -> Word32 -> Word32

Ord Word64

Since: base-2.1

Defined in GHC.Word

Methods

compare :: Word64 -> Word64 -> Ordering

(<) :: Word64 -> Word64 -> Bool

(<=) :: Word64 -> Word64 -> Bool

(>) :: Word64 -> Word64 -> Bool

(>=) :: Word64 -> Word64 -> Bool

max :: Word64 -> Word64 -> Word64

min :: Word64 -> Word64 -> Word64

Ord SomeTypeRep

Defined in Data.Typeable.Internal

Methods

compare :: SomeTypeRep -> SomeTypeRep -> Ordering

(<) :: SomeTypeRep -> SomeTypeRep -> Bool

(<=) :: SomeTypeRep -> SomeTypeRep -> Bool

(>) :: SomeTypeRep -> SomeTypeRep -> Bool

(>=) :: SomeTypeRep -> SomeTypeRep -> Bool

max :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep

min :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep

Ord Exp

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Exp -> Exp -> Ordering

(<) :: Exp -> Exp -> Bool

(<=) :: Exp -> Exp -> Bool

(>) :: Exp -> Exp -> Bool

(>=) :: Exp -> Exp -> Bool

max :: Exp -> Exp -> Exp

min :: Exp -> Exp -> Exp

Ord Match

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Match -> Match -> Ordering

(<) :: Match -> Match -> Bool

(<=) :: Match -> Match -> Bool

(>) :: Match -> Match -> Bool

(>=) :: Match -> Match -> Bool

max :: Match -> Match -> Match

min :: Match -> Match -> Match

Ord Clause

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Clause -> Clause -> Ordering

(<) :: Clause -> Clause -> Bool

(<=) :: Clause -> Clause -> Bool

(>) :: Clause -> Clause -> Bool

(>=) :: Clause -> Clause -> Bool

max :: Clause -> Clause -> Clause

min :: Clause -> Clause -> Clause

Ord Pat

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Pat -> Pat -> Ordering

(<) :: Pat -> Pat -> Bool

(<=) :: Pat -> Pat -> Bool

(>) :: Pat -> Pat -> Bool

(>=) :: Pat -> Pat -> Bool

max :: Pat -> Pat -> Pat

min :: Pat -> Pat -> Pat

Ord Type

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Type -> Type -> Ordering

(<) :: Type -> Type -> Bool

(<=) :: Type -> Type -> Bool

(>) :: Type -> Type -> Bool

(>=) :: Type -> Type -> Bool

max :: Type -> Type -> Type

min :: Type -> Type -> Type

Ord Dec

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Dec -> Dec -> Ordering

(<) :: Dec -> Dec -> Bool

(<=) :: Dec -> Dec -> Bool

(>) :: Dec -> Dec -> Bool

(>=) :: Dec -> Dec -> Bool

max :: Dec -> Dec -> Dec

min :: Dec -> Dec -> Dec

Ord Name

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Ord FunDep

Defined in Language.Haskell.TH.Syntax

Methods

compare :: FunDep -> FunDep -> Ordering

(<) :: FunDep -> FunDep -> Bool

(<=) :: FunDep -> FunDep -> Bool

(>) :: FunDep -> FunDep -> Bool

(>=) :: FunDep -> FunDep -> Bool

max :: FunDep -> FunDep -> FunDep

min :: FunDep -> FunDep -> FunDep

Ord InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Methods

compare :: InjectivityAnn -> InjectivityAnn -> Ordering

(<) :: InjectivityAnn -> InjectivityAnn -> Bool

(<=) :: InjectivityAnn -> InjectivityAnn -> Bool

(>) :: InjectivityAnn -> InjectivityAnn -> Bool

(>=) :: InjectivityAnn -> InjectivityAnn -> Bool

max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn

min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn

Ord Overlap

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Overlap -> Overlap -> Ordering

(<) :: Overlap -> Overlap -> Bool

(<=) :: Overlap -> Overlap -> Bool

(>) :: Overlap -> Overlap -> Bool

(>=) :: Overlap -> Overlap -> Bool

max :: Overlap -> Overlap -> Overlap

min :: Overlap -> Overlap -> Overlap

Ord DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

compare :: DerivStrategy -> DerivStrategy -> Ordering

(<) :: DerivStrategy -> DerivStrategy -> Bool

(<=) :: DerivStrategy -> DerivStrategy -> Bool

(>) :: DerivStrategy -> DerivStrategy -> Bool

(>=) :: DerivStrategy -> DerivStrategy -> Bool

max :: DerivStrategy -> DerivStrategy -> DerivStrategy

min :: DerivStrategy -> DerivStrategy -> DerivStrategy

Ord ()

Defined in GHC.Classes

Methods

compare :: () -> () -> Ordering

(<) :: () -> () -> Bool

(<=) :: () -> () -> Bool

(>) :: () -> () -> Bool

(>=) :: () -> () -> Bool

max :: () -> () -> ()

min :: () -> () -> ()

Ord TyCon

Defined in GHC.Classes

Methods

compare :: TyCon -> TyCon -> Ordering

(<) :: TyCon -> TyCon -> Bool

(<=) :: TyCon -> TyCon -> Bool

(>) :: TyCon -> TyCon -> Bool

(>=) :: TyCon -> TyCon -> Bool

max :: TyCon -> TyCon -> TyCon

min :: TyCon -> TyCon -> TyCon

Ord BigNat

Defined in GHC.Integer.Type

Methods

compare :: BigNat -> BigNat -> Ordering

(<) :: BigNat -> BigNat -> Bool

(<=) :: BigNat -> BigNat -> Bool

(>) :: BigNat -> BigNat -> Bool

(>=) :: BigNat -> BigNat -> Bool

max :: BigNat -> BigNat -> BigNat

min :: BigNat -> BigNat -> BigNat

Ord Void

Since: base-4.8.0.0

Defined in Data.Void

Methods

compare :: Void -> Void -> Ordering

(<) :: Void -> Void -> Bool

(<=) :: Void -> Void -> Bool

(>) :: Void -> Void -> Bool

(>=) :: Void -> Void -> Bool

max :: Void -> Void -> Void

min :: Void -> Void -> Void

Ord Unique

Defined in Data.Unique

Methods

compare :: Unique -> Unique -> Ordering

(<) :: Unique -> Unique -> Bool

(<=) :: Unique -> Unique -> Bool

(>) :: Unique -> Unique -> Bool

(>=) :: Unique -> Unique -> Bool

max :: Unique -> Unique -> Unique

min :: Unique -> Unique -> Unique

Ord Version

Since: base-2.1

Defined in Data.Version

Methods

compare :: Version -> Version -> Ordering

(<) :: Version -> Version -> Bool

(<=) :: Version -> Version -> Bool

(>) :: Version -> Version -> Bool

(>=) :: Version -> Version -> Bool

max :: Version -> Version -> Version

min :: Version -> Version -> Version

Ord ThreadId

Since: base-4.2.0.0

Defined in GHC.Conc.Sync

Methods

compare :: ThreadId -> ThreadId -> Ordering

(<) :: ThreadId -> ThreadId -> Bool

(<=) :: ThreadId -> ThreadId -> Bool

(>) :: ThreadId -> ThreadId -> Bool

(>=) :: ThreadId -> ThreadId -> Bool

max :: ThreadId -> ThreadId -> ThreadId

min :: ThreadId -> ThreadId -> ThreadId

Ord BlockReason

Defined in GHC.Conc.Sync

Methods

compare :: BlockReason -> BlockReason -> Ordering

(<) :: BlockReason -> BlockReason -> Bool

(<=) :: BlockReason -> BlockReason -> Bool

(>) :: BlockReason -> BlockReason -> Bool

(>=) :: BlockReason -> BlockReason -> Bool

max :: BlockReason -> BlockReason -> BlockReason

min :: BlockReason -> BlockReason -> BlockReason

Ord ThreadStatus

Defined in GHC.Conc.Sync

Methods

compare :: ThreadStatus -> ThreadStatus -> Ordering

(<) :: ThreadStatus -> ThreadStatus -> Bool

(<=) :: ThreadStatus -> ThreadStatus -> Bool

(>) :: ThreadStatus -> ThreadStatus -> Bool

(>=) :: ThreadStatus -> ThreadStatus -> Bool

max :: ThreadStatus -> ThreadStatus -> ThreadStatus

min :: ThreadStatus -> ThreadStatus -> ThreadStatus

Ord AsyncException

Defined in GHC.IO.Exception

Methods

compare :: AsyncException -> AsyncException -> Ordering

(<) :: AsyncException -> AsyncException -> Bool

(<=) :: AsyncException -> AsyncException -> Bool

(>) :: AsyncException -> AsyncException -> Bool

(>=) :: AsyncException -> AsyncException -> Bool

max :: AsyncException -> AsyncException -> AsyncException

min :: AsyncException -> AsyncException -> AsyncException

Ord ArrayException

Defined in GHC.IO.Exception

Methods

compare :: ArrayException -> ArrayException -> Ordering

(<) :: ArrayException -> ArrayException -> Bool

(<=) :: ArrayException -> ArrayException -> Bool

(>) :: ArrayException -> ArrayException -> Bool

(>=) :: ArrayException -> ArrayException -> Bool

max :: ArrayException -> ArrayException -> ArrayException

min :: ArrayException -> ArrayException -> ArrayException

Ord ExitCode

Defined in GHC.IO.Exception

Methods

compare :: ExitCode -> ExitCode -> Ordering

(<) :: ExitCode -> ExitCode -> Bool

(<=) :: ExitCode -> ExitCode -> Bool

(>) :: ExitCode -> ExitCode -> Bool

(>=) :: ExitCode -> ExitCode -> Bool

max :: ExitCode -> ExitCode -> ExitCode

min :: ExitCode -> ExitCode -> ExitCode

Ord ErrorCall

Defined in GHC.Exception

Methods

compare :: ErrorCall -> ErrorCall -> Ordering

(<) :: ErrorCall -> ErrorCall -> Bool

(<=) :: ErrorCall -> ErrorCall -> Bool

(>) :: ErrorCall -> ErrorCall -> Bool

(>=) :: ErrorCall -> ErrorCall -> Bool

max :: ErrorCall -> ErrorCall -> ErrorCall

min :: ErrorCall -> ErrorCall -> ErrorCall

Ord ArithException

Defined in GHC.Exception

Methods

compare :: ArithException -> ArithException -> Ordering

(<) :: ArithException -> ArithException -> Bool

(<=) :: ArithException -> ArithException -> Bool

(>) :: ArithException -> ArithException -> Bool

(>=) :: ArithException -> ArithException -> Bool

max :: ArithException -> ArithException -> ArithException

min :: ArithException -> ArithException -> ArithException

Ord All

Defined in Data.Semigroup.Internal

Methods

compare :: All -> All -> Ordering

(<) :: All -> All -> Bool

(<=) :: All -> All -> Bool

(>) :: All -> All -> Bool

(>=) :: All -> All -> Bool

max :: All -> All -> All

min :: All -> All -> All

Ord Any

Defined in Data.Semigroup.Internal

Methods

compare :: Any -> Any -> Ordering

(<) :: Any -> Any -> Bool

(<=) :: Any -> Any -> Bool

(>) :: Any -> Any -> Bool

(>=) :: Any -> Any -> Bool

max :: Any -> Any -> Any

min :: Any -> Any -> Any

Ord Fixity

Defined in GHC.Generics

Methods

compare :: Fixity -> Fixity -> Ordering

(<) :: Fixity -> Fixity -> Bool

(<=) :: Fixity -> Fixity -> Bool

(>) :: Fixity -> Fixity -> Bool

(>=) :: Fixity -> Fixity -> Bool

max :: Fixity -> Fixity -> Fixity

min :: Fixity -> Fixity -> Fixity

Ord Associativity

Defined in GHC.Generics

Methods

compare :: Associativity -> Associativity -> Ordering

(<) :: Associativity -> Associativity -> Bool

(<=) :: Associativity -> Associativity -> Bool

(>) :: Associativity -> Associativity -> Bool

(>=) :: Associativity -> Associativity -> Bool

max :: Associativity -> Associativity -> Associativity

min :: Associativity -> Associativity -> Associativity

Ord SourceUnpackedness

Defined in GHC.Generics

Methods

compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering

(<) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

Ord SourceStrictness

Defined in GHC.Generics

Methods

compare :: SourceStrictness -> SourceStrictness -> Ordering

(<) :: SourceStrictness -> SourceStrictness -> Bool

(<=) :: SourceStrictness -> SourceStrictness -> Bool

(>) :: SourceStrictness -> SourceStrictness -> Bool

(>=) :: SourceStrictness -> SourceStrictness -> Bool

max :: SourceStrictness -> SourceStrictness -> SourceStrictness

min :: SourceStrictness -> SourceStrictness -> SourceStrictness

Ord DecidedStrictness

Defined in GHC.Generics

Methods

compare :: DecidedStrictness -> DecidedStrictness -> Ordering

(<) :: DecidedStrictness -> DecidedStrictness -> Bool

(<=) :: DecidedStrictness -> DecidedStrictness -> Bool

(>) :: DecidedStrictness -> DecidedStrictness -> Bool

(>=) :: DecidedStrictness -> DecidedStrictness -> Bool

max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

Ord SomeSymbol

Since: base-4.7.0.0

Defined in GHC.TypeLits

Methods

compare :: SomeSymbol -> SomeSymbol -> Ordering

(<) :: SomeSymbol -> SomeSymbol -> Bool

(<=) :: SomeSymbol -> SomeSymbol -> Bool

(>) :: SomeSymbol -> SomeSymbol -> Bool

(>=) :: SomeSymbol -> SomeSymbol -> Bool

max :: SomeSymbol -> SomeSymbol -> SomeSymbol

min :: SomeSymbol -> SomeSymbol -> SomeSymbol

Ord SomeNat

Since: base-4.7.0.0

Defined in GHC.TypeNats

Methods

compare :: SomeNat -> SomeNat -> Ordering

(<) :: SomeNat -> SomeNat -> Bool

(<=) :: SomeNat -> SomeNat -> Bool

(>) :: SomeNat -> SomeNat -> Bool

(>=) :: SomeNat -> SomeNat -> Bool

max :: SomeNat -> SomeNat -> SomeNat

min :: SomeNat -> SomeNat -> SomeNat

Ord CChar

Defined in Foreign.C.Types

Methods

compare :: CChar -> CChar -> Ordering

(<) :: CChar -> CChar -> Bool

(<=) :: CChar -> CChar -> Bool

(>) :: CChar -> CChar -> Bool

(>=) :: CChar -> CChar -> Bool

max :: CChar -> CChar -> CChar

min :: CChar -> CChar -> CChar

Ord CSChar

Defined in Foreign.C.Types

Methods

compare :: CSChar -> CSChar -> Ordering

(<) :: CSChar -> CSChar -> Bool

(<=) :: CSChar -> CSChar -> Bool

(>) :: CSChar -> CSChar -> Bool

(>=) :: CSChar -> CSChar -> Bool

max :: CSChar -> CSChar -> CSChar

min :: CSChar -> CSChar -> CSChar

Ord CUChar

Defined in Foreign.C.Types

Methods

compare :: CUChar -> CUChar -> Ordering

(<) :: CUChar -> CUChar -> Bool

(<=) :: CUChar -> CUChar -> Bool

(>) :: CUChar -> CUChar -> Bool

(>=) :: CUChar -> CUChar -> Bool

max :: CUChar -> CUChar -> CUChar

min :: CUChar -> CUChar -> CUChar

Ord CShort

Defined in Foreign.C.Types

Methods

compare :: CShort -> CShort -> Ordering

(<) :: CShort -> CShort -> Bool

(<=) :: CShort -> CShort -> Bool

(>) :: CShort -> CShort -> Bool

(>=) :: CShort -> CShort -> Bool

max :: CShort -> CShort -> CShort

min :: CShort -> CShort -> CShort

Ord CUShort

Defined in Foreign.C.Types

Methods

compare :: CUShort -> CUShort -> Ordering

(<) :: CUShort -> CUShort -> Bool

(<=) :: CUShort -> CUShort -> Bool

(>) :: CUShort -> CUShort -> Bool

(>=) :: CUShort -> CUShort -> Bool

max :: CUShort -> CUShort -> CUShort

min :: CUShort -> CUShort -> CUShort

Ord CInt

Defined in Foreign.C.Types

Methods

compare :: CInt -> CInt -> Ordering

(<) :: CInt -> CInt -> Bool

(<=) :: CInt -> CInt -> Bool

(>) :: CInt -> CInt -> Bool

(>=) :: CInt -> CInt -> Bool

max :: CInt -> CInt -> CInt

min :: CInt -> CInt -> CInt

Ord CUInt

Defined in Foreign.C.Types

Methods

compare :: CUInt -> CUInt -> Ordering

(<) :: CUInt -> CUInt -> Bool

(<=) :: CUInt -> CUInt -> Bool

(>) :: CUInt -> CUInt -> Bool

(>=) :: CUInt -> CUInt -> Bool

max :: CUInt -> CUInt -> CUInt

min :: CUInt -> CUInt -> CUInt

Ord CLong

Defined in Foreign.C.Types

Methods

compare :: CLong -> CLong -> Ordering

(<) :: CLong -> CLong -> Bool

(<=) :: CLong -> CLong -> Bool

(>) :: CLong -> CLong -> Bool

(>=) :: CLong -> CLong -> Bool

max :: CLong -> CLong -> CLong

min :: CLong -> CLong -> CLong

Ord CULong

Defined in Foreign.C.Types

Methods

compare :: CULong -> CULong -> Ordering

(<) :: CULong -> CULong -> Bool

(<=) :: CULong -> CULong -> Bool

(>) :: CULong -> CULong -> Bool

(>=) :: CULong -> CULong -> Bool

max :: CULong -> CULong -> CULong

min :: CULong -> CULong -> CULong

Ord CLLong

Defined in Foreign.C.Types

Methods

compare :: CLLong -> CLLong -> Ordering

(<) :: CLLong -> CLLong -> Bool

(<=) :: CLLong -> CLLong -> Bool

(>) :: CLLong -> CLLong -> Bool

(>=) :: CLLong -> CLLong -> Bool

max :: CLLong -> CLLong -> CLLong

min :: CLLong -> CLLong -> CLLong

Ord CULLong

Defined in Foreign.C.Types

Methods

compare :: CULLong -> CULLong -> Ordering

(<) :: CULLong -> CULLong -> Bool

(<=) :: CULLong -> CULLong -> Bool

(>) :: CULLong -> CULLong -> Bool

(>=) :: CULLong -> CULLong -> Bool

max :: CULLong -> CULLong -> CULLong

min :: CULLong -> CULLong -> CULLong

Ord CBool

Defined in Foreign.C.Types

Methods

compare :: CBool -> CBool -> Ordering

(<) :: CBool -> CBool -> Bool

(<=) :: CBool -> CBool -> Bool

(>) :: CBool -> CBool -> Bool

(>=) :: CBool -> CBool -> Bool

max :: CBool -> CBool -> CBool

min :: CBool -> CBool -> CBool

Ord CFloat

Defined in Foreign.C.Types

Methods

compare :: CFloat -> CFloat -> Ordering

(<) :: CFloat -> CFloat -> Bool

(<=) :: CFloat -> CFloat -> Bool

(>) :: CFloat -> CFloat -> Bool

(>=) :: CFloat -> CFloat -> Bool

max :: CFloat -> CFloat -> CFloat

min :: CFloat -> CFloat -> CFloat

Ord CDouble

Defined in Foreign.C.Types

Methods

compare :: CDouble -> CDouble -> Ordering

(<) :: CDouble -> CDouble -> Bool

(<=) :: CDouble -> CDouble -> Bool

(>) :: CDouble -> CDouble -> Bool

(>=) :: CDouble -> CDouble -> Bool

max :: CDouble -> CDouble -> CDouble

min :: CDouble -> CDouble -> CDouble

Ord CPtrdiff

Defined in Foreign.C.Types

Methods

compare :: CPtrdiff -> CPtrdiff -> Ordering

(<) :: CPtrdiff -> CPtrdiff -> Bool

(<=) :: CPtrdiff -> CPtrdiff -> Bool

(>) :: CPtrdiff -> CPtrdiff -> Bool

(>=) :: CPtrdiff -> CPtrdiff -> Bool

max :: CPtrdiff -> CPtrdiff -> CPtrdiff

min :: CPtrdiff -> CPtrdiff -> CPtrdiff

Ord CSize

Defined in Foreign.C.Types

Methods

compare :: CSize -> CSize -> Ordering

(<) :: CSize -> CSize -> Bool

(<=) :: CSize -> CSize -> Bool

(>) :: CSize -> CSize -> Bool

(>=) :: CSize -> CSize -> Bool

max :: CSize -> CSize -> CSize

min :: CSize -> CSize -> CSize

Ord CWchar

Defined in Foreign.C.Types

Methods

compare :: CWchar -> CWchar -> Ordering

(<) :: CWchar -> CWchar -> Bool

(<=) :: CWchar -> CWchar -> Bool

(>) :: CWchar -> CWchar -> Bool

(>=) :: CWchar -> CWchar -> Bool

max :: CWchar -> CWchar -> CWchar

min :: CWchar -> CWchar -> CWchar

Ord CSigAtomic

Defined in Foreign.C.Types

Methods

compare :: CSigAtomic -> CSigAtomic -> Ordering

(<) :: CSigAtomic -> CSigAtomic -> Bool

(<=) :: CSigAtomic -> CSigAtomic -> Bool

(>) :: CSigAtomic -> CSigAtomic -> Bool

(>=) :: CSigAtomic -> CSigAtomic -> Bool

max :: CSigAtomic -> CSigAtomic -> CSigAtomic

min :: CSigAtomic -> CSigAtomic -> CSigAtomic

Ord CClock

Defined in Foreign.C.Types

Methods

compare :: CClock -> CClock -> Ordering

(<) :: CClock -> CClock -> Bool

(<=) :: CClock -> CClock -> Bool

(>) :: CClock -> CClock -> Bool

(>=) :: CClock -> CClock -> Bool

max :: CClock -> CClock -> CClock

min :: CClock -> CClock -> CClock

Ord CTime

Defined in Foreign.C.Types

Methods

compare :: CTime -> CTime -> Ordering

(<) :: CTime -> CTime -> Bool

(<=) :: CTime -> CTime -> Bool

(>) :: CTime -> CTime -> Bool

(>=) :: CTime -> CTime -> Bool

max :: CTime -> CTime -> CTime

min :: CTime -> CTime -> CTime

Ord CUSeconds

Defined in Foreign.C.Types

Methods

compare :: CUSeconds -> CUSeconds -> Ordering

(<) :: CUSeconds -> CUSeconds -> Bool

(<=) :: CUSeconds -> CUSeconds -> Bool

(>) :: CUSeconds -> CUSeconds -> Bool

(>=) :: CUSeconds -> CUSeconds -> Bool

max :: CUSeconds -> CUSeconds -> CUSeconds

min :: CUSeconds -> CUSeconds -> CUSeconds

Ord CSUSeconds

Defined in Foreign.C.Types

Methods

compare :: CSUSeconds -> CSUSeconds -> Ordering

(<) :: CSUSeconds -> CSUSeconds -> Bool

(<=) :: CSUSeconds -> CSUSeconds -> Bool

(>) :: CSUSeconds -> CSUSeconds -> Bool

(>=) :: CSUSeconds -> CSUSeconds -> Bool

max :: CSUSeconds -> CSUSeconds -> CSUSeconds

min :: CSUSeconds -> CSUSeconds -> CSUSeconds

Ord CIntPtr

Defined in Foreign.C.Types

Methods

compare :: CIntPtr -> CIntPtr -> Ordering

(<) :: CIntPtr -> CIntPtr -> Bool

(<=) :: CIntPtr -> CIntPtr -> Bool

(>) :: CIntPtr -> CIntPtr -> Bool

(>=) :: CIntPtr -> CIntPtr -> Bool

max :: CIntPtr -> CIntPtr -> CIntPtr

min :: CIntPtr -> CIntPtr -> CIntPtr

Ord CUIntPtr

Defined in Foreign.C.Types

Methods

compare :: CUIntPtr -> CUIntPtr -> Ordering

(<) :: CUIntPtr -> CUIntPtr -> Bool

(<=) :: CUIntPtr -> CUIntPtr -> Bool

(>) :: CUIntPtr -> CUIntPtr -> Bool

(>=) :: CUIntPtr -> CUIntPtr -> Bool

max :: CUIntPtr -> CUIntPtr -> CUIntPtr

min :: CUIntPtr -> CUIntPtr -> CUIntPtr

Ord CIntMax

Defined in Foreign.C.Types

Methods

compare :: CIntMax -> CIntMax -> Ordering

(<) :: CIntMax -> CIntMax -> Bool

(<=) :: CIntMax -> CIntMax -> Bool

(>) :: CIntMax -> CIntMax -> Bool

(>=) :: CIntMax -> CIntMax -> Bool

max :: CIntMax -> CIntMax -> CIntMax

min :: CIntMax -> CIntMax -> CIntMax

Ord CUIntMax

Defined in Foreign.C.Types

Methods

compare :: CUIntMax -> CUIntMax -> Ordering

(<) :: CUIntMax -> CUIntMax -> Bool

(<=) :: CUIntMax -> CUIntMax -> Bool

(>) :: CUIntMax -> CUIntMax -> Bool

(>=) :: CUIntMax -> CUIntMax -> Bool

max :: CUIntMax -> CUIntMax -> CUIntMax

min :: CUIntMax -> CUIntMax -> CUIntMax

Ord Fingerprint

Defined in GHC.Fingerprint.Type

Methods

compare :: Fingerprint -> Fingerprint -> Ordering

(<) :: Fingerprint -> Fingerprint -> Bool

(<=) :: Fingerprint -> Fingerprint -> Bool

(>) :: Fingerprint -> Fingerprint -> Bool

(>=) :: Fingerprint -> Fingerprint -> Bool

max :: Fingerprint -> Fingerprint -> Fingerprint

min :: Fingerprint -> Fingerprint -> Fingerprint

Ord GeneralCategory

Defined in GHC.Unicode

Methods

compare :: GeneralCategory -> GeneralCategory -> Ordering

(<) :: GeneralCategory -> GeneralCategory -> Bool

(<=) :: GeneralCategory -> GeneralCategory -> Bool

(>) :: GeneralCategory -> GeneralCategory -> Bool

(>=) :: GeneralCategory -> GeneralCategory -> Bool

max :: GeneralCategory -> GeneralCategory -> GeneralCategory

min :: GeneralCategory -> GeneralCategory -> GeneralCategory

Ord ByteString

Defined in Data.ByteString.Lazy.Internal

Methods

compare :: ByteString -> ByteString -> Ordering

(<) :: ByteString -> ByteString -> Bool

(<=) :: ByteString -> ByteString -> Bool

(>) :: ByteString -> ByteString -> Bool

(>=) :: ByteString -> ByteString -> Bool

max :: ByteString -> ByteString -> ByteString

min :: ByteString -> ByteString -> ByteString

Ord ByteString

Defined in Data.ByteString.Internal

Methods

compare :: ByteString -> ByteString -> Ordering

(<) :: ByteString -> ByteString -> Bool

(<=) :: ByteString -> ByteString -> Bool

(>) :: ByteString -> ByteString -> Bool

(>=) :: ByteString -> ByteString -> Bool

max :: ByteString -> ByteString -> ByteString

min :: ByteString -> ByteString -> ByteString

Ord IntSet

Defined in Data.IntSet.Internal

Methods

compare :: IntSet -> IntSet -> Ordering

(<) :: IntSet -> IntSet -> Bool

(<=) :: IntSet -> IntSet -> Bool

(>) :: IntSet -> IntSet -> Bool

(>=) :: IntSet -> IntSet -> Bool

max :: IntSet -> IntSet -> IntSet

min :: IntSet -> IntSet -> IntSet

Ord TyVarBndr

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TyVarBndr -> TyVarBndr -> Ordering

(<) :: TyVarBndr -> TyVarBndr -> Bool

(<=) :: TyVarBndr -> TyVarBndr -> Bool

(>) :: TyVarBndr -> TyVarBndr -> Bool

(>=) :: TyVarBndr -> TyVarBndr -> Bool

max :: TyVarBndr -> TyVarBndr -> TyVarBndr

min :: TyVarBndr -> TyVarBndr -> TyVarBndr

Ord ModName

Defined in Language.Haskell.TH.Syntax

Methods

compare :: ModName -> ModName -> Ordering

(<) :: ModName -> ModName -> Bool

(<=) :: ModName -> ModName -> Bool

(>) :: ModName -> ModName -> Bool

(>=) :: ModName -> ModName -> Bool

max :: ModName -> ModName -> ModName

min :: ModName -> ModName -> ModName

Ord PkgName

Defined in Language.Haskell.TH.Syntax

Methods

compare :: PkgName -> PkgName -> Ordering

(<) :: PkgName -> PkgName -> Bool

(<=) :: PkgName -> PkgName -> Bool

(>) :: PkgName -> PkgName -> Bool

(>=) :: PkgName -> PkgName -> Bool

max :: PkgName -> PkgName -> PkgName

min :: PkgName -> PkgName -> PkgName

Ord Module

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Module -> Module -> Ordering

(<) :: Module -> Module -> Bool

(<=) :: Module -> Module -> Bool

(>) :: Module -> Module -> Bool

(>=) :: Module -> Module -> Bool

max :: Module -> Module -> Module

min :: Module -> Module -> Module

Ord OccName

Defined in Language.Haskell.TH.Syntax

Methods

compare :: OccName -> OccName -> Ordering

(<) :: OccName -> OccName -> Bool

(<=) :: OccName -> OccName -> Bool

(>) :: OccName -> OccName -> Bool

(>=) :: OccName -> OccName -> Bool

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

Ord NameFlavour

Defined in Language.Haskell.TH.Syntax

Methods

compare :: NameFlavour -> NameFlavour -> Ordering

(<) :: NameFlavour -> NameFlavour -> Bool

(<=) :: NameFlavour -> NameFlavour -> Bool

(>) :: NameFlavour -> NameFlavour -> Bool

(>=) :: NameFlavour -> NameFlavour -> Bool

max :: NameFlavour -> NameFlavour -> NameFlavour

min :: NameFlavour -> NameFlavour -> NameFlavour

Ord NameSpace

Defined in Language.Haskell.TH.Syntax

Methods

compare :: NameSpace -> NameSpace -> Ordering

(<) :: NameSpace -> NameSpace -> Bool

(<=) :: NameSpace -> NameSpace -> Bool

(>) :: NameSpace -> NameSpace -> Bool

(>=) :: NameSpace -> NameSpace -> Bool

max :: NameSpace -> NameSpace -> NameSpace

min :: NameSpace -> NameSpace -> NameSpace

Ord Loc

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Loc -> Loc -> Ordering

(<) :: Loc -> Loc -> Bool

(<=) :: Loc -> Loc -> Bool

(>) :: Loc -> Loc -> Bool

(>=) :: Loc -> Loc -> Bool

max :: Loc -> Loc -> Loc

min :: Loc -> Loc -> Loc

Ord Info

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Info -> Info -> Ordering

(<) :: Info -> Info -> Bool

(<=) :: Info -> Info -> Bool

(>) :: Info -> Info -> Bool

(>=) :: Info -> Info -> Bool

max :: Info -> Info -> Info

min :: Info -> Info -> Info

Ord ModuleInfo

Defined in Language.Haskell.TH.Syntax

Methods

compare :: ModuleInfo -> ModuleInfo -> Ordering

(<) :: ModuleInfo -> ModuleInfo -> Bool

(<=) :: ModuleInfo -> ModuleInfo -> Bool

(>) :: ModuleInfo -> ModuleInfo -> Bool

(>=) :: ModuleInfo -> ModuleInfo -> Bool

max :: ModuleInfo -> ModuleInfo -> ModuleInfo

min :: ModuleInfo -> ModuleInfo -> ModuleInfo

Ord Fixity

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Fixity -> Fixity -> Ordering

(<) :: Fixity -> Fixity -> Bool

(<=) :: Fixity -> Fixity -> Bool

(>) :: Fixity -> Fixity -> Bool

(>=) :: Fixity -> Fixity -> Bool

max :: Fixity -> Fixity -> Fixity

min :: Fixity -> Fixity -> Fixity

Ord FixityDirection

Defined in Language.Haskell.TH.Syntax

Methods

compare :: FixityDirection -> FixityDirection -> Ordering

(<) :: FixityDirection -> FixityDirection -> Bool

(<=) :: FixityDirection -> FixityDirection -> Bool

(>) :: FixityDirection -> FixityDirection -> Bool

(>=) :: FixityDirection -> FixityDirection -> Bool

max :: FixityDirection -> FixityDirection -> FixityDirection

min :: FixityDirection -> FixityDirection -> FixityDirection

Ord Lit

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Lit -> Lit -> Ordering

(<) :: Lit -> Lit -> Bool

(<=) :: Lit -> Lit -> Bool

(>) :: Lit -> Lit -> Bool

(>=) :: Lit -> Lit -> Bool

max :: Lit -> Lit -> Lit

min :: Lit -> Lit -> Lit

Ord Body

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Body -> Body -> Ordering

(<) :: Body -> Body -> Bool

(<=) :: Body -> Body -> Bool

(>) :: Body -> Body -> Bool

(>=) :: Body -> Body -> Bool

max :: Body -> Body -> Body

min :: Body -> Body -> Body

Ord Guard

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Guard -> Guard -> Ordering

(<) :: Guard -> Guard -> Bool

(<=) :: Guard -> Guard -> Bool

(>) :: Guard -> Guard -> Bool

(>=) :: Guard -> Guard -> Bool

max :: Guard -> Guard -> Guard

min :: Guard -> Guard -> Guard

Ord Stmt

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Stmt -> Stmt -> Ordering

(<) :: Stmt -> Stmt -> Bool

(<=) :: Stmt -> Stmt -> Bool

(>) :: Stmt -> Stmt -> Bool

(>=) :: Stmt -> Stmt -> Bool

max :: Stmt -> Stmt -> Stmt

min :: Stmt -> Stmt -> Stmt

Ord Range

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Range -> Range -> Ordering

(<) :: Range -> Range -> Bool

(<=) :: Range -> Range -> Bool

(>) :: Range -> Range -> Bool

(>=) :: Range -> Range -> Bool

max :: Range -> Range -> Range

min :: Range -> Range -> Range

Ord DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

compare :: DerivClause -> DerivClause -> Ordering

(<) :: DerivClause -> DerivClause -> Bool

(<=) :: DerivClause -> DerivClause -> Bool

(>) :: DerivClause -> DerivClause -> Bool

(>=) :: DerivClause -> DerivClause -> Bool

max :: DerivClause -> DerivClause -> DerivClause

min :: DerivClause -> DerivClause -> DerivClause

Ord TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering

(<) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(>) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool

max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead

min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead

Ord TySynEqn

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TySynEqn -> TySynEqn -> Ordering

(<) :: TySynEqn -> TySynEqn -> Bool

(<=) :: TySynEqn -> TySynEqn -> Bool

(>) :: TySynEqn -> TySynEqn -> Bool

(>=) :: TySynEqn -> TySynEqn -> Bool

max :: TySynEqn -> TySynEqn -> TySynEqn

min :: TySynEqn -> TySynEqn -> TySynEqn

Ord Foreign

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Foreign -> Foreign -> Ordering

(<) :: Foreign -> Foreign -> Bool

(<=) :: Foreign -> Foreign -> Bool

(>) :: Foreign -> Foreign -> Bool

(>=) :: Foreign -> Foreign -> Bool

max :: Foreign -> Foreign -> Foreign

min :: Foreign -> Foreign -> Foreign

Ord Callconv

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Callconv -> Callconv -> Ordering

(<) :: Callconv -> Callconv -> Bool

(<=) :: Callconv -> Callconv -> Bool

(>) :: Callconv -> Callconv -> Bool

(>=) :: Callconv -> Callconv -> Bool

max :: Callconv -> Callconv -> Callconv

min :: Callconv -> Callconv -> Callconv

Ord Safety

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Safety -> Safety -> Ordering

(<) :: Safety -> Safety -> Bool

(<=) :: Safety -> Safety -> Bool

(>) :: Safety -> Safety -> Bool

(>=) :: Safety -> Safety -> Bool

max :: Safety -> Safety -> Safety

min :: Safety -> Safety -> Safety

Ord Pragma

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Pragma -> Pragma -> Ordering

(<) :: Pragma -> Pragma -> Bool

(<=) :: Pragma -> Pragma -> Bool

(>) :: Pragma -> Pragma -> Bool

(>=) :: Pragma -> Pragma -> Bool

max :: Pragma -> Pragma -> Pragma

min :: Pragma -> Pragma -> Pragma

Ord Inline

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Inline -> Inline -> Ordering

(<) :: Inline -> Inline -> Bool

(<=) :: Inline -> Inline -> Bool

(>) :: Inline -> Inline -> Bool

(>=) :: Inline -> Inline -> Bool

max :: Inline -> Inline -> Inline

min :: Inline -> Inline -> Inline

Ord RuleMatch

Defined in Language.Haskell.TH.Syntax

Methods

compare :: RuleMatch -> RuleMatch -> Ordering

(<) :: RuleMatch -> RuleMatch -> Bool

(<=) :: RuleMatch -> RuleMatch -> Bool

(>) :: RuleMatch -> RuleMatch -> Bool

(>=) :: RuleMatch -> RuleMatch -> Bool

max :: RuleMatch -> RuleMatch -> RuleMatch

min :: RuleMatch -> RuleMatch -> RuleMatch

Ord Phases

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Phases -> Phases -> Ordering

(<) :: Phases -> Phases -> Bool

(<=) :: Phases -> Phases -> Bool

(>) :: Phases -> Phases -> Bool

(>=) :: Phases -> Phases -> Bool

max :: Phases -> Phases -> Phases

min :: Phases -> Phases -> Phases

Ord RuleBndr

Defined in Language.Haskell.TH.Syntax

Methods

compare :: RuleBndr -> RuleBndr -> Ordering

(<) :: RuleBndr -> RuleBndr -> Bool

(<=) :: RuleBndr -> RuleBndr -> Bool

(>) :: RuleBndr -> RuleBndr -> Bool

(>=) :: RuleBndr -> RuleBndr -> Bool

max :: RuleBndr -> RuleBndr -> RuleBndr

min :: RuleBndr -> RuleBndr -> RuleBndr

Ord AnnTarget

Defined in Language.Haskell.TH.Syntax

Methods

compare :: AnnTarget -> AnnTarget -> Ordering

(<) :: AnnTarget -> AnnTarget -> Bool

(<=) :: AnnTarget -> AnnTarget -> Bool

(>) :: AnnTarget -> AnnTarget -> Bool

(>=) :: AnnTarget -> AnnTarget -> Bool

max :: AnnTarget -> AnnTarget -> AnnTarget

min :: AnnTarget -> AnnTarget -> AnnTarget

Ord SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Methods

compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering

(<) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

Ord SourceStrictness

Defined in Language.Haskell.TH.Syntax

Methods

compare :: SourceStrictness -> SourceStrictness -> Ordering

(<) :: SourceStrictness -> SourceStrictness -> Bool

(<=) :: SourceStrictness -> SourceStrictness -> Bool

(>) :: SourceStrictness -> SourceStrictness -> Bool

(>=) :: SourceStrictness -> SourceStrictness -> Bool

max :: SourceStrictness -> SourceStrictness -> SourceStrictness

min :: SourceStrictness -> SourceStrictness -> SourceStrictness

Ord DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Methods

compare :: DecidedStrictness -> DecidedStrictness -> Ordering

(<) :: DecidedStrictness -> DecidedStrictness -> Bool

(<=) :: DecidedStrictness -> DecidedStrictness -> Bool

(>) :: DecidedStrictness -> DecidedStrictness -> Bool

(>=) :: DecidedStrictness -> DecidedStrictness -> Bool

max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

Ord Con

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Con -> Con -> Ordering

(<) :: Con -> Con -> Bool

(<=) :: Con -> Con -> Bool

(>) :: Con -> Con -> Bool

(>=) :: Con -> Con -> Bool

max :: Con -> Con -> Con

min :: Con -> Con -> Con

Ord Bang

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Bang -> Bang -> Ordering

(<) :: Bang -> Bang -> Bool

(<=) :: Bang -> Bang -> Bool

(>) :: Bang -> Bang -> Bool

(>=) :: Bang -> Bang -> Bool

max :: Bang -> Bang -> Bang

min :: Bang -> Bang -> Bang

Ord PatSynDir

Defined in Language.Haskell.TH.Syntax

Methods

compare :: PatSynDir -> PatSynDir -> Ordering

(<) :: PatSynDir -> PatSynDir -> Bool

(<=) :: PatSynDir -> PatSynDir -> Bool

(>) :: PatSynDir -> PatSynDir -> Bool

(>=) :: PatSynDir -> PatSynDir -> Bool

max :: PatSynDir -> PatSynDir -> PatSynDir

min :: PatSynDir -> PatSynDir -> PatSynDir

Ord PatSynArgs

Defined in Language.Haskell.TH.Syntax

Methods

compare :: PatSynArgs -> PatSynArgs -> Ordering

(<) :: PatSynArgs -> PatSynArgs -> Bool

(<=) :: PatSynArgs -> PatSynArgs -> Bool

(>) :: PatSynArgs -> PatSynArgs -> Bool

(>=) :: PatSynArgs -> PatSynArgs -> Bool

max :: PatSynArgs -> PatSynArgs -> PatSynArgs

min :: PatSynArgs -> PatSynArgs -> PatSynArgs

Ord FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Methods

compare :: FamilyResultSig -> FamilyResultSig -> Ordering

(<) :: FamilyResultSig -> FamilyResultSig -> Bool

(<=) :: FamilyResultSig -> FamilyResultSig -> Bool

(>) :: FamilyResultSig -> FamilyResultSig -> Bool

(>=) :: FamilyResultSig -> FamilyResultSig -> Bool

max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig

min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig

Ord TyLit

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TyLit -> TyLit -> Ordering

(<) :: TyLit -> TyLit -> Bool

(<=) :: TyLit -> TyLit -> Bool

(>) :: TyLit -> TyLit -> Bool

(>=) :: TyLit -> TyLit -> Bool

max :: TyLit -> TyLit -> TyLit

min :: TyLit -> TyLit -> TyLit

Ord Role

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Role -> Role -> Ordering

(<) :: Role -> Role -> Bool

(<=) :: Role -> Role -> Bool

(>) :: Role -> Role -> Bool

(>=) :: Role -> Role -> Bool

max :: Role -> Role -> Role

min :: Role -> Role -> Role

Ord AnnLookup

Defined in Language.Haskell.TH.Syntax

Methods

compare :: AnnLookup -> AnnLookup -> Ordering

(<) :: AnnLookup -> AnnLookup -> Bool

(<=) :: AnnLookup -> AnnLookup -> Bool

(>) :: AnnLookup -> AnnLookup -> Bool

(>=) :: AnnLookup -> AnnLookup -> Bool

max :: AnnLookup -> AnnLookup -> AnnLookup

min :: AnnLookup -> AnnLookup -> AnnLookup

Ord LocalTime

Defined in Data.Time.LocalTime.Internal.LocalTime

Methods

compare :: LocalTime -> LocalTime -> Ordering

(<) :: LocalTime -> LocalTime -> Bool

(<=) :: LocalTime -> LocalTime -> Bool

(>) :: LocalTime -> LocalTime -> Bool

(>=) :: LocalTime -> LocalTime -> Bool

max :: LocalTime -> LocalTime -> LocalTime

min :: LocalTime -> LocalTime -> LocalTime

Ord UniversalTime

Defined in Data.Time.Clock.Internal.UniversalTime

Methods

compare :: UniversalTime -> UniversalTime -> Ordering

(<) :: UniversalTime -> UniversalTime -> Bool

(<=) :: UniversalTime -> UniversalTime -> Bool

(>) :: UniversalTime -> UniversalTime -> Bool

(>=) :: UniversalTime -> UniversalTime -> Bool

max :: UniversalTime -> UniversalTime -> UniversalTime

min :: UniversalTime -> UniversalTime -> UniversalTime

Ord UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

compare :: UTCTime -> UTCTime -> Ordering

(<) :: UTCTime -> UTCTime -> Bool

(<=) :: UTCTime -> UTCTime -> Bool

(>) :: UTCTime -> UTCTime -> Bool

(>=) :: UTCTime -> UTCTime -> Bool

max :: UTCTime -> UTCTime -> UTCTime

min :: UTCTime -> UTCTime -> UTCTime

Ord Day

Defined in Data.Time.Calendar.Days

Methods

compare :: Day -> Day -> Ordering

(<) :: Day -> Day -> Bool

(<=) :: Day -> Day -> Bool

(>) :: Day -> Day -> Bool

(>=) :: Day -> Day -> Bool

max :: Day -> Day -> Day

min :: Day -> Day -> Day

Ord Bit

Defined in Clash.Sized.Internal.BitVector

Methods

compare :: Bit -> Bit -> Ordering

(<) :: Bit -> Bit -> Bool

(<=) :: Bit -> Bit -> Bool

(>) :: Bit -> Bit -> Bool

(>=) :: Bit -> Bit -> Bool

max :: Bit -> Bit -> Bit

min :: Bit -> Bit -> Bit

Ord DefName

Defined in Control.Lens.Internal.FieldTH

Methods

compare :: DefName -> DefName -> Ordering

(<) :: DefName -> DefName -> Bool

(<=) :: DefName -> DefName -> Bool

(>) :: DefName -> DefName -> Bool

(>=) :: DefName -> DefName -> Bool

max :: DefName -> DefName -> DefName

min :: DefName -> DefName -> DefName

Ord TimeLocale

Defined in System.Locale

Methods

compare :: TimeLocale -> TimeLocale -> Ordering

(<) :: TimeLocale -> TimeLocale -> Bool

(<=) :: TimeLocale -> TimeLocale -> Bool

(>) :: TimeLocale -> TimeLocale -> Bool

(>=) :: TimeLocale -> TimeLocale -> Bool

max :: TimeLocale -> TimeLocale -> TimeLocale

min :: TimeLocale -> TimeLocale -> TimeLocale

Ord ByteArray

Defined in Data.Primitive.ByteArray

Methods

compare :: ByteArray -> ByteArray -> Ordering

(<) :: ByteArray -> ByteArray -> Bool

(<=) :: ByteArray -> ByteArray -> Bool

(>) :: ByteArray -> ByteArray -> Bool

(>=) :: ByteArray -> ByteArray -> Bool

max :: ByteArray -> ByteArray -> ByteArray

min :: ByteArray -> ByteArray -> ByteArray

Ord Addr

Defined in Data.Primitive.Types

Methods

compare :: Addr -> Addr -> Ordering

(<) :: Addr -> Addr -> Bool

(<=) :: Addr -> Addr -> Bool

(>) :: Addr -> Addr -> Bool

(>=) :: Addr -> Addr -> Bool

max :: Addr -> Addr -> Addr

min :: Addr -> Addr -> Addr

Ord ConstructorVariant

Defined in Language.Haskell.TH.Datatype

Methods

compare :: ConstructorVariant -> ConstructorVariant -> Ordering

(<) :: ConstructorVariant -> ConstructorVariant -> Bool

(<=) :: ConstructorVariant -> ConstructorVariant -> Bool

(>) :: ConstructorVariant -> ConstructorVariant -> Bool

(>=) :: ConstructorVariant -> ConstructorVariant -> Bool

max :: ConstructorVariant -> ConstructorVariant -> ConstructorVariant

min :: ConstructorVariant -> ConstructorVariant -> ConstructorVariant

Ord DatatypeVariant

Defined in Language.Haskell.TH.Datatype

Methods

compare :: DatatypeVariant -> DatatypeVariant -> Ordering

(<) :: DatatypeVariant -> DatatypeVariant -> Bool

(<=) :: DatatypeVariant -> DatatypeVariant -> Bool

(>) :: DatatypeVariant -> DatatypeVariant -> Bool

(>=) :: DatatypeVariant -> DatatypeVariant -> Bool

max :: DatatypeVariant -> DatatypeVariant -> DatatypeVariant

min :: DatatypeVariant -> DatatypeVariant -> DatatypeVariant

Ord FieldStrictness

Defined in Language.Haskell.TH.Datatype

Methods

compare :: FieldStrictness -> FieldStrictness -> Ordering

(<) :: FieldStrictness -> FieldStrictness -> Bool

(<=) :: FieldStrictness -> FieldStrictness -> Bool

(>) :: FieldStrictness -> FieldStrictness -> Bool

(>=) :: FieldStrictness -> FieldStrictness -> Bool

max :: FieldStrictness -> FieldStrictness -> FieldStrictness

min :: FieldStrictness -> FieldStrictness -> FieldStrictness

Ord Strictness

Defined in Language.Haskell.TH.Datatype

Methods

compare :: Strictness -> Strictness -> Ordering

(<) :: Strictness -> Strictness -> Bool

(<=) :: Strictness -> Strictness -> Bool

(>) :: Strictness -> Strictness -> Bool

(>=) :: Strictness -> Strictness -> Bool

max :: Strictness -> Strictness -> Strictness

min :: Strictness -> Strictness -> Strictness

Ord Unpackedness

Defined in Language.Haskell.TH.Datatype

Methods

compare :: Unpackedness -> Unpackedness -> Ordering

(<) :: Unpackedness -> Unpackedness -> Bool

(<=) :: Unpackedness -> Unpackedness -> Bool

(>) :: Unpackedness -> Unpackedness -> Bool

(>=) :: Unpackedness -> Unpackedness -> Bool

max :: Unpackedness -> Unpackedness -> Unpackedness

min :: Unpackedness -> Unpackedness -> Unpackedness

Ord Half

Defined in Numeric.Half

Methods

compare :: Half -> Half -> Ordering

(<) :: Half -> Half -> Bool

(<=) :: Half -> Half -> Bool

(>) :: Half -> Half -> Bool

(>=) :: Half -> Half -> Bool

max :: Half -> Half -> Half

min :: Half -> Half -> Half

Ord ResetKind

Defined in Clash.Signal.Internal

Methods

compare :: ResetKind -> ResetKind -> Ordering

(<) :: ResetKind -> ResetKind -> Bool

(<=) :: ResetKind -> ResetKind -> Bool

(>) :: ResetKind -> ResetKind -> Bool

(>=) :: ResetKind -> ResetKind -> Bool

max :: ResetKind -> ResetKind -> ResetKind

min :: ResetKind -> ResetKind -> ResetKind

Ord ClockKind

Defined in Clash.Signal.Internal

Methods

compare :: ClockKind -> ClockKind -> Ordering

(<) :: ClockKind -> ClockKind -> Bool

(<=) :: ClockKind -> ClockKind -> Bool

(>) :: ClockKind -> ClockKind -> Bool

(>=) :: ClockKind -> ClockKind -> Bool

max :: ClockKind -> ClockKind -> ClockKind

min :: ClockKind -> ClockKind -> ClockKind

() :=> (Ord Bool)

Defined in Data.Constraint

Methods

ins :: () :- Ord Bool

() :=> (Ord Char)

Defined in Data.Constraint

Methods

ins :: () :- Ord Char

() :=> (Ord Double)

Defined in Data.Constraint

Methods

ins :: () :- Ord Double

() :=> (Ord Float)

Defined in Data.Constraint

Methods

ins :: () :- Ord Float

() :=> (Ord Int)

Defined in Data.Constraint

Methods

ins :: () :- Ord Int

() :=> (Ord Integer)

Defined in Data.Constraint

Methods

ins :: () :- Ord Integer

() :=> (Ord Natural)

Defined in Data.Constraint

Methods

ins :: () :- Ord Natural

() :=> (Ord Word)

Defined in Data.Constraint

Methods

ins :: () :- Ord Word

() :=> (Ord ())

Defined in Data.Constraint

Methods

ins :: () :- Ord ()

() :=> (Ord (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Ord (a :- b)

() :=> (Ord (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Ord (Dict a)

Ord a => Ord [a]

Defined in GHC.Classes

Methods

compare :: [a] -> [a] -> Ordering

(<) :: [a] -> [a] -> Bool

(<=) :: [a] -> [a] -> Bool

(>) :: [a] -> [a] -> Bool

(>=) :: [a] -> [a] -> Bool

max :: [a] -> [a] -> [a]

min :: [a] -> [a] -> [a]

Ord a => Ord (Maybe a)

Defined in GHC.Base

Methods

compare :: Maybe a -> Maybe a -> Ordering

(<) :: Maybe a -> Maybe a -> Bool

(<=) :: Maybe a -> Maybe a -> Bool

(>) :: Maybe a -> Maybe a -> Bool

(>=) :: Maybe a -> Maybe a -> Bool

max :: Maybe a -> Maybe a -> Maybe a

min :: Maybe a -> Maybe a -> Maybe a

Integral a => Ord (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

compare :: Ratio a -> Ratio a -> Ordering

(<) :: Ratio a -> Ratio a -> Bool

(<=) :: Ratio a -> Ratio a -> Bool

(>) :: Ratio a -> Ratio a -> Bool

(>=) :: Ratio a -> Ratio a -> Bool

max :: Ratio a -> Ratio a -> Ratio a

min :: Ratio a -> Ratio a -> Ratio a

Ord (Ptr a)

Defined in GHC.Ptr

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Ord (FunPtr a)

Defined in GHC.Ptr

Methods

compare :: FunPtr a -> FunPtr a -> Ordering

(<) :: FunPtr a -> FunPtr a -> Bool

(<=) :: FunPtr a -> FunPtr a -> Bool

(>) :: FunPtr a -> FunPtr a -> Bool

(>=) :: FunPtr a -> FunPtr a -> Bool

max :: FunPtr a -> FunPtr a -> FunPtr a

min :: FunPtr a -> FunPtr a -> FunPtr a

Ord p => Ord (Par1 p)

Defined in GHC.Generics

Methods

compare :: Par1 p -> Par1 p -> Ordering

(<) :: Par1 p -> Par1 p -> Bool

(<=) :: Par1 p -> Par1 p -> Bool

(>) :: Par1 p -> Par1 p -> Bool

(>=) :: Par1 p -> Par1 p -> Bool

max :: Par1 p -> Par1 p -> Par1 p

min :: Par1 p -> Par1 p -> Par1 p

Ord (Fixed a)

Defined in Data.Fixed

Methods

compare :: Fixed a -> Fixed a -> Ordering

(<) :: Fixed a -> Fixed a -> Bool

(<=) :: Fixed a -> Fixed a -> Bool

(>) :: Fixed a -> Fixed a -> Bool

(>=) :: Fixed a -> Fixed a -> Bool

max :: Fixed a -> Fixed a -> Fixed a

min :: Fixed a -> Fixed a -> Fixed a

Ord a => Ord (Min a)

Defined in Data.Semigroup

Methods

compare :: Min a -> Min a -> Ordering

(<) :: Min a -> Min a -> Bool

(<=) :: Min a -> Min a -> Bool

(>) :: Min a -> Min a -> Bool

(>=) :: Min a -> Min a -> Bool

max :: Min a -> Min a -> Min a

min :: Min a -> Min a -> Min a

Ord a => Ord (Max a)

Defined in Data.Semigroup

Methods

compare :: Max a -> Max a -> Ordering

(<) :: Max a -> Max a -> Bool

(<=) :: Max a -> Max a -> Bool

(>) :: Max a -> Max a -> Bool

(>=) :: Max a -> Max a -> Bool

max :: Max a -> Max a -> Max a

min :: Max a -> Max a -> Max a

Ord a => Ord (First a)

Defined in Data.Semigroup

Methods

compare :: First a -> First a -> Ordering

(<) :: First a -> First a -> Bool

(<=) :: First a -> First a -> Bool

(>) :: First a -> First a -> Bool

(>=) :: First a -> First a -> Bool

max :: First a -> First a -> First a

min :: First a -> First a -> First a

Ord a => Ord (Last a)

Defined in Data.Semigroup

Methods

compare :: Last a -> Last a -> Ordering

(<) :: Last a -> Last a -> Bool

(<=) :: Last a -> Last a -> Bool

(>) :: Last a -> Last a -> Bool

(>=) :: Last a -> Last a -> Bool

max :: Last a -> Last a -> Last a

min :: Last a -> Last a -> Last a

Ord m => Ord (WrappedMonoid m)

Defined in Data.Semigroup

Methods

compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering

(<) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(>) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool

max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

Ord a => Ord (Option a)

Defined in Data.Semigroup

Methods

compare :: Option a -> Option a -> Ordering

(<) :: Option a -> Option a -> Bool

(<=) :: Option a -> Option a -> Bool

(>) :: Option a -> Option a -> Bool

(>=) :: Option a -> Option a -> Bool

max :: Option a -> Option a -> Option a

min :: Option a -> Option a -> Option a

Ord a => Ord (ZipList a)

Defined in Control.Applicative

Methods

compare :: ZipList a -> ZipList a -> Ordering

(<) :: ZipList a -> ZipList a -> Bool

(<=) :: ZipList a -> ZipList a -> Bool

(>) :: ZipList a -> ZipList a -> Bool

(>=) :: ZipList a -> ZipList a -> Bool

max :: ZipList a -> ZipList a -> ZipList a

min :: ZipList a -> ZipList a -> ZipList a

Ord a => Ord (Identity a)

Defined in Data.Functor.Identity

Methods

compare :: Identity a -> Identity a -> Ordering

(<) :: Identity a -> Identity a -> Bool

(<=) :: Identity a -> Identity a -> Bool

(>) :: Identity a -> Identity a -> Bool

(>=) :: Identity a -> Identity a -> Bool

max :: Identity a -> Identity a -> Identity a

min :: Identity a -> Identity a -> Identity a

Ord a => Ord (First a)

Defined in Data.Monoid

Methods

compare :: First a -> First a -> Ordering

(<) :: First a -> First a -> Bool

(<=) :: First a -> First a -> Bool

(>) :: First a -> First a -> Bool

(>=) :: First a -> First a -> Bool

max :: First a -> First a -> First a

min :: First a -> First a -> First a

Ord a => Ord (Last a)

Defined in Data.Monoid

Methods

compare :: Last a -> Last a -> Ordering

(<) :: Last a -> Last a -> Bool

(<=) :: Last a -> Last a -> Bool

(>) :: Last a -> Last a -> Bool

(>=) :: Last a -> Last a -> Bool

max :: Last a -> Last a -> Last a

min :: Last a -> Last a -> Last a

Ord a => Ord (Dual a)

Defined in Data.Semigroup.Internal

Methods

compare :: Dual a -> Dual a -> Ordering

(<) :: Dual a -> Dual a -> Bool

(<=) :: Dual a -> Dual a -> Bool

(>) :: Dual a -> Dual a -> Bool

(>=) :: Dual a -> Dual a -> Bool

max :: Dual a -> Dual a -> Dual a

min :: Dual a -> Dual a -> Dual a

Ord a => Ord (Sum a)

Defined in Data.Semigroup.Internal

Methods

compare :: Sum a -> Sum a -> Ordering

(<) :: Sum a -> Sum a -> Bool

(<=) :: Sum a -> Sum a -> Bool

(>) :: Sum a -> Sum a -> Bool

(>=) :: Sum a -> Sum a -> Bool

max :: Sum a -> Sum a -> Sum a

min :: Sum a -> Sum a -> Sum a

Ord a => Ord (Product a)

Defined in Data.Semigroup.Internal

Methods

compare :: Product a -> Product a -> Ordering

(<) :: Product a -> Product a -> Bool

(<=) :: Product a -> Product a -> Bool

(>) :: Product a -> Product a -> Bool

(>=) :: Product a -> Product a -> Bool

max :: Product a -> Product a -> Product a

min :: Product a -> Product a -> Product a

Ord a => Ord (Down a)

Since: base-4.6.0.0

Defined in Data.Ord

Methods

compare :: Down a -> Down a -> Ordering

(<) :: Down a -> Down a -> Bool

(<=) :: Down a -> Down a -> Bool

(>) :: Down a -> Down a -> Bool

(>=) :: Down a -> Down a -> Bool

max :: Down a -> Down a -> Down a

min :: Down a -> Down a -> Down a

Ord a => Ord (NonEmpty a)

Defined in GHC.Base

Methods

compare :: NonEmpty a -> NonEmpty a -> Ordering

(<) :: NonEmpty a -> NonEmpty a -> Bool

(<=) :: NonEmpty a -> NonEmpty a -> Bool

(>) :: NonEmpty a -> NonEmpty a -> Bool

(>=) :: NonEmpty a -> NonEmpty a -> Bool

max :: NonEmpty a -> NonEmpty a -> NonEmpty a

min :: NonEmpty a -> NonEmpty a -> NonEmpty a

Ord a => Ord (IntMap a)

Defined in Data.IntMap.Internal

Methods

compare :: IntMap a -> IntMap a -> Ordering

(<) :: IntMap a -> IntMap a -> Bool

(<=) :: IntMap a -> IntMap a -> Bool

(>) :: IntMap a -> IntMap a -> Bool

(>=) :: IntMap a -> IntMap a -> Bool

max :: IntMap a -> IntMap a -> IntMap a

min :: IntMap a -> IntMap a -> IntMap a

Ord a => Ord (Seq a)

Defined in Data.Sequence.Internal

Methods

compare :: Seq a -> Seq a -> Ordering

(<) :: Seq a -> Seq a -> Bool

(<=) :: Seq a -> Seq a -> Bool

(>) :: Seq a -> Seq a -> Bool

(>=) :: Seq a -> Seq a -> Bool

max :: Seq a -> Seq a -> Seq a

min :: Seq a -> Seq a -> Seq a

Ord a => Ord (ViewL a)

Defined in Data.Sequence.Internal

Methods

compare :: ViewL a -> ViewL a -> Ordering

(<) :: ViewL a -> ViewL a -> Bool

(<=) :: ViewL a -> ViewL a -> Bool

(>) :: ViewL a -> ViewL a -> Bool

(>=) :: ViewL a -> ViewL a -> Bool

max :: ViewL a -> ViewL a -> ViewL a

min :: ViewL a -> ViewL a -> ViewL a

Ord a => Ord (ViewR a)

Defined in Data.Sequence.Internal

Methods

compare :: ViewR a -> ViewR a -> Ordering

(<) :: ViewR a -> ViewR a -> Bool

(<=) :: ViewR a -> ViewR a -> Bool

(>) :: ViewR a -> ViewR a -> Bool

(>=) :: ViewR a -> ViewR a -> Bool

max :: ViewR a -> ViewR a -> ViewR a

min :: ViewR a -> ViewR a -> ViewR a

Ord a => Ord (Set a)

Defined in Data.Set.Internal

Methods

compare :: Set a -> Set a -> Ordering

(<) :: Set a -> Set a -> Bool

(<=) :: Set a -> Set a -> Bool

(>) :: Set a -> Set a -> Bool

(>=) :: Set a -> Set a -> Bool

max :: Set a -> Set a -> Set a

min :: Set a -> Set a -> Set a

Ord (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

compare :: BitVector n -> BitVector n -> Ordering

(<) :: BitVector n -> BitVector n -> Bool

(<=) :: BitVector n -> BitVector n -> Bool

(>) :: BitVector n -> BitVector n -> Bool

(>=) :: BitVector n -> BitVector n -> Bool

max :: BitVector n -> BitVector n -> BitVector n

min :: BitVector n -> BitVector n -> BitVector n

Ord (Index n)

Defined in Clash.Sized.Internal.Index

Methods

compare :: Index n -> Index n -> Ordering

(<) :: Index n -> Index n -> Bool

(<=) :: Index n -> Index n -> Bool

(>) :: Index n -> Index n -> Bool

(>=) :: Index n -> Index n -> Bool

max :: Index n -> Index n -> Index n

min :: Index n -> Index n -> Index n

Ord a => Ord (Bounds a)

Defined in Test.QuickCheck.Arbitrary

Methods

compare :: Bounds a -> Bounds a -> Ordering

(<) :: Bounds a -> Bounds a -> Bool

(<=) :: Bounds a -> Bounds a -> Bool

(>) :: Bounds a -> Bounds a -> Bool

(>=) :: Bounds a -> Bounds a -> Bool

max :: Bounds a -> Bounds a -> Bounds a

min :: Bounds a -> Bounds a -> Bounds a

Ord a => Ord (DList a)

Defined in Data.DList

Methods

compare :: DList a -> DList a -> Ordering

(<) :: DList a -> DList a -> Bool

(<=) :: DList a -> DList a -> Bool

(>) :: DList a -> DList a -> Bool

(>=) :: DList a -> DList a -> Bool

max :: DList a -> DList a -> DList a

min :: DList a -> DList a -> DList a

Ord a => Ord (HashSet a)

Defined in Data.HashSet

Methods

compare :: HashSet a -> HashSet a -> Ordering

(<) :: HashSet a -> HashSet a -> Bool

(<=) :: HashSet a -> HashSet a -> Bool

(>) :: HashSet a -> HashSet a -> Bool

(>=) :: HashSet a -> HashSet a -> Bool

max :: HashSet a -> HashSet a -> HashSet a

min :: HashSet a -> HashSet a -> HashSet a

(Storable a, Ord a) => Ord (Vector a)

Defined in Data.Vector.Storable

Methods

compare :: Vector a -> Vector a -> Ordering

(<) :: Vector a -> Vector a -> Bool

(<=) :: Vector a -> Vector a -> Bool

(>) :: Vector a -> Vector a -> Bool

(>=) :: Vector a -> Vector a -> Bool

max :: Vector a -> Vector a -> Vector a

min :: Vector a -> Vector a -> Vector a

(Prim a, Ord a) => Ord (Vector a)

Defined in Data.Vector.Primitive

Methods

compare :: Vector a -> Vector a -> Ordering

(<) :: Vector a -> Vector a -> Bool

(<=) :: Vector a -> Vector a -> Bool

(>) :: Vector a -> Vector a -> Bool

(>=) :: Vector a -> Vector a -> Bool

max :: Vector a -> Vector a -> Vector a

min :: Vector a -> Vector a -> Vector a

Ord a => Ord (Vector a)

Defined in Data.Vector

Methods

compare :: Vector a -> Vector a -> Ordering

(<) :: Vector a -> Vector a -> Bool

(<=) :: Vector a -> Vector a -> Bool

(>) :: Vector a -> Vector a -> Bool

(>=) :: Vector a -> Vector a -> Bool

max :: Vector a -> Vector a -> Vector a

min :: Vector a -> Vector a -> Vector a

Ord a => Ord (Array a)

Defined in Data.Primitive.Array

Methods

compare :: Array a -> Array a -> Ordering

(<) :: Array a -> Array a -> Bool

(<=) :: Array a -> Array a -> Bool

(>) :: Array a -> Array a -> Bool

(>=) :: Array a -> Array a -> Bool

max :: Array a -> Array a -> Array a

min :: Array a -> Array a -> Array a

(Ord a, Prim a) => Ord (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

compare :: PrimArray a -> PrimArray a -> Ordering

(<) :: PrimArray a -> PrimArray a -> Bool

(<=) :: PrimArray a -> PrimArray a -> Bool

(>) :: PrimArray a -> PrimArray a -> Bool

(>=) :: PrimArray a -> PrimArray a -> Bool

max :: PrimArray a -> PrimArray a -> PrimArray a

min :: PrimArray a -> PrimArray a -> PrimArray a

Ord a => Ord (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

compare :: SmallArray a -> SmallArray a -> Ordering

(<) :: SmallArray a -> SmallArray a -> Bool

(<=) :: SmallArray a -> SmallArray a -> Bool

(>) :: SmallArray a -> SmallArray a -> Bool

(>=) :: SmallArray a -> SmallArray a -> Bool

max :: SmallArray a -> SmallArray a -> SmallArray a

min :: SmallArray a -> SmallArray a -> SmallArray a

(Ord a, PrimUnlifted a) => Ord (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

compare :: UnliftedArray a -> UnliftedArray a -> Ordering

(<) :: UnliftedArray a -> UnliftedArray a -> Bool

(<=) :: UnliftedArray a -> UnliftedArray a -> Bool

(>) :: UnliftedArray a -> UnliftedArray a -> Bool

(>=) :: UnliftedArray a -> UnliftedArray a -> Bool

max :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a

min :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a

Ord (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

compare :: Unsigned n -> Unsigned n -> Ordering

(<) :: Unsigned n -> Unsigned n -> Bool

(<=) :: Unsigned n -> Unsigned n -> Bool

(>) :: Unsigned n -> Unsigned n -> Bool

(>=) :: Unsigned n -> Unsigned n -> Bool

max :: Unsigned n -> Unsigned n -> Unsigned n

min :: Unsigned n -> Unsigned n -> Unsigned n

Ord (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

compare :: Signed n -> Signed n -> Ordering

(<) :: Signed n -> Signed n -> Bool

(<=) :: Signed n -> Signed n -> Bool

(>) :: Signed n -> Signed n -> Bool

(>=) :: Signed n -> Signed n -> Bool

max :: Signed n -> Signed n -> Signed n

min :: Signed n -> Signed n -> Signed n

Ord (Dict a)

Defined in Data.Constraint

Methods

compare :: Dict a -> Dict a -> Ordering

(<) :: Dict a -> Dict a -> Bool

(<=) :: Dict a -> Dict a -> Bool

(>) :: Dict a -> Dict a -> Bool

(>=) :: Dict a -> Dict a -> Bool

max :: Dict a -> Dict a -> Dict a

min :: Dict a -> Dict a -> Dict a

(Integral a) :=> (Ord (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Ord (Ratio a)

(Ord a) :=> (Ord (Maybe a))

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord (Maybe a)

(Ord a) :=> (Ord [a])

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord [a]

(Ord a) :=> (Ord (Identity a))

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord (Identity a)

(Ord a) :=> (Ord (Const a b))

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord (Const a b)

Class (Eq a) (Ord a)

Defined in Data.Constraint

Methods

cls :: Ord a :- Eq a

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

Defined in Data.Either

Methods

compare :: Either a b -> Either a b -> Ordering

(<) :: Either a b -> Either a b -> Bool

(<=) :: Either a b -> Either a b -> Bool

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

(>=) :: Either a b -> Either a b -> Bool

max :: Either a b -> Either a b -> Either a b

min :: Either a b -> Either a b -> Either a b

Ord (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: V1 p -> V1 p -> Ordering

(<) :: V1 p -> V1 p -> Bool

(<=) :: V1 p -> V1 p -> Bool

(>) :: V1 p -> V1 p -> Bool

(>=) :: V1 p -> V1 p -> Bool

max :: V1 p -> V1 p -> V1 p

min :: V1 p -> V1 p -> V1 p

Ord (U1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: U1 p -> U1 p -> Ordering

(<) :: U1 p -> U1 p -> Bool

(<=) :: U1 p -> U1 p -> Bool

(>) :: U1 p -> U1 p -> Bool

(>=) :: U1 p -> U1 p -> Bool

max :: U1 p -> U1 p -> U1 p

min :: U1 p -> U1 p -> U1 p

Ord (TypeRep a)

Since: base-4.4.0.0

Defined in Data.Typeable.Internal

Methods

compare :: TypeRep a -> TypeRep a -> Ordering

(<) :: TypeRep a -> TypeRep a -> Bool

(<=) :: TypeRep a -> TypeRep a -> Bool

(>) :: TypeRep a -> TypeRep a -> Bool

(>=) :: TypeRep a -> TypeRep a -> Bool

max :: TypeRep a -> TypeRep a -> TypeRep a

min :: TypeRep a -> TypeRep a -> TypeRep a

(Ord a, Ord b) => Ord (a, b)

Defined in GHC.Classes

Methods

compare :: (a, b) -> (a, b) -> Ordering

(<) :: (a, b) -> (a, b) -> Bool

(<=) :: (a, b) -> (a, b) -> Bool

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

(>=) :: (a, b) -> (a, b) -> Bool

max :: (a, b) -> (a, b) -> (a, b)

min :: (a, b) -> (a, b) -> (a, b)

(Ix i, Ord e) => Ord (Array i e)

Since: base-2.1

Defined in GHC.Arr

Methods

compare :: Array i e -> Array i e -> Ordering

(<) :: Array i e -> Array i e -> Bool

(<=) :: Array i e -> Array i e -> Bool

(>) :: Array i e -> Array i e -> Bool

(>=) :: Array i e -> Array i e -> Bool

max :: Array i e -> Array i e -> Array i e

min :: Array i e -> Array i e -> Array i e

Ord a => Ord (Arg a b)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

compare :: Arg a b -> Arg a b -> Ordering

(<) :: Arg a b -> Arg a b -> Bool

(<=) :: Arg a b -> Arg a b -> Bool

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

(>=) :: Arg a b -> Arg a b -> Bool

max :: Arg a b -> Arg a b -> Arg a b

min :: Arg a b -> Arg a b -> Arg a b

Ord (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

compare :: Proxy s -> Proxy s -> Ordering

(<) :: Proxy s -> Proxy s -> Bool

(<=) :: Proxy s -> Proxy s -> Bool

(>) :: Proxy s -> Proxy s -> Bool

(>=) :: Proxy s -> Proxy s -> Bool

max :: Proxy s -> Proxy s -> Proxy s

min :: Proxy s -> Proxy s -> Proxy s

(Ord k, Ord v) => Ord (Map k v)

Defined in Data.Map.Internal

Methods

compare :: Map k v -> Map k v -> Ordering

(<) :: Map k v -> Map k v -> Bool

(<=) :: Map k v -> Map k v -> Bool

(>) :: Map k v -> Map k v -> Bool

(>=) :: Map k v -> Map k v -> Bool

max :: Map k v -> Map k v -> Map k v

min :: Map k v -> Map k v -> Map k v

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

Defined in Clash.Sized.Vector

Methods

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

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

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

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

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

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

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

(Ord i, Ord a) => Ord (Level i a)

Defined in Control.Lens.Internal.Level

Methods

compare :: Level i a -> Level i a -> Ordering

(<) :: Level i a -> Level i a -> Bool

(<=) :: Level i a -> Level i a -> Bool

(>) :: Level i a -> Level i a -> Bool

(>=) :: Level i a -> Level i a -> Bool

max :: Level i a -> Level i a -> Level i a

min :: Level i a -> Level i a -> Level i a

(Ord1 f, Ord a) => Ord (Cofree f a)

Defined in Control.Comonad.Cofree

Methods

compare :: Cofree f a -> Cofree f a -> Ordering

(<) :: Cofree f a -> Cofree f a -> Bool

(<=) :: Cofree f a -> Cofree f a -> Bool

(>) :: Cofree f a -> Cofree f a -> Bool

(>=) :: Cofree f a -> Cofree f a -> Bool

max :: Cofree f a -> Cofree f a -> Cofree f a

min :: Cofree f a -> Cofree f a -> Cofree f a

(Ord1 f, Ord a) => Ord (Free f a)

Defined in Control.Monad.Free

Methods

compare :: Free f a -> Free f a -> Ordering

(<) :: Free f a -> Free f a -> Bool

(<=) :: Free f a -> Free f a -> Bool

(>) :: Free f a -> Free f a -> Bool

(>=) :: Free f a -> Free f a -> Bool

max :: Free f a -> Free f a -> Free f a

min :: Free f a -> Free f a -> Free f a

(Ord1 f, Ord a) => Ord (Yoneda f a)

Defined in Data.Functor.Yoneda

Methods

compare :: Yoneda f a -> Yoneda f a -> Ordering

(<) :: Yoneda f a -> Yoneda f a -> Bool

(<=) :: Yoneda f a -> Yoneda f a -> Bool

(>) :: Yoneda f a -> Yoneda f a -> Bool

(>=) :: Yoneda f a -> Yoneda f a -> Bool

max :: Yoneda f a -> Yoneda f a -> Yoneda f a

min :: Yoneda f a -> Yoneda f a -> Yoneda f a

(Ord k, Ord v) => Ord (HashMap k v)

Defined in Data.HashMap.Base

Methods

compare :: HashMap k v -> HashMap k v -> Ordering

(<) :: HashMap k v -> HashMap k v -> Bool

(<=) :: HashMap k v -> HashMap k v -> Bool

(>) :: HashMap k v -> HashMap k v -> Bool

(>=) :: HashMap k v -> HashMap k v -> Bool

max :: HashMap k v -> HashMap k v -> HashMap k v

min :: HashMap k v -> HashMap k v -> HashMap k v

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

Defined in Clash.Sized.RTree

Methods

compare :: RTree d a -> RTree d a -> Ordering

(<) :: RTree d a -> RTree d a -> Bool

(<=) :: RTree d a -> RTree d a -> Bool

(>) :: RTree d a -> RTree d a -> Bool

(>=) :: RTree d a -> RTree d a -> Bool

max :: RTree d a -> RTree d a -> RTree d a

min :: RTree d a -> RTree d a -> RTree d a

Ord (a :- b)

Defined in Data.Constraint

Methods

compare :: (a :- b) -> (a :- b) -> Ordering

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

(<=) :: (a :- b) -> (a :- b) -> Bool

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

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

max :: (a :- b) -> (a :- b) -> a :- b

min :: (a :- b) -> (a :- b) -> a :- b

(Ord a, Ord b) :=> (Ord (a, b))

Defined in Data.Constraint

Methods

ins :: (Ord a, Ord b) :- Ord (a, b)

(Ord a, Ord b) :=> (Ord (Either a b))

Defined in Data.Constraint

Methods

ins :: (Ord a, Ord b) :- Ord (Either a b)

Class (Num a, Ord a) (Real a)

Defined in Data.Constraint

Methods

cls :: Real a :- (Num a, Ord a)

Ord (f p) => Ord (Rec1 f p)

Defined in GHC.Generics

Methods

compare :: Rec1 f p -> Rec1 f p -> Ordering

(<) :: Rec1 f p -> Rec1 f p -> Bool

(<=) :: Rec1 f p -> Rec1 f p -> Bool

(>) :: Rec1 f p -> Rec1 f p -> Bool

(>=) :: Rec1 f p -> Rec1 f p -> Bool

max :: Rec1 f p -> Rec1 f p -> Rec1 f p

min :: Rec1 f p -> Rec1 f p -> Rec1 f p

Ord (URec (Ptr ()) p)

Defined in GHC.Generics

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

Ord (URec Char p)

Defined in GHC.Generics

Methods

compare :: URec Char p -> URec Char p -> Ordering

(<) :: URec Char p -> URec Char p -> Bool

(<=) :: URec Char p -> URec Char p -> Bool

(>) :: URec Char p -> URec Char p -> Bool

(>=) :: URec Char p -> URec Char p -> Bool

max :: URec Char p -> URec Char p -> URec Char p

min :: URec Char p -> URec Char p -> URec Char p

Ord (URec Double p)

Defined in GHC.Generics

Methods

compare :: URec Double p -> URec Double p -> Ordering

(<) :: URec Double p -> URec Double p -> Bool

(<=) :: URec Double p -> URec Double p -> Bool

(>) :: URec Double p -> URec Double p -> Bool

(>=) :: URec Double p -> URec Double p -> Bool

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

Ord (URec Float p)

Defined in GHC.Generics

Methods

compare :: URec Float p -> URec Float p -> Ordering

(<) :: URec Float p -> URec Float p -> Bool

(<=) :: URec Float p -> URec Float p -> Bool

(>) :: URec Float p -> URec Float p -> Bool

(>=) :: URec Float p -> URec Float p -> Bool

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

Ord (URec Int p)

Defined in GHC.Generics

Methods

compare :: URec Int p -> URec Int p -> Ordering

(<) :: URec Int p -> URec Int p -> Bool

(<=) :: URec Int p -> URec Int p -> Bool

(>) :: URec Int p -> URec Int p -> Bool

(>=) :: URec Int p -> URec Int p -> Bool

max :: URec Int p -> URec Int p -> URec Int p

min :: URec Int p -> URec Int p -> URec Int p

Ord (URec Word p)

Defined in GHC.Generics

Methods

compare :: URec Word p -> URec Word p -> Ordering

(<) :: URec Word p -> URec Word p -> Bool

(<=) :: URec Word p -> URec Word p -> Bool

(>) :: URec Word p -> URec Word p -> Bool

(>=) :: URec Word p -> URec Word p -> Bool

max :: URec Word p -> URec Word p -> URec Word p

min :: URec Word p -> URec Word p -> URec Word p

(Ord a, Ord b, Ord c) => Ord (a, b, c)

Defined in GHC.Classes

Methods

compare :: (a, b, c) -> (a, b, c) -> Ordering

(<) :: (a, b, c) -> (a, b, c) -> Bool

(<=) :: (a, b, c) -> (a, b, c) -> Bool

(>) :: (a, b, c) -> (a, b, c) -> Bool

(>=) :: (a, b, c) -> (a, b, c) -> Bool

max :: (a, b, c) -> (a, b, c) -> (a, b, c)

min :: (a, b, c) -> (a, b, c) -> (a, b, c)

Ord a => Ord (Const a b)

Defined in Data.Functor.Const

Methods

compare :: Const a b -> Const a b -> Ordering

(<) :: Const a b -> Const a b -> Bool

(<=) :: Const a b -> Const a b -> Bool

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

(>=) :: Const a b -> Const a b -> Bool

max :: Const a b -> Const a b -> Const a b

min :: Const a b -> Const a b -> Const a b

Ord (f a) => Ord (Alt f a)

Defined in Data.Semigroup.Internal

Methods

compare :: Alt f a -> Alt f a -> Ordering

(<) :: Alt f a -> Alt f a -> Bool

(<=) :: Alt f a -> Alt f a -> Bool

(>) :: Alt f a -> Alt f a -> Bool

(>=) :: Alt f a -> Alt f a -> Bool

max :: Alt f a -> Alt f a -> Alt f a

min :: Alt f a -> Alt f a -> Alt f a

Ord (a :~: b)

Defined in Data.Type.Equality

Methods

compare :: (a :~: b) -> (a :~: b) -> Ordering

(<) :: (a :~: b) -> (a :~: b) -> Bool

(<=) :: (a :~: b) -> (a :~: b) -> Bool

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

(>=) :: (a :~: b) -> (a :~: b) -> Bool

max :: (a :~: b) -> (a :~: b) -> a :~: b

min :: (a :~: b) -> (a :~: b) -> a :~: b

(Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a)

Defined in Control.Monad.Trans.Error

Methods

compare :: ErrorT e m a -> ErrorT e m a -> Ordering

(<) :: ErrorT e m a -> ErrorT e m a -> Bool

(<=) :: ErrorT e m a -> ErrorT e m a -> Bool

(>) :: ErrorT e m a -> ErrorT e m a -> Bool

(>=) :: ErrorT e m a -> ErrorT e m a -> Bool

max :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

min :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

Ord a => Ord (Constant a b)

Defined in Data.Functor.Constant

Methods

compare :: Constant a b -> Constant a b -> Ordering

(<) :: Constant a b -> Constant a b -> Bool

(<=) :: Constant a b -> Constant a b -> Bool

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

(>=) :: Constant a b -> Constant a b -> Bool

max :: Constant a b -> Constant a b -> Constant a b

min :: Constant a b -> Constant a b -> Constant a b

Ord b => Ord (Tagged s b)

Defined in Data.Tagged

Methods

compare :: Tagged s b -> Tagged s b -> Ordering

(<) :: Tagged s b -> Tagged s b -> Bool

(<=) :: Tagged s b -> Tagged s b -> Bool

(>) :: Tagged s b -> Tagged s b -> Bool

(>=) :: Tagged s b -> Tagged s b -> Bool

max :: Tagged s b -> Tagged s b -> Tagged s b

min :: Tagged s b -> Tagged s b -> Tagged s b

Ord (p (Fix p a) a) => Ord (Fix p a)

Defined in Data.Bifunctor.Fix

Methods

compare :: Fix p a -> Fix p a -> Ordering

(<) :: Fix p a -> Fix p a -> Bool

(<=) :: Fix p a -> Fix p a -> Bool

(>) :: Fix p a -> Fix p a -> Bool

(>=) :: Fix p a -> Fix p a -> Bool

max :: Fix p a -> Fix p a -> Fix p a

min :: Fix p a -> Fix p a -> Fix p a

Ord (p a a) => Ord (Join p a)

Defined in Data.Bifunctor.Join

Methods

compare :: Join p a -> Join p a -> Ordering

(<) :: Join p a -> Join p a -> Bool

(<=) :: Join p a -> Join p a -> Bool

(>) :: Join p a -> Join p a -> Bool

(>=) :: Join p a -> Join p a -> Bool

max :: Join p a -> Join p a -> Join p a

min :: Join p a -> Join p a -> Join p a

(Ord a, Ord (f b)) => Ord (CofreeF f a b)

Defined in Control.Comonad.Trans.Cofree

Methods

compare :: CofreeF f a b -> CofreeF f a b -> Ordering

(<) :: CofreeF f a b -> CofreeF f a b -> Bool

(<=) :: CofreeF f a b -> CofreeF f a b -> Bool

(>) :: CofreeF f a b -> CofreeF f a b -> Bool

(>=) :: CofreeF f a b -> CofreeF f a b -> Bool

max :: CofreeF f a b -> CofreeF f a b -> CofreeF f a b

min :: CofreeF f a b -> CofreeF f a b -> CofreeF f a b

Ord (w (CofreeF f a (CofreeT f w a))) => Ord (CofreeT f w a)

Defined in Control.Comonad.Trans.Cofree

Methods

compare :: CofreeT f w a -> CofreeT f w a -> Ordering

(<) :: CofreeT f w a -> CofreeT f w a -> Bool

(<=) :: CofreeT f w a -> CofreeT f w a -> Bool

(>) :: CofreeT f w a -> CofreeT f w a -> Bool

(>=) :: CofreeT f w a -> CofreeT f w a -> Bool

max :: CofreeT f w a -> CofreeT f w a -> CofreeT f w a

min :: CofreeT f w a -> CofreeT f w a -> CofreeT f w a

(Ord1 f, Ord1 m, Ord a) => Ord (FreeT f m a)

Defined in Control.Monad.Trans.Free

Methods

compare :: FreeT f m a -> FreeT f m a -> Ordering

(<) :: FreeT f m a -> FreeT f m a -> Bool

(<=) :: FreeT f m a -> FreeT f m a -> Bool

(>) :: FreeT f m a -> FreeT f m a -> Bool

(>=) :: FreeT f m a -> FreeT f m a -> Bool

max :: FreeT f m a -> FreeT f m a -> FreeT f m a

min :: FreeT f m a -> FreeT f m a -> FreeT f m a

(Ord a, Ord (f b)) => Ord (FreeF f a b)

Defined in Control.Monad.Trans.Free

Methods

compare :: FreeF f a b -> FreeF f a b -> Ordering

(<) :: FreeF f a b -> FreeF f a b -> Bool

(<=) :: FreeF f a b -> FreeF f a b -> Bool

(>) :: FreeF f a b -> FreeF f a b -> Bool

(>=) :: FreeF f a b -> FreeF f a b -> Bool

max :: FreeF f a b -> FreeF f a b -> FreeF f a b

min :: FreeF f a b -> FreeF f a b -> FreeF f a b

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

Defined in Clash.Sized.Fixed

Methods

compare :: Fixed rep int frac -> Fixed rep int frac -> Ordering

(<) :: Fixed rep int frac -> Fixed rep int frac -> Bool

(<=) :: Fixed rep int frac -> Fixed rep int frac -> Bool

(>) :: Fixed rep int frac -> Fixed rep int frac -> Bool

(>=) :: Fixed rep int frac -> Fixed rep int frac -> Bool

max :: Fixed rep int frac -> Fixed rep int frac -> Fixed rep int frac

min :: Fixed rep int frac -> Fixed rep int frac -> Fixed rep int frac

Ord c => Ord (K1 i c p)

Defined in GHC.Generics

Methods

compare :: K1 i c p -> K1 i c p -> Ordering

(<) :: K1 i c p -> K1 i c p -> Bool

(<=) :: K1 i c p -> K1 i c p -> Bool

(>) :: K1 i c p -> K1 i c p -> Bool

(>=) :: K1 i c p -> K1 i c p -> Bool

max :: K1 i c p -> K1 i c p -> K1 i c p

min :: K1 i c p -> K1 i c p -> K1 i c p

(Ord (f p), Ord (g p)) => Ord ((f :+: g) p)

Defined in GHC.Generics

Methods

compare :: (f :+: g) p -> (f :+: g) p -> Ordering

(<) :: (f :+: g) p -> (f :+: g) p -> Bool

(<=) :: (f :+: g) p -> (f :+: g) p -> Bool

(>) :: (f :+: g) p -> (f :+: g) p -> Bool

(>=) :: (f :+: g) p -> (f :+: g) p -> Bool

max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p

min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p

(Ord (f p), Ord (g p)) => Ord ((f :*: g) p)

Defined in GHC.Generics

Methods

compare :: (f :*: g) p -> (f :*: g) p -> Ordering

(<) :: (f :*: g) p -> (f :*: g) p -> Bool

(<=) :: (f :*: g) p -> (f :*: g) p -> Bool

(>) :: (f :*: g) p -> (f :*: g) p -> Bool

(>=) :: (f :*: g) p -> (f :*: g) p -> Bool

max :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

min :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering

(<) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(>) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool

max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

(Ord1 f, Ord1 g, Ord a) => Ord (Product f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

compare :: Product f g a -> Product f g a -> Ordering

(<) :: Product f g a -> Product f g a -> Bool

(<=) :: Product f g a -> Product f g a -> Bool

(>) :: Product f g a -> Product f g a -> Bool

(>=) :: Product f g a -> Product f g a -> Bool

max :: Product f g a -> Product f g a -> Product f g a

min :: Product f g a -> Product f g a -> Product f g a

(Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

compare :: Sum f g a -> Sum f g a -> Ordering

(<) :: Sum f g a -> Sum f g a -> Bool

(<=) :: Sum f g a -> Sum f g a -> Bool

(>) :: Sum f g a -> Sum f g a -> Bool

(>=) :: Sum f g a -> Sum f g a -> Bool

max :: Sum f g a -> Sum f g a -> Sum f g a

min :: Sum f g a -> Sum f g a -> Sum f g a

Ord (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

compare :: (a :~~: b) -> (a :~~: b) -> Ordering

(<) :: (a :~~: b) -> (a :~~: b) -> Bool

(<=) :: (a :~~: b) -> (a :~~: b) -> Bool

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

(>=) :: (a :~~: b) -> (a :~~: b) -> Bool

max :: (a :~~: b) -> (a :~~: b) -> a :~~: b

min :: (a :~~: b) -> (a :~~: b) -> a :~~: b

Ord (f p) => Ord (M1 i c f p)

Defined in GHC.Generics

Methods

compare :: M1 i c f p -> M1 i c f p -> Ordering

(<) :: M1 i c f p -> M1 i c f p -> Bool

(<=) :: M1 i c f p -> M1 i c f p -> Bool

(>) :: M1 i c f p -> M1 i c f p -> Bool

(>=) :: M1 i c f p -> M1 i c f p -> Bool

max :: M1 i c f p -> M1 i c f p -> M1 i c f p

min :: M1 i c f p -> M1 i c f p -> M1 i c f p

Ord (f (g p)) => Ord ((f :.: g) p)

Defined in GHC.Generics

Methods

compare :: (f :.: g) p -> (f :.: g) p -> Ordering

(<) :: (f :.: g) p -> (f :.: g) p -> Bool

(<=) :: (f :.: g) p -> (f :.: g) p -> Bool

(>) :: (f :.: g) p -> (f :.: g) p -> Bool

(>=) :: (f :.: g) p -> (f :.: g) p -> Bool

max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p

min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p

(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering

(<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

compare :: Compose f g a -> Compose f g a -> Ordering

(<) :: Compose f g a -> Compose f g a -> Bool

(<=) :: Compose f g a -> Compose f g a -> Bool

(>) :: Compose f g a -> Compose f g a -> Bool

(>=) :: Compose f g a -> Compose f g a -> Bool

max :: Compose f g a -> Compose f g a -> Compose f g a

min :: Compose f g a -> Compose f g a -> Compose f g a

Ord (f a) => Ord (Clown f a b)

Defined in Data.Bifunctor.Clown

Methods

compare :: Clown f a b -> Clown f a b -> Ordering

(<) :: Clown f a b -> Clown f a b -> Bool

(<=) :: Clown f a b -> Clown f a b -> Bool

(>) :: Clown f a b -> Clown f a b -> Bool

(>=) :: Clown f a b -> Clown f a b -> Bool

max :: Clown f a b -> Clown f a b -> Clown f a b

min :: Clown f a b -> Clown f a b -> Clown f a b

Ord (p b a) => Ord (Flip p a b)

Defined in Data.Bifunctor.Flip

Methods

compare :: Flip p a b -> Flip p a b -> Ordering

(<) :: Flip p a b -> Flip p a b -> Bool

(<=) :: Flip p a b -> Flip p a b -> Bool

(>) :: Flip p a b -> Flip p a b -> Bool

(>=) :: Flip p a b -> Flip p a b -> Bool

max :: Flip p a b -> Flip p a b -> Flip p a b

min :: Flip p a b -> Flip p a b -> Flip p a b

Ord (g b) => Ord (Joker g a b)

Defined in Data.Bifunctor.Joker

Methods

compare :: Joker g a b -> Joker g a b -> Ordering

(<) :: Joker g a b -> Joker g a b -> Bool

(<=) :: Joker g a b -> Joker g a b -> Bool

(>) :: Joker g a b -> Joker g a b -> Bool

(>=) :: Joker g a b -> Joker g a b -> Bool

max :: Joker g a b -> Joker g a b -> Joker g a b

min :: Joker g a b -> Joker g a b -> Joker g a b

Ord (p a b) => Ord (WrappedBifunctor p a b)

Defined in Data.Bifunctor.Wrapped

Methods

compare :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Ordering

(<) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

(<=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

(>) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

(>=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

max :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> WrappedBifunctor p a b

min :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> WrappedBifunctor p a b

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering

(<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

(Ord (f a b), Ord (g a b)) => Ord (Product f g a b)

Defined in Data.Bifunctor.Product

Methods

compare :: Product f g a b -> Product f g a b -> Ordering

(<) :: Product f g a b -> Product f g a b -> Bool

(<=) :: Product f g a b -> Product f g a b -> Bool

(>) :: Product f g a b -> Product f g a b -> Bool

(>=) :: Product f g a b -> Product f g a b -> Bool

max :: Product f g a b -> Product f g a b -> Product f g a b

min :: Product f g a b -> Product f g a b -> Product f g a b

(Ord (p a b), Ord (q a b)) => Ord (Sum p q a b)

Defined in Data.Bifunctor.Sum

Methods

compare :: Sum p q a b -> Sum p q a b -> Ordering

(<) :: Sum p q a b -> Sum p q a b -> Bool

(<=) :: Sum p q a b -> Sum p q a b -> Bool

(>) :: Sum p q a b -> Sum p q a b -> Bool

(>=) :: Sum p q a b -> Sum p q a b -> Bool

max :: Sum p q a b -> Sum p q a b -> Sum p q a b

min :: Sum p q a b -> Sum p q a b -> Sum p q a b

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering

(<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

Ord (f (p a b)) => Ord (Tannen f p a b)

Defined in Data.Bifunctor.Tannen

Methods

compare :: Tannen f p a b -> Tannen f p a b -> Ordering

(<) :: Tannen f p a b -> Tannen f p a b -> Bool

(<=) :: Tannen f p a b -> Tannen f p a b -> Bool

(>) :: Tannen f p a b -> Tannen f p a b -> Bool

(>=) :: Tannen f p a b -> Tannen f p a b -> Bool

max :: Tannen f p a b -> Tannen f p a b -> Tannen f p a b

min :: Tannen f p a b -> Tannen f p a b -> Tannen f p a b

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering

(<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

Ord (p (f a) (g b)) => Ord (Biff p f g a b)

Defined in Data.Bifunctor.Biff

Methods

compare :: Biff p f g a b -> Biff p f g a b -> Ordering

(<) :: Biff p f g a b -> Biff p f g a b -> Bool

(<=) :: Biff p f g a b -> Biff p f g a b -> Bool

(>) :: Biff p f g a b -> Biff p f g a b -> Bool

(>=) :: Biff p f g a b -> Biff p f g a b -> Bool

max :: Biff p f g a b -> Biff p f g a b -> Biff p f g a b

min :: Biff p f g a b -> Biff p f g a b -> Biff p f g a b

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in GHC.Classes

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Read a where

Parsing of Strings, producing values.

Derived instances of Read make the following assumptions, which derived instances of Show obey:

• If the constructor is defined to be an infix operator, then the derived Read instance will parse only infix applications of the constructor (not the prefix form).
• Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
• If the constructor is defined using record syntax, the derived Read will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.
• The derived Read instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Read in Haskell 2010 is equivalent to

instance (Read a) => Read (Tree a) where

        readsPrec d r =  readParen (d > app_prec)
                         (\r -> [(Leaf m,t) |
                                 ("Leaf",s) <- lex r,
                                 (m,t) <- readsPrec (app_prec+1) s]) r

                      ++ readParen (d > up_prec)
                         (\r -> [(u:^:v,w) |
                                 (u,s) <- readsPrec (up_prec+1) r,
                                 (":^:",t) <- lex s,
                                 (v,w) <- readsPrec (up_prec+1) t]) r

          where app_prec = 10
                up_prec = 5

Note that right-associativity of :^: is unused.

The derived instance in GHC is equivalent to

instance (Read a) => Read (Tree a) where

        readPrec = parens $ (prec app_prec $ do
                                 Ident "Leaf" <- lexP
                                 m <- step readPrec
                                 return (Leaf m))

                     +++ (prec up_prec $ do
                                 u <- step readPrec
                                 Symbol ":^:" <- lexP
                                 v <- step readPrec
                                 return (u :^: v))

          where app_prec = 10
                up_prec = 5

        readListPrec = readListPrecDefault

Why do both readsPrec and readPrec exist, and why does GHC opt to implement readPrec in derived Read instances instead of readsPrec? The reason is that readsPrec is based on the ReadS type, and although ReadS is mentioned in the Haskell 2010 Report, it is not a very efficient parser data structure.

readPrec, on the other hand, is based on a much more efficient ReadPrec datatype (a.k.a "new-style parsers"), but its definition relies on the use of the RankNTypes language extension. Therefore, readPrec (and its cousin, readListPrec) are marked as GHC-only. Nevertheless, it is recommended to use readPrec instead of readsPrec whenever possible for the efficiency improvements it brings.

As mentioned above, derived Read instances in GHC will implement readPrec instead of readsPrec. The default implementations of readsPrec (and its cousin, readList) will simply use readPrec under the hood. If you are writing a Read instance by hand, it is recommended to write it like so:

instance Read T where
  readPrec     = ...
  readListPrec = readListPrecDefault

Minimal complete definition

readsPrec | readPrec

Methods

readsPrec

Arguments

:: Int

the operator precedence of the enclosing context (a number from 0 to 11). Function application has precedence 10.

-> ReadS a

attempts to parse a value from the front of the string, returning a list of (parsed value, remaining string) pairs. If there is no successful parse, the returned list is empty.

Derived instances of Read and Show satisfy the following:

• (x,"") is an element of (readsPrec d (showsPrec d x "")).

That is, readsPrec parses the string produced by showsPrec, and delivers the value that showsPrec started with.

readList :: ReadS [a]

The method readList is provided to allow the programmer to give a specialised way of parsing lists of values. For example, this is used by the predefined Read instance of the Char type, where values of type String should be are expected to use double quotes, rather than square brackets.

Instances

Read Bool

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Bool

readList :: ReadS [Bool]

readPrec :: ReadPrec Bool

readListPrec :: ReadPrec [Bool]

Read Char

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Read Double

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

Read Float

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

Read Int

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Read Int8

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int8

readList :: ReadS [Int8]

readPrec :: ReadPrec Int8

readListPrec :: ReadPrec [Int8]

Read Int16

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int16

readList :: ReadS [Int16]

readPrec :: ReadPrec Int16

readListPrec :: ReadPrec [Int16]

Read Int32

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int32

readList :: ReadS [Int32]

readPrec :: ReadPrec Int32

readListPrec :: ReadPrec [Int32]

Read Int64

Since: base-2.1

Defined in GHC.Int

Methods

readsPrec :: Int -> ReadS Int64

readList :: ReadS [Int64]

readPrec :: ReadPrec Int64

readListPrec :: ReadPrec [Int64]

Read Integer

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Integer

readList :: ReadS [Integer]

readPrec :: ReadPrec Integer

readListPrec :: ReadPrec [Integer]

Read Natural

Since: base-4.8.0.0

Defined in GHC.Natural

Methods

readsPrec :: Int -> ReadS Natural

readList :: ReadS [Natural]

readPrec :: ReadPrec Natural

readListPrec :: ReadPrec [Natural]

Read Ordering

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Ordering

readList :: ReadS [Ordering]

readPrec :: ReadPrec Ordering

readListPrec :: ReadPrec [Ordering]

Read Word

Since: base-4.5.0.0

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Read Word8

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word8

readList :: ReadS [Word8]

readPrec :: ReadPrec Word8

readListPrec :: ReadPrec [Word8]

Read Word16

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word16

readList :: ReadS [Word16]

readPrec :: ReadPrec Word16

readListPrec :: ReadPrec [Word16]

Read Word32

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word32

readList :: ReadS [Word32]

readPrec :: ReadPrec Word32

readListPrec :: ReadPrec [Word32]

Read Word64

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word64

readList :: ReadS [Word64]

readPrec :: ReadPrec Word64

readListPrec :: ReadPrec [Word64]

Read ()

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS ()

readList :: ReadS [()]

readPrec :: ReadPrec ()

readListPrec :: ReadPrec [()]

Read Void

Reading a Void value is always a parse error, considering Void as a data type with no constructors.

Since: base-4.8.0.0

Defined in Data.Void

Methods

readsPrec :: Int -> ReadS Void

readList :: ReadS [Void]

readPrec :: ReadPrec Void

readListPrec :: ReadPrec [Void]

Read Version

Defined in Data.Version

Methods

readsPrec :: Int -> ReadS Version

readList :: ReadS [Version]

readPrec :: ReadPrec Version

readListPrec :: ReadPrec [Version]

Read ExitCode

Defined in GHC.IO.Exception

Methods

readsPrec :: Int -> ReadS ExitCode

readList :: ReadS [ExitCode]

readPrec :: ReadPrec ExitCode

readListPrec :: ReadPrec [ExitCode]

Read All

Defined in Data.Semigroup.Internal

Methods

readsPrec :: Int -> ReadS All

readList :: ReadS [All]

readPrec :: ReadPrec All

readListPrec :: ReadPrec [All]

Read Any

Defined in Data.Semigroup.Internal

Methods

readsPrec :: Int -> ReadS Any

readList :: ReadS [Any]

readPrec :: ReadPrec Any

readListPrec :: ReadPrec [Any]

Read Fixity

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS Fixity

readList :: ReadS [Fixity]

readPrec :: ReadPrec Fixity

readListPrec :: ReadPrec [Fixity]

Read Associativity

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS Associativity

readList :: ReadS [Associativity]

readPrec :: ReadPrec Associativity

readListPrec :: ReadPrec [Associativity]

Read SourceUnpackedness

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS SourceUnpackedness

readList :: ReadS [SourceUnpackedness]

readPrec :: ReadPrec SourceUnpackedness

readListPrec :: ReadPrec [SourceUnpackedness]

Read SourceStrictness

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS SourceStrictness

readList :: ReadS [SourceStrictness]

readPrec :: ReadPrec SourceStrictness

readListPrec :: ReadPrec [SourceStrictness]

Read DecidedStrictness

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS DecidedStrictness

readList :: ReadS [DecidedStrictness]

readPrec :: ReadPrec DecidedStrictness

readListPrec :: ReadPrec [DecidedStrictness]

Read SomeSymbol

Since: base-4.7.0.0

Defined in GHC.TypeLits

Methods

readsPrec :: Int -> ReadS SomeSymbol

readList :: ReadS [SomeSymbol]

readPrec :: ReadPrec SomeSymbol

readListPrec :: ReadPrec [SomeSymbol]

Read SomeNat

Since: base-4.7.0.0

Defined in GHC.TypeNats

Methods

readsPrec :: Int -> ReadS SomeNat

readList :: ReadS [SomeNat]

readPrec :: ReadPrec SomeNat

readListPrec :: ReadPrec [SomeNat]

Read CChar

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CChar

readList :: ReadS [CChar]

readPrec :: ReadPrec CChar

readListPrec :: ReadPrec [CChar]

Read CSChar

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CSChar

readList :: ReadS [CSChar]

readPrec :: ReadPrec CSChar

readListPrec :: ReadPrec [CSChar]

Read CUChar

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUChar

readList :: ReadS [CUChar]

readPrec :: ReadPrec CUChar

readListPrec :: ReadPrec [CUChar]

Read CShort

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CShort

readList :: ReadS [CShort]

readPrec :: ReadPrec CShort

readListPrec :: ReadPrec [CShort]

Read CUShort

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUShort

readList :: ReadS [CUShort]

readPrec :: ReadPrec CUShort

readListPrec :: ReadPrec [CUShort]

Read CInt

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CInt

readList :: ReadS [CInt]

readPrec :: ReadPrec CInt

readListPrec :: ReadPrec [CInt]

Read CUInt

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUInt

readList :: ReadS [CUInt]

readPrec :: ReadPrec CUInt

readListPrec :: ReadPrec [CUInt]

Read CLong

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CLong

readList :: ReadS [CLong]

readPrec :: ReadPrec CLong

readListPrec :: ReadPrec [CLong]

Read CULong

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CULong

readList :: ReadS [CULong]

readPrec :: ReadPrec CULong

readListPrec :: ReadPrec [CULong]

Read CLLong

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CLLong

readList :: ReadS [CLLong]

readPrec :: ReadPrec CLLong

readListPrec :: ReadPrec [CLLong]

Read CULLong

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CULLong

readList :: ReadS [CULLong]

readPrec :: ReadPrec CULLong

readListPrec :: ReadPrec [CULLong]

Read CBool

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CBool

readList :: ReadS [CBool]

readPrec :: ReadPrec CBool

readListPrec :: ReadPrec [CBool]

Read CFloat

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CFloat

readList :: ReadS [CFloat]

readPrec :: ReadPrec CFloat

readListPrec :: ReadPrec [CFloat]

Read CDouble

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CDouble

readList :: ReadS [CDouble]

readPrec :: ReadPrec CDouble

readListPrec :: ReadPrec [CDouble]

Read CPtrdiff

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CPtrdiff

readList :: ReadS [CPtrdiff]

readPrec :: ReadPrec CPtrdiff

readListPrec :: ReadPrec [CPtrdiff]

Read CSize

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CSize

readList :: ReadS [CSize]

readPrec :: ReadPrec CSize

readListPrec :: ReadPrec [CSize]

Read CWchar

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CWchar

readList :: ReadS [CWchar]

readPrec :: ReadPrec CWchar

readListPrec :: ReadPrec [CWchar]

Read CSigAtomic

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CSigAtomic

readList :: ReadS [CSigAtomic]

readPrec :: ReadPrec CSigAtomic

readListPrec :: ReadPrec [CSigAtomic]

Read CClock

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CClock

readList :: ReadS [CClock]

readPrec :: ReadPrec CClock

readListPrec :: ReadPrec [CClock]

Read CTime

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CTime

readList :: ReadS [CTime]

readPrec :: ReadPrec CTime

readListPrec :: ReadPrec [CTime]

Read CUSeconds

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUSeconds

readList :: ReadS [CUSeconds]

readPrec :: ReadPrec CUSeconds

readListPrec :: ReadPrec [CUSeconds]

Read CSUSeconds

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CSUSeconds

readList :: ReadS [CSUSeconds]

readPrec :: ReadPrec CSUSeconds

readListPrec :: ReadPrec [CSUSeconds]

Read CIntPtr

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CIntPtr

readList :: ReadS [CIntPtr]

readPrec :: ReadPrec CIntPtr

readListPrec :: ReadPrec [CIntPtr]

Read CUIntPtr

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUIntPtr

readList :: ReadS [CUIntPtr]

readPrec :: ReadPrec CUIntPtr

readListPrec :: ReadPrec [CUIntPtr]

Read CIntMax

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CIntMax

readList :: ReadS [CIntMax]

readPrec :: ReadPrec CIntMax

readListPrec :: ReadPrec [CIntMax]

Read CUIntMax

Defined in Foreign.C.Types

Methods

readsPrec :: Int -> ReadS CUIntMax

readList :: ReadS [CUIntMax]

readPrec :: ReadPrec CUIntMax

readListPrec :: ReadPrec [CUIntMax]

Read Lexeme

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Lexeme

readList :: ReadS [Lexeme]

readPrec :: ReadPrec Lexeme

readListPrec :: ReadPrec [Lexeme]

Read GeneralCategory

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS GeneralCategory

readList :: ReadS [GeneralCategory]

readPrec :: ReadPrec GeneralCategory

readListPrec :: ReadPrec [GeneralCategory]

Read ByteString

Defined in Data.ByteString.Lazy.Internal

Methods

readsPrec :: Int -> ReadS ByteString

readList :: ReadS [ByteString]

readPrec :: ReadPrec ByteString

readListPrec :: ReadPrec [ByteString]

Read ByteString

Defined in Data.ByteString.Internal

Methods

readsPrec :: Int -> ReadS ByteString

readList :: ReadS [ByteString]

readPrec :: ReadPrec ByteString

readListPrec :: ReadPrec [ByteString]

Read IntSet

Defined in Data.IntSet.Internal

Methods

readsPrec :: Int -> ReadS IntSet

readList :: ReadS [IntSet]

readPrec :: ReadPrec IntSet

readListPrec :: ReadPrec [IntSet]

Read Primitive

Defined in Clash.Annotations.Primitive

Methods

readsPrec :: Int -> ReadS Primitive

readList :: ReadS [Primitive]

readPrec :: ReadPrec Primitive

readListPrec :: ReadPrec [Primitive]

Read HDL

Defined in Clash.Annotations.Primitive

Methods

readsPrec :: Int -> ReadS HDL

readList :: ReadS [HDL]

readPrec :: ReadPrec HDL

readListPrec :: ReadPrec [HDL]

Read QCGen

Defined in Test.QuickCheck.Random

Methods

readsPrec :: Int -> ReadS QCGen

readList :: ReadS [QCGen]

readPrec :: ReadPrec QCGen

readListPrec :: ReadPrec [QCGen]

Read DatatypeVariant

Defined in Language.Haskell.TH.Datatype

Methods

readsPrec :: Int -> ReadS DatatypeVariant

readList :: ReadS [DatatypeVariant]

readPrec :: ReadPrec DatatypeVariant

readListPrec :: ReadPrec [DatatypeVariant]

Read Half

Defined in Numeric.Half

Methods

readsPrec :: Int -> ReadS Half

readList :: ReadS [Half]

readPrec :: ReadPrec Half

readListPrec :: ReadPrec [Half]

a :=> (Read (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a)

() :=> (Read Bool)

Defined in Data.Constraint

Methods

ins :: () :- Read Bool

() :=> (Read Char)

Defined in Data.Constraint

Methods

ins :: () :- Read Char

() :=> (Read Int)

Defined in Data.Constraint

Methods

ins :: () :- Read Int

() :=> (Read Natural)

Defined in Data.Constraint

Methods

ins :: () :- Read Natural

() :=> (Read Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Read Ordering

() :=> (Read Word)

Defined in Data.Constraint

Methods

ins :: () :- Read Word

() :=> (Read ())

Defined in Data.Constraint

Methods

ins :: () :- Read ()

Class () (Read a)

Defined in Data.Constraint

Methods

cls :: Read a :- ()

Read a => Read [a]

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS [a]

readList :: ReadS [[a]]

readPrec :: ReadPrec [a]

readListPrec :: ReadPrec [[a]]

Read a => Read (Maybe a)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (Maybe a)

readList :: ReadS [Maybe a]

readPrec :: ReadPrec (Maybe a)

readListPrec :: ReadPrec [Maybe a]

(Integral a, Read a) => Read (Ratio a)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (Ratio a)

readList :: ReadS [Ratio a]

readPrec :: ReadPrec (Ratio a)

readListPrec :: ReadPrec [Ratio a]

Read p => Read (Par1 p)

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS (Par1 p)

readList :: ReadS [Par1 p]

readPrec :: ReadPrec (Par1 p)

readListPrec :: ReadPrec [Par1 p]

Read a => Read (Complex a)

Defined in Data.Complex

Methods

readsPrec :: Int -> ReadS (Complex a)

readList :: ReadS [Complex a]

readPrec :: ReadPrec (Complex a)

readListPrec :: ReadPrec [Complex a]

HasResolution a => Read (Fixed a)

Since: base-4.3.0.0

Defined in Data.Fixed

Methods

readsPrec :: Int -> ReadS (Fixed a)

readList :: ReadS [Fixed a]

readPrec :: ReadPrec (Fixed a)

readListPrec :: ReadPrec [Fixed a]

Read a => Read (Min a)

Defined in Data.Semigroup

Methods

readsPrec :: Int -> ReadS (Min a)

readList :: ReadS [Min a]

readPrec :: ReadPrec (Min a)

readListPrec :: ReadPrec [Min a]

Read a => Read (Max a)

Defined in Data.Semigroup

Methods

readsPrec :: Int -> ReadS (Max a)

readList :: ReadS [Max a]

readPrec :: ReadPrec (Max a)

readListPrec :: ReadPrec [Max a]

Read a => Read (First a)

Defined in Data.Semigroup

Methods

readsPrec :: Int -> ReadS (First a)

readList :: ReadS [First a]

readPrec :: ReadPrec (First a)

readListPrec :: ReadPrec [First a]

Read a => Read (Last a)

Defined in Data.Semigroup

Methods

readsPrec :: Int -> ReadS (Last a)

readList :: ReadS [Last a]

readPrec :: ReadPrec (Last a)

readListPrec :: ReadPrec [Last a]

Read m => Read (WrappedMonoid m)

Defined in Data.Semigroup

Methods

readsPrec :: Int -> ReadS (WrappedMonoid m)

readList :: ReadS [WrappedMonoid m]

readPrec :: ReadPrec (WrappedMonoid m)

readListPrec :: ReadPrec [WrappedMonoid m]

Read a => Read (Option a)

Defined in Data.Semigroup

Methods

readsPrec :: Int -> ReadS (Option a)

readList :: ReadS [Option a]

readPrec :: ReadPrec (Option a)

readListPrec :: ReadPrec [Option a]

Read a => Read (ZipList a)

Defined in Control.Applicative

Methods

readsPrec :: Int -> ReadS (ZipList a)

readList :: ReadS [ZipList a]

readPrec :: ReadPrec (ZipList a)

readListPrec :: ReadPrec [ZipList a]

Read a => Read (Identity a)

This instance would be equivalent to the derived instances of the Identity newtype if the runIdentity field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

readsPrec :: Int -> ReadS (Identity a)

readList :: ReadS [Identity a]

readPrec :: ReadPrec (Identity a)

readListPrec :: ReadPrec [Identity a]

Read a => Read (First a)

Defined in Data.Monoid

Methods

readsPrec :: Int -> ReadS (First a)

readList :: ReadS [First a]

readPrec :: ReadPrec (First a)

readListPrec :: ReadPrec [First a]

Read a => Read (Last a)

Defined in Data.Monoid

Methods

readsPrec :: Int -> ReadS (Last a)

readList :: ReadS [Last a]

readPrec :: ReadPrec (Last a)

readListPrec :: ReadPrec [Last a]

Read a => Read (Dual a)

Defined in Data.Semigroup.Internal

Methods

readsPrec :: Int -> ReadS (Dual a)

readList :: ReadS [Dual a]

readPrec :: ReadPrec (Dual a)

readListPrec :: ReadPrec [Dual a]

Read a => Read (Sum a)

Defined in Data.Semigroup.Internal

Methods

readsPrec :: Int -> ReadS (Sum a)

readList :: ReadS [Sum a]

readPrec :: ReadPrec (Sum a)

readListPrec :: ReadPrec [Sum a]

Read a => Read (Product a)

Defined in Data.Semigroup.Internal

Methods

readsPrec :: Int -> ReadS (Product a)

readList :: ReadS [Product a]

readPrec :: ReadPrec (Product a)

readListPrec :: ReadPrec [Product a]

Read a => Read (Down a)

Since: base-4.7.0.0

Defined in Data.Ord

Methods

readsPrec :: Int -> ReadS (Down a)

readList :: ReadS [Down a]

readPrec :: ReadPrec (Down a)

readListPrec :: ReadPrec [Down a]

Read a => Read (NonEmpty a)

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (NonEmpty a)

readList :: ReadS [NonEmpty a]

readPrec :: ReadPrec (NonEmpty a)

readListPrec :: ReadPrec [NonEmpty a]

Read e => Read (IntMap e)

Defined in Data.IntMap.Internal

Methods

readsPrec :: Int -> ReadS (IntMap e)

readList :: ReadS [IntMap e]

readPrec :: ReadPrec (IntMap e)

readListPrec :: ReadPrec [IntMap e]

Read a => Read (Tree a)

Defined in Data.Tree

Methods

readsPrec :: Int -> ReadS (Tree a)

readList :: ReadS [Tree a]

readPrec :: ReadPrec (Tree a)

readListPrec :: ReadPrec [Tree a]

Read a => Read (Seq a)

Defined in Data.Sequence.Internal

Methods

readsPrec :: Int -> ReadS (Seq a)

readList :: ReadS [Seq a]

readPrec :: ReadPrec (Seq a)

readListPrec :: ReadPrec [Seq a]

Read a => Read (ViewL a)

Defined in Data.Sequence.Internal

Methods

readsPrec :: Int -> ReadS (ViewL a)

readList :: ReadS [ViewL a]

readPrec :: ReadPrec (ViewL a)

readListPrec :: ReadPrec [ViewL a]

Read a => Read (ViewR a)

Defined in Data.Sequence.Internal

Methods

readsPrec :: Int -> ReadS (ViewR a)

readList :: ReadS [ViewR a]

readPrec :: ReadPrec (ViewR a)

readListPrec :: ReadPrec [ViewR a]

(Read a, Ord a) => Read (Set a)

Defined in Data.Set.Internal

Methods

readsPrec :: Int -> ReadS (Set a)

readList :: ReadS [Set a]

readPrec :: ReadPrec (Set a)

readListPrec :: ReadPrec [Set a]

KnownNat n => Read (Index n)

None of the Read class' methods are synthesisable.

Defined in Clash.Sized.Internal.Index

Methods

readsPrec :: Int -> ReadS (Index n)

readList :: ReadS [Index n]

readPrec :: ReadPrec (Index n)

readListPrec :: ReadPrec [Index n]

Read a => Read (DList a)

Defined in Data.DList

Methods

readsPrec :: Int -> ReadS (DList a)

readList :: ReadS [DList a]

readPrec :: ReadPrec (DList a)

readListPrec :: ReadPrec [DList a]

(Eq a, Hashable a, Read a) => Read (HashSet a)

Defined in Data.HashSet

Methods

readsPrec :: Int -> ReadS (HashSet a)

readList :: ReadS [HashSet a]

readPrec :: ReadPrec (HashSet a)

readListPrec :: ReadPrec [HashSet a]

(Read a, Storable a) => Read (Vector a)

Defined in Data.Vector.Storable

Methods

readsPrec :: Int -> ReadS (Vector a)

readList :: ReadS [Vector a]

readPrec :: ReadPrec (Vector a)

readListPrec :: ReadPrec [Vector a]

(Read a, Prim a) => Read (Vector a)

Defined in Data.Vector.Primitive

Methods

readsPrec :: Int -> ReadS (Vector a)

readList :: ReadS [Vector a]

readPrec :: ReadPrec (Vector a)

readListPrec :: ReadPrec [Vector a]

Read a => Read (Vector a)

Defined in Data.Vector

Methods

readsPrec :: Int -> ReadS (Vector a)

readList :: ReadS [Vector a]

readPrec :: ReadPrec (Vector a)

readListPrec :: ReadPrec [Vector a]

Read a => Read (Array a)

Defined in Data.Primitive.Array

Methods

readsPrec :: Int -> ReadS (Array a)

readList :: ReadS [Array a]

readPrec :: ReadPrec (Array a)

readListPrec :: ReadPrec [Array a]

Read a => Read (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

readsPrec :: Int -> ReadS (SmallArray a)

readList :: ReadS [SmallArray a]

readPrec :: ReadPrec (SmallArray a)

readListPrec :: ReadPrec [SmallArray a]

KnownNat n => Read (Unsigned n)

None of the Read class' methods are synthesisable.

Defined in Clash.Sized.Internal.Unsigned

Methods

readsPrec :: Int -> ReadS (Unsigned n)

readList :: ReadS [Unsigned n]

readPrec :: ReadPrec (Unsigned n)

readListPrec :: ReadPrec [Unsigned n]

KnownNat n => Read (Signed n)

None of the Read class' methods are synthesisable.

Defined in Clash.Sized.Internal.Signed

Methods

readsPrec :: Int -> ReadS (Signed n)

readList :: ReadS [Signed n]

readPrec :: ReadPrec (Signed n)

readListPrec :: ReadPrec [Signed n]

a => Read (Dict a)

Defined in Data.Constraint

Methods

readsPrec :: Int -> ReadS (Dict a)

readList :: ReadS [Dict a]

readPrec :: ReadPrec (Dict a)

readListPrec :: ReadPrec [Dict a]

(Read a) :=> (Read (Complex a))

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Complex a)

(Read a) :=> (Read [a])

Defined in Data.Constraint

Methods

ins :: Read a :- Read [a]

(Read a) :=> (Read (Maybe a))

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Maybe a)

(Read a) :=> (Read (Identity a))

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Identity a)

(Read a) :=> (Read (Const a b))

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Const a b)

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

Defined in Data.Either

Methods

readsPrec :: Int -> ReadS (Either a b)

readList :: ReadS [Either a b]

readPrec :: ReadPrec (Either a b)

readListPrec :: ReadPrec [Either a b]

Read (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS (V1 p)

readList :: ReadS [V1 p]

readPrec :: ReadPrec (V1 p)

readListPrec :: ReadPrec [V1 p]

Read (U1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS (U1 p)

readList :: ReadS [U1 p]

readPrec :: ReadPrec (U1 p)

readListPrec :: ReadPrec [U1 p]

(Read a, Read b) => Read (a, b)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b)

readList :: ReadS [(a, b)]

readPrec :: ReadPrec (a, b)

readListPrec :: ReadPrec [(a, b)]

(Ix a, Read a, Read b) => Read (Array a b)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (Array a b)

readList :: ReadS [Array a b]

readPrec :: ReadPrec (Array a b)

readListPrec :: ReadPrec [Array a b]

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

Defined in Data.Semigroup

Methods

readsPrec :: Int -> ReadS (Arg a b)

readList :: ReadS [Arg a b]

readPrec :: ReadPrec (Arg a b)

readListPrec :: ReadPrec [Arg a b]

Read (Proxy t)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

readsPrec :: Int -> ReadS (Proxy t)

readList :: ReadS [Proxy t]

readPrec :: ReadPrec (Proxy t)

readListPrec :: ReadPrec [Proxy t]

(Ord k, Read k, Read e) => Read (Map k e)

Defined in Data.Map.Internal

Methods

readsPrec :: Int -> ReadS (Map k e)

readList :: ReadS [Map k e]

readPrec :: ReadPrec (Map k e)

readListPrec :: ReadPrec [Map k e]

(Read i, Read a) => Read (Level i a)

Defined in Control.Lens.Internal.Level

Methods

readsPrec :: Int -> ReadS (Level i a)

readList :: ReadS [Level i a]

readPrec :: ReadPrec (Level i a)

readListPrec :: ReadPrec [Level i a]

(Read1 f, Read a) => Read (Cofree f a)

Defined in Control.Comonad.Cofree

Methods

readsPrec :: Int -> ReadS (Cofree f a)

readList :: ReadS [Cofree f a]

readPrec :: ReadPrec (Cofree f a)

readListPrec :: ReadPrec [Cofree f a]

(Read1 f, Read a) => Read (Free f a)

Defined in Control.Monad.Free

Methods

readsPrec :: Int -> ReadS (Free f a)

readList :: ReadS [Free f a]

readPrec :: ReadPrec (Free f a)

readListPrec :: ReadPrec [Free f a]

(Functor f, Read (f a)) => Read (Yoneda f a)

Defined in Data.Functor.Yoneda

Methods

readsPrec :: Int -> ReadS (Yoneda f a)

readList :: ReadS [Yoneda f a]

readPrec :: ReadPrec (Yoneda f a)

readListPrec :: ReadPrec [Yoneda f a]

(Eq k, Hashable k, Read k, Read e) => Read (HashMap k e)

Defined in Data.HashMap.Base

Methods

readsPrec :: Int -> ReadS (HashMap k e)

readList :: ReadS [HashMap k e]

readPrec :: ReadPrec (HashMap k e)

readListPrec :: ReadPrec [HashMap k e]

(Integral a, Read a) :=> (Read (Ratio a))

Defined in Data.Constraint

Methods

ins :: (Integral a, Read a) :- Read (Ratio a)

(Read a, Read b) :=> (Read (a, b))

Defined in Data.Constraint

Methods

ins :: (Read a, Read b) :- Read (a, b)

(Read a, Read b) :=> (Read (Either a b))

Defined in Data.Constraint

Methods

ins :: (Read a, Read b) :- Read (Either a b)

Read (f p) => Read (Rec1 f p)

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS (Rec1 f p)

readList :: ReadS [Rec1 f p]

readPrec :: ReadPrec (Rec1 f p)

readListPrec :: ReadPrec [Rec1 f p]

(Read a, Read b, Read c) => Read (a, b, c)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c)

readList :: ReadS [(a, b, c)]

readPrec :: ReadPrec (a, b, c)

readListPrec :: ReadPrec [(a, b, c)]

Read a => Read (Const a b)

This instance would be equivalent to the derived instances of the Const newtype if the runConst field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Const

Methods

readsPrec :: Int -> ReadS (Const a b)

readList :: ReadS [Const a b]

readPrec :: ReadPrec (Const a b)

readListPrec :: ReadPrec [Const a b]

Read (f a) => Read (Alt f a)

Defined in Data.Semigroup.Internal

Methods

readsPrec :: Int -> ReadS (Alt f a)

readList :: ReadS [Alt f a]

readPrec :: ReadPrec (Alt f a)

readListPrec :: ReadPrec [Alt f a]

a ~ b => Read (a :~: b)

Since: base-4.7.0.0

Defined in Data.Type.Equality

Methods

readsPrec :: Int -> ReadS (a :~: b)

readList :: ReadS [a :~: b]

readPrec :: ReadPrec (a :~: b)

readListPrec :: ReadPrec [a :~: b]

(Read e, Read1 m, Read a) => Read (ErrorT e m a)

Defined in Control.Monad.Trans.Error

Methods

readsPrec :: Int -> ReadS (ErrorT e m a)

readList :: ReadS [ErrorT e m a]

readPrec :: ReadPrec (ErrorT e m a)

readListPrec :: ReadPrec [ErrorT e m a]

Read a => Read (Constant a b)

Defined in Data.Functor.Constant

Methods

readsPrec :: Int -> ReadS (Constant a b)

readList :: ReadS [Constant a b]

readPrec :: ReadPrec (Constant a b)

readListPrec :: ReadPrec [Constant a b]

Read b => Read (Tagged s b)

Defined in Data.Tagged

Methods

readsPrec :: Int -> ReadS (Tagged s b)

readList :: ReadS [Tagged s b]

readPrec :: ReadPrec (Tagged s b)

readListPrec :: ReadPrec [Tagged s b]

Read (p (Fix p a) a) => Read (Fix p a)

Defined in Data.Bifunctor.Fix

Methods

readsPrec :: Int -> ReadS (Fix p a)

readList :: ReadS [Fix p a]

readPrec :: ReadPrec (Fix p a)

readListPrec :: ReadPrec [Fix p a]

Read (p a a) => Read (Join p a)

Defined in Data.Bifunctor.Join

Methods

readsPrec :: Int -> ReadS (Join p a)

readList :: ReadS [Join p a]

readPrec :: ReadPrec (Join p a)

readListPrec :: ReadPrec [Join p a]

(Read a, Read (f b)) => Read (CofreeF f a b)

Defined in Control.Comonad.Trans.Cofree

Methods

readsPrec :: Int -> ReadS (CofreeF f a b)

readList :: ReadS [CofreeF f a b]

readPrec :: ReadPrec (CofreeF f a b)

readListPrec :: ReadPrec [CofreeF f a b]

Read (w (CofreeF f a (CofreeT f w a))) => Read (CofreeT f w a)

Defined in Control.Comonad.Trans.Cofree

Methods

readsPrec :: Int -> ReadS (CofreeT f w a)

readList :: ReadS [CofreeT f w a]

readPrec :: ReadPrec (CofreeT f w a)

readListPrec :: ReadPrec [CofreeT f w a]

(Read1 f, Read1 m, Read a) => Read (FreeT f m a)

Defined in Control.Monad.Trans.Free

Methods

readsPrec :: Int -> ReadS (FreeT f m a)

readList :: ReadS [FreeT f m a]

readPrec :: ReadPrec (FreeT f m a)

readListPrec :: ReadPrec [FreeT f m a]

(Read a, Read (f b)) => Read (FreeF f a b)

Defined in Control.Monad.Trans.Free

Methods

readsPrec :: Int -> ReadS (FreeF f a b)

readList :: ReadS [FreeF f a b]

readPrec :: ReadPrec (FreeF f a b)

readListPrec :: ReadPrec [FreeF f a b]

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

None of the Read class' methods are synthesisable.

Defined in Clash.Sized.Fixed

Methods

readsPrec :: Int -> ReadS (Fixed rep int frac)

readList :: ReadS [Fixed rep int frac]

readPrec :: ReadPrec (Fixed rep int frac)

readListPrec :: ReadPrec [Fixed rep int frac]

Read c => Read (K1 i c p)

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS (K1 i c p)

readList :: ReadS [K1 i c p]

readPrec :: ReadPrec (K1 i c p)

readListPrec :: ReadPrec [K1 i c p]

(Read (f p), Read (g p)) => Read ((f :+: g) p)

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS ((f :+: g) p)

readList :: ReadS [(f :+: g) p]

readPrec :: ReadPrec ((f :+: g) p)

readListPrec :: ReadPrec [(f :+: g) p]

(Read (f p), Read (g p)) => Read ((f :*: g) p)

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS ((f :*: g) p)

readList :: ReadS [(f :*: g) p]

readPrec :: ReadPrec ((f :*: g) p)

readListPrec :: ReadPrec [(f :*: g) p]

(Read a, Read b, Read c, Read d) => Read (a, b, c, d)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d)

readList :: ReadS [(a, b, c, d)]

readPrec :: ReadPrec (a, b, c, d)

readListPrec :: ReadPrec [(a, b, c, d)]

(Read1 f, Read1 g, Read a) => Read (Product f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

readsPrec :: Int -> ReadS (Product f g a)

readList :: ReadS [Product f g a]

readPrec :: ReadPrec (Product f g a)

readListPrec :: ReadPrec [Product f g a]

(Read1 f, Read1 g, Read a) => Read (Sum f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

readsPrec :: Int -> ReadS (Sum f g a)

readList :: ReadS [Sum f g a]

readPrec :: ReadPrec (Sum f g a)

readListPrec :: ReadPrec [Sum f g a]

a ~~ b => Read (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

readsPrec :: Int -> ReadS (a :~~: b)

readList :: ReadS [a :~~: b]

readPrec :: ReadPrec (a :~~: b)

readListPrec :: ReadPrec [a :~~: b]

Read (f p) => Read (M1 i c f p)

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS (M1 i c f p)

readList :: ReadS [M1 i c f p]

readPrec :: ReadPrec (M1 i c f p)

readListPrec :: ReadPrec [M1 i c f p]

Read (f (g p)) => Read ((f :.: g) p)

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS ((f :.: g) p)

readList :: ReadS [(f :.: g) p]

readPrec :: ReadPrec ((f :.: g) p)

readListPrec :: ReadPrec [(f :.: g) p]

(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e)

readList :: ReadS [(a, b, c, d, e)]

readPrec :: ReadPrec (a, b, c, d, e)

readListPrec :: ReadPrec [(a, b, c, d, e)]

(Read1 f, Read1 g, Read a) => Read (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

readsPrec :: Int -> ReadS (Compose f g a)

readList :: ReadS [Compose f g a]

readPrec :: ReadPrec (Compose f g a)

readListPrec :: ReadPrec [Compose f g a]

Read (f a) => Read (Clown f a b)

Defined in Data.Bifunctor.Clown

Methods

readsPrec :: Int -> ReadS (Clown f a b)

readList :: ReadS [Clown f a b]

readPrec :: ReadPrec (Clown f a b)

readListPrec :: ReadPrec [Clown f a b]

Read (p b a) => Read (Flip p a b)

Defined in Data.Bifunctor.Flip

Methods

readsPrec :: Int -> ReadS (Flip p a b)

readList :: ReadS [Flip p a b]

readPrec :: ReadPrec (Flip p a b)

readListPrec :: ReadPrec [Flip p a b]

Read (g b) => Read (Joker g a b)

Defined in Data.Bifunctor.Joker

Methods

readsPrec :: Int -> ReadS (Joker g a b)

readList :: ReadS [Joker g a b]

readPrec :: ReadPrec (Joker g a b)

readListPrec :: ReadPrec [Joker g a b]

Read (p a b) => Read (WrappedBifunctor p a b)

Defined in Data.Bifunctor.Wrapped

Methods

readsPrec :: Int -> ReadS (WrappedBifunctor p a b)

readList :: ReadS [WrappedBifunctor p a b]

readPrec :: ReadPrec (WrappedBifunctor p a b)

readListPrec :: ReadPrec [WrappedBifunctor p a b]

(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f)

readList :: ReadS [(a, b, c, d, e, f)]

readPrec :: ReadPrec (a, b, c, d, e, f)

readListPrec :: ReadPrec [(a, b, c, d, e, f)]

(Read (f a b), Read (g a b)) => Read (Product f g a b)

Defined in Data.Bifunctor.Product

Methods

readsPrec :: Int -> ReadS (Product f g a b)

readList :: ReadS [Product f g a b]

readPrec :: ReadPrec (Product f g a b)

readListPrec :: ReadPrec [Product f g a b]

(Read (p a b), Read (q a b)) => Read (Sum p q a b)

Defined in Data.Bifunctor.Sum

Methods

readsPrec :: Int -> ReadS (Sum p q a b)

readList :: ReadS [Sum p q a b]

readPrec :: ReadPrec (Sum p q a b)

readListPrec :: ReadPrec [Sum p q a b]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g)

readList :: ReadS [(a, b, c, d, e, f, g)]

readPrec :: ReadPrec (a, b, c, d, e, f, g)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g)]

Read (f (p a b)) => Read (Tannen f p a b)

Defined in Data.Bifunctor.Tannen

Methods

readsPrec :: Int -> ReadS (Tannen f p a b)

readList :: ReadS [Tannen f p a b]

readPrec :: ReadPrec (Tannen f p a b)

readListPrec :: ReadPrec [Tannen f p a b]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h)

readList :: ReadS [(a, b, c, d, e, f, g, h)]

readPrec :: ReadPrec (a, b, c, d, e, f, g, h)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h)]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i)

readList :: ReadS [(a, b, c, d, e, f, g, h, i)]

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i)]

Read (p (f a) (g b)) => Read (Biff p f g a b)

Defined in Data.Bifunctor.Biff

Methods

readsPrec :: Int -> ReadS (Biff p f g a b)

readList :: ReadS [Biff p f g a b]

readPrec :: ReadPrec (Biff p f g a b)

readListPrec :: ReadPrec [Biff p f g a b]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j)

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j)]

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j)]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k)

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k)]

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l)

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)]

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m)

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)]

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]

class (Num a, Ord a) => Real a where

Minimal complete definition

toRational

Methods

toRational :: a -> Rational

the rational equivalent of its real argument with full precision

Instances

Real Int

Since: base-2.0.1

Defined in GHC.Real

Methods

toRational :: Int -> Rational

Real Int8

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int8 -> Rational

Real Int16

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int16 -> Rational

Real Int32

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int32 -> Rational

Real Int64

Since: base-2.1

Defined in GHC.Int

Methods

toRational :: Int64 -> Rational

Real Integer

Since: base-2.0.1

Defined in GHC.Real

Methods

toRational :: Integer -> Rational

Real Natural

Since: base-4.8.0.0

Defined in GHC.Natural

Methods

toRational :: Natural -> Rational

Real Word

Since: base-2.1

Defined in GHC.Real

Methods

toRational :: Word -> Rational

Real Word8

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word8 -> Rational

Real Word16

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word16 -> Rational

Real Word32

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word32 -> Rational

Real Word64

Since: base-2.1

Defined in GHC.Word

Methods

toRational :: Word64 -> Rational

Real CChar

Defined in Foreign.C.Types

Methods

toRational :: CChar -> Rational

Real CSChar

Defined in Foreign.C.Types

Methods

toRational :: CSChar -> Rational

Real CUChar

Defined in Foreign.C.Types

Methods

toRational :: CUChar -> Rational

Real CShort

Defined in Foreign.C.Types

Methods

toRational :: CShort -> Rational

Real CUShort

Defined in Foreign.C.Types

Methods

toRational :: CUShort -> Rational

Real CInt

Defined in Foreign.C.Types

Methods

toRational :: CInt -> Rational

Real CUInt

Defined in Foreign.C.Types

Methods

toRational :: CUInt -> Rational

Real CLong

Defined in Foreign.C.Types

Methods

toRational :: CLong -> Rational

Real CULong

Defined in Foreign.C.Types

Methods

toRational :: CULong -> Rational

Real CLLong

Defined in Foreign.C.Types

Methods

toRational :: CLLong -> Rational

Real CULLong

Defined in Foreign.C.Types

Methods

toRational :: CULLong -> Rational

Real CBool

Defined in Foreign.C.Types

Methods

toRational :: CBool -> Rational

Real CFloat

Defined in Foreign.C.Types

Methods

toRational :: CFloat -> Rational

Real CDouble

Defined in Foreign.C.Types

Methods

toRational :: CDouble -> Rational

Real CPtrdiff

Defined in Foreign.C.Types

Methods

toRational :: CPtrdiff -> Rational

Real CSize

Defined in Foreign.C.Types

Methods

toRational :: CSize -> Rational

Real CWchar

Defined in Foreign.C.Types

Methods

toRational :: CWchar -> Rational

Real CSigAtomic

Defined in Foreign.C.Types

Methods

toRational :: CSigAtomic -> Rational

Real CClock

Defined in Foreign.C.Types

Methods

toRational :: CClock -> Rational

Real CTime

Defined in Foreign.C.Types

Methods

toRational :: CTime -> Rational

Real CUSeconds

Defined in Foreign.C.Types

Methods

toRational :: CUSeconds -> Rational

Real CSUSeconds

Defined in Foreign.C.Types

Methods

toRational :: CSUSeconds -> Rational

Real CIntPtr

Defined in Foreign.C.Types

Methods

toRational :: CIntPtr -> Rational

Real CUIntPtr

Defined in Foreign.C.Types

Methods

toRational :: CUIntPtr -> Rational

Real CIntMax

Defined in Foreign.C.Types

Methods

toRational :: CIntMax -> Rational

Real CUIntMax

Defined in Foreign.C.Types

Methods

toRational :: CUIntMax -> Rational

Real Bit

Defined in Clash.Sized.Internal.BitVector

Methods

toRational :: Bit -> Rational

Real Half

Defined in Numeric.Half

Methods

toRational :: Half -> Rational

() :=> (Real Double)

Defined in Data.Constraint

Methods

ins :: () :- Real Double

() :=> (Real Float)

Defined in Data.Constraint

Methods

ins :: () :- Real Float

() :=> (Real Int)

Defined in Data.Constraint

Methods

ins :: () :- Real Int

() :=> (Real Integer)

Defined in Data.Constraint

Methods

ins :: () :- Real Integer

() :=> (Real Natural)

Defined in Data.Constraint

Methods

ins :: () :- Real Natural

() :=> (Real Word)

Defined in Data.Constraint

Methods

ins :: () :- Real Word

Integral a => Real (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

toRational :: Ratio a -> Rational

HasResolution a => Real (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

toRational :: Fixed a -> Rational

Real a => Real (Identity a)

Defined in Data.Functor.Identity

Methods

toRational :: Identity a -> Rational

KnownNat n => Real (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

toRational :: BitVector n -> Rational

KnownNat n => Real (Index n)

Defined in Clash.Sized.Internal.Index

Methods

toRational :: Index n -> Rational

Real a => Real (Bounds a)

Defined in Test.QuickCheck.Arbitrary

Methods

toRational :: Bounds a -> Rational

KnownNat n => Real (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

toRational :: Unsigned n -> Rational

KnownNat n => Real (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

toRational :: Signed n -> Rational

(Integral a) :=> (Real (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- Real (Ratio a)

(Real a) :=> (Real (Identity a))

Defined in Data.Constraint

Methods

ins :: Real a :- Real (Identity a)

(Real a) :=> (Real (Const a b))

Defined in Data.Constraint

Methods

ins :: Real a :- Real (Const a b)

Class (Num a, Ord a) (Real a)

Defined in Data.Constraint

Methods

cls :: Real a :- (Num a, Ord a)

Class (Real a, Fractional a) (RealFrac a)

Defined in Data.Constraint

Methods

cls :: RealFrac a :- (Real a, Fractional a)

Class (Real a, Enum a) (Integral a)

Defined in Data.Constraint

Methods

cls :: Integral a :- (Real a, Enum a)

Real a => Real (Const a b)

Defined in Data.Functor.Const

Methods

toRational :: Const a b -> Rational

Real a => Real (Tagged s a)

Defined in Data.Tagged

Methods

toRational :: Tagged s a -> Rational

(NumFixedC rep int frac, Integral (rep (int + frac))) => Real (Fixed rep int frac)

Defined in Clash.Sized.Fixed

Methods

toRational :: Fixed rep int frac -> Rational

class (RealFrac a, Floating a) => RealFloat a where

Efficient, machine-independent access to the components of a floating-point number.

Minimal complete definition

floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE

Methods

floatRadix :: a -> Integer

a constant function, returning the radix of the representation (often 2)

floatDigits :: a -> Int

a constant function, returning the number of digits of floatRadix in the significand

floatRange :: a -> (Int, Int)

a constant function, returning the lowest and highest values the exponent may assume

decodeFloat :: a -> (Integer, Int)

The function decodeFloat applied to a real floating-point number returns the significand expressed as an Integer and an appropriately scaled exponent (an Int). If decodeFloat x yields (m,n), then x is equal in value to m*b^^n, where b is the floating-point radix, and furthermore, either m and n are both zero or else b^(d-1) <= abs m < b^d, where d is the value of floatDigits x. In particular, decodeFloat 0 = (0,0). If the type contains a negative zero, also decodeFloat (-0.0) = (0,0). The result of decodeFloat x is unspecified if either of isNaN x or isInfinite x is True.

encodeFloat :: Integer -> Int -> a

encodeFloat performs the inverse of decodeFloat in the sense that for finite x with the exception of -0.0, uncurry encodeFloat (decodeFloat x) = x. encodeFloat m n is one of the two closest representable floating-point numbers to m*b^^n (or ±Infinity if overflow occurs); usually the closer, but if m contains too many bits, the result may be rounded in the wrong direction.

exponent :: a -> Int

exponent corresponds to the second component of decodeFloat. exponent 0 = 0 and for finite nonzero x, exponent x = snd (decodeFloat x) + floatDigits x. If x is a finite floating-point number, it is equal in value to significand x * b ^^ exponent x, where b is the floating-point radix. The behaviour is unspecified on infinite or NaN values.

significand :: a -> a

The first component of decodeFloat, scaled to lie in the open interval (-1,1), either 0.0 or of absolute value >= 1/b, where b is the floating-point radix. The behaviour is unspecified on infinite or NaN values.

scaleFloat :: Int -> a -> a

multiplies a floating-point number by an integer power of the radix

isNaN :: a -> Bool

True if the argument is an IEEE "not-a-number" (NaN) value

isInfinite :: a -> Bool

True if the argument is an IEEE infinity or negative infinity

isDenormalized :: a -> Bool

True if the argument is too small to be represented in normalized format

isNegativeZero :: a -> Bool

True if the argument is an IEEE negative zero

isIEEE :: a -> Bool

True if the argument is an IEEE floating point number

atan2 :: a -> a -> a

a version of arctangent taking two real floating-point arguments. For real floating x and y, atan2 y x computes the angle (from the positive x-axis) of the vector from the origin to the point (x,y). atan2 y x returns a value in the range [-pi, pi]. It follows the Common Lisp semantics for the origin when signed zeroes are supported. atan2 y 1, with y in a type that is RealFloat, should return the same value as atan y. A default definition of atan2 is provided, but implementors can provide a more accurate implementation.

Instances

RealFloat Double

Since: base-2.1

Defined in GHC.Float

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

RealFloat Float

Since: base-2.1

Defined in GHC.Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

RealFloat CFloat

Defined in Foreign.C.Types

Methods

floatRadix :: CFloat -> Integer

floatDigits :: CFloat -> Int

floatRange :: CFloat -> (Int, Int)

decodeFloat :: CFloat -> (Integer, Int)

encodeFloat :: Integer -> Int -> CFloat

exponent :: CFloat -> Int

significand :: CFloat -> CFloat

scaleFloat :: Int -> CFloat -> CFloat

isNaN :: CFloat -> Bool

isInfinite :: CFloat -> Bool

isDenormalized :: CFloat -> Bool

isNegativeZero :: CFloat -> Bool

isIEEE :: CFloat -> Bool

atan2 :: CFloat -> CFloat -> CFloat

RealFloat CDouble

Defined in Foreign.C.Types

Methods

floatRadix :: CDouble -> Integer

floatDigits :: CDouble -> Int

floatRange :: CDouble -> (Int, Int)

decodeFloat :: CDouble -> (Integer, Int)

encodeFloat :: Integer -> Int -> CDouble

exponent :: CDouble -> Int

significand :: CDouble -> CDouble

scaleFloat :: Int -> CDouble -> CDouble

isNaN :: CDouble -> Bool

isInfinite :: CDouble -> Bool

isDenormalized :: CDouble -> Bool

isNegativeZero :: CDouble -> Bool

isIEEE :: CDouble -> Bool

atan2 :: CDouble -> CDouble -> CDouble

RealFloat Half

Defined in Numeric.Half

Methods

floatRadix :: Half -> Integer

floatDigits :: Half -> Int

floatRange :: Half -> (Int, Int)

decodeFloat :: Half -> (Integer, Int)

encodeFloat :: Integer -> Int -> Half

exponent :: Half -> Int

significand :: Half -> Half

scaleFloat :: Int -> Half -> Half

isNaN :: Half -> Bool

isInfinite :: Half -> Bool

isDenormalized :: Half -> Bool

isNegativeZero :: Half -> Bool

isIEEE :: Half -> Bool

atan2 :: Half -> Half -> Half

() :=> (RealFloat Double)

Defined in Data.Constraint

Methods

ins :: () :- RealFloat Double

() :=> (RealFloat Float)

Defined in Data.Constraint

Methods

ins :: () :- RealFloat Float

RealFloat a => RealFloat (Identity a)

Defined in Data.Functor.Identity

Methods

floatRadix :: Identity a -> Integer

floatDigits :: Identity a -> Int

floatRange :: Identity a -> (Int, Int)

decodeFloat :: Identity a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Identity a

exponent :: Identity a -> Int

significand :: Identity a -> Identity a

scaleFloat :: Int -> Identity a -> Identity a

isNaN :: Identity a -> Bool

isInfinite :: Identity a -> Bool

isDenormalized :: Identity a -> Bool

isNegativeZero :: Identity a -> Bool

isIEEE :: Identity a -> Bool

atan2 :: Identity a -> Identity a -> Identity a

(RealFloat a) :=> (RealFloat (Identity a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- RealFloat (Identity a)

(RealFloat a) :=> (RealFloat (Const a b))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- RealFloat (Const a b)

(RealFloat a) :=> (Num (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Num (Complex a)

(RealFloat a) :=> (Fractional (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Fractional (Complex a)

(RealFloat a) :=> (Floating (Complex a))

Defined in Data.Constraint

Methods

ins :: RealFloat a :- Floating (Complex a)

Class (RealFrac a, Floating a) (RealFloat a)

Defined in Data.Constraint

Methods

cls :: RealFloat a :- (RealFrac a, Floating a)

RealFloat a => RealFloat (Const a b)

Defined in Data.Functor.Const

Methods

floatRadix :: Const a b -> Integer

floatDigits :: Const a b -> Int

floatRange :: Const a b -> (Int, Int)

decodeFloat :: Const a b -> (Integer, Int)

encodeFloat :: Integer -> Int -> Const a b

exponent :: Const a b -> Int

significand :: Const a b -> Const a b

scaleFloat :: Int -> Const a b -> Const a b

isNaN :: Const a b -> Bool

isInfinite :: Const a b -> Bool

isDenormalized :: Const a b -> Bool

isNegativeZero :: Const a b -> Bool

isIEEE :: Const a b -> Bool

atan2 :: Const a b -> Const a b -> Const a b

RealFloat a => RealFloat (Tagged s a)

Defined in Data.Tagged

Methods

floatRadix :: Tagged s a -> Integer

floatDigits :: Tagged s a -> Int

floatRange :: Tagged s a -> (Int, Int)

decodeFloat :: Tagged s a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Tagged s a

exponent :: Tagged s a -> Int

significand :: Tagged s a -> Tagged s a

scaleFloat :: Int -> Tagged s a -> Tagged s a

isNaN :: Tagged s a -> Bool

isInfinite :: Tagged s a -> Bool

isDenormalized :: Tagged s a -> Bool

isNegativeZero :: Tagged s a -> Bool

isIEEE :: Tagged s a -> Bool

atan2 :: Tagged s a -> Tagged s a -> Tagged s a

class (Real a, Fractional a) => RealFrac a where

Extracting components of fractions.

Minimal complete definition

properFraction

Methods

properFraction :: Integral b => a -> (b, a)

The function properFraction takes a real fractional number x and returns a pair (n,f) such that x = n+f, and:

• n is an integral number with the same sign as x; and
• f is a fraction with the same type and sign as x, and with absolute value less than 1.

The default definitions of the ceiling, floor, truncate and round functions are in terms of properFraction.

truncate :: Integral b => a -> b

truncate x returns the integer nearest x between zero and x

round :: Integral b => a -> b

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

ceiling :: Integral b => a -> b

ceiling x returns the least integer not less than x

floor :: Integral b => a -> b

floor x returns the greatest integer not greater than x

Instances

RealFrac CFloat

Defined in Foreign.C.Types

Methods

properFraction :: Integral b => CFloat -> (b, CFloat)

truncate :: Integral b => CFloat -> b

round :: Integral b => CFloat -> b

ceiling :: Integral b => CFloat -> b

floor :: Integral b => CFloat -> b

RealFrac CDouble

Defined in Foreign.C.Types

Methods

properFraction :: Integral b => CDouble -> (b, CDouble)

truncate :: Integral b => CDouble -> b

round :: Integral b => CDouble -> b

ceiling :: Integral b => CDouble -> b

floor :: Integral b => CDouble -> b

RealFrac Half

Defined in Numeric.Half

Methods

properFraction :: Integral b => Half -> (b, Half)

truncate :: Integral b => Half -> b

round :: Integral b => Half -> b

ceiling :: Integral b => Half -> b

floor :: Integral b => Half -> b

() :=> (RealFrac Double)

Defined in Data.Constraint

Methods

ins :: () :- RealFrac Double

() :=> (RealFrac Float)

Defined in Data.Constraint

Methods

ins :: () :- RealFrac Float

Integral a => RealFrac (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

properFraction :: Integral b => Ratio a -> (b, Ratio a)

truncate :: Integral b => Ratio a -> b

round :: Integral b => Ratio a -> b

ceiling :: Integral b => Ratio a -> b

floor :: Integral b => Ratio a -> b

HasResolution a => RealFrac (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

properFraction :: Integral b => Fixed a -> (b, Fixed a)

truncate :: Integral b => Fixed a -> b

round :: Integral b => Fixed a -> b

ceiling :: Integral b => Fixed a -> b

floor :: Integral b => Fixed a -> b

RealFrac a => RealFrac (Identity a)

Defined in Data.Functor.Identity

Methods

properFraction :: Integral b => Identity a -> (b, Identity a)

truncate :: Integral b => Identity a -> b

round :: Integral b => Identity a -> b

ceiling :: Integral b => Identity a -> b

floor :: Integral b => Identity a -> b

(Integral a) :=> (RealFrac (Ratio a))

Defined in Data.Constraint

Methods

ins :: Integral a :- RealFrac (Ratio a)

(RealFrac a) :=> (RealFrac (Identity a))

Defined in Data.Constraint

Methods

ins :: RealFrac a :- RealFrac (Identity a)

(RealFrac a) :=> (RealFrac (Const a b))

Defined in Data.Constraint

Methods

ins :: RealFrac a :- RealFrac (Const a b)

Class (Real a, Fractional a) (RealFrac a)

Defined in Data.Constraint

Methods

cls :: RealFrac a :- (Real a, Fractional a)

Class (RealFrac a, Floating a) (RealFloat a)

Defined in Data.Constraint

Methods

cls :: RealFloat a :- (RealFrac a, Floating a)

RealFrac a => RealFrac (Const a b)

Defined in Data.Functor.Const

Methods

properFraction :: Integral b0 => Const a b -> (b0, Const a b)

truncate :: Integral b0 => Const a b -> b0

round :: Integral b0 => Const a b -> b0

ceiling :: Integral b0 => Const a b -> b0

floor :: Integral b0 => Const a b -> b0

RealFrac a => RealFrac (Tagged s a)

Defined in Data.Tagged

Methods

properFraction :: Integral b => Tagged s a -> (b, Tagged s a)

truncate :: Integral b => Tagged s a -> b

round :: Integral b => Tagged s a -> b

ceiling :: Integral b => Tagged s a -> b

floor :: Integral b => Tagged s a -> b

class Show a where

Conversion of values to readable Strings.

Derived instances of Show have the following properties, which are compatible with derived instances of Read:

• The result of show is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
• If the constructor is defined to be an infix operator, then showsPrec will produce infix applications of the constructor.
• the representation will be enclosed in parentheses if the precedence of the top-level constructor in x is less than d (associativity is ignored). Thus, if d is 0 then the result is never surrounded in parentheses; if d is 11 it is always surrounded in parentheses, unless it is an atomic expression.
• If the constructor is defined using record syntax, then show will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Show is equivalent to

instance (Show a) => Show (Tree a) where

       showsPrec d (Leaf m) = showParen (d > app_prec) $
            showString "Leaf " . showsPrec (app_prec+1) m
         where app_prec = 10

       showsPrec d (u :^: v) = showParen (d > up_prec) $
            showsPrec (up_prec+1) u .
            showString " :^: "      .
            showsPrec (up_prec+1) v
         where up_prec = 5

Note that right-associativity of :^: is ignored. For example,

• show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

Minimal complete definition

showsPrec | show

Methods

showsPrec

Arguments

:: Int

the operator precedence of the enclosing context (a number from 0 to 11). Function application has precedence 10.

-> a

the value to be converted to a String

-> ShowS

Convert a value to a readable String.

showsPrec should satisfy the law

showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)

Derived instances of Read and Show satisfy the following:

• (x,"") is an element of (readsPrec d (showsPrec d x "")).

That is, readsPrec parses the string produced by showsPrec, and delivers the value that showsPrec started with.

show :: a -> String

A specialised variant of showsPrec, using precedence context zero, and returning an ordinary String.

showList :: [a] -> ShowS

The method showList is provided to allow the programmer to give a specialised way of showing lists of values. For example, this is used by the predefined Show instance of the Char type, where values of type String should be shown in double quotes, rather than between square brackets.

Instances

Show Bool

Defined in GHC.Show

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Show Char

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Show Int

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Show Int8

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int8 -> ShowS

show :: Int8 -> String

showList :: [Int8] -> ShowS

Show Int16

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int16 -> ShowS

show :: Int16 -> String

showList :: [Int16] -> ShowS

Show Int32

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int32 -> ShowS

show :: Int32 -> String

showList :: [Int32] -> ShowS

Show Int64

Since: base-2.1

Defined in GHC.Int

Methods

showsPrec :: Int -> Int64 -> ShowS

show :: Int64 -> String

showList :: [Int64] -> ShowS

Show Integer

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

Show Natural

Since: base-4.8.0.0

Defined in GHC.Natural

Methods

showsPrec :: Int -> Natural -> ShowS

show :: Natural -> String

showList :: [Natural] -> ShowS

Show Ordering

Defined in GHC.Show

Methods

showsPrec :: Int -> Ordering -> ShowS

show :: Ordering -> String

showList :: [Ordering] -> ShowS

Show Word

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Show Word8

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Show Word16

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word16 -> ShowS

show :: Word16 -> String

showList :: [Word16] -> ShowS

Show Word32

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word32 -> ShowS

show :: Word32 -> String

showList :: [Word32] -> ShowS

Show Word64

Since: base-2.1

Defined in GHC.Word

Methods

showsPrec :: Int -> Word64 -> ShowS

show :: Word64 -> String

showList :: [Word64] -> ShowS

Show RuntimeRep

Defined in GHC.Show

Methods

showsPrec :: Int -> RuntimeRep -> ShowS

show :: RuntimeRep -> String

showList :: [RuntimeRep] -> ShowS

Show VecCount

Defined in GHC.Show

Methods

showsPrec :: Int -> VecCount -> ShowS

show :: VecCount -> String

showList :: [VecCount] -> ShowS

Show VecElem

Defined in GHC.Show

Methods

showsPrec :: Int -> VecElem -> ShowS

show :: VecElem -> String

showList :: [VecElem] -> ShowS

Show CallStack

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> CallStack -> ShowS

show :: CallStack -> String

showList :: [CallStack] -> ShowS

Show SomeTypeRep

Since: base-4.10.0.0

Defined in Data.Typeable.Internal

Methods

showsPrec :: Int -> SomeTypeRep -> ShowS

show :: SomeTypeRep -> String

showList :: [SomeTypeRep] -> ShowS

Show Exp

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Exp -> ShowS

show :: Exp -> String

showList :: [Exp] -> ShowS

Show Match

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Match -> ShowS

show :: Match -> String

showList :: [Match] -> ShowS

Show Clause

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Clause -> ShowS

show :: Clause -> String

showList :: [Clause] -> ShowS

Show Pat

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Pat -> ShowS

show :: Pat -> String

showList :: [Pat] -> ShowS

Show Type

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

Show Dec

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Dec -> ShowS

show :: Dec -> String

showList :: [Dec] -> ShowS

Show Name

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

Show FunDep

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> FunDep -> ShowS

show :: FunDep -> String

showList :: [FunDep] -> ShowS

Show InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> InjectivityAnn -> ShowS

show :: InjectivityAnn -> String

showList :: [InjectivityAnn] -> ShowS

Show Overlap

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Overlap -> ShowS

show :: Overlap -> String

showList :: [Overlap] -> ShowS

Show DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> DerivStrategy -> ShowS

show :: DerivStrategy -> String

showList :: [DerivStrategy] -> ShowS

Show ()

Defined in GHC.Show

Methods

showsPrec :: Int -> () -> ShowS

show :: () -> String

showList :: [()] -> ShowS

Show TyCon

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> TyCon -> ShowS

show :: TyCon -> String

showList :: [TyCon] -> ShowS

Show Module

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> Module -> ShowS

show :: Module -> String

showList :: [Module] -> ShowS

Show TrName

Since: base-4.9.0.0

Defined in GHC.Show

Methods

showsPrec :: Int -> TrName -> ShowS

show :: TrName -> String

showList :: [TrName] -> ShowS

Show KindRep

Defined in GHC.Show

Methods

showsPrec :: Int -> KindRep -> ShowS

show :: KindRep -> String

showList :: [KindRep] -> ShowS

Show TypeLitSort

Defined in GHC.Show

Methods

showsPrec :: Int -> TypeLitSort -> ShowS

show :: TypeLitSort -> String

showList :: [TypeLitSort] -> ShowS

Show Void

Since: base-4.8.0.0

Defined in Data.Void

Methods

showsPrec :: Int -> Void -> ShowS

show :: Void -> String

showList :: [Void] -> ShowS

Show DataType

Defined in Data.Data

Methods

showsPrec :: Int -> DataType -> ShowS

show :: DataType -> String

showList :: [DataType] -> ShowS

Show Constr

Since: base-4.0.0.0

Defined in Data.Data

Methods

showsPrec :: Int -> Constr -> ShowS

show :: Constr -> String

showList :: [Constr] -> ShowS

Show DataRep

Defined in Data.Data

Methods

showsPrec :: Int -> DataRep -> ShowS

show :: DataRep -> String

showList :: [DataRep] -> ShowS

Show ConstrRep

Defined in Data.Data

Methods

showsPrec :: Int -> ConstrRep -> ShowS

show :: ConstrRep -> String

showList :: [ConstrRep] -> ShowS

Show Fixity

Defined in Data.Data

Methods

showsPrec :: Int -> Fixity -> ShowS

show :: Fixity -> String

showList :: [Fixity] -> ShowS

Show Version

Defined in Data.Version

Methods

showsPrec :: Int -> Version -> ShowS

show :: Version -> String

showList :: [Version] -> ShowS

Show ThreadId

Since: base-4.2.0.0

Defined in GHC.Conc.Sync

Methods

showsPrec :: Int -> ThreadId -> ShowS

show :: ThreadId -> String

showList :: [ThreadId] -> ShowS

Show BlockReason

Defined in GHC.Conc.Sync

Methods

showsPrec :: Int -> BlockReason -> ShowS

show :: BlockReason -> String

showList :: [BlockReason] -> ShowS

Show ThreadStatus

Defined in GHC.Conc.Sync

Methods

showsPrec :: Int -> ThreadStatus -> ShowS

show :: ThreadStatus -> String

showList :: [ThreadStatus] -> ShowS

Show BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS

show :: BlockedIndefinitelyOnMVar -> String

showList :: [BlockedIndefinitelyOnMVar] -> ShowS

Show BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS

show :: BlockedIndefinitelyOnSTM -> String

showList :: [BlockedIndefinitelyOnSTM] -> ShowS

Show Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> Deadlock -> ShowS

show :: Deadlock -> String

showList :: [Deadlock] -> ShowS

Show AllocationLimitExceeded

Since: base-4.7.1.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AllocationLimitExceeded -> ShowS

show :: AllocationLimitExceeded -> String

showList :: [AllocationLimitExceeded] -> ShowS

Show CompactionFailed

Since: base-4.10.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> CompactionFailed -> ShowS

show :: CompactionFailed -> String

showList :: [CompactionFailed] -> ShowS

Show AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AssertionFailed -> ShowS

show :: AssertionFailed -> String

showList :: [AssertionFailed] -> ShowS

Show SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> SomeAsyncException -> ShowS

show :: SomeAsyncException -> String

showList :: [SomeAsyncException] -> ShowS

Show AsyncException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> AsyncException -> ShowS

show :: AsyncException -> String

showList :: [AsyncException] -> ShowS

Show ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> ArrayException -> ShowS

show :: ArrayException -> String

showList :: [ArrayException] -> ShowS

Show FixIOException

Since: base-4.11.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> FixIOException -> ShowS

show :: FixIOException -> String

showList :: [FixIOException] -> ShowS

Show ExitCode

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> ExitCode -> ShowS

show :: ExitCode -> String

showList :: [ExitCode] -> ShowS

Show IOErrorType

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> IOErrorType -> ShowS

show :: IOErrorType -> String

showList :: [IOErrorType] -> ShowS

Show MaskingState

Defined in GHC.IO

Methods

showsPrec :: Int -> MaskingState -> ShowS

show :: MaskingState -> String

showList :: [MaskingState] -> ShowS

Show IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> IOException -> ShowS

show :: IOException -> String

showList :: [IOException] -> ShowS

Show ErrorCall

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

showsPrec :: Int -> ErrorCall -> ShowS

show :: ErrorCall -> String

showList :: [ErrorCall] -> ShowS

Show ArithException

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

showsPrec :: Int -> ArithException -> ShowS

show :: ArithException -> String

showList :: [ArithException] -> ShowS

Show All

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> All -> ShowS

show :: All -> String

showList :: [All] -> ShowS

Show Any

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Any -> ShowS

show :: Any -> String

showList :: [Any] -> ShowS

Show Fixity

Defined in GHC.Generics

Methods

showsPrec :: Int -> Fixity -> ShowS

show :: Fixity -> String

showList :: [Fixity] -> ShowS

Show Associativity

Defined in GHC.Generics

Methods

showsPrec :: Int -> Associativity -> ShowS

show :: Associativity -> String

showList :: [Associativity] -> ShowS

Show SourceUnpackedness

Defined in GHC.Generics

Methods

showsPrec :: Int -> SourceUnpackedness -> ShowS

show :: SourceUnpackedness -> String

showList :: [SourceUnpackedness] -> ShowS

Show SourceStrictness

Defined in GHC.Generics

Methods

showsPrec :: Int -> SourceStrictness -> ShowS

show :: SourceStrictness -> String

showList :: [SourceStrictness] -> ShowS

Show DecidedStrictness

Defined in GHC.Generics

Methods

showsPrec :: Int -> DecidedStrictness -> ShowS

show :: DecidedStrictness -> String

showList :: [DecidedStrictness] -> ShowS

Show SomeSymbol

Since: base-4.7.0.0

Defined in GHC.TypeLits

Methods

showsPrec :: Int -> SomeSymbol -> ShowS

show :: SomeSymbol -> String

showList :: [SomeSymbol] -> ShowS

Show SomeNat

Since: base-4.7.0.0

Defined in GHC.TypeNats

Methods

showsPrec :: Int -> SomeNat -> ShowS

show :: SomeNat -> String

showList :: [SomeNat] -> ShowS

Show CChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CChar -> ShowS

show :: CChar -> String

showList :: [CChar] -> ShowS

Show CSChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSChar -> ShowS

show :: CSChar -> String

showList :: [CSChar] -> ShowS

Show CUChar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUChar -> ShowS

show :: CUChar -> String

showList :: [CUChar] -> ShowS

Show CShort

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CShort -> ShowS

show :: CShort -> String

showList :: [CShort] -> ShowS

Show CUShort

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUShort -> ShowS

show :: CUShort -> String

showList :: [CUShort] -> ShowS

Show CInt

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CInt -> ShowS

show :: CInt -> String

showList :: [CInt] -> ShowS

Show CUInt

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUInt -> ShowS

show :: CUInt -> String

showList :: [CUInt] -> ShowS

Show CLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CLong -> ShowS

show :: CLong -> String

showList :: [CLong] -> ShowS

Show CULong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CULong -> ShowS

show :: CULong -> String

showList :: [CULong] -> ShowS

Show CLLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CLLong -> ShowS

show :: CLLong -> String

showList :: [CLLong] -> ShowS

Show CULLong

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CULLong -> ShowS

show :: CULLong -> String

showList :: [CULLong] -> ShowS

Show CBool

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CBool -> ShowS

show :: CBool -> String

showList :: [CBool] -> ShowS

Show CFloat

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CFloat -> ShowS

show :: CFloat -> String

showList :: [CFloat] -> ShowS

Show CDouble

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CDouble -> ShowS

show :: CDouble -> String

showList :: [CDouble] -> ShowS

Show CPtrdiff

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CPtrdiff -> ShowS

show :: CPtrdiff -> String

showList :: [CPtrdiff] -> ShowS

Show CSize

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSize -> ShowS

show :: CSize -> String

showList :: [CSize] -> ShowS

Show CWchar

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CWchar -> ShowS

show :: CWchar -> String

showList :: [CWchar] -> ShowS

Show CSigAtomic

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSigAtomic -> ShowS

show :: CSigAtomic -> String

showList :: [CSigAtomic] -> ShowS

Show CClock

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CClock -> ShowS

show :: CClock -> String

showList :: [CClock] -> ShowS

Show CTime

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CTime -> ShowS

show :: CTime -> String

showList :: [CTime] -> ShowS

Show CUSeconds

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUSeconds -> ShowS

show :: CUSeconds -> String

showList :: [CUSeconds] -> ShowS

Show CSUSeconds

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CSUSeconds -> ShowS

show :: CSUSeconds -> String

showList :: [CSUSeconds] -> ShowS

Show CIntPtr

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CIntPtr -> ShowS

show :: CIntPtr -> String

showList :: [CIntPtr] -> ShowS

Show CUIntPtr

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUIntPtr -> ShowS

show :: CUIntPtr -> String

showList :: [CUIntPtr] -> ShowS

Show CIntMax

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CIntMax -> ShowS

show :: CIntMax -> String

showList :: [CIntMax] -> ShowS

Show CUIntMax

Defined in Foreign.C.Types

Methods

showsPrec :: Int -> CUIntMax -> ShowS

show :: CUIntMax -> String

showList :: [CUIntMax] -> ShowS

Show Fingerprint

Since: base-4.7.0.0

Defined in GHC.Fingerprint.Type

Methods

showsPrec :: Int -> Fingerprint -> ShowS

show :: Fingerprint -> String

showList :: [Fingerprint] -> ShowS

Show Lexeme

Defined in Text.Read.Lex

Methods

showsPrec :: Int -> Lexeme -> ShowS

show :: Lexeme -> String

showList :: [Lexeme] -> ShowS

Show Number

Defined in Text.Read.Lex

Methods

showsPrec :: Int -> Number -> ShowS

show :: Number -> String

showList :: [Number] -> ShowS

Show GeneralCategory

Defined in GHC.Unicode

Methods

showsPrec :: Int -> GeneralCategory -> ShowS

show :: GeneralCategory -> String

showList :: [GeneralCategory] -> ShowS

Show SomeException

Since: base-3.0

Defined in GHC.Exception

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

Show SrcLoc

Defined in GHC.Show

Methods

showsPrec :: Int -> SrcLoc -> ShowS

show :: SrcLoc -> String

showList :: [SrcLoc] -> ShowS

Show ByteString

Defined in Data.ByteString.Lazy.Internal

Methods

showsPrec :: Int -> ByteString -> ShowS

show :: ByteString -> String

showList :: [ByteString] -> ShowS

Show ByteString

Defined in Data.ByteString.Internal

Methods

showsPrec :: Int -> ByteString -> ShowS

show :: ByteString -> String

showList :: [ByteString] -> ShowS

Show IntSet

Defined in Data.IntSet.Internal

Methods

showsPrec :: Int -> IntSet -> ShowS

show :: IntSet -> String

showList :: [IntSet] -> ShowS

Show TyVarBndr

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TyVarBndr -> ShowS

show :: TyVarBndr -> String

showList :: [TyVarBndr] -> ShowS

Show Extension

Defined in GHC.LanguageExtensions.Type

Methods

showsPrec :: Int -> Extension -> ShowS

show :: Extension -> String

showList :: [Extension] -> ShowS

Show ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

showsPrec :: Int -> ForeignSrcLang -> ShowS

show :: ForeignSrcLang -> String

showList :: [ForeignSrcLang] -> ShowS

Show Doc

Defined in Text.PrettyPrint.HughesPJ

Methods

showsPrec :: Int -> Doc -> ShowS

show :: Doc -> String

showList :: [Doc] -> ShowS

Show TextDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> TextDetails -> ShowS

show :: TextDetails -> String

showList :: [TextDetails] -> ShowS

Show Style

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> Style -> ShowS

show :: Style -> String

showList :: [Style] -> ShowS

Show Mode

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> Mode -> ShowS

show :: Mode -> String

showList :: [Mode] -> ShowS

Show ModName

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> ModName -> ShowS

show :: ModName -> String

showList :: [ModName] -> ShowS

Show PkgName

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> PkgName -> ShowS

show :: PkgName -> String

showList :: [PkgName] -> ShowS

Show Module

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Module -> ShowS

show :: Module -> String

showList :: [Module] -> ShowS

Show OccName

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> OccName -> ShowS

show :: OccName -> String

showList :: [OccName] -> ShowS

Show NameFlavour

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> NameFlavour -> ShowS

show :: NameFlavour -> String

showList :: [NameFlavour] -> ShowS

Show NameSpace

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> NameSpace -> ShowS

show :: NameSpace -> String

showList :: [NameSpace] -> ShowS

Show Loc

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Loc -> ShowS

show :: Loc -> String

showList :: [Loc] -> ShowS

Show Info

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Info -> ShowS

show :: Info -> String

showList :: [Info] -> ShowS

Show ModuleInfo

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> ModuleInfo -> ShowS

show :: ModuleInfo -> String

showList :: [ModuleInfo] -> ShowS

Show Fixity

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Fixity -> ShowS

show :: Fixity -> String

showList :: [Fixity] -> ShowS

Show FixityDirection

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> FixityDirection -> ShowS

show :: FixityDirection -> String

showList :: [FixityDirection] -> ShowS

Show Lit

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Lit -> ShowS

show :: Lit -> String

showList :: [Lit] -> ShowS

Show Body

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Body -> ShowS

show :: Body -> String

showList :: [Body] -> ShowS

Show Guard

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Guard -> ShowS

show :: Guard -> String

showList :: [Guard] -> ShowS

Show Stmt

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Stmt -> ShowS

show :: Stmt -> String

showList :: [Stmt] -> ShowS

Show Range

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Range -> ShowS

show :: Range -> String

showList :: [Range] -> ShowS

Show DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> DerivClause -> ShowS

show :: DerivClause -> String

showList :: [DerivClause] -> ShowS

Show TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TypeFamilyHead -> ShowS

show :: TypeFamilyHead -> String

showList :: [TypeFamilyHead] -> ShowS

Show TySynEqn

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TySynEqn -> ShowS

show :: TySynEqn -> String

showList :: [TySynEqn] -> ShowS

Show Foreign

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Foreign -> ShowS

show :: Foreign -> String

showList :: [Foreign] -> ShowS

Show Callconv

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Callconv -> ShowS

show :: Callconv -> String

showList :: [Callconv] -> ShowS

Show Safety

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Safety -> ShowS

show :: Safety -> String

showList :: [Safety] -> ShowS

Show Pragma

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Pragma -> ShowS

show :: Pragma -> String

showList :: [Pragma] -> ShowS

Show Inline

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Inline -> ShowS

show :: Inline -> String

showList :: [Inline] -> ShowS

Show RuleMatch

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> RuleMatch -> ShowS

show :: RuleMatch -> String

showList :: [RuleMatch] -> ShowS

Show Phases

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Phases -> ShowS

show :: Phases -> String

showList :: [Phases] -> ShowS

Show RuleBndr

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> RuleBndr -> ShowS

show :: RuleBndr -> String

showList :: [RuleBndr] -> ShowS

Show AnnTarget

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> AnnTarget -> ShowS

show :: AnnTarget -> String

showList :: [AnnTarget] -> ShowS

Show SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> SourceUnpackedness -> ShowS

show :: SourceUnpackedness -> String

showList :: [SourceUnpackedness] -> ShowS

Show SourceStrictness

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> SourceStrictness -> ShowS

show :: SourceStrictness -> String

showList :: [SourceStrictness] -> ShowS

Show DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> DecidedStrictness -> ShowS

show :: DecidedStrictness -> String

showList :: [DecidedStrictness] -> ShowS

Show Con

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Con -> ShowS

show :: Con -> String

showList :: [Con] -> ShowS

Show Bang

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Bang -> ShowS

show :: Bang -> String

showList :: [Bang] -> ShowS

Show PatSynDir

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> PatSynDir -> ShowS

show :: PatSynDir -> String

showList :: [PatSynDir] -> ShowS

Show PatSynArgs

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> PatSynArgs -> ShowS

show :: PatSynArgs -> String

showList :: [PatSynArgs] -> ShowS

Show FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> FamilyResultSig -> ShowS

show :: FamilyResultSig -> String

showList :: [FamilyResultSig] -> ShowS

Show TyLit

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> TyLit -> ShowS

show :: TyLit -> String

showList :: [TyLit] -> ShowS

Show Role

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> Role -> ShowS

show :: Role -> String

showList :: [Role] -> ShowS

Show AnnLookup

Defined in Language.Haskell.TH.Syntax

Methods

showsPrec :: Int -> AnnLookup -> ShowS

show :: AnnLookup -> String

showList :: [AnnLookup] -> ShowS

Show ZonedTime

Defined in Data.Time.LocalTime.Internal.ZonedTime

Methods

showsPrec :: Int -> ZonedTime -> ShowS

show :: ZonedTime -> String

showList :: [ZonedTime] -> ShowS

Show LocalTime

Defined in Data.Time.LocalTime.Internal.LocalTime

Methods

showsPrec :: Int -> LocalTime -> ShowS

show :: LocalTime -> String

showList :: [LocalTime] -> ShowS

Show Primitive

Defined in Clash.Annotations.Primitive

Methods

showsPrec :: Int -> Primitive -> ShowS

show :: Primitive -> String

showList :: [Primitive] -> ShowS

Show HDL

Defined in Clash.Annotations.Primitive

Methods

showsPrec :: Int -> HDL -> ShowS

show :: HDL -> String

showList :: [HDL] -> ShowS

Show PortName

Defined in Clash.Annotations.TopEntity

Methods

showsPrec :: Int -> PortName -> ShowS

show :: PortName -> String

showList :: [PortName] -> ShowS

Show TopEntity

Defined in Clash.Annotations.TopEntity

Methods

showsPrec :: Int -> TopEntity -> ShowS

show :: TopEntity -> String

showList :: [TopEntity] -> ShowS

Show Bit

Defined in Clash.Sized.Internal.BitVector

Methods

showsPrec :: Int -> Bit -> ShowS

show :: Bit -> String

showList :: [Bit] -> ShowS

Show XException

Defined in Clash.XException

Methods

showsPrec :: Int -> XException -> ShowS

show :: XException -> String

showList :: [XException] -> ShowS

Show DefName

Defined in Control.Lens.Internal.FieldTH

Methods

showsPrec :: Int -> DefName -> ShowS

show :: DefName -> String

showList :: [DefName] -> ShowS

Show QCGen

Defined in Test.QuickCheck.Random

Methods

showsPrec :: Int -> QCGen -> ShowS

show :: QCGen -> String

showList :: [QCGen] -> ShowS

Show TimeLocale

Defined in System.Locale

Methods

showsPrec :: Int -> TimeLocale -> ShowS

show :: TimeLocale -> String

showList :: [TimeLocale] -> ShowS

Show DateFormatSpec

Defined in Data.Time.Format.Parse

Methods

showsPrec :: Int -> DateFormatSpec -> ShowS

show :: DateFormatSpec -> String

showList :: [DateFormatSpec] -> ShowS

Show Padding

Defined in Data.Time.Format.Parse

Methods

showsPrec :: Int -> Padding -> ShowS

show :: Padding -> String

showList :: [Padding] -> ShowS

Show ByteArray

Defined in Data.Primitive.ByteArray

Methods

showsPrec :: Int -> ByteArray -> ShowS

show :: ByteArray -> String

showList :: [ByteArray] -> ShowS

Show Addr

Defined in Data.Primitive.Types

Methods

showsPrec :: Int -> Addr -> ShowS

show :: Addr -> String

showList :: [Addr] -> ShowS

Show ConstructorInfo

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> ConstructorInfo -> ShowS

show :: ConstructorInfo -> String

showList :: [ConstructorInfo] -> ShowS

Show ConstructorVariant

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> ConstructorVariant -> ShowS

show :: ConstructorVariant -> String

showList :: [ConstructorVariant] -> ShowS

Show DatatypeInfo

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> DatatypeInfo -> ShowS

show :: DatatypeInfo -> String

showList :: [DatatypeInfo] -> ShowS

Show DatatypeVariant

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> DatatypeVariant -> ShowS

show :: DatatypeVariant -> String

showList :: [DatatypeVariant] -> ShowS

Show FieldStrictness

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> FieldStrictness -> ShowS

show :: FieldStrictness -> String

showList :: [FieldStrictness] -> ShowS

Show Strictness

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> Strictness -> ShowS

show :: Strictness -> String

showList :: [Strictness] -> ShowS

Show Unpackedness

Defined in Language.Haskell.TH.Datatype

Methods

showsPrec :: Int -> Unpackedness -> ShowS

show :: Unpackedness -> String

showList :: [Unpackedness] -> ShowS

Show Half

Defined in Numeric.Half

Methods

showsPrec :: Int -> Half -> ShowS

show :: Half -> String

showList :: [Half] -> ShowS

Show ResetKind

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> ResetKind -> ShowS

show :: ResetKind -> String

showList :: [ResetKind] -> ShowS

Show ClockKind

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> ClockKind -> ShowS

show :: ClockKind -> String

showList :: [ClockKind] -> ShowS

Show DType

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DType -> ShowS

show :: DType -> String

showList :: [DType] -> ShowS

Show DPat

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DPat -> ShowS

show :: DPat -> String

showList :: [DPat] -> ShowS

Show DTyVarBndr

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DTyVarBndr -> ShowS

show :: DTyVarBndr -> String

showList :: [DTyVarBndr] -> ShowS

Show NewOrData

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> NewOrData -> ShowS

show :: NewOrData -> String

showList :: [NewOrData] -> ShowS

Show DCon

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DCon -> ShowS

show :: DCon -> String

showList :: [DCon] -> ShowS

Show DPred

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DPred -> ShowS

show :: DPred -> String

showList :: [DPred] -> ShowS

Show DClause

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DClause -> ShowS

show :: DClause -> String

showList :: [DClause] -> ShowS

Show DExp

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DExp -> ShowS

show :: DExp -> String

showList :: [DExp] -> ShowS

Show DLetDec

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DLetDec -> ShowS

show :: DLetDec -> String

showList :: [DLetDec] -> ShowS

Show DConFields

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DConFields -> ShowS

show :: DConFields -> String

showList :: [DConFields] -> ShowS

Show DDec

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DDec -> ShowS

show :: DDec -> String

showList :: [DDec] -> ShowS

Show DDerivClause

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DDerivClause -> ShowS

show :: DDerivClause -> String

showList :: [DDerivClause] -> ShowS

Show DFamilyResultSig

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DFamilyResultSig -> ShowS

show :: DFamilyResultSig -> String

showList :: [DFamilyResultSig] -> ShowS

Show DForeign

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DForeign -> ShowS

show :: DForeign -> String

showList :: [DForeign] -> ShowS

Show DInfo

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DInfo -> ShowS

show :: DInfo -> String

showList :: [DInfo] -> ShowS

Show DMatch

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DMatch -> ShowS

show :: DMatch -> String

showList :: [DMatch] -> ShowS

Show DPatSynDir

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DPatSynDir -> ShowS

show :: DPatSynDir -> String

showList :: [DPatSynDir] -> ShowS

Show DPragma

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DPragma -> ShowS

show :: DPragma -> String

showList :: [DPragma] -> ShowS

Show DRuleBndr

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DRuleBndr -> ShowS

show :: DRuleBndr -> String

showList :: [DRuleBndr] -> ShowS

Show DTySynEqn

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DTySynEqn -> ShowS

show :: DTySynEqn -> String

showList :: [DTySynEqn] -> ShowS

Show DTypeFamilyHead

Defined in Language.Haskell.TH.Desugar.Core

Methods

showsPrec :: Int -> DTypeFamilyHead -> ShowS

show :: DTypeFamilyHead -> String

showList :: [DTypeFamilyHead] -> ShowS

() :=> (Show Bool)

Defined in Data.Constraint

Methods

ins :: () :- Show Bool

() :=> (Show Char)

Defined in Data.Constraint

Methods

ins :: () :- Show Char

() :=> (Show Int)

Defined in Data.Constraint

Methods

ins :: () :- Show Int

() :=> (Show Natural)

Defined in Data.Constraint

Methods

ins :: () :- Show Natural

() :=> (Show Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Show Ordering

() :=> (Show Word)

Defined in Data.Constraint

Methods

ins :: () :- Show Word

() :=> (Show ())

Defined in Data.Constraint

Methods

ins :: () :- Show ()

() :=> (Show (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Show (a :- b)

() :=> (Show (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Show (Dict a)

Class () (Show a)

Defined in Data.Constraint

Methods

cls :: Show a :- ()

Show a => Show [a]

Since: base-2.1

Defined in GHC.Show

Methods

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

show :: [a] -> String

showList :: [[a]] -> ShowS

Show a => Show (Maybe a)

Defined in GHC.Show

Methods

showsPrec :: Int -> Maybe a -> ShowS

show :: Maybe a -> String

showList :: [Maybe a] -> ShowS

Show a => Show (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

Methods

showsPrec :: Int -> Ratio a -> ShowS

show :: Ratio a -> String

showList :: [Ratio a] -> ShowS

Show (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Show (FunPtr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> FunPtr a -> ShowS

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

Show p => Show (Par1 p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> Par1 p -> ShowS

show :: Par1 p -> String

showList :: [Par1 p] -> ShowS

Show a => Show (Complex a)

Defined in Data.Complex

Methods

showsPrec :: Int -> Complex a -> ShowS

show :: Complex a -> String

showList :: [Complex a] -> ShowS

HasResolution a => Show (Fixed a)

Since: base-2.1

Defined in Data.Fixed

Methods

showsPrec :: Int -> Fixed a -> ShowS

show :: Fixed a -> String

showList :: [Fixed a] -> ShowS

Show a => Show (Min a)

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Min a -> ShowS

show :: Min a -> String

showList :: [Min a] -> ShowS

Show a => Show (Max a)

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Max a -> ShowS

show :: Max a -> String

showList :: [Max a] -> ShowS

Show a => Show (First a)

Defined in Data.Semigroup

Methods

showsPrec :: Int -> First a -> ShowS

show :: First a -> String

showList :: [First a] -> ShowS

Show a => Show (Last a)

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Last a -> ShowS

show :: Last a -> String

showList :: [Last a] -> ShowS

Show m => Show (WrappedMonoid m)

Defined in Data.Semigroup

Methods

showsPrec :: Int -> WrappedMonoid m -> ShowS

show :: WrappedMonoid m -> String

showList :: [WrappedMonoid m] -> ShowS

Show a => Show (Option a)

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Option a -> ShowS

show :: Option a -> String

showList :: [Option a] -> ShowS

Show a => Show (ZipList a)

Defined in Control.Applicative

Methods

showsPrec :: Int -> ZipList a -> ShowS

show :: ZipList a -> String

showList :: [ZipList a] -> ShowS

Show a => Show (Identity a)

This instance would be equivalent to the derived instances of the Identity newtype if the runIdentity field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

showsPrec :: Int -> Identity a -> ShowS

show :: Identity a -> String

showList :: [Identity a] -> ShowS

Show a => Show (First a)

Defined in Data.Monoid

Methods

showsPrec :: Int -> First a -> ShowS

show :: First a -> String

showList :: [First a] -> ShowS

Show a => Show (Last a)

Defined in Data.Monoid

Methods

showsPrec :: Int -> Last a -> ShowS

show :: Last a -> String

showList :: [Last a] -> ShowS

Show a => Show (Dual a)

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Dual a -> ShowS

show :: Dual a -> String

showList :: [Dual a] -> ShowS

Show a => Show (Sum a)

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Sum a -> ShowS

show :: Sum a -> String

showList :: [Sum a] -> ShowS

Show a => Show (Product a)

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Product a -> ShowS

show :: Product a -> String

showList :: [Product a] -> ShowS

Show a => Show (Down a)

Since: base-4.7.0.0

Defined in Data.Ord

Methods

showsPrec :: Int -> Down a -> ShowS

show :: Down a -> String

showList :: [Down a] -> ShowS

Show a => Show (NonEmpty a)

Defined in GHC.Show

Methods

showsPrec :: Int -> NonEmpty a -> ShowS

show :: NonEmpty a -> String

showList :: [NonEmpty a] -> ShowS

Show a => Show (IntMap a)

Defined in Data.IntMap.Internal

Methods

showsPrec :: Int -> IntMap a -> ShowS

show :: IntMap a -> String

showList :: [IntMap a] -> ShowS

Show a => Show (Tree a)

Defined in Data.Tree

Methods

showsPrec :: Int -> Tree a -> ShowS

show :: Tree a -> String

showList :: [Tree a] -> ShowS

Show a => Show (Seq a)

Defined in Data.Sequence.Internal

Methods

showsPrec :: Int -> Seq a -> ShowS

show :: Seq a -> String

showList :: [Seq a] -> ShowS

Show a => Show (ViewL a)

Defined in Data.Sequence.Internal

Methods

showsPrec :: Int -> ViewL a -> ShowS

show :: ViewL a -> String

showList :: [ViewL a] -> ShowS

Show a => Show (ViewR a)

Defined in Data.Sequence.Internal

Methods

showsPrec :: Int -> ViewR a -> ShowS

show :: ViewR a -> String

showList :: [ViewR a] -> ShowS

Show a => Show (Set a)

Defined in Data.Set.Internal

Methods

showsPrec :: Int -> Set a -> ShowS

show :: Set a -> String

showList :: [Set a] -> ShowS

Show (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> Doc a -> ShowS

show :: Doc a -> String

showList :: [Doc a] -> ShowS

Show a => Show (AnnotDetails a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> AnnotDetails a -> ShowS

show :: AnnotDetails a -> String

showList :: [AnnotDetails a] -> ShowS

Show a => Show (Span a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

showsPrec :: Int -> Span a -> ShowS

show :: Span a -> String

showList :: [Span a] -> ShowS

Show (SSymbol s)

Defined in Clash.Promoted.Symbol

Methods

showsPrec :: Int -> SSymbol s -> ShowS

show :: SSymbol s -> String

showList :: [SSymbol s] -> ShowS

KnownNat n => Show (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

showsPrec :: Int -> BitVector n -> ShowS

show :: BitVector n -> String

showList :: [BitVector n] -> ShowS

Show (Index n)

Defined in Clash.Sized.Internal.Index

Methods

showsPrec :: Int -> Index n -> ShowS

show :: Index n -> String

showList :: [Index n] -> ShowS

KnownNat n => Show (BNat n)

Defined in Clash.Promoted.Nat

Methods

showsPrec :: Int -> BNat n -> ShowS

show :: BNat n -> String

showList :: [BNat n] -> ShowS

KnownNat n => Show (UNat n)

Defined in Clash.Promoted.Nat

Methods

showsPrec :: Int -> UNat n -> ShowS

show :: UNat n -> String

showList :: [UNat n] -> ShowS

Show (SNat n)

Defined in Clash.Promoted.Nat

Methods

showsPrec :: Int -> SNat n -> ShowS

show :: SNat n -> String

showList :: [SNat n] -> ShowS

Show a => Show (Bounds a)

Defined in Test.QuickCheck.Arbitrary

Methods

showsPrec :: Int -> Bounds a -> ShowS

show :: Bounds a -> String

showList :: [Bounds a] -> ShowS

Show a => Show (DList a)

Defined in Data.DList

Methods

showsPrec :: Int -> DList a -> ShowS

show :: DList a -> String

showList :: [DList a] -> ShowS

Show a => Show (HashSet a)

Defined in Data.HashSet

Methods

showsPrec :: Int -> HashSet a -> ShowS

show :: HashSet a -> String

showList :: [HashSet a] -> ShowS

(Show a, Storable a) => Show (Vector a)

Defined in Data.Vector.Storable

Methods

showsPrec :: Int -> Vector a -> ShowS

show :: Vector a -> String

showList :: [Vector a] -> ShowS

(Show a, Prim a) => Show (Vector a)

Defined in Data.Vector.Primitive

Methods

showsPrec :: Int -> Vector a -> ShowS

show :: Vector a -> String

showList :: [Vector a] -> ShowS

Show a => Show (Vector a)

Defined in Data.Vector

Methods

showsPrec :: Int -> Vector a -> ShowS

show :: Vector a -> String

showList :: [Vector a] -> ShowS

Show a => Show (Array a)

Defined in Data.Primitive.Array

Methods

showsPrec :: Int -> Array a -> ShowS

show :: Array a -> String

showList :: [Array a] -> ShowS

(Show a, Prim a) => Show (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

showsPrec :: Int -> PrimArray a -> ShowS

show :: PrimArray a -> String

showList :: [PrimArray a] -> ShowS

Show a => Show (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

showsPrec :: Int -> SmallArray a -> ShowS

show :: SmallArray a -> String

showList :: [SmallArray a] -> ShowS

(Show a, PrimUnlifted a) => Show (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

showsPrec :: Int -> UnliftedArray a -> ShowS

show :: UnliftedArray a -> String

showList :: [UnliftedArray a] -> ShowS

Show (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Methods

showsPrec :: Int -> Unsigned n -> ShowS

show :: Unsigned n -> String

showList :: [Unsigned n] -> ShowS

Show (Signed n)

Defined in Clash.Sized.Internal.Signed

Methods

showsPrec :: Int -> Signed n -> ShowS

show :: Signed n -> String

showList :: [Signed n] -> ShowS

Show (Dict a)

Defined in Data.Constraint

Methods

showsPrec :: Int -> Dict a -> ShowS

show :: Dict a -> String

showList :: [Dict a] -> ShowS

(Show a) :=> (Show (Complex a))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Complex a)

(Show a) :=> (Show [a])

Defined in Data.Constraint

Methods

ins :: Show a :- Show [a]

(Show a) :=> (Show (Maybe a))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Maybe a)

(Show a) :=> (Show (Identity a))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Identity a)

(Show a) :=> (Show (Const a b))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Const a b)

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

Defined in Data.Either

Methods

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

show :: Either a b -> String

showList :: [Either a b] -> ShowS

Show (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> V1 p -> ShowS

show :: V1 p -> String

showList :: [V1 p] -> ShowS

Show (U1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> U1 p -> ShowS

show :: U1 p -> String

showList :: [U1 p] -> ShowS

Show (TypeRep a)

Defined in Data.Typeable.Internal

Methods

showsPrec :: Int -> TypeRep a -> ShowS

show :: TypeRep a -> String

showList :: [TypeRep a] -> ShowS

(Show a, Show b) => Show (a, b)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b) -> ShowS

show :: (a, b) -> String

showList :: [(a, b)] -> ShowS

Show (ST s a)

Since: base-2.1

Defined in GHC.ST

Methods

showsPrec :: Int -> ST s a -> ShowS

show :: ST s a -> String

showList :: [ST s a] -> ShowS

(Ix a, Show a, Show b) => Show (Array a b)

Since: base-2.1

Defined in GHC.Arr

Methods

showsPrec :: Int -> Array a b -> ShowS

show :: Array a b -> String

showList :: [Array a b] -> ShowS

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

Defined in Data.Semigroup

Methods

showsPrec :: Int -> Arg a b -> ShowS

show :: Arg a b -> String

showList :: [Arg a b] -> ShowS

Show (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

showsPrec :: Int -> Proxy s -> ShowS

show :: Proxy s -> String

showList :: [Proxy s] -> ShowS

(Show k, Show a) => Show (Map k a)

Defined in Data.Map.Internal

Methods

showsPrec :: Int -> Map k a -> ShowS

show :: Map k a -> String

showList :: [Map k a] -> ShowS

Show a => Show (Vec n a)

Defined in Clash.Sized.Vector

Methods

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

show :: Vec n a -> String

showList :: [Vec n a] -> ShowS

(Show i, Show a) => Show (Level i a)

Defined in Control.Lens.Internal.Level

Methods

showsPrec :: Int -> Level i a -> ShowS

show :: Level i a -> String

showList :: [Level i a] -> ShowS

(Show1 f, Show a) => Show (Cofree f a)

Defined in Control.Comonad.Cofree

Methods

showsPrec :: Int -> Cofree f a -> ShowS

show :: Cofree f a -> String

showList :: [Cofree f a] -> ShowS

(Show1 f, Show a) => Show (Free f a)

Defined in Control.Monad.Free

Methods

showsPrec :: Int -> Free f a -> ShowS

show :: Free f a -> String

showList :: [Free f a] -> ShowS

Show (f a) => Show (Yoneda f a)

Defined in Data.Functor.Yoneda

Methods

showsPrec :: Int -> Yoneda f a -> ShowS

show :: Yoneda f a -> String

showList :: [Yoneda f a] -> ShowS

(Show k, Show v) => Show (HashMap k v)

Defined in Data.HashMap.Base

Methods

showsPrec :: Int -> HashMap k v -> ShowS

show :: HashMap k v -> String

showList :: [HashMap k v] -> ShowS

Show (Clock domain gated)

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> Clock domain gated -> ShowS

show :: Clock domain gated -> String

showList :: [Clock domain gated] -> ShowS

Show a => Show (Signal domain a)

Defined in Clash.Signal.Internal

Methods

showsPrec :: Int -> Signal domain a -> ShowS

show :: Signal domain a -> String

showList :: [Signal domain a] -> ShowS

Show a => Show (RTree n a)

Defined in Clash.Sized.RTree

Methods

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

show :: RTree n a -> String

showList :: [RTree n a] -> ShowS

Show (a :- b)

Defined in Data.Constraint

Methods

showsPrec :: Int -> (a :- b) -> ShowS

show :: (a :- b) -> String

showList :: [a :- b] -> ShowS

(Integral a, Show a) :=> (Show (Ratio a))

Defined in Data.Constraint

Methods

ins :: (Integral a, Show a) :- Show (Ratio a)

(Show a, Show b) :=> (Show (a, b))

Defined in Data.Constraint

Methods

ins :: (Show a, Show b) :- Show (a, b)

(Show a, Show b) :=> (Show (Either a b))

Defined in Data.Constraint

Methods

ins :: (Show a, Show b) :- Show (Either a b)

Show (f p) => Show (Rec1 f p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> Rec1 f p -> ShowS

show :: Rec1 f p -> String

showList :: [Rec1 f p] -> ShowS

Show (URec Char p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Show (URec Double p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Show (URec Float p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Show (URec Int p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Show (URec Word p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Word p -> ShowS

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

(Show a, Show b, Show c) => Show (a, b, c)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c) -> ShowS

show :: (a, b, c) -> String

showList :: [(a, b, c)] -> ShowS

Show a => Show (Const a b)

This instance would be equivalent to the derived instances of the Const newtype if the runConst field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Const

Methods

showsPrec :: Int -> Const a b -> ShowS

show :: Const a b -> String

showList :: [Const a b] -> ShowS

Show (f a) => Show (Alt f a)

Defined in Data.Semigroup.Internal

Methods

showsPrec :: Int -> Alt f a -> ShowS

show :: Alt f a -> String

showList :: [Alt f a] -> ShowS

Show (a :~: b)

Defined in Data.Type.Equality

Methods

showsPrec :: Int -> (a :~: b) -> ShowS

show :: (a :~: b) -> String

showList :: [a :~: b] -> ShowS

(Show e, Show1 m, Show a) => Show (ErrorT e m a)

Defined in Control.Monad.Trans.Error

Methods

showsPrec :: Int -> ErrorT e m a -> ShowS

show :: ErrorT e m a -> String

showList :: [ErrorT e m a] -> ShowS

Show a => Show (Constant a b)

Defined in Data.Functor.Constant

Methods

showsPrec :: Int -> Constant a b -> ShowS

show :: Constant a b -> String

showList :: [Constant a b] -> ShowS

Show b => Show (Tagged s b)

Defined in Data.Tagged

Methods

showsPrec :: Int -> Tagged s b -> ShowS

show :: Tagged s b -> String

showList :: [Tagged s b] -> ShowS

Show (p (Fix p a) a) => Show (Fix p a)

Defined in Data.Bifunctor.Fix

Methods

showsPrec :: Int -> Fix p a -> ShowS

show :: Fix p a -> String

showList :: [Fix p a] -> ShowS

Show (p a a) => Show (Join p a)

Defined in Data.Bifunctor.Join

Methods

showsPrec :: Int -> Join p a -> ShowS

show :: Join p a -> String

showList :: [Join p a] -> ShowS

(Show a, Show (f b)) => Show (CofreeF f a b)

Defined in Control.Comonad.Trans.Cofree

Methods

showsPrec :: Int -> CofreeF f a b -> ShowS

show :: CofreeF f a b -> String

showList :: [CofreeF f a b] -> ShowS

Show (w (CofreeF f a (CofreeT f w a))) => Show (CofreeT f w a)

Defined in Control.Comonad.Trans.Cofree

Methods

showsPrec :: Int -> CofreeT f w a -> ShowS

show :: CofreeT f w a -> String

showList :: [CofreeT f w a] -> ShowS

(Show1 f, Show1 m, Show a) => Show (FreeT f m a)

Defined in Control.Monad.Trans.Free

Methods

showsPrec :: Int -> FreeT f m a -> ShowS

show :: FreeT f m a -> String

showList :: [FreeT f m a] -> ShowS

(Show a, Show (f b)) => Show (FreeF f a b)

Defined in Control.Monad.Trans.Free

Methods

showsPrec :: Int -> FreeF f a b -> ShowS

show :: FreeF f a b -> String

showList :: [FreeF f a b] -> ShowS

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

Defined in Clash.Sized.Fixed

Methods

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

show :: Fixed rep int frac -> String

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

Show a => Show (DSignal domain delay a)

Defined in Clash.Explicit.Signal.Delayed

Methods

showsPrec :: Int -> DSignal domain delay a -> ShowS

show :: DSignal domain delay a -> String

showList :: [DSignal domain delay a] -> ShowS

Show c => Show (K1 i c p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> K1 i c p -> ShowS

show :: K1 i c p -> String

showList :: [K1 i c p] -> ShowS

(Show (f p), Show (g p)) => Show ((f :+: g) p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> (f :+: g) p -> ShowS

show :: (f :+: g) p -> String

showList :: [(f :+: g) p] -> ShowS

(Show (f p), Show (g p)) => Show ((f :*: g) p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> (f :*: g) p -> ShowS

show :: (f :*: g) p -> String

showList :: [(f :*: g) p] -> ShowS

(Show a, Show b, Show c, Show d) => Show (a, b, c, d)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d) -> ShowS

show :: (a, b, c, d) -> String

showList :: [(a, b, c, d)] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Product f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

showsPrec :: Int -> Product f g a -> ShowS

show :: Product f g a -> String

showList :: [Product f g a] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Sum f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

showsPrec :: Int -> Sum f g a -> ShowS

show :: Sum f g a -> String

showList :: [Sum f g a] -> ShowS

Show (a :~~: b)

Since: base-4.10.0.0

Defined in Data.Type.Equality

Methods

showsPrec :: Int -> (a :~~: b) -> ShowS

show :: (a :~~: b) -> String

showList :: [a :~~: b] -> ShowS

(Show i, Show a) => Show (Magma i t b a)

Defined in Control.Lens.Internal.Magma

Methods

showsPrec :: Int -> Magma i t b a -> ShowS

show :: Magma i t b a -> String

showList :: [Magma i t b a] -> ShowS

Show (f p) => Show (M1 i c f p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> M1 i c f p -> ShowS

show :: M1 i c f p -> String

showList :: [M1 i c f p] -> ShowS

Show (f (g p)) => Show ((f :.: g) p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> (f :.: g) p -> ShowS

show :: (f :.: g) p -> String

showList :: [(f :.: g) p] -> ShowS

(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e) -> ShowS

show :: (a, b, c, d, e) -> String

showList :: [(a, b, c, d, e)] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

showsPrec :: Int -> Compose f g a -> ShowS

show :: Compose f g a -> String

showList :: [Compose f g a] -> ShowS

Show (f a) => Show (Clown f a b)

Defined in Data.Bifunctor.Clown

Methods

showsPrec :: Int -> Clown f a b -> ShowS

show :: Clown f a b -> String

showList :: [Clown f a b] -> ShowS

Show (p b a) => Show (Flip p a b)

Defined in Data.Bifunctor.Flip

Methods

showsPrec :: Int -> Flip p a b -> ShowS

show :: Flip p a b -> String

showList :: [Flip p a b] -> ShowS

Show (g b) => Show (Joker g a b)

Defined in Data.Bifunctor.Joker

Methods

showsPrec :: Int -> Joker g a b -> ShowS

show :: Joker g a b -> String

showList :: [Joker g a b] -> ShowS

Show (p a b) => Show (WrappedBifunctor p a b)

Defined in Data.Bifunctor.Wrapped

Methods

showsPrec :: Int -> WrappedBifunctor p a b -> ShowS

show :: WrappedBifunctor p a b -> String

showList :: [WrappedBifunctor p a b] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS

show :: (a, b, c, d, e, f) -> String

showList :: [(a, b, c, d, e, f)] -> ShowS

(Show (f a b), Show (g a b)) => Show (Product f g a b)

Defined in Data.Bifunctor.Product

Methods

showsPrec :: Int -> Product f g a b -> ShowS

show :: Product f g a b -> String

showList :: [Product f g a b] -> ShowS

(Show (p a b), Show (q a b)) => Show (Sum p q a b)

Defined in Data.Bifunctor.Sum

Methods

showsPrec :: Int -> Sum p q a b -> ShowS

show :: Sum p q a b -> String

showList :: [Sum p q a b] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS

show :: (a, b, c, d, e, f, g) -> String

showList :: [(a, b, c, d, e, f, g)] -> ShowS

Show (f (p a b)) => Show (Tannen f p a b)

Defined in Data.Bifunctor.Tannen

Methods

showsPrec :: Int -> Tannen f p a b -> ShowS

show :: Tannen f p a b -> String

showList :: [Tannen f p a b] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS

show :: (a, b, c, d, e, f, g, h) -> String

showList :: [(a, b, c, d, e, f, g, h)] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS

show :: (a, b, c, d, e, f, g, h, i) -> String

showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS

Show (p (f a) (g b)) => Show (Biff p f g a b)

Defined in Data.Bifunctor.Biff

Methods

showsPrec :: Int -> Biff p f g a b -> ShowS

show :: Biff p f g a b -> String

showList :: [Biff p f g a b] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ShowS

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS

class Functor f => Applicative (f :: * -> *) where

A functor with application, providing operations to

• embed pure expressions (pure), and
• sequence computations and combine their results (<*> and liftA2).

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id

liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

identity

pure id <*> v = v

composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

homomorphism

pure f <*> pure x = pure (f x)

interchange

u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

• u *> v = (id <$ u) <*> v

• u <* v = liftA2 const u v

As a consequence of these laws, the Functor instance for f will satisfy

• fmap f x = pure f <*> x

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If f is also a Monad, it should satisfy

• pure = return

• (<*>) = ap

• (*>) = (>>)

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

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b infixl 4

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

(*>) :: f a -> f b -> f b infixl 4

Sequence actions, discarding the value of the first argument.

(<*) :: f a -> f b -> f a infixl 4

Sequence actions, discarding the value of the second argument.

Instances

Applicative []

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> [a]

(<*>) :: [a -> b] -> [a] -> [b]

liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c]

(*>) :: [a] -> [b] -> [b]

(<*) :: [a] -> [b] -> [a]

Applicative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Applicative IO

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> IO a

(<*>) :: IO (a -> b) -> IO a -> IO b

liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c

(*>) :: IO a -> IO b -> IO b

(<*) :: IO a -> IO b -> IO a

Applicative Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Par1 a

(<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b

liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c

(*>) :: Par1 a -> Par1 b -> Par1 b

(<*) :: Par1 a -> Par1 b -> Par1 a

Applicative Q

Defined in Language.Haskell.TH.Syntax

Methods

pure :: a -> Q a

(<*>) :: Q (a -> b) -> Q a -> Q b

liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c

(*>) :: Q a -> Q b -> Q b

(<*) :: Q a -> Q b -> Q a

Applicative Complex

Since: base-4.9.0.0

Defined in Data.Complex

Methods

pure :: a -> Complex a

(<*>) :: Complex (a -> b) -> Complex a -> Complex b

liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c

(*>) :: Complex a -> Complex b -> Complex b

(<*) :: Complex a -> Complex b -> Complex a

Applicative Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Min a

(<*>) :: Min (a -> b) -> Min a -> Min b

liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c

(*>) :: Min a -> Min b -> Min b

(<*) :: Min a -> Min b -> Min a

Applicative Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Max a

(<*>) :: Max (a -> b) -> Max a -> Max b

liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c

(*>) :: Max a -> Max b -> Max b

(<*) :: Max a -> Max b -> Max a

Applicative First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Option a

(<*>) :: Option (a -> b) -> Option a -> Option b

liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c

(*>) :: Option a -> Option b -> Option b

(<*) :: Option a -> Option b -> Option a

Applicative ZipList

f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN
    = 'ZipList' (zipWithN f xs1 ... xsN)

where zipWithN refers to the zipWith function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example:

(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
    = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
    = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> ZipList a

(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b

liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

(*>) :: ZipList a -> ZipList b -> ZipList b

(<*) :: ZipList a -> ZipList b -> ZipList a

Applicative Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

pure :: a -> Identity a

(<*>) :: Identity (a -> b) -> Identity a -> Identity b

liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

(*>) :: Identity a -> Identity b -> Identity b

(<*) :: Identity a -> Identity b -> Identity a

Applicative STM

Since: base-4.8.0.0

Defined in GHC.Conc.Sync

Methods

pure :: a -> STM a

(<*>) :: STM (a -> b) -> STM a -> STM b

liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c

(*>) :: STM a -> STM b -> STM b

(<*) :: STM a -> STM b -> STM a

Applicative First

Defined in Data.Monoid

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Defined in Data.Monoid

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative Dual

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Dual a

(<*>) :: Dual (a -> b) -> Dual a -> Dual b

liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c

(*>) :: Dual a -> Dual b -> Dual b

(<*) :: Dual a -> Dual b -> Dual a

Applicative Sum

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Sum a

(<*>) :: Sum (a -> b) -> Sum a -> Sum b

liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c

(*>) :: Sum a -> Sum b -> Sum b

(<*) :: Sum a -> Sum b -> Sum a

Applicative Product

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Product a

(<*>) :: Product (a -> b) -> Product a -> Product b

liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c

(*>) :: Product a -> Product b -> Product b

(<*) :: Product a -> Product b -> Product a

Applicative Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

pure :: a -> Down a

(<*>) :: Down (a -> b) -> Down a -> Down b

liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c

(*>) :: Down a -> Down b -> Down b

(<*) :: Down a -> Down b -> Down a

Applicative ReadPrec

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadPrec

Methods

pure :: a -> ReadPrec a

(<*>) :: ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b

liftA2 :: (a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c

(*>) :: ReadPrec a -> ReadPrec b -> ReadPrec b

(<*) :: ReadPrec a -> ReadPrec b -> ReadPrec a

Applicative ReadP

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> ReadP a

(<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b

liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c

(*>) :: ReadP a -> ReadP b -> ReadP b

(<*) :: ReadP a -> ReadP b -> ReadP a

Applicative NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

pure :: a -> NonEmpty a

(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b

liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a

Applicative Tree

Defined in Data.Tree

Methods

pure :: a -> Tree a

(<*>) :: Tree (a -> b) -> Tree a -> Tree b

liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c

(*>) :: Tree a -> Tree b -> Tree b

(<*) :: Tree a -> Tree b -> Tree a

Applicative Seq

Since: containers-0.5.4

Defined in Data.Sequence.Internal

Methods

pure :: a -> Seq a

(<*>) :: Seq (a -> b) -> Seq a -> Seq b

liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c

(*>) :: Seq a -> Seq b -> Seq b

(<*) :: Seq a -> Seq b -> Seq a

Applicative P

Since: base-4.5.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> P a

(<*>) :: P (a -> b) -> P a -> P b

liftA2 :: (a -> b -> c) -> P a -> P b -> P c

(*>) :: P a -> P b -> P b

(<*) :: P a -> P b -> P a

Applicative Gen

Defined in Test.QuickCheck.Gen

Methods

pure :: a -> Gen a

(<*>) :: Gen (a -> b) -> Gen a -> Gen b

liftA2 :: (a -> b -> c) -> Gen a -> Gen b -> Gen c

(*>) :: Gen a -> Gen b -> Gen b

(<*) :: Gen a -> Gen b -> Gen a

Applicative Id

Defined in Data.Vector.Fusion.Util

Methods

pure :: a -> Id a

(<*>) :: Id (a -> b) -> Id a -> Id b

liftA2 :: (a -> b -> c) -> Id a -> Id b -> Id c

(*>) :: Id a -> Id b -> Id b

(<*) :: Id a -> Id b -> Id a

Applicative Box

Defined in Data.Vector.Fusion.Util

Methods

pure :: a -> Box a

(<*>) :: Box (a -> b) -> Box a -> Box b

liftA2 :: (a -> b -> c) -> Box a -> Box b -> Box c

(*>) :: Box a -> Box b -> Box b

(<*) :: Box a -> Box b -> Box a

Applicative DList

Defined in Data.DList

Methods

pure :: a -> DList a

(<*>) :: DList (a -> b) -> DList a -> DList b

liftA2 :: (a -> b -> c) -> DList a -> DList b -> DList c

(*>) :: DList a -> DList b -> DList b

(<*) :: DList a -> DList b -> DList a

Applicative Vector

Defined in Data.Vector

Methods

pure :: a -> Vector a

(<*>) :: Vector (a -> b) -> Vector a -> Vector b

liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c

(*>) :: Vector a -> Vector b -> Vector b

(<*) :: Vector a -> Vector b -> Vector a

Applicative Array

Defined in Data.Primitive.Array

Methods

pure :: a -> Array a

(<*>) :: Array (a -> b) -> Array a -> Array b

liftA2 :: (a -> b -> c) -> Array a -> Array b -> Array c

(*>) :: Array a -> Array b -> Array b

(<*) :: Array a -> Array b -> Array a

Applicative SmallArray

Defined in Data.Primitive.SmallArray

Methods

pure :: a -> SmallArray a

(<*>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b

liftA2 :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c

(*>) :: SmallArray a -> SmallArray b -> SmallArray b

(<*) :: SmallArray a -> SmallArray b -> SmallArray a

Applicative Rose

Defined in Test.QuickCheck.Property

Methods

pure :: a -> Rose a

(<*>) :: Rose (a -> b) -> Rose a -> Rose b

liftA2 :: (a -> b -> c) -> Rose a -> Rose b -> Rose c

(*>) :: Rose a -> Rose b -> Rose b

(<*) :: Rose a -> Rose b -> Rose a

() :=> (Applicative ((->) a :: * -> *))

Defined in Data.Constraint

Methods

ins :: () :- Applicative ((->) a)

() :=> (Applicative [])

Defined in Data.Constraint

Methods

ins :: () :- Applicative []

() :=> (Applicative Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Applicative Maybe

() :=> (Applicative IO)

Defined in Data.Constraint

Methods

ins :: () :- Applicative IO

() :=> (Applicative (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Applicative (Either a)

Applicative (Either e)

Since: base-3.0

Defined in Data.Either

Methods

pure :: a -> Either e a

(<*>) :: Either e (a -> b) -> Either e a -> Either e b

liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c

(*>) :: Either e a -> Either e b -> Either e b

(<*) :: Either e a -> Either e b -> Either e a

Applicative (U1 :: * -> *)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> U1 a

(<*>) :: U1 (a -> b) -> U1 a -> U1 b

liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c

(*>) :: U1 a -> U1 b -> U1 b

(<*) :: U1 a -> U1 b -> U1 a

Monoid a => Applicative ((,) a)

For tuples, the Monoid constraint on a determines how the first values merge. For example, Strings concatenate:

("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a0 -> (a, a0)

(<*>) :: (a, a0 -> b) -> (a, a0) -> (a, b)

liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c)

(*>) :: (a, a0) -> (a, b) -> (a, b)

(<*) :: (a, a0) -> (a, b) -> (a, a0)

Applicative (ST s)

Since: base-4.4.0.0

Defined in GHC.ST

Methods

pure :: a -> ST s a

(<*>) :: ST s (a -> b) -> ST s a -> ST s b

liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c

(*>) :: ST s a -> ST s b -> ST s b

(<*) :: ST s a -> ST s b -> ST s a

Monad m => Applicative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> WrappedMonad m a

(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

Arrow a => Applicative (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> ArrowMonad a a0

(<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c

(*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b

(<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0

Applicative (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

pure :: a -> Proxy a

(<*>) :: Proxy (a -> b) -> Proxy a -> Proxy b

liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

(*>) :: Proxy a -> Proxy b -> Proxy b

(<*) :: Proxy a -> Proxy b -> Proxy a

KnownNat n => Applicative (Vec n)

Defined in Clash.Sized.Vector

Methods

pure :: a -> Vec n a

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

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

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

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

Applicative (ReifiedFold s)

Defined in Control.Lens.Reified

Methods

pure :: a -> ReifiedFold s a

(<*>) :: ReifiedFold s (a -> b) -> ReifiedFold s a -> ReifiedFold s b

liftA2 :: (a -> b -> c) -> ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s c

(*>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b

(<*) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s a

Applicative (ReifiedGetter s)

Defined in Control.Lens.Reified

Methods

pure :: a -> ReifiedGetter s a

(<*>) :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b

liftA2 :: (a -> b -> c) -> ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s c

(*>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b

(<*) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a

Representable f => Applicative (Co f)

Defined in Data.Functor.Rep

Methods

pure :: a -> Co f a

(<*>) :: Co f (a -> b) -> Co f a -> Co f b

liftA2 :: (a -> b -> c) -> Co f a -> Co f b -> Co f c

(*>) :: Co f a -> Co f b -> Co f b

(<*) :: Co f a -> Co f b -> Co f a

Alternative f => Applicative (Cofree f)

Defined in Control.Comonad.Cofree

Methods

pure :: a -> Cofree f a

(<*>) :: Cofree f (a -> b) -> Cofree f a -> Cofree f b

liftA2 :: (a -> b -> c) -> Cofree f a -> Cofree f b -> Cofree f c

(*>) :: Cofree f a -> Cofree f b -> Cofree f b

(<*) :: Cofree f a -> Cofree f b -> Cofree f a

Functor f => Applicative (Free f)

Defined in Control.Monad.Free

Methods

pure :: a -> Free f a

(<*>) :: Free f (a -> b) -> Free f a -> Free f b

liftA2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

(*>) :: Free f a -> Free f b -> Free f b

(<*) :: Free f a -> Free f b -> Free f a

Applicative f => Applicative (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

pure :: a -> Yoneda f a

(<*>) :: Yoneda f (a -> b) -> Yoneda f a -> Yoneda f b

liftA2 :: (a -> b -> c) -> Yoneda f a -> Yoneda f b -> Yoneda f c

(*>) :: Yoneda f a -> Yoneda f b -> Yoneda f b

(<*) :: Yoneda f a -> Yoneda f b -> Yoneda f a

Applicative f => Applicative (Indexing f)

Defined in Control.Lens.Internal.Indexed

Methods

pure :: a -> Indexing f a

(<*>) :: Indexing f (a -> b) -> Indexing f a -> Indexing f b

liftA2 :: (a -> b -> c) -> Indexing f a -> Indexing f b -> Indexing f c

(*>) :: Indexing f a -> Indexing f b -> Indexing f b

(<*) :: Indexing f a -> Indexing f b -> Indexing f a

Applicative f => Applicative (Indexing64 f)

Defined in Control.Lens.Internal.Indexed

Methods

pure :: a -> Indexing64 f a

(<*>) :: Indexing64 f (a -> b) -> Indexing64 f a -> Indexing64 f b

liftA2 :: (a -> b -> c) -> Indexing64 f a -> Indexing64 f b -> Indexing64 f c

(*>) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f b

(<*) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f a

(Applicative (Rep p), Representable p) => Applicative (Prep p)

Defined in Data.Profunctor.Rep

Methods

pure :: a -> Prep p a

(<*>) :: Prep p (a -> b) -> Prep p a -> Prep p b

liftA2 :: (a -> b -> c) -> Prep p a -> Prep p b -> Prep p c

(*>) :: Prep p a -> Prep p b -> Prep p b

(<*) :: Prep p a -> Prep p b -> Prep p a

Applicative (Signal domain)

Defined in Clash.Signal.Internal

Methods

pure :: a -> Signal domain a

(<*>) :: Signal domain (a -> b) -> Signal domain a -> Signal domain b

liftA2 :: (a -> b -> c) -> Signal domain a -> Signal domain b -> Signal domain c

(*>) :: Signal domain a -> Signal domain b -> Signal domain b

(<*) :: Signal domain a -> Signal domain b -> Signal domain a

KnownNat d => Applicative (RTree d)

Defined in Clash.Sized.RTree

Methods

pure :: a -> RTree d a

(<*>) :: RTree d (a -> b) -> RTree d a -> RTree d b

liftA2 :: (a -> b -> c) -> RTree d a -> RTree d b -> RTree d c

(*>) :: RTree d a -> RTree d b -> RTree d b

(<*) :: RTree d a -> RTree d b -> RTree d a

(Monad m) :=> (Applicative (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Applicative (WrappedMonad m)

(Monoid a) :=> (Applicative ((,) a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Applicative ((,) a)

(Monoid a) :=> (Applicative (Const a :: * -> *))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Applicative (Const a)

Class (Functor f) (Applicative f)

Defined in Data.Constraint

Methods

cls :: Applicative f :- Functor f

Class (Applicative f) (Monad f)

Defined in Data.Constraint

Methods

cls :: Monad f :- Applicative f

Class (Applicative f) (Alternative f)

Defined in Data.Constraint

Methods

cls :: Alternative f :- Applicative f

Applicative f => Applicative (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Rec1 f a

(<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b

liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c

(*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

(<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a

Arrow a => Applicative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a0 -> WrappedArrow a b a0

(<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c

(*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0

(<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

Monoid m => Applicative (Const m :: * -> *)

Since: base-2.0.1

Defined in Data.Functor.Const

Methods

pure :: a -> Const m a

(<*>) :: Const m (a -> b) -> Const m a -> Const m b

liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c

(*>) :: Const m a -> Const m b -> Const m b

(<*) :: Const m a -> Const m b -> Const m a

Applicative f => Applicative (Alt f)

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Alt f a

(<*>) :: Alt f (a -> b) -> Alt f a -> Alt f b

liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c

(*>) :: Alt f a -> Alt f b -> Alt f b

(<*) :: Alt f a -> Alt f b -> Alt f a

(Applicative f, Monad f) => Applicative (WhenMissing f x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)).

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

pure :: a -> WhenMissing f x a

(<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b

liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c

(*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b

(<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a

(Functor m, Monad m) => Applicative (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

pure :: a -> ErrorT e m a

(<*>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b

liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c

(*>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b

(<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a

(Functor m, Monad m) => Applicative (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(*>) :: StateT s m a -> StateT s m b -> StateT s m b

(<*) :: StateT s m a -> StateT s m b -> StateT s m a

Monoid a => Applicative (Constant a :: * -> *)

Defined in Data.Functor.Constant

Methods

pure :: a0 -> Constant a a0

(<*>) :: Constant a (a0 -> b) -> Constant a a0 -> Constant a b

liftA2 :: (a0 -> b -> c) -> Constant a a0 -> Constant a b -> Constant a c

(*>) :: Constant a a0 -> Constant a b -> Constant a b

(<*) :: Constant a a0 -> Constant a b -> Constant a a0

Applicative (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

pure :: a0 -> Indexed i a a0

(<*>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b

liftA2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c

(*>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b

(<*) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0

Applicative (Tagged s)

Defined in Data.Tagged

Methods

pure :: a -> Tagged s a

(<*>) :: Tagged s (a -> b) -> Tagged s a -> Tagged s b

liftA2 :: (a -> b -> c) -> Tagged s a -> Tagged s b -> Tagged s c

(*>) :: Tagged s a -> Tagged s b -> Tagged s b

(<*) :: Tagged s a -> Tagged s b -> Tagged s a

Biapplicative p => Applicative (Fix p)

Defined in Data.Bifunctor.Fix

Methods

pure :: a -> Fix p a

(<*>) :: Fix p (a -> b) -> Fix p a -> Fix p b

liftA2 :: (a -> b -> c) -> Fix p a -> Fix p b -> Fix p c

(*>) :: Fix p a -> Fix p b -> Fix p b

(<*) :: Fix p a -> Fix p b -> Fix p a

Biapplicative p => Applicative (Join p)

Defined in Data.Bifunctor.Join

Methods

pure :: a -> Join p a

(<*>) :: Join p (a -> b) -> Join p a -> Join p b

liftA2 :: (a -> b -> c) -> Join p a -> Join p b -> Join p c

(*>) :: Join p a -> Join p b -> Join p b

(<*) :: Join p a -> Join p b -> Join p a

(Alternative f, Applicative w) => Applicative (CofreeT f w)

Defined in Control.Comonad.Trans.Cofree

Methods

pure :: a -> CofreeT f w a

(<*>) :: CofreeT f w (a -> b) -> CofreeT f w a -> CofreeT f w b

liftA2 :: (a -> b -> c) -> CofreeT f w a -> CofreeT f w b -> CofreeT f w c

(*>) :: CofreeT f w a -> CofreeT f w b -> CofreeT f w b

(<*) :: CofreeT f w a -> CofreeT f w b -> CofreeT f w a

(Functor f, Monad m) => Applicative (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

pure :: a -> FreeT f m a

(<*>) :: FreeT f m (a -> b) -> FreeT f m a -> FreeT f m b

liftA2 :: (a -> b -> c) -> FreeT f m a -> FreeT f m b -> FreeT f m c

(*>) :: FreeT f m a -> FreeT f m b -> FreeT f m b

(<*) :: FreeT f m a -> FreeT f m b -> FreeT f m a

(Applicative f, Applicative g) => Applicative (Day f g)

Defined in Data.Functor.Day

Methods

pure :: a -> Day f g a

(<*>) :: Day f g (a -> b) -> Day f g a -> Day f g b

liftA2 :: (a -> b -> c) -> Day f g a -> Day f g b -> Day f g c

(*>) :: Day f g a -> Day f g b -> Day f g b

(<*) :: Day f g a -> Day f g b -> Day f g a

Applicative (DSignal domain delay)

Defined in Clash.Explicit.Signal.Delayed

Methods

pure :: a -> DSignal domain delay a

(<*>) :: DSignal domain delay (a -> b) -> DSignal domain delay a -> DSignal domain delay b

liftA2 :: (a -> b -> c) -> DSignal domain delay a -> DSignal domain delay b -> DSignal domain delay c

(*>) :: DSignal domain delay a -> DSignal domain delay b -> DSignal domain delay b

(<*) :: DSignal domain delay a -> DSignal domain delay b -> DSignal domain delay a

Applicative (Flows i b)

Defined in Control.Lens.Internal.Level

Methods

pure :: a -> Flows i b a

(<*>) :: Flows i b (a -> b0) -> Flows i b a -> Flows i b b0

liftA2 :: (a -> b0 -> c) -> Flows i b a -> Flows i b b0 -> Flows i b c

(*>) :: Flows i b a -> Flows i b b0 -> Flows i b b0

(<*) :: Flows i b a -> Flows i b b0 -> Flows i b a

Applicative (Mafic a b)

Defined in Control.Lens.Internal.Magma

Methods

pure :: a0 -> Mafic a b a0

(<*>) :: Mafic a b (a0 -> b0) -> Mafic a b a0 -> Mafic a b b0

liftA2 :: (a0 -> b0 -> c) -> Mafic a b a0 -> Mafic a b b0 -> Mafic a b c

(*>) :: Mafic a b a0 -> Mafic a b b0 -> Mafic a b b0

(<*) :: Mafic a b a0 -> Mafic a b b0 -> Mafic a b a0

Monoid m => Applicative (Holes t m)

Defined in Control.Lens.Traversal

Methods

pure :: a -> Holes t m a

(<*>) :: Holes t m (a -> b) -> Holes t m a -> Holes t m b

liftA2 :: (a -> b -> c) -> Holes t m a -> Holes t m b -> Holes t m c

(*>) :: Holes t m a -> Holes t m b -> Holes t m b

(<*) :: Holes t m a -> Holes t m b -> Holes t m a

Applicative ((->) a :: * -> *)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a0 -> a -> a0

(<*>) :: (a -> a0 -> b) -> (a -> a0) -> a -> b

liftA2 :: (a0 -> b -> c) -> (a -> a0) -> (a -> b) -> a -> c

(*>) :: (a -> a0) -> (a -> b) -> a -> b

(<*) :: (a -> a0) -> (a -> b) -> a -> a0

(Applicative f, Applicative g) => Applicative (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :*: g) a

(<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b

liftA2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c

(*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

(<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a

(Applicative f, Applicative g) => Applicative (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

pure :: a -> Product f g a

(<*>) :: Product f g (a -> b) -> Product f g a -> Product f g b

liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c

(*>) :: Product f g a -> Product f g b -> Product f g b

(<*) :: Product f g a -> Product f g b -> Product f g a

(Monad f, Applicative f) => Applicative (WhenMatched f x y)

Equivalent to ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

pure :: a -> WhenMatched f x y a

(<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b

liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c

(*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b

(<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a

(Applicative f, Monad f) => Applicative (WhenMissing f k x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)) .

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

pure :: a -> WhenMissing f k x a

(<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b

liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c

(*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b

(<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a

Applicative (Bazaar p a b)

Defined in Control.Lens.Internal.Bazaar

Methods

pure :: a0 -> Bazaar p a b a0

(<*>) :: Bazaar p a b (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0

liftA2 :: (a0 -> b0 -> c) -> Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b c

(*>) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b b0

(<*) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b a0

Applicative (Molten i a b)

Defined in Control.Lens.Internal.Magma

Methods

pure :: a0 -> Molten i a b a0

(<*>) :: Molten i a b (a0 -> b0) -> Molten i a b a0 -> Molten i a b b0

liftA2 :: (a0 -> b0 -> c) -> Molten i a b a0 -> Molten i a b b0 -> Molten i a b c

(*>) :: Molten i a b a0 -> Molten i a b b0 -> Molten i a b b0

(<*) :: Molten i a b a0 -> Molten i a b b0 -> Molten i a b a0

Applicative f => Applicative (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> M1 i c f a

(<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b

liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0

(*>) :: M1 i c f a -> M1 i c f b -> M1 i c f b

(<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a

(Applicative f, Applicative g) => Applicative (f :.: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :.: g) a

(<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b

liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c

(*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b

(<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a

(Applicative f, Applicative g) => Applicative (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

pure :: a -> Compose f g a

(<*>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b

liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c

(*>) :: Compose f g a -> Compose f g b -> Compose f g b

(<*) :: Compose f g a -> Compose f g b -> Compose f g a

(Monad f, Applicative f) => Applicative (WhenMatched f k x y)

Equivalent to ReaderT k (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

pure :: a -> WhenMatched f k x y a

(<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c

(*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b

(<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a

Reifies s (ReifiedApplicative f) => Applicative (ReflectedApplicative f s)

Defined in Data.Reflection

Methods

pure :: a -> ReflectedApplicative f s a

(<*>) :: ReflectedApplicative f s (a -> b) -> ReflectedApplicative f s a -> ReflectedApplicative f s b

liftA2 :: (a -> b -> c) -> ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s c

(*>) :: ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s b

(<*) :: ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s a

Applicative (BazaarT p g a b)

Defined in Control.Lens.Internal.Bazaar

Methods

pure :: a0 -> BazaarT p g a b a0

(<*>) :: BazaarT p g a b (a0 -> b0) -> BazaarT p g a b a0 -> BazaarT p g a b b0

liftA2 :: (a0 -> b0 -> c) -> BazaarT p g a b a0 -> BazaarT p g a b b0 -> BazaarT p g a b c

(*>) :: BazaarT p g a b a0 -> BazaarT p g a b b0 -> BazaarT p g a b b0

(<*) :: BazaarT p g a b a0 -> BazaarT p g a b b0 -> BazaarT p g a b a0

Applicative (TakingWhile p f a b)

Defined in Control.Lens.Internal.Magma

Methods

pure :: a0 -> TakingWhile p f a b a0

(<*>) :: TakingWhile p f a b (a0 -> b0) -> TakingWhile p f a b a0 -> TakingWhile p f a b b0

liftA2 :: (a0 -> b0 -> c) -> TakingWhile p f a b a0 -> TakingWhile p f a b b0 -> TakingWhile p f a b c

(*>) :: TakingWhile p f a b a0 -> TakingWhile p f a b b0 -> TakingWhile p f a b b0

(<*) :: TakingWhile p f a b a0 -> TakingWhile p f a b b0 -> TakingWhile p f a b a0

class Foldable (t :: * -> *) where

Data structures that can be folded.

For example, given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Foldable Tree where
   foldMap f Empty = mempty
   foldMap f (Leaf x) = f x
   foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr:

instance Foldable Tree where
   foldr f z Empty = z
   foldr f z (Leaf x) = f x z
   foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l

Foldable instances are expected to satisfy the following laws:

foldr f z t = appEndo (foldMap (Endo . f) t ) z

foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z

fold = foldMap id

length = getSum . foldMap (Sum . const  1)

sum, product, maximum, and minimum should all be essentially equivalent to foldMap forms, such as

sum = getSum . foldMap Sum

but may be less defined.

If the type is also a Functor instance, it should satisfy

foldMap f = fold . fmap f

which implies that

foldMap f . fmap g = foldMap (f . g)

Minimal complete definition

foldMap | foldr

Methods

foldMap :: Monoid m => (a -> m) -> t a -> m

Map each element of the structure to a monoid, and combine the results.

null :: t a -> Bool

Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

elem :: Eq a => a -> t a -> Bool infix 4

Does the element occur in the structure?

maximum :: Ord a => t a -> a

The largest element of a non-empty structure.

minimum :: Ord a => t a -> a

The least element of a non-empty structure.

sum :: Num a => t a -> a

The sum function computes the sum of the numbers of a structure.

product :: Num a => t a -> a

The product function computes the product of the numbers of a structure.

Instances

Foldable []

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => [m] -> m

foldMap :: Monoid m => (a -> m) -> [a] -> m

foldr :: (a -> b -> b) -> b -> [a] -> b

foldr' :: (a -> b -> b) -> b -> [a] -> b

foldl :: (b -> a -> b) -> b -> [a] -> b

foldl' :: (b -> a -> b) -> b -> [a] -> b

foldr1 :: (a -> a -> a) -> [a] -> a

foldl1 :: (a -> a -> a) -> [a] -> a

toList :: [a] -> [a]

null :: [a] -> Bool

length :: [a] -> Int

elem :: Eq a => a -> [a] -> Bool

maximum :: Ord a => [a] -> a

minimum :: Ord a => [a] -> a

sum :: Num a => [a] -> a

product :: Num a => [a] -> a

Foldable Maybe

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => Maybe m -> m

foldMap :: Monoid m => (a -> m) -> Maybe a -> m

foldr :: (a -> b -> b) -> b -> Maybe a -> b

foldr' :: (a -> b -> b) -> b -> Maybe a -> b

foldl :: (b -> a -> b) -> b -> Maybe a -> b

foldl' :: (b -> a -> b) -> b -> Maybe a -> b

foldr1 :: (a -> a -> a) -> Maybe a -> a

foldl1 :: (a -> a -> a) -> Maybe a -> a

toList :: Maybe a -> [a]

null :: Maybe a -> Bool

length :: Maybe a -> Int

elem :: Eq a => a -> Maybe a -> Bool

maximum :: Ord a => Maybe a -> a

minimum :: Ord a => Maybe a -> a

sum :: Num a => Maybe a -> a

product :: Num a => Maybe a -> a

Foldable Par1

Defined in Data.Foldable

Methods

fold :: Monoid m => Par1 m -> m

foldMap :: Monoid m => (a -> m) -> Par1 a -> m

foldr :: (a -> b -> b) -> b -> Par1 a -> b

foldr' :: (a -> b -> b) -> b -> Par1 a -> b

foldl :: (b -> a -> b) -> b -> Par1 a -> b

foldl' :: (b -> a -> b) -> b -> Par1 a -> b

foldr1 :: (a -> a -> a) -> Par1 a -> a

foldl1 :: (a -> a -> a) -> Par1 a -> a

toList :: Par1 a -> [a]

null :: Par1 a -> Bool

length :: Par1 a -> Int

elem :: Eq a => a -> Par1 a -> Bool

maximum :: Ord a => Par1 a -> a

minimum :: Ord a => Par1 a -> a

sum :: Num a => Par1 a -> a

product :: Num a => Par1 a -> a

Foldable Complex

Defined in Data.Complex

Methods

fold :: Monoid m => Complex m -> m

foldMap :: Monoid m => (a -> m) -> Complex a -> m

foldr :: (a -> b -> b) -> b -> Complex a -> b

foldr' :: (a -> b -> b) -> b -> Complex a -> b

foldl :: (b -> a -> b) -> b -> Complex a -> b

foldl' :: (b -> a -> b) -> b -> Complex a -> b

foldr1 :: (a -> a -> a) -> Complex a -> a

foldl1 :: (a -> a -> a) -> Complex a -> a

toList :: Complex a -> [a]

null :: Complex a -> Bool

length :: Complex a -> Int

elem :: Eq a => a -> Complex a -> Bool

maximum :: Ord a => Complex a -> a

minimum :: Ord a => Complex a -> a

sum :: Num a => Complex a -> a

product :: Num a => Complex a -> a

Foldable Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Min m -> m

foldMap :: Monoid m => (a -> m) -> Min a -> m

foldr :: (a -> b -> b) -> b -> Min a -> b

foldr' :: (a -> b -> b) -> b -> Min a -> b

foldl :: (b -> a -> b) -> b -> Min a -> b

foldl' :: (b -> a -> b) -> b -> Min a -> b

foldr1 :: (a -> a -> a) -> Min a -> a

foldl1 :: (a -> a -> a) -> Min a -> a

toList :: Min a -> [a]

null :: Min a -> Bool

length :: Min a -> Int

elem :: Eq a => a -> Min a -> Bool

maximum :: Ord a => Min a -> a

minimum :: Ord a => Min a -> a

sum :: Num a => Min a -> a

product :: Num a => Min a -> a

Foldable Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Max m -> m

foldMap :: Monoid m => (a -> m) -> Max a -> m

foldr :: (a -> b -> b) -> b -> Max a -> b

foldr' :: (a -> b -> b) -> b -> Max a -> b

foldl :: (b -> a -> b) -> b -> Max a -> b

foldl' :: (b -> a -> b) -> b -> Max a -> b

foldr1 :: (a -> a -> a) -> Max a -> a

foldl1 :: (a -> a -> a) -> Max a -> a

toList :: Max a -> [a]

null :: Max a -> Bool

length :: Max a -> Int

elem :: Eq a => a -> Max a -> Bool

maximum :: Ord a => Max a -> a

minimum :: Ord a => Max a -> a

sum :: Num a => Max a -> a

product :: Num a => Max a -> a

Foldable First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => First m -> m

foldMap :: Monoid m => (a -> m) -> First a -> m

foldr :: (a -> b -> b) -> b -> First a -> b

foldr' :: (a -> b -> b) -> b -> First a -> b

foldl :: (b -> a -> b) -> b -> First a -> b

foldl' :: (b -> a -> b) -> b -> First a -> b

foldr1 :: (a -> a -> a) -> First a -> a

foldl1 :: (a -> a -> a) -> First a -> a

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

elem :: Eq a => a -> First a -> Bool

maximum :: Ord a => First a -> a

minimum :: Ord a => First a -> a

sum :: Num a => First a -> a

product :: Num a => First a -> a

Foldable Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Last m -> m

foldMap :: Monoid m => (a -> m) -> Last a -> m

foldr :: (a -> b -> b) -> b -> Last a -> b

foldr' :: (a -> b -> b) -> b -> Last a -> b

foldl :: (b -> a -> b) -> b -> Last a -> b

foldl' :: (b -> a -> b) -> b -> Last a -> b

foldr1 :: (a -> a -> a) -> Last a -> a

foldl1 :: (a -> a -> a) -> Last a -> a

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

elem :: Eq a => a -> Last a -> Bool

maximum :: Ord a => Last a -> a

minimum :: Ord a => Last a -> a

sum :: Num a => Last a -> a

product :: Num a => Last a -> a

Foldable Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Option m -> m

foldMap :: Monoid m => (a -> m) -> Option a -> m

foldr :: (a -> b -> b) -> b -> Option a -> b

foldr' :: (a -> b -> b) -> b -> Option a -> b

foldl :: (b -> a -> b) -> b -> Option a -> b

foldl' :: (b -> a -> b) -> b -> Option a -> b

foldr1 :: (a -> a -> a) -> Option a -> a

foldl1 :: (a -> a -> a) -> Option a -> a

toList :: Option a -> [a]

null :: Option a -> Bool

length :: Option a -> Int

elem :: Eq a => a -> Option a -> Bool

maximum :: Ord a => Option a -> a

minimum :: Ord a => Option a -> a

sum :: Num a => Option a -> a

product :: Num a => Option a -> a

Foldable ZipList

Defined in Control.Applicative

Methods

fold :: Monoid m => ZipList m -> m

foldMap :: Monoid m => (a -> m) -> ZipList a -> m

foldr :: (a -> b -> b) -> b -> ZipList a -> b

foldr' :: (a -> b -> b) -> b -> ZipList a -> b

foldl :: (b -> a -> b) -> b -> ZipList a -> b

foldl' :: (b -> a -> b) -> b -> ZipList a -> b

foldr1 :: (a -> a -> a) -> ZipList a -> a

foldl1 :: (a -> a -> a) -> ZipList a -> a

toList :: ZipList a -> [a]

null :: ZipList a -> Bool

length :: ZipList a -> Int

elem :: Eq a => a -> ZipList a -> Bool

maximum :: Ord a => ZipList a -> a

minimum :: Ord a => ZipList a -> a

sum :: Num a => ZipList a -> a

product :: Num a => ZipList a -> a

Foldable Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

fold :: Monoid m => Identity m -> m

foldMap :: Monoid m => (a -> m) -> Identity a -> m

foldr :: (a -> b -> b) -> b -> Identity a -> b

foldr' :: (a -> b -> b) -> b -> Identity a -> b

foldl :: (b -> a -> b) -> b -> Identity a -> b

foldl' :: (b -> a -> b) -> b -> Identity a -> b

foldr1 :: (a -> a -> a) -> Identity a -> a

foldl1 :: (a -> a -> a) -> Identity a -> a

toList :: Identity a -> [a]

null :: Identity a -> Bool

length :: Identity a -> Int

elem :: Eq a => a -> Identity a -> Bool

maximum :: Ord a => Identity a -> a

minimum :: Ord a => Identity a -> a

sum :: Num a => Identity a -> a

product :: Num a => Identity a -> a

Foldable First

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => First m -> m

foldMap :: Monoid m => (a -> m) -> First a -> m

foldr :: (a -> b -> b) -> b -> First a -> b

foldr' :: (a -> b -> b) -> b -> First a -> b

foldl :: (b -> a -> b) -> b -> First a -> b

foldl' :: (b -> a -> b) -> b -> First a -> b

foldr1 :: (a -> a -> a) -> First a -> a

foldl1 :: (a -> a -> a) -> First a -> a

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

elem :: Eq a => a -> First a -> Bool

maximum :: Ord a => First a -> a

minimum :: Ord a => First a -> a

sum :: Num a => First a -> a

product :: Num a => First a -> a

Foldable Last

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Last m -> m

foldMap :: Monoid m => (a -> m) -> Last a -> m

foldr :: (a -> b -> b) -> b -> Last a -> b

foldr' :: (a -> b -> b) -> b -> Last a -> b

foldl :: (b -> a -> b) -> b -> Last a -> b

foldl' :: (b -> a -> b) -> b -> Last a -> b

foldr1 :: (a -> a -> a) -> Last a -> a

foldl1 :: (a -> a -> a) -> Last a -> a

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

elem :: Eq a => a -> Last a -> Bool

maximum :: Ord a => Last a -> a

minimum :: Ord a => Last a -> a

sum :: Num a => Last a -> a

product :: Num a => Last a -> a

Foldable Dual

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Dual m -> m

foldMap :: Monoid m => (a -> m) -> Dual a -> m

foldr :: (a -> b -> b) -> b -> Dual a -> b

foldr' :: (a -> b -> b) -> b -> Dual a -> b

foldl :: (b -> a -> b) -> b -> Dual a -> b

foldl' :: (b -> a -> b) -> b -> Dual a -> b

foldr1 :: (a -> a -> a) -> Dual a -> a

foldl1 :: (a -> a -> a) -> Dual a -> a

toList :: Dual a -> [a]

null :: Dual a -> Bool

length :: Dual a -> Int

elem :: Eq a => a -> Dual a -> Bool

maximum :: Ord a => Dual a -> a

minimum :: Ord a => Dual a -> a

sum :: Num a => Dual a -> a

product :: Num a => Dual a -> a

Foldable Sum

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Sum m -> m

foldMap :: Monoid m => (a -> m) -> Sum a -> m

foldr :: (a -> b -> b) -> b -> Sum a -> b

foldr' :: (a -> b -> b) -> b -> Sum a -> b

foldl :: (b -> a -> b) -> b -> Sum a -> b

foldl' :: (b -> a -> b) -> b -> Sum a -> b

foldr1 :: (a -> a -> a) -> Sum a -> a

foldl1 :: (a -> a -> a) -> Sum a -> a

toList :: Sum a -> [a]

null :: Sum a -> Bool

length :: Sum a -> Int

elem :: Eq a => a -> Sum a -> Bool

maximum :: Ord a => Sum a -> a

minimum :: Ord a => Sum a -> a

sum :: Num a => Sum a -> a

product :: Num a => Sum a -> a

Foldable Product

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Product m -> m

foldMap :: Monoid m => (a -> m) -> Product a -> m

foldr :: (a -> b -> b) -> b -> Product a -> b

foldr' :: (a -> b -> b) -> b -> Product a -> b

foldl :: (b -> a -> b) -> b -> Product a -> b

foldl' :: (b -> a -> b) -> b -> Product a -> b

foldr1 :: (a -> a -> a) -> Product a -> a

foldl1 :: (a -> a -> a) -> Product a -> a

toList :: Product a -> [a]

null :: Product a -> Bool

length :: Product a -> Int

elem :: Eq a => a -> Product a -> Bool

maximum :: Ord a => Product a -> a

minimum :: Ord a => Product a -> a

sum :: Num a => Product a -> a

product :: Num a => Product a -> a

Foldable NonEmpty

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => NonEmpty m -> m

foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m

foldr :: (a -> b -> b) -> b -> NonEmpty a -> b

foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b

foldl :: (b -> a -> b) -> b -> NonEmpty a -> b

foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b

foldr1 :: (a -> a -> a) -> NonEmpty a -> a

foldl1 :: (a -> a -> a) -> NonEmpty a -> a

toList :: NonEmpty a -> [a]

null :: NonEmpty a -> Bool

length :: NonEmpty a -> Int

elem :: Eq a => a -> NonEmpty a -> Bool

maximum :: Ord a => NonEmpty a -> a

minimum :: Ord a => NonEmpty a -> a

sum :: Num a => NonEmpty a -> a

product :: Num a => NonEmpty a -> a

Foldable IntMap

Defined in Data.IntMap.Internal

Methods

fold :: Monoid m => IntMap m -> m

foldMap :: Monoid m => (a -> m) -> IntMap a -> m

foldr :: (a -> b -> b) -> b -> IntMap a -> b

foldr' :: (a -> b -> b) -> b -> IntMap a -> b

foldl :: (b -> a -> b) -> b -> IntMap a -> b

foldl' :: (b -> a -> b) -> b -> IntMap a -> b

foldr1 :: (a -> a -> a) -> IntMap a -> a

foldl1 :: (a -> a -> a) -> IntMap a -> a

toList :: IntMap a -> [a]

null :: IntMap a -> Bool

length :: IntMap a -> Int

elem :: Eq a => a -> IntMap a -> Bool

maximum :: Ord a => IntMap a -> a

minimum :: Ord a => IntMap a -> a

sum :: Num a => IntMap a -> a

product :: Num a => IntMap a -> a

Foldable Tree

Defined in Data.Tree

Methods

fold :: Monoid m => Tree m -> m

foldMap :: Monoid m => (a -> m) -> Tree a -> m

foldr :: (a -> b -> b) -> b -> Tree a -> b

foldr' :: (a -> b -> b) -> b -> Tree a -> b

foldl :: (b -> a -> b) -> b -> Tree a -> b

foldl' :: (b -> a -> b) -> b -> Tree a -> b

foldr1 :: (a -> a -> a) -> Tree a -> a

foldl1 :: (a -> a -> a) -> Tree a -> a

toList :: Tree a -> [a]

null :: Tree a -> Bool

length :: Tree a -> Int

elem :: Eq a => a -> Tree a -> Bool

maximum :: Ord a => Tree a -> a

minimum :: Ord a => Tree a -> a

sum :: Num a => Tree a -> a

product :: Num a => Tree a -> a

Foldable Seq

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Seq m -> m

foldMap :: Monoid m => (a -> m) -> Seq a -> m

foldr :: (a -> b -> b) -> b -> Seq a -> b

foldr' :: (a -> b -> b) -> b -> Seq a -> b

foldl :: (b -> a -> b) -> b -> Seq a -> b

foldl' :: (b -> a -> b) -> b -> Seq a -> b

foldr1 :: (a -> a -> a) -> Seq a -> a

foldl1 :: (a -> a -> a) -> Seq a -> a

toList :: Seq a -> [a]

null :: Seq a -> Bool

length :: Seq a -> Int

elem :: Eq a => a -> Seq a -> Bool

maximum :: Ord a => Seq a -> a

minimum :: Ord a => Seq a -> a

sum :: Num a => Seq a -> a

product :: Num a => Seq a -> a

Foldable FingerTree

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => FingerTree m -> m

foldMap :: Monoid m => (a -> m) -> FingerTree a -> m

foldr :: (a -> b -> b) -> b -> FingerTree a -> b

foldr' :: (a -> b -> b) -> b -> FingerTree a -> b

foldl :: (b -> a -> b) -> b -> FingerTree a -> b

foldl' :: (b -> a -> b) -> b -> FingerTree a -> b

foldr1 :: (a -> a -> a) -> FingerTree a -> a

foldl1 :: (a -> a -> a) -> FingerTree a -> a

toList :: FingerTree a -> [a]

null :: FingerTree a -> Bool

length :: FingerTree a -> Int

elem :: Eq a => a -> FingerTree a -> Bool

maximum :: Ord a => FingerTree a -> a

minimum :: Ord a => FingerTree a -> a

sum :: Num a => FingerTree a -> a

product :: Num a => FingerTree a -> a

Foldable Digit

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Digit m -> m

foldMap :: Monoid m => (a -> m) -> Digit a -> m

foldr :: (a -> b -> b) -> b -> Digit a -> b

foldr' :: (a -> b -> b) -> b -> Digit a -> b

foldl :: (b -> a -> b) -> b -> Digit a -> b

foldl' :: (b -> a -> b) -> b -> Digit a -> b

foldr1 :: (a -> a -> a) -> Digit a -> a

foldl1 :: (a -> a -> a) -> Digit a -> a

toList :: Digit a -> [a]

null :: Digit a -> Bool

length :: Digit a -> Int

elem :: Eq a => a -> Digit a -> Bool

maximum :: Ord a => Digit a -> a

minimum :: Ord a => Digit a -> a

sum :: Num a => Digit a -> a

product :: Num a => Digit a -> a

Foldable Node

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Node m -> m

foldMap :: Monoid m => (a -> m) -> Node a -> m

foldr :: (a -> b -> b) -> b -> Node a -> b

foldr' :: (a -> b -> b) -> b -> Node a -> b

foldl :: (b -> a -> b) -> b -> Node a -> b

foldl' :: (b -> a -> b) -> b -> Node a -> b

foldr1 :: (a -> a -> a) -> Node a -> a

foldl1 :: (a -> a -> a) -> Node a -> a

toList :: Node a -> [a]

null :: Node a -> Bool

length :: Node a -> Int

elem :: Eq a => a -> Node a -> Bool

maximum :: Ord a => Node a -> a

minimum :: Ord a => Node a -> a

sum :: Num a => Node a -> a

product :: Num a => Node a -> a

Foldable Elem

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Elem m -> m

foldMap :: Monoid m => (a -> m) -> Elem a -> m

foldr :: (a -> b -> b) -> b -> Elem a -> b

foldr' :: (a -> b -> b) -> b -> Elem a -> b

foldl :: (b -> a -> b) -> b -> Elem a -> b

foldl' :: (b -> a -> b) -> b -> Elem a -> b

foldr1 :: (a -> a -> a) -> Elem a -> a

foldl1 :: (a -> a -> a) -> Elem a -> a

toList :: Elem a -> [a]

null :: Elem a -> Bool

length :: Elem a -> Int

elem :: Eq a => a -> Elem a -> Bool

maximum :: Ord a => Elem a -> a

minimum :: Ord a => Elem a -> a

sum :: Num a => Elem a -> a

product :: Num a => Elem a -> a

Foldable ViewL

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => ViewL m -> m

foldMap :: Monoid m => (a -> m) -> ViewL a -> m

foldr :: (a -> b -> b) -> b -> ViewL a -> b

foldr' :: (a -> b -> b) -> b -> ViewL a -> b

foldl :: (b -> a -> b) -> b -> ViewL a -> b

foldl' :: (b -> a -> b) -> b -> ViewL a -> b

foldr1 :: (a -> a -> a) -> ViewL a -> a

foldl1 :: (a -> a -> a) -> ViewL a -> a

toList :: ViewL a -> [a]

null :: ViewL a -> Bool

length :: ViewL a -> Int

elem :: Eq a => a -> ViewL a -> Bool

maximum :: Ord a => ViewL a -> a

minimum :: Ord a => ViewL a -> a

sum :: Num a => ViewL a -> a

product :: Num a => ViewL a -> a

Foldable ViewR

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => ViewR m -> m

foldMap :: Monoid m => (a -> m) -> ViewR a -> m

foldr :: (a -> b -> b) -> b -> ViewR a -> b

foldr' :: (a -> b -> b) -> b -> ViewR a -> b

foldl :: (b -> a -> b) -> b -> ViewR a -> b

foldl' :: (b -> a -> b) -> b -> ViewR a -> b

foldr1 :: (a -> a -> a) -> ViewR a -> a

foldl1 :: (a -> a -> a) -> ViewR a -> a

toList :: ViewR a -> [a]

null :: ViewR a -> Bool

length :: ViewR a -> Int

elem :: Eq a => a -> ViewR a -> Bool

maximum :: Ord a => ViewR a -> a

minimum :: Ord a => ViewR a -> a

sum :: Num a => ViewR a -> a

product :: Num a => ViewR a -> a

Foldable Set

Defined in Data.Set.Internal

Methods

fold :: Monoid m => Set m -> m

foldMap :: Monoid m => (a -> m) -> Set a -> m

foldr :: (a -> b -> b) -> b -> Set a -> b

foldr' :: (a -> b -> b) -> b -> Set a -> b

foldl :: (b -> a -> b) -> b -> Set a -> b

foldl' :: (b -> a -> b) -> b -> Set a -> b

foldr1 :: (a -> a -> a) -> Set a -> a

foldl1 :: (a -> a -> a) -> Set a -> a

toList :: Set a -> [a]

null :: Set a -> Bool

length :: Set a -> Int

elem :: Eq a => a -> Set a -> Bool

maximum :: Ord a => Set a -> a

minimum :: Ord a => Set a -> a

sum :: Num a => Set a -> a

product :: Num a => Set a -> a

Foldable DList

Defined in Data.DList

Methods

fold :: Monoid m => DList m -> m

foldMap :: Monoid m => (a -> m) -> DList a -> m

foldr :: (a -> b -> b) -> b -> DList a -> b

foldr' :: (a -> b -> b) -> b -> DList a -> b

foldl :: (b -> a -> b) -> b -> DList a -> b

foldl' :: (b -> a -> b) -> b -> DList a -> b

foldr1 :: (a -> a -> a) -> DList a -> a

foldl1 :: (a -> a -> a) -> DList a -> a

toList :: DList a -> [a]

null :: DList a -> Bool

length :: DList a -> Int

elem :: Eq a => a -> DList a -> Bool

maximum :: Ord a => DList a -> a

minimum :: Ord a => DList a -> a

sum :: Num a => DList a -> a

product :: Num a => DList a -> a

Foldable HashSet

Defined in Data.HashSet

Methods

fold :: Monoid m => HashSet m -> m

foldMap :: Monoid m => (a -> m) -> HashSet a -> m

foldr :: (a -> b -> b) -> b -> HashSet a -> b

foldr' :: (a -> b -> b) -> b -> HashSet a -> b

foldl :: (b -> a -> b) -> b -> HashSet a -> b

foldl' :: (b -> a -> b) -> b -> HashSet a -> b

foldr1 :: (a -> a -> a) -> HashSet a -> a

foldl1 :: (a -> a -> a) -> HashSet a -> a

toList :: HashSet a -> [a]

null :: HashSet a -> Bool

length :: HashSet a -> Int

elem :: Eq a => a -> HashSet a -> Bool

maximum :: Ord a => HashSet a -> a

minimum :: Ord a => HashSet a -> a

sum :: Num a => HashSet a -> a

product :: Num a => HashSet a -> a

Foldable Vector

Defined in Data.Vector

Methods

fold :: Monoid m => Vector m -> m

foldMap :: Monoid m => (a -> m) -> Vector a -> m

foldr :: (a -> b -> b) -> b -> Vector a -> b

foldr' :: (a -> b -> b) -> b -> Vector a -> b

foldl :: (b -> a -> b) -> b -> Vector a -> b

foldl' :: (b -> a -> b) -> b -> Vector a -> b

foldr1 :: (a -> a -> a) -> Vector a -> a

foldl1 :: (a -> a -> a) -> Vector a -> a

toList :: Vector a -> [a]

null :: Vector a -> Bool

length :: Vector a -> Int

elem :: Eq a => a -> Vector a -> Bool

maximum :: Ord a => Vector a -> a

minimum :: Ord a => Vector a -> a

sum :: Num a => Vector a -> a

product :: Num a => Vector a -> a

Foldable Array

Defined in Data.Primitive.Array

Methods

fold :: Monoid m => Array m -> m

foldMap :: Monoid m => (a -> m) -> Array a -> m

foldr :: (a -> b -> b) -> b -> Array a -> b

foldr' :: (a -> b -> b) -> b -> Array a -> b

foldl :: (b -> a -> b) -> b -> Array a -> b

foldl' :: (b -> a -> b) -> b -> Array a -> b

foldr1 :: (a -> a -> a) -> Array a -> a

foldl1 :: (a -> a -> a) -> Array a -> a

toList :: Array a -> [a]

null :: Array a -> Bool

length :: Array a -> Int

elem :: Eq a => a -> Array a -> Bool

maximum :: Ord a => Array a -> a

minimum :: Ord a => Array a -> a

sum :: Num a => Array a -> a

product :: Num a => Array a -> a

Foldable SmallArray

Defined in Data.Primitive.SmallArray

Methods

fold :: Monoid m => SmallArray m -> m

foldMap :: Monoid m => (a -> m) -> SmallArray a -> m

foldr :: (a -> b -> b) -> b -> SmallArray a -> b

foldr' :: (a -> b -> b) -> b -> SmallArray a -> b

foldl :: (b -> a -> b) -> b -> SmallArray a -> b

foldl' :: (b -> a -> b) -> b -> SmallArray a -> b

foldr1 :: (a -> a -> a) -> SmallArray a -> a

foldl1 :: (a -> a -> a) -> SmallArray a -> a

toList :: SmallArray a -> [a]

null :: SmallArray a -> Bool

length :: SmallArray a -> Int

elem :: Eq a => a -> SmallArray a -> Bool

maximum :: Ord a => SmallArray a -> a

minimum :: Ord a => SmallArray a -> a

sum :: Num a => SmallArray a -> a

product :: Num a => SmallArray a -> a

Foldable (Either a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Either a m -> m

foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0

toList :: Either a a0 -> [a0]

null :: Either a a0 -> Bool

length :: Either a a0 -> Int

elem :: Eq a0 => a0 -> Either a a0 -> Bool

maximum :: Ord a0 => Either a a0 -> a0

minimum :: Ord a0 => Either a a0 -> a0

sum :: Num a0 => Either a a0 -> a0

product :: Num a0 => Either a a0 -> a0

Foldable (V1 :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => V1 m -> m

foldMap :: Monoid m => (a -> m) -> V1 a -> m

foldr :: (a -> b -> b) -> b -> V1 a -> b

foldr' :: (a -> b -> b) -> b -> V1 a -> b

foldl :: (b -> a -> b) -> b -> V1 a -> b

foldl' :: (b -> a -> b) -> b -> V1 a -> b

foldr1 :: (a -> a -> a) -> V1 a -> a

foldl1 :: (a -> a -> a) -> V1 a -> a

toList :: V1 a -> [a]

null :: V1 a -> Bool

length :: V1 a -> Int

elem :: Eq a => a -> V1 a -> Bool

maximum :: Ord a => V1 a -> a

minimum :: Ord a => V1 a -> a

sum :: Num a => V1 a -> a

product :: Num a => V1 a -> a

Foldable (U1 :: * -> *)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => U1 m -> m

foldMap :: Monoid m => (a -> m) -> U1 a -> m

foldr :: (a -> b -> b) -> b -> U1 a -> b

foldr' :: (a -> b -> b) -> b -> U1 a -> b

foldl :: (b -> a -> b) -> b -> U1 a -> b

foldl' :: (b -> a -> b) -> b -> U1 a -> b

foldr1 :: (a -> a -> a) -> U1 a -> a

foldl1 :: (a -> a -> a) -> U1 a -> a

toList :: U1 a -> [a]

null :: U1 a -> Bool

length :: U1 a -> Int

elem :: Eq a => a -> U1 a -> Bool

maximum :: Ord a => U1 a -> a

minimum :: Ord a => U1 a -> a

sum :: Num a => U1 a -> a

product :: Num a => U1 a -> a

Foldable ((,) a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => (a, m) -> m

foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m

foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b

foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b

foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b

foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b

foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0

foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0

toList :: (a, a0) -> [a0]

null :: (a, a0) -> Bool

length :: (a, a0) -> Int

elem :: Eq a0 => a0 -> (a, a0) -> Bool

maximum :: Ord a0 => (a, a0) -> a0

minimum :: Ord a0 => (a, a0) -> a0

sum :: Num a0 => (a, a0) -> a0

product :: Num a0 => (a, a0) -> a0

Foldable (Array i)

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Array i m -> m

foldMap :: Monoid m => (a -> m) -> Array i a -> m

foldr :: (a -> b -> b) -> b -> Array i a -> b

foldr' :: (a -> b -> b) -> b -> Array i a -> b

foldl :: (b -> a -> b) -> b -> Array i a -> b

foldl' :: (b -> a -> b) -> b -> Array i a -> b

foldr1 :: (a -> a -> a) -> Array i a -> a

foldl1 :: (a -> a -> a) -> Array i a -> a

toList :: Array i a -> [a]

null :: Array i a -> Bool

length :: Array i a -> Int

elem :: Eq a => a -> Array i a -> Bool

maximum :: Ord a => Array i a -> a

minimum :: Ord a => Array i a -> a

sum :: Num a => Array i a -> a

product :: Num a => Array i a -> a

Foldable (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Arg a m -> m

foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0

toList :: Arg a a0 -> [a0]

null :: Arg a a0 -> Bool

length :: Arg a a0 -> Int

elem :: Eq a0 => a0 -> Arg a a0 -> Bool

maximum :: Ord a0 => Arg a a0 -> a0

minimum :: Ord a0 => Arg a a0 -> a0

sum :: Num a0 => Arg a a0 -> a0

product :: Num a0 => Arg a a0 -> a0

Foldable (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Proxy m -> m

foldMap :: Monoid m => (a -> m) -> Proxy a -> m

foldr :: (a -> b -> b) -> b -> Proxy a -> b

foldr' :: (a -> b -> b) -> b -> Proxy a -> b

foldl :: (b -> a -> b) -> b -> Proxy a -> b

foldl' :: (b -> a -> b) -> b -> Proxy a -> b

foldr1 :: (a -> a -> a) -> Proxy a -> a

foldl1 :: (a -> a -> a) -> Proxy a -> a

toList :: Proxy a -> [a]

null :: Proxy a -> Bool

length :: Proxy a -> Int

elem :: Eq a => a -> Proxy a -> Bool

maximum :: Ord a => Proxy a -> a

minimum :: Ord a => Proxy a -> a

sum :: Num a => Proxy a -> a

product :: Num a => Proxy a -> a

Foldable (Map k)

Defined in Data.Map.Internal

Methods

fold :: Monoid m => Map k m -> m

foldMap :: Monoid m => (a -> m) -> Map k a -> m

foldr :: (a -> b -> b) -> b -> Map k a -> b

foldr' :: (a -> b -> b) -> b -> Map k a -> b

foldl :: (b -> a -> b) -> b -> Map k a -> b

foldl' :: (b -> a -> b) -> b -> Map k a -> b

foldr1 :: (a -> a -> a) -> Map k a -> a

foldl1 :: (a -> a -> a) -> Map k a -> a

toList :: Map k a -> [a]

null :: Map k a -> Bool

length :: Map k a -> Int

elem :: Eq a => a -> Map k a -> Bool

maximum :: Ord a => Map k a -> a

minimum :: Ord a => Map k a -> a

sum :: Num a => Map k a -> a

product :: Num a => Map k a -> a

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

Defined in Clash.Sized.Vector

Methods

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

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

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

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

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

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

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

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

toList :: Vec n a -> [a]

null :: Vec n a -> Bool

length :: Vec n a -> Int

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

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

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

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

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

Foldable (Level i)

Defined in Control.Lens.Internal.Level

Methods

fold :: Monoid m => Level i m -> m

foldMap :: Monoid m => (a -> m) -> Level i a -> m

foldr :: (a -> b -> b) -> b -> Level i a -> b

foldr' :: (a -> b -> b) -> b -> Level i a -> b

foldl :: (b -> a -> b) -> b -> Level i a -> b

foldl' :: (b -> a -> b) -> b -> Level i a -> b

foldr1 :: (a -> a -> a) -> Level i a -> a

foldl1 :: (a -> a -> a) -> Level i a -> a

toList :: Level i a -> [a]

null :: Level i a -> Bool

length :: Level i a -> Int

elem :: Eq a => a -> Level i a -> Bool

maximum :: Ord a => Level i a -> a

minimum :: Ord a => Level i a -> a

sum :: Num a => Level i a -> a

product :: Num a => Level i a -> a

Foldable f => Foldable (Cofree f)

Defined in Control.Comonad.Cofree

Methods

fold :: Monoid m => Cofree f m -> m

foldMap :: Monoid m => (a -> m) -> Cofree f a -> m

foldr :: (a -> b -> b) -> b -> Cofree f a -> b

foldr' :: (a -> b -> b) -> b -> Cofree f a -> b

foldl :: (b -> a -> b) -> b -> Cofree f a -> b

foldl' :: (b -> a -> b) -> b -> Cofree f a -> b

foldr1 :: (a -> a -> a) -> Cofree f a -> a

foldl1 :: (a -> a -> a) -> Cofree f a -> a

toList :: Cofree f a -> [a]

null :: Cofree f a -> Bool

length :: Cofree f a -> Int

elem :: Eq a => a -> Cofree f a -> Bool

maximum :: Ord a => Cofree f a -> a

minimum :: Ord a => Cofree f a -> a

sum :: Num a => Cofree f a -> a

product :: Num a => Cofree f a -> a

Foldable f => Foldable (Free f)

Defined in Control.Monad.Free

Methods

fold :: Monoid m => Free f m -> m

foldMap :: Monoid m => (a -> m) -> Free f a -> m

foldr :: (a -> b -> b) -> b -> Free f a -> b

foldr' :: (a -> b -> b) -> b -> Free f a -> b

foldl :: (b -> a -> b) -> b -> Free f a -> b

foldl' :: (b -> a -> b) -> b -> Free f a -> b

foldr1 :: (a -> a -> a) -> Free f a -> a

foldl1 :: (a -> a -> a) -> Free f a -> a

toList :: Free f a -> [a]

null :: Free f a -> Bool

length :: Free f a -> Int

elem :: Eq a => a -> Free f a -> Bool

maximum :: Ord a => Free f a -> a

minimum :: Ord a => Free f a -> a

sum :: Num a => Free f a -> a

product :: Num a => Free f a -> a

Foldable f => Foldable (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

fold :: Monoid m => Yoneda f m -> m

foldMap :: Monoid m => (a -> m) -> Yoneda f a -> m

foldr :: (a -> b -> b) -> b -> Yoneda f a -> b

foldr' :: (a -> b -> b) -> b -> Yoneda f a -> b

foldl :: (b -> a -> b) -> b -> Yoneda f a -> b

foldl' :: (b -> a -> b) -> b -> Yoneda f a -> b

foldr1 :: (a -> a -> a) -> Yoneda f a -> a

foldl1 :: (a -> a -> a) -> Yoneda f a -> a

toList :: Yoneda f a -> [a]

null :: Yoneda f a -> Bool

length :: Yoneda f a -> Int

elem :: Eq a => a -> Yoneda f a -> Bool

maximum :: Ord a => Yoneda f a -> a

minimum :: Ord a => Yoneda f a -> a

sum :: Num a => Yoneda f a -> a

product :: Num a => Yoneda f a -> a

Foldable (HashMap k)

Defined in Data.HashMap.Base

Methods

fold :: Monoid m => HashMap k m -> m

foldMap :: Monoid m => (a -> m) -> HashMap k a -> m

foldr :: (a -> b -> b) -> b -> HashMap k a -> b

foldr' :: (a -> b -> b) -> b -> HashMap k a -> b

foldl :: (b -> a -> b) -> b -> HashMap k a -> b

foldl' :: (b -> a -> b) -> b -> HashMap k a -> b

foldr1 :: (a -> a -> a) -> HashMap k a -> a

foldl1 :: (a -> a -> a) -> HashMap k a -> a

toList :: HashMap k a -> [a]

null :: HashMap k a -> Bool

length :: HashMap k a -> Int

elem :: Eq a => a -> HashMap k a -> Bool

maximum :: Ord a => HashMap k a -> a

minimum :: Ord a => HashMap k a -> a

sum :: Num a => HashMap k a -> a

product :: Num a => HashMap k a -> a

Foldable (Signal domain)

NB: Not synthesisable

NB: In "foldr f z s":

• The function f should be lazy in its second argument.
• The z element will never be used.

Defined in Clash.Signal.Internal

Methods

fold :: Monoid m => Signal domain m -> m

foldMap :: Monoid m => (a -> m) -> Signal domain a -> m

foldr :: (a -> b -> b) -> b -> Signal domain a -> b

foldr' :: (a -> b -> b) -> b -> Signal domain a -> b

foldl :: (b -> a -> b) -> b -> Signal domain a -> b

foldl' :: (b -> a -> b) -> b -> Signal domain a -> b

foldr1 :: (a -> a -> a) -> Signal domain a -> a

foldl1 :: (a -> a -> a) -> Signal domain a -> a

toList :: Signal domain a -> [a]

null :: Signal domain a -> Bool

length :: Signal domain a -> Int

elem :: Eq a => a -> Signal domain a -> Bool

maximum :: Ord a => Signal domain a -> a

minimum :: Ord a => Signal domain a -> a

sum :: Num a => Signal domain a -> a

product :: Num a => Signal domain a -> a

KnownNat d => Foldable (RTree d)

Defined in Clash.Sized.RTree

Methods

fold :: Monoid m => RTree d m -> m

foldMap :: Monoid m => (a -> m) -> RTree d a -> m

foldr :: (a -> b -> b) -> b -> RTree d a -> b

foldr' :: (a -> b -> b) -> b -> RTree d a -> b

foldl :: (b -> a -> b) -> b -> RTree d a -> b

foldl' :: (b -> a -> b) -> b -> RTree d a -> b

foldr1 :: (a -> a -> a) -> RTree d a -> a

foldl1 :: (a -> a -> a) -> RTree d a -> a

toList :: RTree d a -> [a]

null :: RTree d a -> Bool

length :: RTree d a -> Int

elem :: Eq a => a -> RTree d a -> Bool

maximum :: Ord a => RTree d a -> a

minimum :: Ord a => RTree d a -> a

sum :: Num a => RTree d a -> a

product :: Num a => RTree d a -> a

Foldable f => Foldable (Rec1 f)

Defined in Data.Foldable

Methods

fold :: Monoid m => Rec1 f m -> m

foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m

foldr :: (a -> b -> b) -> b -> Rec1 f a -> b

foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b

foldl :: (b -> a -> b) -> b -> Rec1 f a -> b

foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b

foldr1 :: (a -> a -> a) -> Rec1 f a -> a

foldl1 :: (a -> a -> a) -> Rec1 f a -> a

toList :: Rec1 f a -> [a]

null :: Rec1 f a -> Bool

length :: Rec1 f a -> Int

elem :: Eq a => a -> Rec1 f a -> Bool

maximum :: Ord a => Rec1 f a -> a

minimum :: Ord a => Rec1 f a -> a

sum :: Num a => Rec1 f a -> a

product :: Num a => Rec1 f a -> a

Foldable (URec Char :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Char m -> m

foldMap :: Monoid m => (a -> m) -> URec Char a -> m

foldr :: (a -> b -> b) -> b -> URec Char a -> b

foldr' :: (a -> b -> b) -> b -> URec Char a -> b

foldl :: (b -> a -> b) -> b -> URec Char a -> b

foldl' :: (b -> a -> b) -> b -> URec Char a -> b

foldr1 :: (a -> a -> a) -> URec Char a -> a

foldl1 :: (a -> a -> a) -> URec Char a -> a

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

elem :: Eq a => a -> URec Char a -> Bool

maximum :: Ord a => URec Char a -> a

minimum :: Ord a => URec Char a -> a

sum :: Num a => URec Char a -> a

product :: Num a => URec Char a -> a

Foldable (URec Double :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Double m -> m

foldMap :: Monoid m => (a -> m) -> URec Double a -> m

foldr :: (a -> b -> b) -> b -> URec Double a -> b

foldr' :: (a -> b -> b) -> b -> URec Double a -> b

foldl :: (b -> a -> b) -> b -> URec Double a -> b

foldl' :: (b -> a -> b) -> b -> URec Double a -> b

foldr1 :: (a -> a -> a) -> URec Double a -> a

foldl1 :: (a -> a -> a) -> URec Double a -> a

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

elem :: Eq a => a -> URec Double a -> Bool

maximum :: Ord a => URec Double a -> a

minimum :: Ord a => URec Double a -> a

sum :: Num a => URec Double a -> a

product :: Num a => URec Double a -> a

Foldable (URec Float :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Float m -> m

foldMap :: Monoid m => (a -> m) -> URec Float a -> m

foldr :: (a -> b -> b) -> b -> URec Float a -> b

foldr' :: (a -> b -> b) -> b -> URec Float a -> b

foldl :: (b -> a -> b) -> b -> URec Float a -> b

foldl' :: (b -> a -> b) -> b -> URec Float a -> b

foldr1 :: (a -> a -> a) -> URec Float a -> a

foldl1 :: (a -> a -> a) -> URec Float a -> a

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

elem :: Eq a => a -> URec Float a -> Bool

maximum :: Ord a => URec Float a -> a

minimum :: Ord a => URec Float a -> a

sum :: Num a => URec Float a -> a

product :: Num a => URec Float a -> a

Foldable (URec Int :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Int m -> m

foldMap :: Monoid m => (a -> m) -> URec Int a -> m

foldr :: (a -> b -> b) -> b -> URec Int a -> b

foldr' :: (a -> b -> b) -> b -> URec Int a -> b

foldl :: (b -> a -> b) -> b -> URec Int a -> b

foldl' :: (b -> a -> b) -> b -> URec Int a -> b

foldr1 :: (a -> a -> a) -> URec Int a -> a

foldl1 :: (a -> a -> a) -> URec Int a -> a

toList :: URec Int a -> [a]

null :: URec Int a -> Bool

length :: URec Int a -> Int

elem :: Eq a => a -> URec Int a -> Bool

maximum :: Ord a => URec Int a -> a

minimum :: Ord a => URec Int a -> a

sum :: Num a => URec Int a -> a

product :: Num a => URec Int a -> a

Foldable (URec Word :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Word m -> m

foldMap :: Monoid m => (a -> m) -> URec Word a -> m

foldr :: (a -> b -> b) -> b -> URec Word a -> b

foldr' :: (a -> b -> b) -> b -> URec Word a -> b

foldl :: (b -> a -> b) -> b -> URec Word a -> b

foldl' :: (b -> a -> b) -> b -> URec Word a -> b

foldr1 :: (a -> a -> a) -> URec Word a -> a

foldl1 :: (a -> a -> a) -> URec Word a -> a

toList :: URec Word a -> [a]

null :: URec Word a -> Bool

length :: URec Word a -> Int

elem :: Eq a => a -> URec Word a -> Bool

maximum :: Ord a => URec Word a -> a

minimum :: Ord a => URec Word a -> a

sum :: Num a => URec Word a -> a

product :: Num a => URec Word a -> a

Foldable (URec (Ptr ()) :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec (Ptr ()) m -> m

foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m

foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

toList :: URec (Ptr ()) a -> [a]

null :: URec (Ptr ()) a -> Bool

length :: URec (Ptr ()) a -> Int

elem :: Eq a => a -> URec (Ptr ()) a -> Bool

maximum :: Ord a => URec (Ptr ()) a -> a

minimum :: Ord a => URec (Ptr ()) a -> a

sum :: Num a => URec (Ptr ()) a -> a

product :: Num a => URec (Ptr ()) a -> a

Foldable (Const m :: * -> *)

Since: base-4.7.0.0

Defined in Data.Functor.Const

Methods

fold :: Monoid m0 => Const m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0

foldr :: (a -> b -> b) -> b -> Const m a -> b

foldr' :: (a -> b -> b) -> b -> Const m a -> b

foldl :: (b -> a -> b) -> b -> Const m a -> b

foldl' :: (b -> a -> b) -> b -> Const m a -> b

foldr1 :: (a -> a -> a) -> Const m a -> a

foldl1 :: (a -> a -> a) -> Const m a -> a

toList :: Const m a -> [a]

null :: Const m a -> Bool

length :: Const m a -> Int

elem :: Eq a => a -> Const m a -> Bool

maximum :: Ord a => Const m a -> a

minimum :: Ord a => Const m a -> a

sum :: Num a => Const m a -> a

product :: Num a => Const m a -> a

Foldable f => Foldable (ErrorT e f)

Defined in Control.Monad.Trans.Error

Methods

fold :: Monoid m => ErrorT e f m -> m

foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m

foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldr1 :: (a -> a -> a) -> ErrorT e f a -> a

foldl1 :: (a -> a -> a) -> ErrorT e f a -> a

toList :: ErrorT e f a -> [a]

null :: ErrorT e f a -> Bool

length :: ErrorT e f a -> Int

elem :: Eq a => a -> ErrorT e f a -> Bool

maximum :: Ord a => ErrorT e f a -> a

minimum :: Ord a => ErrorT e f a -> a

sum :: Num a => ErrorT e f a -> a

product :: Num a => ErrorT e f a -> a

Foldable (Constant a :: * -> *)

Defined in Data.Functor.Constant

Methods

fold :: Monoid m => Constant a m -> m

foldMap :: Monoid m => (a0 -> m) -> Constant a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Constant a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Constant a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Constant a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Constant a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Constant a a0 -> a0

toList :: Constant a a0 -> [a0]

null :: Constant a a0 -> Bool

length :: Constant a a0 -> Int

elem :: Eq a0 => a0 -> Constant a a0 -> Bool

maximum :: Ord a0 => Constant a a0 -> a0

minimum :: Ord a0 => Constant a a0 -> a0

sum :: Num a0 => Constant a a0 -> a0

product :: Num a0 => Constant a a0 -> a0

Foldable (Tagged s)

Defined in Data.Tagged

Methods

fold :: Monoid m => Tagged s m -> m

foldMap :: Monoid m => (a -> m) -> Tagged s a -> m

foldr :: (a -> b -> b) -> b -> Tagged s a -> b

foldr' :: (a -> b -> b) -> b -> Tagged s a -> b

foldl :: (b -> a -> b) -> b -> Tagged s a -> b

foldl' :: (b -> a -> b) -> b -> Tagged s a -> b

foldr1 :: (a -> a -> a) -> Tagged s a -> a

foldl1 :: (a -> a -> a) -> Tagged s a -> a

toList :: Tagged s a -> [a]

null :: Tagged s a -> Bool

length :: Tagged s a -> Int

elem :: Eq a => a -> Tagged s a -> Bool

maximum :: Ord a => Tagged s a -> a

minimum :: Ord a => Tagged s a -> a

sum :: Num a => Tagged s a -> a

product :: Num a => Tagged s a -> a

Bifoldable p => Foldable (Fix p)

Defined in Data.Bifunctor.Fix

Methods

fold :: Monoid m => Fix p m -> m

foldMap :: Monoid m => (a -> m) -> Fix p a -> m

foldr :: (a -> b -> b) -> b -> Fix p a -> b

foldr' :: (a -> b -> b) -> b -> Fix p a -> b

foldl :: (b -> a -> b) -> b -> Fix p a -> b

foldl' :: (b -> a -> b) -> b -> Fix p a -> b

foldr1 :: (a -> a -> a) -> Fix p a -> a

foldl1 :: (a -> a -> a) -> Fix p a -> a

toList :: Fix p a -> [a]

null :: Fix p a -> Bool

length :: Fix p a -> Int

elem :: Eq a => a -> Fix p a -> Bool

maximum :: Ord a => Fix p a -> a

minimum :: Ord a => Fix p a -> a

sum :: Num a => Fix p a -> a

product :: Num a => Fix p a -> a

Bifoldable p => Foldable (Join p)

Defined in Data.Bifunctor.Join

Methods

fold :: Monoid m => Join p m -> m

foldMap :: Monoid m => (a -> m) -> Join p a -> m

foldr :: (a -> b -> b) -> b -> Join p a -> b

foldr' :: (a -> b -> b) -> b -> Join p a -> b

foldl :: (b -> a -> b) -> b -> Join p a -> b

foldl' :: (b -> a -> b) -> b -> Join p a -> b

foldr1 :: (a -> a -> a) -> Join p a -> a

foldl1 :: (a -> a -> a) -> Join p a -> a

toList :: Join p a -> [a]

null :: Join p a -> Bool

length :: Join p a -> Int

elem :: Eq a => a -> Join p a -> Bool

maximum :: Ord a => Join p a -> a

minimum :: Ord a => Join p a -> a

sum :: Num a => Join p a -> a

product :: Num a => Join p a -> a

Foldable f => Foldable (CofreeF f a)

Defined in Control.Comonad.Trans.Cofree

Methods

fold :: Monoid m => CofreeF f a m -> m

foldMap :: Monoid m => (a0 -> m) -> CofreeF f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> CofreeF f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> CofreeF f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> CofreeF f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> CofreeF f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> CofreeF f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> CofreeF f a a0 -> a0

toList :: CofreeF f a a0 -> [a0]

null :: CofreeF f a a0 -> Bool

length :: CofreeF f a a0 -> Int

elem :: Eq a0 => a0 -> CofreeF f a a0 -> Bool

maximum :: Ord a0 => CofreeF f a a0 -> a0

minimum :: Ord a0 => CofreeF f a a0 -> a0

sum :: Num a0 => CofreeF f a a0 -> a0

product :: Num a0 => CofreeF f a a0 -> a0

(Foldable f, Foldable w) => Foldable (CofreeT f w)

Defined in Control.Comonad.Trans.Cofree

Methods

fold :: Monoid m => CofreeT f w m -> m

foldMap :: Monoid m => (a -> m) -> CofreeT f w a -> m

foldr :: (a -> b -> b) -> b -> CofreeT f w a -> b

foldr' :: (a -> b -> b) -> b -> CofreeT f w a -> b

foldl :: (b -> a -> b) -> b -> CofreeT f w a -> b

foldl' :: (b -> a -> b) -> b -> CofreeT f w a -> b

foldr1 :: (a -> a -> a) -> CofreeT f w a -> a

foldl1 :: (a -> a -> a) -> CofreeT f w a -> a

toList :: CofreeT f w a -> [a]

null :: CofreeT f w a -> Bool

length :: CofreeT f w a -> Int

elem :: Eq a => a -> CofreeT f w a -> Bool

maximum :: Ord a => CofreeT f w a -> a

minimum :: Ord a => CofreeT f w a -> a

sum :: Num a => CofreeT f w a -> a

product :: Num a => CofreeT f w a -> a

(Foldable m, Foldable f) => Foldable (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

fold :: Monoid m0 => FreeT f m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0

foldr :: (a -> b -> b) -> b -> FreeT f m a -> b

foldr' :: (a -> b -> b) -> b -> FreeT f m a -> b

foldl :: (b -> a -> b) -> b -> FreeT f m a -> b

foldl' :: (b -> a -> b) -> b -> FreeT f m a -> b

foldr1 :: (a -> a -> a) -> FreeT f m a -> a

foldl1 :: (a -> a -> a) -> FreeT f m a -> a

toList :: FreeT f m a -> [a]

null :: FreeT f m a -> Bool

length :: FreeT f m a -> Int

elem :: Eq a => a -> FreeT f m a -> Bool

maximum :: Ord a => FreeT f m a -> a

minimum :: Ord a => FreeT f m a -> a

sum :: Num a => FreeT f m a -> a

product :: Num a => FreeT f m a -> a

Foldable f => Foldable (FreeF f a)

Defined in Control.Monad.Trans.Free

Methods

fold :: Monoid m => FreeF f a m -> m

foldMap :: Monoid m => (a0 -> m) -> FreeF f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0

toList :: FreeF f a a0 -> [a0]

null :: FreeF f a a0 -> Bool

length :: FreeF f a a0 -> Int

elem :: Eq a0 => a0 -> FreeF f a a0 -> Bool

maximum :: Ord a0 => FreeF f a a0 -> a0

minimum :: Ord a0 => FreeF f a a0 -> a0

sum :: Num a0 => FreeF f a a0 -> a0

product :: Num a0 => FreeF f a a0 -> a0

Foldable (DSignal domain delay)

Defined in Clash.Explicit.Signal.Delayed

Methods

fold :: Monoid m => DSignal domain delay m -> m

foldMap :: Monoid m => (a -> m) -> DSignal domain delay a -> m

foldr :: (a -> b -> b) -> b -> DSignal domain delay a -> b

foldr' :: (a -> b -> b) -> b -> DSignal domain delay a -> b

foldl :: (b -> a -> b) -> b -> DSignal domain delay a -> b

foldl' :: (b -> a -> b) -> b -> DSignal domain delay a -> b

foldr1 :: (a -> a -> a) -> DSignal domain delay a -> a

foldl1 :: (a -> a -> a) -> DSignal domain delay a -> a

toList :: DSignal domain delay a -> [a]

null :: DSignal domain delay a -> Bool

length :: DSignal domain delay a -> Int

elem :: Eq a => a -> DSignal domain delay a -> Bool

maximum :: Ord a => DSignal domain delay a -> a

minimum :: Ord a => DSignal domain delay a -> a

sum :: Num a => DSignal domain delay a -> a

product :: Num a => DSignal domain delay a -> a

Foldable (K1 i c :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => K1 i c m -> m

foldMap :: Monoid m => (a -> m) -> K1 i c a -> m

foldr :: (a -> b -> b) -> b -> K1 i c a -> b

foldr' :: (a -> b -> b) -> b -> K1 i c a -> b

foldl :: (b -> a -> b) -> b -> K1 i c a -> b

foldl' :: (b -> a -> b) -> b -> K1 i c a -> b

foldr1 :: (a -> a -> a) -> K1 i c a -> a

foldl1 :: (a -> a -> a) -> K1 i c a -> a

toList :: K1 i c a -> [a]

null :: K1 i c a -> Bool

length :: K1 i c a -> Int

elem :: Eq a => a -> K1 i c a -> Bool

maximum :: Ord a => K1 i c a -> a

minimum :: Ord a => K1 i c a -> a

sum :: Num a => K1 i c a -> a

product :: Num a => K1 i c a -> a

(Foldable f, Foldable g) => Foldable (f :+: g)

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :+: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldr1 :: (a -> a -> a) -> (f :+: g) a -> a

foldl1 :: (a -> a -> a) -> (f :+: g) a -> a

toList :: (f :+: g) a -> [a]

null :: (f :+: g) a -> Bool

length :: (f :+: g) a -> Int

elem :: Eq a => a -> (f :+: g) a -> Bool

maximum :: Ord a => (f :+: g) a -> a

minimum :: Ord a => (f :+: g) a -> a

sum :: Num a => (f :+: g) a -> a

product :: Num a => (f :+: g) a -> a

(Foldable f, Foldable g) => Foldable (f :*: g)

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :*: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b

foldr1 :: (a -> a -> a) -> (f :*: g) a -> a

foldl1 :: (a -> a -> a) -> (f :*: g) a -> a

toList :: (f :*: g) a -> [a]

null :: (f :*: g) a -> Bool

length :: (f :*: g) a -> Int

elem :: Eq a => a -> (f :*: g) a -> Bool

maximum :: Ord a => (f :*: g) a -> a

minimum :: Ord a => (f :*: g) a -> a

sum :: Num a => (f :*: g) a -> a

product :: Num a => (f :*: g) a -> a

(Foldable f, Foldable g) => Foldable (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

fold :: Monoid m => Product f g m -> m

foldMap :: Monoid m => (a -> m) -> Product f g a -> m

foldr :: (a -> b -> b) -> b -> Product f g a -> b

foldr' :: (a -> b -> b) -> b -> Product f g a -> b

foldl :: (b -> a -> b) -> b -> Product f g a -> b

foldl' :: (b -> a -> b) -> b -> Product f g a -> b

foldr1 :: (a -> a -> a) -> Product f g a -> a

foldl1 :: (a -> a -> a) -> Product f g a -> a

toList :: Product f g a -> [a]

null :: Product f g a -> Bool

length :: Product f g a -> Int

elem :: Eq a => a -> Product f g a -> Bool

maximum :: Ord a => Product f g a -> a

minimum :: Ord a => Product f g a -> a

sum :: Num a => Product f g a -> a

product :: Num a => Product f g a -> a

(Foldable f, Foldable g) => Foldable (Sum f g)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

fold :: Monoid m => Sum f g m -> m

foldMap :: Monoid m => (a -> m) -> Sum f g a -> m

foldr :: (a -> b -> b) -> b -> Sum f g a -> b

foldr' :: (a -> b -> b) -> b -> Sum f g a -> b

foldl :: (b -> a -> b) -> b -> Sum f g a -> b

foldl' :: (b -> a -> b) -> b -> Sum f g a -> b

foldr1 :: (a -> a -> a) -> Sum f g a -> a

foldl1 :: (a -> a -> a) -> Sum f g a -> a

toList :: Sum f g a -> [a]

null :: Sum f g a -> Bool

length :: Sum f g a -> Int

elem :: Eq a => a -> Sum f g a -> Bool

maximum :: Ord a => Sum f g a -> a

minimum :: Ord a => Sum f g a -> a

sum :: Num a => Sum f g a -> a

product :: Num a => Sum f g a -> a

Foldable (Magma i t b)

Defined in Control.Lens.Internal.Magma

Methods

fold :: Monoid m => Magma i t b m -> m

foldMap :: Monoid m => (a -> m) -> Magma i t b a -> m

foldr :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0

foldr' :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0

foldl :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0

foldl' :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0

foldr1 :: (a -> a -> a) -> Magma i t b a -> a

foldl1 :: (a -> a -> a) -> Magma i t b a -> a

toList :: Magma i t b a -> [a]

null :: Magma i t b a -> Bool

length :: Magma i t b a -> Int

elem :: Eq a => a -> Magma i t b a -> Bool

maximum :: Ord a => Magma i t b a -> a

minimum :: Ord a => Magma i t b a -> a

sum :: Num a => Magma i t b a -> a

product :: Num a => Magma i t b a -> a

Foldable f => Foldable (M1 i c f)

Defined in Data.Foldable

Methods

fold :: Monoid m => M1 i c f m -> m

foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m

foldr :: (a -> b -> b) -> b -> M1 i c f a -> b

foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b

foldl :: (b -> a -> b) -> b -> M1 i c f a -> b

foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b

foldr1 :: (a -> a -> a) -> M1 i c f a -> a

foldl1 :: (a -> a -> a) -> M1 i c f a -> a

toList :: M1 i c f a -> [a]

null :: M1 i c f a -> Bool

length :: M1 i c f a -> Int

elem :: Eq a => a -> M1 i c f a -> Bool

maximum :: Ord a => M1 i c f a -> a

minimum :: Ord a => M1 i c f a -> a

sum :: Num a => M1 i c f a -> a

product :: Num a => M1 i c f a -> a

(Foldable f, Foldable g) => Foldable (f :.: g)

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :.: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b

foldr1 :: (a -> a -> a) -> (f :.: g) a -> a

foldl1 :: (a -> a -> a) -> (f :.: g) a -> a

toList :: (f :.: g) a -> [a]

null :: (f :.: g) a -> Bool

length :: (f :.: g) a -> Int

elem :: Eq a => a -> (f :.: g) a -> Bool

maximum :: Ord a => (f :.: g) a -> a

minimum :: Ord a => (f :.: g) a -> a

sum :: Num a => (f :.: g) a -> a

product :: Num a => (f :.: g) a -> a

(Foldable f, Foldable g) => Foldable (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

fold :: Monoid m => Compose f g m -> m

foldMap :: Monoid m => (a -> m) -> Compose f g a -> m

foldr :: (a -> b -> b) -> b -> Compose f g a -> b

foldr' :: (a -> b -> b) -> b -> Compose f g a -> b

foldl :: (b -> a -> b) -> b -> Compose f g a -> b

foldl' :: (b -> a -> b) -> b -> Compose f g a -> b

foldr1 :: (a -> a -> a) -> Compose f g a -> a

foldl1 :: (a -> a -> a) -> Compose f g a -> a

toList :: Compose f g a -> [a]

null :: Compose f g a -> Bool

length :: Compose f g a -> Int

elem :: Eq a => a -> Compose f g a -> Bool

maximum :: Ord a => Compose f g a -> a

minimum :: Ord a => Compose f g a -> a

sum :: Num a => Compose f g a -> a

product :: Num a => Compose f g a -> a

Foldable (Clown f a :: * -> *)

Defined in Data.Bifunctor.Clown

Methods

fold :: Monoid m => Clown f a m -> m

foldMap :: Monoid m => (a0 -> m) -> Clown f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Clown f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Clown f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Clown f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Clown f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0

toList :: Clown f a a0 -> [a0]

null :: Clown f a a0 -> Bool

length :: Clown f a a0 -> Int

elem :: Eq a0 => a0 -> Clown f a a0 -> Bool

maximum :: Ord a0 => Clown f a a0 -> a0

minimum :: Ord a0 => Clown f a a0 -> a0

sum :: Num a0 => Clown f a a0 -> a0

product :: Num a0 => Clown f a a0 -> a0

Bifoldable p => Foldable (Flip p a)

Defined in Data.Bifunctor.Flip

Methods

fold :: Monoid m => Flip p a m -> m

foldMap :: Monoid m => (a0 -> m) -> Flip p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Flip p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Flip p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Flip p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Flip p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0

toList :: Flip p a a0 -> [a0]

null :: Flip p a a0 -> Bool

length :: Flip p a a0 -> Int

elem :: Eq a0 => a0 -> Flip p a a0 -> Bool

maximum :: Ord a0 => Flip p a a0 -> a0

minimum :: Ord a0 => Flip p a a0 -> a0

sum :: Num a0 => Flip p a a0 -> a0

product :: Num a0 => Flip p a a0 -> a0

Foldable g => Foldable (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

fold :: Monoid m => Joker g a m -> m

foldMap :: Monoid m => (a0 -> m) -> Joker g a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Joker g a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Joker g a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Joker g a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Joker g a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0

toList :: Joker g a a0 -> [a0]

null :: Joker g a a0 -> Bool

length :: Joker g a a0 -> Int

elem :: Eq a0 => a0 -> Joker g a a0 -> Bool

maximum :: Ord a0 => Joker g a a0 -> a0

minimum :: Ord a0 => Joker g a a0 -> a0

sum :: Num a0 => Joker g a a0 -> a0

product :: Num a0 => Joker g a a0 -> a0

Bifoldable p => Foldable (WrappedBifunctor p a)

Defined in Data.Bifunctor.Wrapped

Methods

fold :: Monoid m => WrappedBifunctor p a m -> m

foldMap :: Monoid m => (a0 -> m) -> WrappedBifunctor p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> WrappedBifunctor p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> WrappedBifunctor p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> WrappedBifunctor p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> WrappedBifunctor p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> WrappedBifunctor p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> WrappedBifunctor p a a0 -> a0

toList :: WrappedBifunctor p a a0 -> [a0]

null :: WrappedBifunctor p a a0 -> Bool

length :: WrappedBifunctor p a a0 -> Int

elem :: Eq a0 => a0 -> WrappedBifunctor p a a0 -> Bool

maximum :: Ord a0 => WrappedBifunctor p a a0 -> a0

minimum :: Ord a0 => WrappedBifunctor p a a0 -> a0

sum :: Num a0 => WrappedBifunctor p a a0 -> a0

product :: Num a0 => WrappedBifunctor p a a0 -> a0

(Foldable f, Bifoldable p) => Foldable (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

fold :: Monoid m => Tannen f p a m -> m

foldMap :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0

toList :: Tannen f p a a0 -> [a0]

null :: Tannen f p a a0 -> Bool

length :: Tannen f p a a0 -> Int

elem :: Eq a0 => a0 -> Tannen f p a a0 -> Bool

maximum :: Ord a0 => Tannen f p a a0 -> a0

minimum :: Ord a0 => Tannen f p a a0 -> a0

sum :: Num a0 => Tannen f p a a0 -> a0

product :: Num a0 => Tannen f p a a0 -> a0

(Bifoldable p, Foldable g) => Foldable (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

fold :: Monoid m => Biff p f g a m -> m

foldMap :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0

toList :: Biff p f g a a0 -> [a0]

null :: Biff p f g a a0 -> Bool

length :: Biff p f g a a0 -> Int

elem :: Eq a0 => a0 -> Biff p f g a a0 -> Bool

maximum :: Ord a0 => Biff p f g a a0 -> a0

minimum :: Ord a0 => Biff p f g a a0 -> a0

sum :: Num a0 => Biff p f g a a0 -> a0

product :: Num a0 => Biff p f g a a0 -> a0

class (Functor t, Foldable t) => Traversable (t :: * -> *) where

Functors representing data structures that can be traversed from left to right.

A definition of traverse must satisfy the following laws:

naturality

t . traverse f = traverse (t . f) for every applicative transformation t

identity

traverse Identity = Identity

composition

traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality

t . sequenceA = sequenceA . fmap t for every applicative transformation t

identity

sequenceA . fmap Identity = Identity

composition

sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations, i.e.

• t (pure x) = pure x

• t (x <*> y) = t x <*> t y

and the identity functor Identity and composition of functors Compose are defined as

  newtype Identity a = Identity a

  instance Functor Identity where
    fmap f (Identity x) = Identity (f x)

  instance Applicative Identity where
    pure x = Identity x
    Identity f <*> Identity x = Identity (f x)

  newtype Compose f g a = Compose (f (g a))

  instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose x) = Compose (fmap (fmap f) x)

  instance (Applicative f, Applicative g) => Applicative (Compose f g) where
    pure x = Compose (pure (pure x))
    Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

(The naturality law is implied by parametricity.)

Instances are similar to Functor, e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree where
   traverse f Empty = pure Empty
   traverse f (Leaf x) = Leaf <$> f x
   traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

• In the Functor instance, fmap should be equivalent to traversal with the identity applicative functor (fmapDefault).
• In the Foldable instance, foldMap should be equivalent to traversal with a constant applicative functor (foldMapDefault).

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b)

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

sequenceA :: Applicative f => t (f a) -> f (t a)

Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see sequenceA_.

mapM :: Monad m => (a -> m b) -> t a -> m (t b)

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_.

sequence :: Monad m => t (m a) -> m (t a)

Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_.

Instances

Traversable []

Since: base-2.1

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> [a] -> f [b]

sequenceA :: Applicative f => [f a] -> f [a]

mapM :: Monad m => (a -> m b) -> [a] -> m [b]

sequence :: Monad m => [m a] -> m [a]

Traversable Maybe

Since: base-2.1

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b)

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a)

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)

sequence :: Monad m => Maybe (m a) -> m (Maybe a)

Traversable Par1

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b)

sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a)

mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b)

sequence :: Monad m => Par1 (m a) -> m (Par1 a)

Traversable Complex

Defined in Data.Complex

Methods

traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b)

sequenceA :: Applicative f => Complex (f a) -> f (Complex a)

mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b)

sequence :: Monad m => Complex (m a) -> m (Complex a)

Traversable Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b)

sequenceA :: Applicative f => Min (f a) -> f (Min a)

mapM :: Monad m => (a -> m b) -> Min a -> m (Min b)

sequence :: Monad m => Min (m a) -> m (Min a)

Traversable Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b)

sequenceA :: Applicative f => Max (f a) -> f (Max a)

mapM :: Monad m => (a -> m b) -> Max a -> m (Max b)

sequence :: Monad m => Max (m a) -> m (Max a)

Traversable First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> First a -> f (First b)

sequenceA :: Applicative f => First (f a) -> f (First a)

mapM :: Monad m => (a -> m b) -> First a -> m (First b)

sequence :: Monad m => First (m a) -> m (First a)

Traversable Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b)

sequenceA :: Applicative f => Last (f a) -> f (Last a)

mapM :: Monad m => (a -> m b) -> Last a -> m (Last b)

sequence :: Monad m => Last (m a) -> m (Last a)

Traversable Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b)

sequenceA :: Applicative f => Option (f a) -> f (Option a)

mapM :: Monad m => (a -> m b) -> Option a -> m (Option b)

sequence :: Monad m => Option (m a) -> m (Option a)

Traversable ZipList

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b)

sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a)

mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b)

sequence :: Monad m => ZipList (m a) -> m (ZipList a)

Traversable Identity

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b)

sequenceA :: Applicative f => Identity (f a) -> f (Identity a)

mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b)

sequence :: Monad m => Identity (m a) -> m (Identity a)

Traversable First

Since: base-4.8.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> First a -> f (First b)

sequenceA :: Applicative f => First (f a) -> f (First a)

mapM :: Monad m => (a -> m b) -> First a -> m (First b)

sequence :: Monad m => First (m a) -> m (First a)

Traversable Last

Since: base-4.8.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b)

sequenceA :: Applicative f => Last (f a) -> f (Last a)

mapM :: Monad m => (a -> m b) -> Last a -> m (Last b)

sequence :: Monad m => Last (m a) -> m (Last a)

Traversable Dual

Since: base-4.8.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b)

sequenceA :: Applicative f => Dual (f a) -> f (Dual a)

mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b)

sequence :: Monad m => Dual (m a) -> m (Dual a)

Traversable Sum

Since: base-4.8.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b)

sequenceA :: Applicative f => Sum (f a) -> f (Sum a)

mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b)

sequence :: Monad m => Sum (m a) -> m (Sum a)

Traversable Product

Since: base-4.8.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b)

sequenceA :: Applicative f => Product (f a) -> f (Product a)

mapM :: Monad m => (a -> m b) -> Product a -> m (Product b)

sequence :: Monad m => Product (m a) -> m (Product a)

Traversable NonEmpty

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b)

sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a)

mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b)

sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a)

Traversable IntMap

Defined in Data.IntMap.Internal

Methods

traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b)

sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a)

mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b)

sequence :: Monad m => IntMap (m a) -> m (IntMap a)

Traversable Tree

Defined in Data.Tree

Methods

traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b)

sequenceA :: Applicative f => Tree (f a) -> f (Tree a)

mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b)

sequence :: Monad m => Tree (m a) -> m (Tree a)

Traversable Seq

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b)

sequenceA :: Applicative f => Seq (f a) -> f (Seq a)

mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b)

sequence :: Monad m => Seq (m a) -> m (Seq a)

Traversable FingerTree

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b)

sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a)

mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b)

sequence :: Monad m => FingerTree (m a) -> m (FingerTree a)

Traversable Digit

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b)

sequenceA :: Applicative f => Digit (f a) -> f (Digit a)

mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b)

sequence :: Monad m => Digit (m a) -> m (Digit a)

Traversable Node

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b)

sequenceA :: Applicative f => Node (f a) -> f (Node a)

mapM :: Monad m => (a -> m b) -> Node a -> m (Node b)

sequence :: Monad m => Node (m a) -> m (Node a)

Traversable Elem

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b)

sequenceA :: Applicative f => Elem (f a) -> f (Elem a)

mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b)

sequence :: Monad m => Elem (m a) -> m (Elem a)

Traversable ViewL

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b)

sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a)

mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b)

sequence :: Monad m => ViewL (m a) -> m (ViewL a)

Traversable ViewR

Defined in Data.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b)

sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a)

mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b)

sequence :: Monad m => ViewR (m a) -> m (ViewR a)

Traversable Vector

Defined in Data.Vector

Methods

traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b)

sequenceA :: Applicative f => Vector (f a) -> f (Vector a)

mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b)

sequence :: Monad m => Vector (m a) -> m (Vector a)

Traversable Array

Defined in Data.Primitive.Array

Methods

traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b)

sequenceA :: Applicative f => Array (f a) -> f (Array a)

mapM :: Monad m => (a -> m b) -> Array a -> m (Array b)

sequence :: Monad m => Array (m a) -> m (Array a)

Traversable SmallArray

Defined in Data.Primitive.SmallArray

Methods

traverse :: Applicative f => (a -> f b) -> SmallArray a -> f (SmallArray b)

sequenceA :: Applicative f => SmallArray (f a) -> f (SmallArray a)

mapM :: Monad m => (a -> m b) -> SmallArray a -> m (SmallArray b)

sequence :: Monad m => SmallArray (m a) -> m (SmallArray a)

Traversable (Either a)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b)

sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0)

mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b)

sequence :: Monad m => Either a (m a0) -> m (Either a a0)

Traversable (V1 :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b)

sequenceA :: Applicative f => V1 (f a) -> f (V1 a)

mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b)

sequence :: Monad m => V1 (m a) -> m (V1 a)

Traversable (U1 :: * -> *)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b)

sequenceA :: Applicative f => U1 (f a) -> f (U1 a)

mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b)

sequence :: Monad m => U1 (m a) -> m (U1 a)

Traversable ((,) a)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a0 -> f b) -> (a, a0) -> f (a, b)

sequenceA :: Applicative f => (a, f a0) -> f (a, a0)

mapM :: Monad m => (a0 -> m b) -> (a, a0) -> m (a, b)

sequence :: Monad m => (a, m a0) -> m (a, a0)

Ix i => Traversable (Array i)

Since: base-2.1

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b)

sequenceA :: Applicative f => Array i (f a) -> f (Array i a)

mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b)

sequence :: Monad m => Array i (m a) -> m (Array i a)

Traversable (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

traverse :: Applicative f => (a0 -> f b) -> Arg a a0 -> f (Arg a b)

sequenceA :: Applicative f => Arg a (f a0) -> f (Arg a a0)

mapM :: Monad m => (a0 -> m b) -> Arg a a0 -> m (Arg a b)

sequence :: Monad m => Arg a (m a0) -> m (Arg a a0)

Traversable (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b)

sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a)

mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b)

sequence :: Monad m => Proxy (m a) -> m (Proxy a)

Traversable (Map k)

Defined in Data.Map.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b)

sequenceA :: Applicative f => Map k (f a) -> f (Map k a)

mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b)

sequence :: Monad m => Map k (m a) -> m (Map k a)

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

Defined in Clash.Sized.Vector

Methods

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

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

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

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

Traversable (Level i)

Defined in Control.Lens.Internal.Level

Methods

traverse :: Applicative f => (a -> f b) -> Level i a -> f (Level i b)

sequenceA :: Applicative f => Level i (f a) -> f (Level i a)

mapM :: Monad m => (a -> m b) -> Level i a -> m (Level i b)

sequence :: Monad m => Level i (m a) -> m (Level i a)

Traversable f => Traversable (Cofree f)

Defined in Control.Comonad.Cofree

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Cofree f a -> f0 (Cofree f b)

sequenceA :: Applicative f0 => Cofree f (f0 a) -> f0 (Cofree f a)

mapM :: Monad m => (a -> m b) -> Cofree f a -> m (Cofree f b)

sequence :: Monad m => Cofree f (m a) -> m (Cofree f a)

Traversable f => Traversable (Free f)

Defined in Control.Monad.Free

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Free f a -> f0 (Free f b)

sequenceA :: Applicative f0 => Free f (f0 a) -> f0 (Free f a)

mapM :: Monad m => (a -> m b) -> Free f a -> m (Free f b)

sequence :: Monad m => Free f (m a) -> m (Free f a)

Traversable f => Traversable (Yoneda f)

Defined in Data.Functor.Yoneda

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Yoneda f a -> f0 (Yoneda f b)

sequenceA :: Applicative f0 => Yoneda f (f0 a) -> f0 (Yoneda f a)

mapM :: Monad m => (a -> m b) -> Yoneda f a -> m (Yoneda f b)

sequence :: Monad m => Yoneda f (m a) -> m (Yoneda f a)

Traversable (HashMap k)

Defined in Data.HashMap.Base

Methods

traverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b)

sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a)

mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b)

sequence :: Monad m => HashMap k (m a) -> m (HashMap k a)

Traversable (Signal domain)

Defined in Clash.Signal.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Signal domain a -> f (Signal domain b)

sequenceA :: Applicative f => Signal domain (f a) -> f (Signal domain a)

mapM :: Monad m => (a -> m b) -> Signal domain a -> m (Signal domain b)

sequence :: Monad m => Signal domain (m a) -> m (Signal domain a)

KnownNat d => Traversable (RTree d)

Defined in Clash.Sized.RTree

Methods

traverse :: Applicative f => (a -> f b) -> RTree d a -> f (RTree d b)

sequenceA :: Applicative f => RTree d (f a) -> f (RTree d a)

mapM :: Monad m => (a -> m b) -> RTree d a -> m (RTree d b)

sequence :: Monad m => RTree d (m a) -> m (RTree d a)

Traversable f => Traversable (Rec1 f)

Defined in Data.Traversable

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b)

sequenceA :: Applicative f0 => Rec1 f (f0 a) -> f0 (Rec1 f a)

mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b)

sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a)

Traversable (URec Char :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b)

sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a)

mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b)

sequence :: Monad m => URec Char (m a) -> m (URec Char a)

Traversable (URec Double :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b)

sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a)

mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b)

sequence :: Monad m => URec Double (m a) -> m (URec Double a)

Traversable (URec Float :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b)

sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a)

mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b)

sequence :: Monad m => URec Float (m a) -> m (URec Float a)

Traversable (URec Int :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b)

sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a)

mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b)

sequence :: Monad m => URec Int (m a) -> m (URec Int a)

Traversable (URec Word :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b)

sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a)

mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b)

sequence :: Monad m => URec Word (m a) -> m (URec Word a)

Traversable (URec (Ptr ()) :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b)

sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a)

mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b)

sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a)

Traversable (Const m :: * -> *)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b)

sequenceA :: Applicative f => Const m (f a) -> f (Const m a)

mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b)

sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a)

Traversable f => Traversable (ErrorT e f)

Defined in Control.Monad.Trans.Error

Methods

traverse :: Applicative f0 => (a -> f0 b) -> ErrorT e f a -> f0 (ErrorT e f b)

sequenceA :: Applicative f0 => ErrorT e f (f0 a) -> f0 (ErrorT e f a)

mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b)

sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a)

Traversable (Constant a :: * -> *)

Defined in Data.Functor.Constant

Methods

traverse :: Applicative f => (a0 -> f b) -> Constant a a0 -> f (Constant a b)

sequenceA :: Applicative f => Constant a (f a0) -> f (Constant a a0)

mapM :: Monad m => (a0 -> m b) -> Constant a a0 -> m (Constant a b)

sequence :: Monad m => Constant a (m a0) -> m (Constant a a0)

Traversable (Tagged s)

Defined in Data.Tagged

Methods

traverse :: Applicative f => (a -> f b) -> Tagged s a -> f (Tagged s b)

sequenceA :: Applicative f => Tagged s (f a) -> f (Tagged s a)

mapM :: Monad m => (a -> m b) -> Tagged s a -> m (Tagged s b)

sequence :: Monad m => Tagged s (m a) -> m (Tagged s a)

Bitraversable p => Traversable (Fix p)

Defined in Data.Bifunctor.Fix

Methods

traverse :: Applicative f => (a -> f b) -> Fix p a -> f (Fix p b)

sequenceA :: Applicative f => Fix p (f a) -> f (Fix p a)

mapM :: Monad m => (a -> m b) -> Fix p a -> m (Fix p b)

sequence :: Monad m => Fix p (m a) -> m (Fix p a)

Bitraversable p => Traversable (Join p)

Defined in Data.Bifunctor.Join

Methods

traverse :: Applicative f => (a -> f b) -> Join p a -> f (Join p b)

sequenceA :: Applicative f => Join p (f a) -> f (Join p a)

mapM :: Monad m => (a -> m b) -> Join p a -> m (Join p b)

sequence :: Monad m => Join p (m a) -> m (Join p a)

Traversable f => Traversable (CofreeF f a)

Defined in Control.Comonad.Trans.Cofree

Methods

traverse :: Applicative f0 => (a0 -> f0 b) -> CofreeF f a a0 -> f0 (CofreeF f a b)

sequenceA :: Applicative f0 => CofreeF f a (f0 a0) -> f0 (CofreeF f a a0)

mapM :: Monad m => (a0 -> m b) -> CofreeF f a a0 -> m (CofreeF f a b)

sequence :: Monad m => CofreeF f a (m a0) -> m (CofreeF f a a0)

(Traversable f, Traversable w) => Traversable (CofreeT f w)

Defined in Control.Comonad.Trans.Cofree

Methods

traverse :: Applicative f0 => (a -> f0 b) -> CofreeT f w a -> f0 (CofreeT f w b)

sequenceA :: Applicative f0 => CofreeT f w (f0 a) -> f0 (CofreeT f w a)

mapM :: Monad m => (a -> m b) -> CofreeT f w a -> m (CofreeT f w b)

sequence :: Monad m => CofreeT f w (m a) -> m (CofreeT f w a)

(Monad m, Traversable m, Traversable f) => Traversable (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

traverse :: Applicative f0 => (a -> f0 b) -> FreeT f m a -> f0 (FreeT f m b)

sequenceA :: Applicative f0 => FreeT f m (f0 a) -> f0 (FreeT f m a)

mapM :: Monad m0 => (a -> m0 b) -> FreeT f m a -> m0 (FreeT f m b)

sequence :: Monad m0 => FreeT f m (m0 a) -> m0 (FreeT f m a)

Traversable f => Traversable (FreeF f a)

Defined in Control.Monad.Trans.Free

Methods

traverse :: Applicative f0 => (a0 -> f0 b) -> FreeF f a a0 -> f0 (FreeF f a b)

sequenceA :: Applicative f0 => FreeF f a (f0 a0) -> f0 (FreeF f a a0)

mapM :: Monad m => (a0 -> m b) -> FreeF f a a0 -> m (FreeF f a b)

sequence :: Monad m => FreeF f a (m a0) -> m (FreeF f a a0)

Traversable (DSignal domain delay)

Defined in Clash.Explicit.Signal.Delayed

Methods

traverse :: Applicative f => (a -> f b) -> DSignal domain delay a -> f (DSignal domain delay b)

sequenceA :: Applicative f => DSignal domain delay (f a) -> f (DSignal domain delay a)

mapM :: Monad m => (a -> m b) -> DSignal domain delay a -> m (DSignal domain delay b)

sequence :: Monad m => DSignal domain delay (m a) -> m (DSignal domain delay a)

Traversable (K1 i c :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b)

sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a)

mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b)

sequence :: Monad m => K1 i c (m a) -> m (K1 i c a)

(Traversable f, Traversable g) => Traversable (f :+: g)

Defined in Data.Traversable

Methods

traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b)

sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a)

mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b)

sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a)

(Traversable f, Traversable g) => Traversable (f :*: g)

Defined in Data.Traversable

Methods

traverse :: Applicative f0 => (a -> f0 b) -> (f :*: g) a -> f0 ((f :*: g) b)

sequenceA :: Applicative f0 => (f :*: g) (f0 a) -> f0 ((f :*: g) a)

mapM :: Monad m => (a -> m b) -> (f :*: g) a -> m ((f :*: g) b)

sequence :: Monad m => (f :*: g) (m a) -> m ((f :*: g) a)

(Traversable f, Traversable g) => Traversable (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Product f g a -> f0 (Product f g b)

sequenceA :: Applicative f0 => Product f g (f0 a) -> f0 (Product f g a)

mapM :: Monad m => (a -> m b) -> Product f g a -> m (Product f g b)

sequence :: Monad m => Product f g (m a) -> m (Product f g a)

(Traversable f, Traversable g) => Traversable (Sum f g)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b)

sequenceA :: Applicative f0 => Sum f g (f0 a) -> f0 (Sum f g a)

mapM :: Monad m => (a -> m b) -> Sum f g a -> m (Sum f g b)

sequence :: Monad m => Sum f g (m a) -> m (Sum f g a)

Traversable (Magma i t b)

Defined in Control.Lens.Internal.Magma

Methods

traverse :: Applicative f => (a -> f b0) -> Magma i t b a -> f (Magma i t b b0)

sequenceA :: Applicative f => Magma i t b (f a) -> f (Magma i t b a)

mapM :: Monad m => (a -> m b0) -> Magma i t b a -> m (Magma i t b b0)

sequence :: Monad m => Magma i t b (m a) -> m (Magma i t b a)

Traversable f => Traversable (M1 i c f)

Defined in Data.Traversable

Methods

traverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b)

sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 (M1 i c f a)

mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b)

sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a)

(Traversable f, Traversable g) => Traversable (f :.: g)

Defined in Data.Traversable

Methods

traverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b)

sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((f :.: g) a)

mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b)

sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a)

(Traversable f, Traversable g) => Traversable (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b)

sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a)

mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b)

sequence :: Monad m => Compose f g (m a) -> m (Compose f g a)

Traversable (Clown f a :: * -> *)

Defined in Data.Bifunctor.Clown

Methods

traverse :: Applicative f0 => (a0 -> f0 b) -> Clown f a a0 -> f0 (Clown f a b)

sequenceA :: Applicative f0 => Clown f a (f0 a0) -> f0 (Clown f a a0)

mapM :: Monad m => (a0 -> m b) -> Clown f a a0 -> m (Clown f a b)

sequence :: Monad m => Clown f a (m a0) -> m (Clown f a a0)

Bitraversable p => Traversable (Flip p a)

Defined in Data.Bifunctor.Flip

Methods

traverse :: Applicative f => (a0 -> f b) -> Flip p a a0 -> f (Flip p a b)

sequenceA :: Applicative f => Flip p a (f a0) -> f (Flip p a a0)

mapM :: Monad m => (a0 -> m b) -> Flip p a a0 -> m (Flip p a b)

sequence :: Monad m => Flip p a (m a0) -> m (Flip p a a0)

Traversable g => Traversable (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

traverse :: Applicative f => (a0 -> f b) -> Joker g a a0 -> f (Joker g a b)

sequenceA :: Applicative f => Joker g a (f a0) -> f (Joker g a a0)

mapM :: Monad m => (a0 -> m b) -> Joker g a a0 -> m (Joker g a b)

sequence :: Monad m => Joker g a (m a0) -> m (Joker g a a0)

Bitraversable p => Traversable (WrappedBifunctor p a)

Defined in Data.Bifunctor.Wrapped

Methods

traverse :: Applicative f => (a0 -> f b) -> WrappedBifunctor p a a0 -> f (WrappedBifunctor p a b)

sequenceA :: Applicative f => WrappedBifunctor p a (f a0) -> f (WrappedBifunctor p a a0)

mapM :: Monad m => (a0 -> m b) -> WrappedBifunctor p a a0 -> m (WrappedBifunctor p a b)

sequence :: Monad m => WrappedBifunctor p a (m a0) -> m (WrappedBifunctor p a a0)

(Traversable f, Bitraversable p) => Traversable (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

traverse :: Applicative f0 => (a0 -> f0 b) -> Tannen f p a a0 -> f0 (Tannen f p a b)

sequenceA :: Applicative f0 => Tannen f p a (f0 a0) -> f0 (Tannen f p a a0)

mapM :: Monad m => (a0 -> m b) -> Tannen f p a a0 -> m (Tannen f p a b)

sequence :: Monad m => Tannen f p a (m a0) -> m (Tannen f p a a0)

(Bitraversable p, Traversable g) => Traversable (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

traverse :: Applicative f0 => (a0 -> f0 b) -> Biff p f g a a0 -> f0 (Biff p f g a b)

sequenceA :: Applicative f0 => Biff p f g a (f0 a0) -> f0 (Biff p f g a a0)

mapM :: Monad m => (a0 -> m b) -> Biff p f g a a0 -> m (Biff p f g a b)

sequence :: Monad m => Biff p f g a (m a0) -> m (Biff p f g a a0)

class Semigroup a where

The class of semigroups (types with an associative binary operation).

Instances should satisfy the associativity law:

• x <> (y <> z) = (x <> y) <> z

Since: base-4.9.0.0

Minimal complete definition

(<>)

Methods

(<>) :: a -> a -> a infixr 6

An associative operation.

Instances

Semigroup Ordering

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: Ordering -> Ordering -> Ordering

sconcat :: NonEmpty Ordering -> Ordering

stimes :: Integral b => b -> Ordering -> Ordering

Semigroup ()

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: () -> () -> ()

sconcat :: NonEmpty () -> ()

stimes :: Integral b => b -> () -> ()

Semigroup Void

Since: base-4.9.0.0

Defined in Data.Void

Methods

(<>) :: Void -> Void -> Void

sconcat :: NonEmpty Void -> Void

stimes :: Integral b => b -> Void -> Void

Semigroup All

Since: base-4.9.0.0

Defined in Data.Semigroup.Internal

Methods

(<>) :: All -> All -> All

sconcat :: NonEmpty All -> All

stimes :: Integral b => b -> All -> All

Semigroup Any

Since: base-4.9.0.0

Defined in Data.Semigroup.Internal

Methods

(<>) :: Any -> Any -> Any

sconcat :: NonEmpty Any -> Any

stimes :: Integral b => b -> Any -> Any

Semigroup ByteString

Defined in Data.ByteString.Lazy.Internal

Methods

(<>) :: ByteString -> ByteString -> ByteString

sconcat :: NonEmpty ByteString -> ByteString

stimes :: Integral b => b -> ByteString -> ByteString

Semigroup ByteString

Defined in Data.ByteString.Internal

Methods

(<>) :: ByteString -> ByteString -> ByteString

sconcat :: NonEmpty ByteString -> ByteString

stimes :: Integral b => b -> ByteString -> ByteString

Semigroup IntSet

Since: containers-0.5.7

Defined in Data.IntSet.Internal

Methods

(<>) :: IntSet -> IntSet -> IntSet

sconcat :: NonEmpty IntSet -> IntSet

stimes :: Integral b => b -> IntSet -> IntSet

Semigroup Doc

Defined in Text.PrettyPrint.HughesPJ

Methods

(<>) :: Doc -> Doc -> Doc

sconcat :: NonEmpty Doc -> Doc

stimes :: Integral b => b -> Doc -> Doc

Semigroup ByteArray

Defined in Data.Primitive.ByteArray

Methods

(<>) :: ByteArray -> ByteArray -> ByteArray

sconcat :: NonEmpty ByteArray -> ByteArray

stimes :: Integral b => b -> ByteArray -> ByteArray

Semigroup ULetDecEnv

Defined in Data.Singletons.Syntax

Methods

(<>) :: ULetDecEnv -> ULetDecEnv -> ULetDecEnv

sconcat :: NonEmpty ULetDecEnv -> ULetDecEnv

stimes :: Integral b => b -> ULetDecEnv -> ULetDecEnv

() :=> (Semigroup [a])

Defined in Data.Constraint

Methods

ins :: () :- Semigroup [a]

() :=> (Semigroup Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Semigroup Ordering

() :=> (Semigroup ())

Defined in Data.Constraint

Methods

ins :: () :- Semigroup ()

() :=> (Semigroup (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Semigroup (Dict a)

Class () (Semigroup a)

Defined in Data.Constraint

Methods

cls :: Semigroup a :- ()

Semigroup [a]

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: [a] -> [a] -> [a]

sconcat :: NonEmpty [a] -> [a]

stimes :: Integral b => b -> [a] -> [a]

Semigroup a => Semigroup (Maybe a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: Maybe a -> Maybe a -> Maybe a

sconcat :: NonEmpty (Maybe a) -> Maybe a

stimes :: Integral b => b -> Maybe a -> Maybe a

Semigroup a => Semigroup (IO a)

Since: base-4.10.0.0

Defined in GHC.Base

Methods

(<>) :: IO a -> IO a -> IO a

sconcat :: NonEmpty (IO a) -> IO a

stimes :: Integral b => b -> IO a -> IO a

Ord a => Semigroup (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(<>) :: Min a -> Min a -> Min a

sconcat :: NonEmpty (Min a) -> Min a

stimes :: Integral b => b -> Min a -> Min a

Ord a => Semigroup (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(<>) :: Max a -> Max a -> Max a

sconcat :: NonEmpty (Max a) -> Max a

stimes :: Integral b => b -> Max a -> Max a

Semigroup (First a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(<>) :: First a -> First a -> First a

sconcat :: NonEmpty (First a) -> First a

stimes :: Integral b => b -> First a -> First a

Semigroup (Last a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(<>) :: Last a -> Last a -> Last a

sconcat :: NonEmpty (Last a) -> Last a

stimes :: Integral b => b -> Last a -> Last a

Monoid m => Semigroup (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m

stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m

Semigroup a => Semigroup (Option a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

(<>) :: Option a -> Option a -> Option a

sconcat :: NonEmpty (Option a) -> Option a

stimes :: Integral b => b -> Option a -> Option a

Semigroup a => Semigroup (Identity a)

Defined in Data.Functor.Identity

Methods

(<>) :: Identity a -> Identity a -> Identity a

sconcat :: NonEmpty (Identity a) -> Identity a

stimes :: Integral b => b -> Identity a -> Identity a

Semigroup (First a)

Since: base-4.9.0.0

Defined in Data.Monoid

Methods

(<>) :: First a -> First a -> First a

sconcat :: NonEmpty (First a) -> First a

stimes :: Integral b => b -> First a -> First a

Semigroup (Last a)

Since: base-4.9.0.0

Defined in Data.Monoid

Methods

(<>) :: Last a -> Last a -> Last a

sconcat :: NonEmpty (Last a) -> Last a

stimes :: Integral b => b -> Last a -> Last a

Semigroup a => Semigroup (Dual a)

Since: base-4.9.0.0

Defined in Data.Semigroup.Internal

Methods

(<>) :: Dual a -> Dual a -> Dual a

sconcat :: NonEmpty (Dual a) -> Dual a

stimes :: Integral b => b -> Dual a -> Dual a

Semigroup (Endo a)

Since: base-4.9.0.0

Defined in Data.Semigroup.Internal

Methods

(<>) :: Endo a -> Endo a -> Endo a

sconcat :: NonEmpty (Endo a) -> Endo a

stimes :: Integral b => b -> Endo a -> Endo a

Num a => Semigroup (Sum a)

Since: base-4.9.0.0

Defined in Data.Semigroup.Internal

Methods

(<>) :: Sum a -> Sum a -> Sum a

sconcat :: NonEmpty (Sum a) -> Sum a

stimes :: Integral b => b -> Sum a -> Sum a

Num a => Semigroup (Product a)

Since: base-4.9.0.0

Defined in Data.Semigroup.Internal

Methods

(<>) :: Product a -> Product a -> Product a

sconcat :: NonEmpty (Product a) -> Product a

stimes :: Integral b => b -> Product a -> Product a

Semigroup a => Semigroup (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(<>) :: Down a -> Down a -> Down a

sconcat :: NonEmpty (Down a) -> Down a

stimes :: Integral b => b -> Down a -> Down a

Semigroup (NonEmpty a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a

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

stimes :: Integral b => b -> NonEmpty a -> NonEmpty a

Semigroup (IntMap a)

Since: containers-0.5.7

Defined in Data.IntMap.Internal

Methods

(<>) :: IntMap a -> IntMap a -> IntMap a

sconcat :: NonEmpty (IntMap a) -> IntMap a

stimes :: Integral b => b -> IntMap a -> IntMap a

Semigroup (Seq a)

Since: containers-0.5.7

Defined in Data.Sequence.Internal

Methods

(<>) :: Seq a -> Seq a -> Seq a

sconcat :: NonEmpty (Seq a) -> Seq a

stimes :: Integral b => b -> Seq a -> Seq a

Ord a => Semigroup (Set a)

Since: containers-0.5.7

Defined in Data.Set.Internal

Methods

(<>) :: Set a -> Set a -> Set a

sconcat :: NonEmpty (Set a) -> Set a

stimes :: Integral b => b -> Set a -> Set a

Semigroup (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

(<>) :: Doc a -> Doc a -> Doc a

sconcat :: NonEmpty (Doc a) -> Doc a

stimes :: Integral b => b -> Doc a -> Doc a

Semigroup (Leftmost a)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: Leftmost a -> Leftmost a -> Leftmost a

sconcat :: NonEmpty (Leftmost a) -> Leftmost a

stimes :: Integral b => b -> Leftmost a -> Leftmost a

Semigroup (Rightmost a)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: Rightmost a -> Rightmost a -> Rightmost a

sconcat :: NonEmpty (Rightmost a) -> Rightmost a

stimes :: Integral b => b -> Rightmost a -> Rightmost a

Semigroup (DList a)

Defined in Data.DList

Methods

(<>) :: DList a -> DList a -> DList a

sconcat :: NonEmpty (DList a) -> DList a

stimes :: Integral b => b -> DList a -> DList a

Semigroup (MergeSet a)

Defined in Data.Set.Internal

Methods

(<>) :: MergeSet a -> MergeSet a -> MergeSet a

sconcat :: NonEmpty (MergeSet a) -> MergeSet a

stimes :: Integral b => b -> MergeSet a -> MergeSet a

(Hashable a, Eq a) => Semigroup (HashSet a)

Defined in Data.HashSet

Methods

(<>) :: HashSet a -> HashSet a -> HashSet a

sconcat :: NonEmpty (HashSet a) -> HashSet a

stimes :: Integral b => b -> HashSet a -> HashSet a

Storable a => Semigroup (Vector a)

Defined in Data.Vector.Storable

Methods

(<>) :: Vector a -> Vector a -> Vector a

sconcat :: NonEmpty (Vector a) -> Vector a

stimes :: Integral b => b -> Vector a -> Vector a

Prim a => Semigroup (Vector a)

Defined in Data.Vector.Primitive

Methods

(<>) :: Vector a -> Vector a -> Vector a

sconcat :: NonEmpty (Vector a) -> Vector a

stimes :: Integral b => b -> Vector a -> Vector a

Semigroup (Vector a)

Defined in Data.Vector

Methods

(<>) :: Vector a -> Vector a -> Vector a

sconcat :: NonEmpty (Vector a) -> Vector a

stimes :: Integral b => b -> Vector a -> Vector a

Semigroup (Comparison a)

Defined in Data.Functor.Contravariant

Methods

(<>) :: Comparison a -> Comparison a -> Comparison a

sconcat :: NonEmpty (Comparison a) -> Comparison a

stimes :: Integral b => b -> Comparison a -> Comparison a

Semigroup (Equivalence a)

Defined in Data.Functor.Contravariant

Methods

(<>) :: Equivalence a -> Equivalence a -> Equivalence a

sconcat :: NonEmpty (Equivalence a) -> Equivalence a

stimes :: Integral b => b -> Equivalence a -> Equivalence a

Semigroup (Predicate a)

Defined in Data.Functor.Contravariant

Methods

(<>) :: Predicate a -> Predicate a -> Predicate a

sconcat :: NonEmpty (Predicate a) -> Predicate a

stimes :: Integral b => b -> Predicate a -> Predicate a

Semigroup (Array a)

Defined in Data.Primitive.Array

Methods

(<>) :: Array a -> Array a -> Array a

sconcat :: NonEmpty (Array a) -> Array a

stimes :: Integral b => b -> Array a -> Array a

Semigroup (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

(<>) :: PrimArray a -> PrimArray a -> PrimArray a

sconcat :: NonEmpty (PrimArray a) -> PrimArray a

stimes :: Integral b => b -> PrimArray a -> PrimArray a

Semigroup (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

(<>) :: SmallArray a -> SmallArray a -> SmallArray a

sconcat :: NonEmpty (SmallArray a) -> SmallArray a

stimes :: Integral b => b -> SmallArray a -> SmallArray a

PrimUnlifted a => Semigroup (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

(<>) :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a

sconcat :: NonEmpty (UnliftedArray a) -> UnliftedArray a

stimes :: Integral b => b -> UnliftedArray a -> UnliftedArray a

Semigroup (Dict a)

Defined in Data.Constraint

Methods

(<>) :: Dict a -> Dict a -> Dict a

sconcat :: NonEmpty (Dict a) -> Dict a

stimes :: Integral b => b -> Dict a -> Dict a

Ord a => Semigroup (Max a)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: Max a -> Max a -> Max a

sconcat :: NonEmpty (Max a) -> Max a

stimes :: Integral b => b -> Max a -> Max a

Ord a => Semigroup (Min a)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: Min a -> Min a -> Min a

sconcat :: NonEmpty (Min a) -> Min a

stimes :: Integral b => b -> Min a -> Min a

Semigroup (NonEmptyDList a)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: NonEmptyDList a -> NonEmptyDList a -> NonEmptyDList a

sconcat :: NonEmpty (NonEmptyDList a) -> NonEmptyDList a

stimes :: Integral b => b -> NonEmptyDList a -> NonEmptyDList a

(Semigroup a) :=> (Semigroup (Maybe a))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (Maybe a)

(Semigroup a) :=> (Semigroup (Const a b))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (Const a b)

(Semigroup a) :=> (Semigroup (Identity a))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (Identity a)

(Semigroup a) :=> (Semigroup (IO a))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (IO a)

Class (Semigroup a) (Monoid a)

Defined in Data.Constraint

Methods

cls :: Monoid a :- Semigroup a

Semigroup b => Semigroup (a -> b)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: (a -> b) -> (a -> b) -> a -> b

sconcat :: NonEmpty (a -> b) -> a -> b

stimes :: Integral b0 => b0 -> (a -> b) -> a -> b

Semigroup (Either a b)

Since: base-4.9.0.0

Defined in Data.Either

Methods

(<>) :: Either a b -> Either a b -> Either a b

sconcat :: NonEmpty (Either a b) -> Either a b

stimes :: Integral b0 => b0 -> Either a b -> Either a b

(Semigroup a, Semigroup b) => Semigroup (a, b)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: (a, b) -> (a, b) -> (a, b)

sconcat :: NonEmpty (a, b) -> (a, b)

stimes :: Integral b0 => b0 -> (a, b) -> (a, b)

Semigroup a => Semigroup (ST s a)

Since: base-4.11.0.0

Defined in GHC.ST

Methods

(<>) :: ST s a -> ST s a -> ST s a

sconcat :: NonEmpty (ST s a) -> ST s a

stimes :: Integral b => b -> ST s a -> ST s a

Semigroup (Proxy s)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

(<>) :: Proxy s -> Proxy s -> Proxy s

sconcat :: NonEmpty (Proxy s) -> Proxy s

stimes :: Integral b => b -> Proxy s -> Proxy s

Ord k => Semigroup (Map k v)

Defined in Data.Map.Internal

Methods

(<>) :: Map k v -> Map k v -> Map k v

sconcat :: NonEmpty (Map k v) -> Map k v

stimes :: Integral b => b -> Map k v -> Map k v

Monad m => Semigroup (Sequenced a m)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: Sequenced a m -> Sequenced a m -> Sequenced a m

sconcat :: NonEmpty (Sequenced a m) -> Sequenced a m

stimes :: Integral b => b -> Sequenced a m -> Sequenced a m

Applicative f => Semigroup (Traversed a f)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: Traversed a f -> Traversed a f -> Traversed a f

sconcat :: NonEmpty (Traversed a f) -> Traversed a f

stimes :: Integral b => b -> Traversed a f -> Traversed a f

Semigroup (ReifiedFold s a)

Defined in Control.Lens.Reified

Methods

(<>) :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a

sconcat :: NonEmpty (ReifiedFold s a) -> ReifiedFold s a

stimes :: Integral b => b -> ReifiedFold s a -> ReifiedFold s a

(Eq k, Hashable k) => Semigroup (HashMap k v)

Defined in Data.HashMap.Base

Methods

(<>) :: HashMap k v -> HashMap k v -> HashMap k v

sconcat :: NonEmpty (HashMap k v) -> HashMap k v

stimes :: Integral b => b -> HashMap k v -> HashMap k v

Semigroup (f a) => Semigroup (Indexing f a)

Defined in Control.Lens.Internal.Indexed

Methods

(<>) :: Indexing f a -> Indexing f a -> Indexing f a

sconcat :: NonEmpty (Indexing f a) -> Indexing f a

stimes :: Integral b => b -> Indexing f a -> Indexing f a

Semigroup a => Semigroup (Op a b)

Defined in Data.Functor.Contravariant

Methods

(<>) :: Op a b -> Op a b -> Op a b

sconcat :: NonEmpty (Op a b) -> Op a b

stimes :: Integral b0 => b0 -> Op a b -> Op a b

(Contravariant f, Applicative f) => Semigroup (Folding f a)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: Folding f a -> Folding f a -> Folding f a

sconcat :: NonEmpty (Folding f a) -> Folding f a

stimes :: Integral b => b -> Folding f a -> Folding f a

Apply f => Semigroup (TraversedF a f)

Defined in Control.Lens.Internal.Fold

Methods

(<>) :: TraversedF a f -> TraversedF a f -> TraversedF a f

sconcat :: NonEmpty (TraversedF a f) -> TraversedF a f

stimes :: Integral b => b -> TraversedF a f -> TraversedF a f

Semigroup (Deepening i a)

Defined in Control.Lens.Internal.Level

Methods

(<>) :: Deepening i a -> Deepening i a -> Deepening i a

sconcat :: NonEmpty (Deepening i a) -> Deepening i a

stimes :: Integral b => b -> Deepening i a -> Deepening i a

(Semigroup a, Semigroup b) :=> (Semigroup (a, b))

Defined in Data.Constraint

Methods

ins :: (Semigroup a, Semigroup b) :- Semigroup (a, b)

(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: (a, b, c) -> (a, b, c) -> (a, b, c)

sconcat :: NonEmpty (a, b, c) -> (a, b, c)

stimes :: Integral b0 => b0 -> (a, b, c) -> (a, b, c)

Semigroup a => Semigroup (Const a b)

Defined in Data.Functor.Const

Methods

(<>) :: Const a b -> Const a b -> Const a b

sconcat :: NonEmpty (Const a b) -> Const a b

stimes :: Integral b0 => b0 -> Const a b -> Const a b

Alternative f => Semigroup (Alt f a)

Since: base-4.9.0.0

Defined in Data.Semigroup.Internal

Methods

(<>) :: Alt f a -> Alt f a -> Alt f a

sconcat :: NonEmpty (Alt f a) -> Alt f a

stimes :: Integral b => b -> Alt f a -> Alt f a

Semigroup a => Semigroup (Constant a b)

Defined in Data.Functor.Constant

Methods

(<>) :: Constant a b -> Constant a b -> Constant a b

sconcat :: NonEmpty (Constant a b) -> Constant a b

stimes :: Integral b0 => b0 -> Constant a b -> Constant a b

Semigroup (ReifiedIndexedFold i s a)

Defined in Control.Lens.Reified

Methods

(<>) :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a

sconcat :: NonEmpty (ReifiedIndexedFold i s a) -> ReifiedIndexedFold i s a

stimes :: Integral b => b -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a

Reifies s (ReifiedMonoid a) => Semigroup (ReflectedMonoid a s)

Defined in Data.Reflection

Methods

(<>) :: ReflectedMonoid a s -> ReflectedMonoid a s -> ReflectedMonoid a s

sconcat :: NonEmpty (ReflectedMonoid a s) -> ReflectedMonoid a s

stimes :: Integral b => b -> ReflectedMonoid a s -> ReflectedMonoid a s

Semigroup a => Semigroup (Tagged s a)

Defined in Data.Tagged

Methods

(<>) :: Tagged s a -> Tagged s a -> Tagged s a

sconcat :: NonEmpty (Tagged s a) -> Tagged s a

stimes :: Integral b => b -> Tagged s a -> Tagged s a

(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d)

stimes :: Integral b0 => b0 -> (a, b, c, d) -> (a, b, c, d)

(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e)

stimes :: Integral b0 => b0 -> (a, b, c, d, e) -> (a, b, c, d, e)

Contravariant g => Semigroup (BazaarT p g a b t)

Defined in Control.Lens.Internal.Bazaar

Methods

(<>) :: BazaarT p g a b t -> BazaarT p g a b t -> BazaarT p g a b t

sconcat :: NonEmpty (BazaarT p g a b t) -> BazaarT p g a b t

stimes :: Integral b0 => b0 -> BazaarT p g a b t -> BazaarT p g a b t

Contravariant g => Semigroup (BazaarT1 p g a b t)

Defined in Control.Lens.Internal.Bazaar

Methods

(<>) :: BazaarT1 p g a b t -> BazaarT1 p g a b t -> BazaarT1 p g a b t

sconcat :: NonEmpty (BazaarT1 p g a b t) -> BazaarT1 p g a b t

stimes :: Integral b0 => b0 -> BazaarT1 p g a b t -> BazaarT1 p g a b t

class Semigroup a => Monoid a where

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

• x <> mempty = x

• mempty <> x = x

• x <> (y <> z) = (x <> y) <> z (Semigroup law)

• mconcat = foldr '(<>)' mempty

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.

Minimal complete definition

mempty

Methods

mempty :: a

Identity of mappend

mappend :: a -> a -> a

An associative operation

NOTE: This method is redundant and has the default implementation mappend = '(<>)' since base-4.11.0.0.

mconcat :: [a] -> a

Fold a list using the monoid.

For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

Monoid Ordering

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

Monoid ()

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: ()

mappend :: () -> () -> ()

mconcat :: [()] -> ()

Monoid All

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: All

mappend :: All -> All -> All

mconcat :: [All] -> All

Monoid Any

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Any

mappend :: Any -> Any -> Any

mconcat :: [Any] -> Any

Monoid ByteString

Defined in Data.ByteString.Lazy.Internal

Methods

mempty :: ByteString

mappend :: ByteString -> ByteString -> ByteString

mconcat :: [ByteString] -> ByteString

Monoid ByteString

Defined in Data.ByteString.Internal

Methods

mempty :: ByteString

mappend :: ByteString -> ByteString -> ByteString

mconcat :: [ByteString] -> ByteString

Monoid IntSet

Defined in Data.IntSet.Internal

Methods

mempty :: IntSet

mappend :: IntSet -> IntSet -> IntSet

mconcat :: [IntSet] -> IntSet

Monoid Doc

Defined in Text.PrettyPrint.HughesPJ

Methods

mempty :: Doc

mappend :: Doc -> Doc -> Doc

mconcat :: [Doc] -> Doc

Monoid ByteArray

Defined in Data.Primitive.ByteArray

Methods

mempty :: ByteArray

mappend :: ByteArray -> ByteArray -> ByteArray

mconcat :: [ByteArray] -> ByteArray

Monoid ULetDecEnv

Defined in Data.Singletons.Syntax

Methods

mempty :: ULetDecEnv

mappend :: ULetDecEnv -> ULetDecEnv -> ULetDecEnv

mconcat :: [ULetDecEnv] -> ULetDecEnv

a :=> (Monoid (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a)

() :=> (Monoid [a])

Defined in Data.Constraint

Methods

ins :: () :- Monoid [a]

() :=> (Monoid Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Monoid Ordering

() :=> (Monoid ())

Defined in Data.Constraint

Methods

ins :: () :- Monoid ()

Monoid [a]

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: [a]

mappend :: [a] -> [a] -> [a]

mconcat :: [[a]] -> [a]

Semigroup a => Monoid (Maybe a)

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S."

Since 4.11.0: constraint on inner a value generalised from Monoid to Semigroup.

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Maybe a

mappend :: Maybe a -> Maybe a -> Maybe a

mconcat :: [Maybe a] -> Maybe a

Monoid a => Monoid (IO a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

mempty :: IO a

mappend :: IO a -> IO a -> IO a

mconcat :: [IO a] -> IO a

(Ord a, Bounded a) => Monoid (Min a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

(Ord a, Bounded a) => Monoid (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Monoid m => Monoid (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: WrappedMonoid m

mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

mconcat :: [WrappedMonoid m] -> WrappedMonoid m

Semigroup a => Monoid (Option a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mempty :: Option a

mappend :: Option a -> Option a -> Option a

mconcat :: [Option a] -> Option a

Monoid a => Monoid (Identity a)

Defined in Data.Functor.Identity

Methods

mempty :: Identity a

mappend :: Identity a -> Identity a -> Identity a

mconcat :: [Identity a] -> Identity a

Monoid (First a)

Since: base-2.1

Defined in Data.Monoid

Methods

mempty :: First a

mappend :: First a -> First a -> First a

mconcat :: [First a] -> First a

Monoid (Last a)

Since: base-2.1

Defined in Data.Monoid

Methods

mempty :: Last a

mappend :: Last a -> Last a -> Last a

mconcat :: [Last a] -> Last a

Monoid a => Monoid (Dual a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Dual a

mappend :: Dual a -> Dual a -> Dual a

mconcat :: [Dual a] -> Dual a

Monoid (Endo a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Endo a

mappend :: Endo a -> Endo a -> Endo a

mconcat :: [Endo a] -> Endo a

Num a => Monoid (Sum a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Sum a

mappend :: Sum a -> Sum a -> Sum a

mconcat :: [Sum a] -> Sum a

Num a => Monoid (Product a)

Since: base-2.1

Defined in Data.Semigroup.Internal

Methods

mempty :: Product a

mappend :: Product a -> Product a -> Product a

mconcat :: [Product a] -> Product a

Monoid a => Monoid (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

mempty :: Down a

mappend :: Down a -> Down a -> Down a

mconcat :: [Down a] -> Down a

Monoid (IntMap a)

Defined in Data.IntMap.Internal

Methods

mempty :: IntMap a

mappend :: IntMap a -> IntMap a -> IntMap a

mconcat :: [IntMap a] -> IntMap a

Monoid (Seq a)

Defined in Data.Sequence.Internal

Methods

mempty :: Seq a

mappend :: Seq a -> Seq a -> Seq a

mconcat :: [Seq a] -> Seq a

Ord a => Monoid (Set a)

Defined in Data.Set.Internal

Methods

mempty :: Set a

mappend :: Set a -> Set a -> Set a

mconcat :: [Set a] -> Set a

Monoid (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

mempty :: Doc a

mappend :: Doc a -> Doc a -> Doc a

mconcat :: [Doc a] -> Doc a

Monoid (Leftmost a)

Defined in Control.Lens.Internal.Fold

Methods

mempty :: Leftmost a

mappend :: Leftmost a -> Leftmost a -> Leftmost a

mconcat :: [Leftmost a] -> Leftmost a

Monoid (Rightmost a)

Defined in Control.Lens.Internal.Fold

Methods

mempty :: Rightmost a

mappend :: Rightmost a -> Rightmost a -> Rightmost a

mconcat :: [Rightmost a] -> Rightmost a

Monoid (DList a)

Defined in Data.DList

Methods

mempty :: DList a

mappend :: DList a -> DList a -> DList a

mconcat :: [DList a] -> DList a

Monoid (MergeSet a)

Defined in Data.Set.Internal

Methods

mempty :: MergeSet a

mappend :: MergeSet a -> MergeSet a -> MergeSet a

mconcat :: [MergeSet a] -> MergeSet a

(Hashable a, Eq a) => Monoid (HashSet a)

Defined in Data.HashSet

Methods

mempty :: HashSet a

mappend :: HashSet a -> HashSet a -> HashSet a

mconcat :: [HashSet a] -> HashSet a

Storable a => Monoid (Vector a)

Defined in Data.Vector.Storable

Methods

mempty :: Vector a

mappend :: Vector a -> Vector a -> Vector a

mconcat :: [Vector a] -> Vector a

Prim a => Monoid (Vector a)

Defined in Data.Vector.Primitive

Methods

mempty :: Vector a

mappend :: Vector a -> Vector a -> Vector a

mconcat :: [Vector a] -> Vector a

Monoid (Vector a)

Defined in Data.Vector

Methods

mempty :: Vector a

mappend :: Vector a -> Vector a -> Vector a

mconcat :: [Vector a] -> Vector a

Monoid (Comparison a)

Defined in Data.Functor.Contravariant

Methods

mempty :: Comparison a

mappend :: Comparison a -> Comparison a -> Comparison a

mconcat :: [Comparison a] -> Comparison a

Monoid (Equivalence a)

Defined in Data.Functor.Contravariant

Methods

mempty :: Equivalence a

mappend :: Equivalence a -> Equivalence a -> Equivalence a

mconcat :: [Equivalence a] -> Equivalence a

Monoid (Predicate a)

Defined in Data.Functor.Contravariant

Methods

mempty :: Predicate a

mappend :: Predicate a -> Predicate a -> Predicate a

mconcat :: [Predicate a] -> Predicate a

Monoid (Array a)

Defined in Data.Primitive.Array

Methods

mempty :: Array a

mappend :: Array a -> Array a -> Array a

mconcat :: [Array a] -> Array a

Monoid (PrimArray a)

Defined in Data.Primitive.PrimArray

Methods

mempty :: PrimArray a

mappend :: PrimArray a -> PrimArray a -> PrimArray a

mconcat :: [PrimArray a] -> PrimArray a

Monoid (SmallArray a)

Defined in Data.Primitive.SmallArray

Methods

mempty :: SmallArray a

mappend :: SmallArray a -> SmallArray a -> SmallArray a

mconcat :: [SmallArray a] -> SmallArray a

PrimUnlifted a => Monoid (UnliftedArray a)

Defined in Data.Primitive.UnliftedArray

Methods

mempty :: UnliftedArray a

mappend :: UnliftedArray a -> UnliftedArray a -> UnliftedArray a

mconcat :: [UnliftedArray a] -> UnliftedArray a

a => Monoid (Dict a)

Defined in Data.Constraint

Methods

mempty :: Dict a

mappend :: Dict a -> Dict a -> Dict a

mconcat :: [Dict a] -> Dict a

Ord a => Monoid (Max a)

Defined in Control.Lens.Internal.Fold

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Ord a => Monoid (Min a)

Defined in Control.Lens.Internal.Fold

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

(Monoid a) :=> (Monoid (Maybe a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (Maybe a)

(Monoid a) :=> (Monoid (Const a b))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (Const a b)

(Monoid a) :=> (Monoid (Identity a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (Identity a)

(Monoid a) :=> (Monoid (IO a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (IO a)

(Monoid a) :=> (Applicative ((,) a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Applicative ((,) a)

(Monoid a) :=> (Applicative (Const a :: * -> *))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Applicative (Const a)

Class (Semigroup a) (Monoid a)

Defined in Data.Constraint

Methods

cls :: Monoid a :- Semigroup a

Monoid b => Monoid (a -> b)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: a -> b

mappend :: (a -> b) -> (a -> b) -> a -> b

mconcat :: [a -> b] -> a -> b

(Monoid a, Monoid b) => Monoid (a, b)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: (a, b)

mappend :: (a, b) -> (a, b) -> (a, b)

mconcat :: [(a, b)] -> (a, b)

Monoid a => Monoid (ST s a)

Since: base-4.11.0.0

Defined in GHC.ST

Methods

mempty :: ST s a

mappend :: ST s a -> ST s a -> ST s a

mconcat :: [ST s a] -> ST s a

Monoid (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

mempty :: Proxy s

mappend :: Proxy s -> Proxy s -> Proxy s

mconcat :: [Proxy s] -> Proxy s

Ord k => Monoid (Map k v)

Defined in Data.Map.Internal

Methods

mempty :: Map k v

mappend :: Map k v -> Map k v -> Map k v

mconcat :: [Map k v] -> Map k v

Monad m => Monoid (Sequenced a m)

Defined in Control.Lens.Internal.Fold

Methods

mempty :: Sequenced a m

mappend :: Sequenced a m -> Sequenced a m -> Sequenced a m

mconcat :: [Sequenced a m] -> Sequenced a m

Applicative f => Monoid (Traversed a f)

Defined in Control.Lens.Internal.Fold

Methods

mempty :: Traversed a f

mappend :: Traversed a f -> Traversed a f -> Traversed a f

mconcat :: [Traversed a f] -> Traversed a f

Monoid (ReifiedFold s a)

Defined in Control.Lens.Reified

Methods

mempty :: ReifiedFold s a

mappend :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a

mconcat :: [ReifiedFold s a] -> ReifiedFold s a

(Eq k, Hashable k) => Monoid (HashMap k v)

Defined in Data.HashMap.Base

Methods

mempty :: HashMap k v

mappend :: HashMap k v -> HashMap k v -> HashMap k v

mconcat :: [HashMap k v] -> HashMap k v

Monoid (f a) => Monoid (Indexing f a)

Defined in Control.Lens.Internal.Indexed

Methods

mempty :: Indexing f a

mappend :: Indexing f a -> Indexing f a -> Indexing f a

mconcat :: [Indexing f a] -> Indexing f a

Monoid a => Monoid (Op a b)

Defined in Data.Functor.Contravariant

Methods

mempty :: Op a b

mappend :: Op a b -> Op a b -> Op a b

mconcat :: [Op a b] -> Op a b

(Contravariant f, Applicative f) => Monoid (Folding f a)

Defined in Control.Lens.Internal.Fold

Methods

mempty :: Folding f a

mappend :: Folding f a -> Folding f a -> Folding f a

mconcat :: [Folding f a] -> Folding f a

(Apply f, Applicative f) => Monoid (TraversedF a f)

Defined in Control.Lens.Internal.Fold

Methods

mempty :: TraversedF a f

mappend :: TraversedF a f -> TraversedF a f -> TraversedF a f

mconcat :: [TraversedF a f] -> TraversedF a f

Monoid (Deepening i a)

Defined in Control.Lens.Internal.Level

Methods

mempty :: Deepening i a

mappend :: Deepening i a -> Deepening i a -> Deepening i a

mconcat :: [Deepening i a] -> Deepening i a

(Monoid a, Monoid b) :=> (Monoid (a, b))

Defined in Data.Constraint

Methods

ins :: (Monoid a, Monoid b) :- Monoid (a, b)

(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: (a, b, c)

mappend :: (a, b, c) -> (a, b, c) -> (a, b, c)

mconcat :: [(a, b, c)] -> (a, b, c)

Monoid a => Monoid (Const a b)

Defined in Data.Functor.Const

Methods

mempty :: Const a b

mappend :: Const a b -> Const a b -> Const a b

mconcat :: [Const a b] -> Const a b

Alternative f => Monoid (Alt f a)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

mempty :: Alt f a

mappend :: Alt f a -> Alt f a -> Alt f a

mconcat :: [Alt f a] -> Alt f a

Monoid a => Monoid (Constant a b)

Defined in Data.Functor.Constant

Methods

mempty :: Constant a b

mappend :: Constant a b -> Constant a b -> Constant a b

mconcat :: [Constant a b] -> Constant a b

Monoid (ReifiedIndexedFold i s a)

Defined in Control.Lens.Reified

Methods

mempty :: ReifiedIndexedFold i s a

mappend :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a

mconcat :: [ReifiedIndexedFold i s a] -> ReifiedIndexedFold i s a

Reifies s (ReifiedMonoid a) => Monoid (ReflectedMonoid a s)

Defined in Data.Reflection

Methods

mempty :: ReflectedMonoid a s

mappend :: ReflectedMonoid a s -> ReflectedMonoid a s -> ReflectedMonoid a s

mconcat :: [ReflectedMonoid a s] -> ReflectedMonoid a s

(Semigroup a, Monoid a) => Monoid (Tagged s a)

Defined in Data.Tagged

Methods

mempty :: Tagged s a

mappend :: Tagged s a -> Tagged s a -> Tagged s a

mconcat :: [Tagged s a] -> Tagged s a

(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: (a, b, c, d)

mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

mconcat :: [(a, b, c, d)] -> (a, b, c, d)

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: (a, b, c, d, e)

mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e)

Contravariant g => Monoid (BazaarT p g a b t)

Defined in Control.Lens.Internal.Bazaar

Methods

mempty :: BazaarT p g a b t

mappend :: BazaarT p g a b t -> BazaarT p g a b t -> BazaarT p g a b t

mconcat :: [BazaarT p g a b t] -> BazaarT p g a b t

data Bool

Constructors

False

True

Instances

Bounded Bool

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Bool

maxBound :: Bool

Enum Bool

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Bool -> Bool

pred :: Bool -> Bool

toEnum :: Int -> Bool

fromEnum :: Bool -> Int

enumFrom :: Bool -> [Bool]

enumFromThen :: Bool -> Bool -> [Bool]

enumFromTo :: Bool -> Bool -> [Bool]

enumFromThenTo :: Bool -> Bool -> Bool -> [Bool]

Eq Bool

Defined in GHC.Classes

Methods

(==) :: Bool -> Bool -> Bool

(/=) :: Bool -> Bool -> Bool

Data Bool

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool

toConstr :: Bool -> Constr

dataTypeOf :: Bool -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool)

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

gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r

gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool

Ord Bool

Defined in GHC.Classes

Methods

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

(<=) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

Read Bool

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Bool

readList :: ReadS [Bool]

readPrec :: ReadPrec Bool

readListPrec :: ReadPrec [Bool]

Show Bool

Defined in GHC.Show

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Ix Bool

Since: base-2.1

Defined in GHC.Arr

Methods

range :: (Bool, Bool) -> [Bool]

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

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

inRange :: (Bool, Bool) -> Bool -> Bool

rangeSize :: (Bool, Bool) -> Int

unsafeRangeSize :: (Bool, Bool) -> Int

Generic Bool

Defined in GHC.Generics

Associated Types

type Rep Bool :: * -> *

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Lift Bool

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Bool -> Q Exp

SingKind Bool

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type DemoteRep Bool :: *

Methods

fromSing :: Sing a -> DemoteRep Bool

Storable Bool

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Bool -> Int

alignment :: Bool -> Int

peekElemOff :: Ptr Bool -> Int -> IO Bool

pokeElemOff :: Ptr Bool -> Int -> Bool -> IO ()

peekByteOff :: Ptr b -> Int -> IO Bool

pokeByteOff :: Ptr b -> Int -> Bool -> IO ()

peek :: Ptr Bool -> IO Bool

poke :: Ptr Bool -> Bool -> IO ()

Bits Bool

Interpret Bool as 1-bit bit-field

Since: base-4.7.0.0

Defined in Data.Bits

Methods

(.&.) :: Bool -> Bool -> Bool

(.|.) :: Bool -> Bool -> Bool

xor :: Bool -> Bool -> Bool

complement :: Bool -> Bool

shift :: Bool -> Int -> Bool

rotate :: Bool -> Int -> Bool

zeroBits :: Bool

bit :: Int -> Bool

setBit :: Bool -> Int -> Bool

clearBit :: Bool -> Int -> Bool

complementBit :: Bool -> Int -> Bool

testBit :: Bool -> Int -> Bool

bitSizeMaybe :: Bool -> Maybe Int

bitSize :: Bool -> Int

isSigned :: Bool -> Bool

shiftL :: Bool -> Int -> Bool

unsafeShiftL :: Bool -> Int -> Bool

shiftR :: Bool -> Int -> Bool

unsafeShiftR :: Bool -> Int -> Bool

rotateL :: Bool -> Int -> Bool

rotateR :: Bool -> Int -> Bool

popCount :: Bool -> Int

FiniteBits Bool

Since: base-4.7.0.0

Defined in Data.Bits

Methods

finiteBitSize :: Bool -> Int

countLeadingZeros :: Bool -> Int

countTrailingZeros :: Bool -> Int

NFData Bool

Defined in Control.DeepSeq

Methods

rnf :: Bool -> ()

ShowX Bool

Defined in Clash.XException

Methods

showsPrecX :: Int -> Bool -> ShowS

showX :: Bool -> String

showListX :: [Bool] -> ShowS

Arbitrary Bool

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Bool

shrink :: Bool -> [Bool]

CoArbitrary Bool

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Bool -> Gen b -> Gen b

Unbox Bool

Defined in Data.Vector.Unboxed.Base

BitPack Bool

Defined in Clash.Class.BitPack

Associated Types

type BitSize Bool :: Nat

Methods

pack :: Bool -> BitVector (BitSize Bool)

unpack :: BitVector (BitSize Bool) -> Bool

Testable Bool

Defined in Test.QuickCheck.Property

Methods

property :: Bool -> Property

PBounded Bool

Defined in Data.Singletons.Prelude.Enum

Associated Types

type MinBound :: a

type MaxBound :: a

PEnum Bool

Defined in Data.Singletons.Prelude.Enum

Associated Types

type Succ arg :: a

type Pred arg :: a

type ToEnum arg :: a

type FromEnum arg :: Nat

type EnumFromTo arg arg1 :: [a]

type EnumFromThenTo arg arg1 arg2 :: [a]

SBounded Bool

Defined in Data.Singletons.Prelude.Enum

Methods

sMinBound :: Sing MinBoundSym0

sMaxBound :: Sing MaxBoundSym0

SEnum Bool

Defined in Data.Singletons.Prelude.Enum

Methods

sSucc :: Sing t -> Sing (Apply SuccSym0 t)

sPred :: Sing t -> Sing (Apply PredSym0 t)

sToEnum :: Sing t -> Sing (Apply ToEnumSym0 t)

sFromEnum :: Sing t -> Sing (Apply FromEnumSym0 t)

sEnumFromTo :: Sing t1 -> Sing t2 -> Sing (Apply (Apply EnumFromToSym0 t1) t2)

sEnumFromThenTo :: Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply EnumFromThenToSym0 t1) t2) t3)

PEq Bool

Defined in Data.Singletons.Prelude.Eq

Associated Types

type x == y :: Bool

type x /= y :: Bool

SEq Bool

Defined in Data.Singletons.Prelude.Eq

Methods

(%==) :: Sing a -> Sing b -> Sing (a == b)

(%/=) :: Sing a -> Sing b -> Sing (a /= b)

POrd Bool

Defined in Data.Singletons.Prelude.Ord

Associated Types

type Compare arg arg1 :: Ordering

type arg < arg1 :: Bool

type arg <= arg1 :: Bool

type arg > arg1 :: Bool

type arg >= arg1 :: Bool

type Max arg arg1 :: a

type Min arg arg1 :: a

SOrd Bool

Defined in Data.Singletons.Prelude.Ord

Methods

sCompare :: Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2)

(%<) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2)

(%<=) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2)

(%>) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2)

(%>=) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2)

sMax :: Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2)

sMin :: Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2)

PShow Bool

Defined in Data.Singletons.Prelude.Show

Associated Types

type ShowsPrec arg arg1 arg2 :: Symbol

type Show_ arg :: Symbol

type ShowList arg arg1 :: Symbol

SShow Bool

Defined in Data.Singletons.Prelude.Show

Methods

sShowsPrec :: Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3)

sShow_ :: Sing t -> Sing (Apply Show_Sym0 t)

sShowList :: Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2)

ShowSing Bool

Defined in Data.Singletons.ShowSing

Methods

showsSingPrec :: Int -> Sing a -> ShowS

Bundle Bool

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled domain Bool = (res :: *)

Methods

bundle :: Unbundled domain Bool -> Signal domain Bool

unbundle :: Signal domain Bool -> Unbundled domain Bool

SingI False

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing False

SingI True

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing True

Vector Vector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool)

basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool)

basicLength :: Vector Bool -> Int

basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool

basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m ()

elemseq :: Vector Bool -> Bool -> b -> b

MVector MVector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Bool -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool

basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool)

basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool)

LockStep Bool c

Defined in Clash.Prelude.DataFlow

Methods

lockStep :: DataFlow dom Bool Bool c c

stepLock :: DataFlow dom Bool Bool c c

() :=> (Bounded Bool)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Bool

() :=> (Enum Bool)

Defined in Data.Constraint

Methods

ins :: () :- Enum Bool

() :=> (Eq Bool)

Defined in Data.Constraint

Methods

ins :: () :- Eq Bool

() :=> (Ord Bool)

Defined in Data.Constraint

Methods

ins :: () :- Ord Bool

() :=> (Read Bool)

Defined in Data.Constraint

Methods

ins :: () :- Read Bool

() :=> (Show Bool)

Defined in Data.Constraint

Methods

ins :: () :- Show Bool

() :=> (Bits Bool)

Defined in Data.Constraint

Methods

ins :: () :- Bits Bool

SuppressUnusedWarnings ShowParenSym2

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (&&@#@$$)

Defined in Data.Singletons.Prelude.Bool

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (||@#@$$)

Defined in Data.Singletons.Prelude.Bool

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554746Sym1

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ShowParenSym1

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ShowsPrec_6989586621679891213Sym2

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ShowsPrec_6989586621679891213Sym1

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings NotSym0

Defined in Data.Singletons.Prelude.Bool

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (&&@#@$)

Defined in Data.Singletons.Prelude.Bool

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (||@#@$)

Defined in Data.Singletons.Prelude.Bool

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554746Sym0

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ShowParenSym0

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings FromEnum_6989586621680024193Sym0

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings AndSym0

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings OrSym0

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ToEnum_6989586621680024183Sym0

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ShowsPrec_6989586621679891213Sym0

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (UnionBySym2 :: (TyFun a6989586621679684397 (TyFun a6989586621679684397 Bool -> Type) -> Type) -> [a6989586621679684397] -> TyFun [a6989586621679684397] [a6989586621679684397] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (UnionBySym1 :: (TyFun a6989586621679684397 (TyFun a6989586621679684397 Bool -> Type) -> Type) -> TyFun [a6989586621679684397] (TyFun [a6989586621679684397] [a6989586621679684397] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TakeWhileSym1 :: (TyFun a6989586621679684424 Bool -> Type) -> TyFun [a6989586621679684424] [a6989586621679684424] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (SpanSym1 :: (TyFun a6989586621679684421 Bool -> Type) -> TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (SelectSym2 :: (TyFun a6989586621679684407 Bool -> Type) -> a6989586621679684407 -> TyFun ([a6989586621679684407], [a6989586621679684407]) ([a6989586621679684407], [a6989586621679684407]) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (SelectSym1 :: (TyFun a6989586621679684407 Bool -> Type) -> TyFun a6989586621679684407 (TyFun ([a6989586621679684407], [a6989586621679684407]) ([a6989586621679684407], [a6989586621679684407]) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (PartitionSym1 :: (TyFun a6989586621679684408 Bool -> Type) -> TyFun [a6989586621679684408] ([a6989586621679684408], [a6989586621679684408]) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (NubBySym1 :: (TyFun a6989586621679684399 (TyFun a6989586621679684399 Bool -> Type) -> Type) -> TyFun [a6989586621679684399] [a6989586621679684399] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139ZsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139ZsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139YsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139YsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139X_6989586621679694140Sym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] ([k], [k]) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139X_6989586621679694140Sym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] ([k], [k]) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046ZsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046ZsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046YsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046YsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046X_6989586621679694047Sym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] ([k], [k]) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046X_6989586621679694047Sym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] ([k], [k]) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IntersectBySym2 :: (TyFun a6989586621679684425 (TyFun a6989586621679684425 Bool -> Type) -> Type) -> [a6989586621679684425] -> TyFun [a6989586621679684425] [a6989586621679684425] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IntersectBySym1 :: (TyFun a6989586621679684425 (TyFun a6989586621679684425 Bool -> Type) -> Type) -> TyFun [a6989586621679684425] (TyFun [a6989586621679684425] [a6989586621679684425] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (GroupBySym1 :: (TyFun a6989586621679684411 (TyFun a6989586621679684411 Bool -> Type) -> Type) -> TyFun [a6989586621679684411] [[a6989586621679684411]] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindSym1 :: (TyFun a6989586621679684431 Bool -> Type) -> TyFun [a6989586621679684431] (Maybe a6989586621679684431) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindIndicesSym1 :: (TyFun a6989586621679684427 Bool -> Type) -> TyFun [a6989586621679684427] [Nat] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindIndexSym1 :: (TyFun a6989586621679684428 Bool -> Type) -> TyFun [a6989586621679684428] (Maybe Nat) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FilterSym1 :: (TyFun a6989586621679684432 Bool -> Type) -> TyFun [a6989586621679684432] [a6989586621679684432] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Elem_bySym2 :: (TyFun a6989586621679684398 (TyFun a6989586621679684398 Bool -> Type) -> Type) -> a6989586621679684398 -> TyFun [a6989586621679684398] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Elem_bySym1 :: (TyFun a6989586621679684398 (TyFun a6989586621679684398 Bool -> Type) -> Type) -> TyFun a6989586621679684398 (TyFun [a6989586621679684398] Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DropWhileSym1 :: (TyFun a6989586621679684423 Bool -> Type) -> TyFun [a6989586621679684423] [a6989586621679684423] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DropWhileEndSym1 :: (TyFun a6989586621679684422 Bool -> Type) -> TyFun [a6989586621679684422] [a6989586621679684422] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DeleteFirstsBySym2 :: (TyFun a6989586621679684437 (TyFun a6989586621679684437 Bool -> Type) -> Type) -> [a6989586621679684437] -> TyFun [a6989586621679684437] [a6989586621679684437] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DeleteFirstsBySym1 :: (TyFun a6989586621679684437 (TyFun a6989586621679684437 Bool -> Type) -> Type) -> TyFun [a6989586621679684437] (TyFun [a6989586621679684437] [a6989586621679684437] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DeleteBySym2 :: (TyFun a6989586621679684438 (TyFun a6989586621679684438 Bool -> Type) -> Type) -> a6989586621679684438 -> TyFun [a6989586621679684438] [a6989586621679684438] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DeleteBySym1 :: (TyFun a6989586621679684438 (TyFun a6989586621679684438 Bool -> Type) -> Type) -> TyFun a6989586621679684438 (TyFun [a6989586621679684438] [a6989586621679684438] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (BreakSym1 :: (TyFun a6989586621679684420 Bool -> Type) -> TyFun [a6989586621679684420] ([a6989586621679684420], [a6989586621679684420]) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (AnySym1 :: (TyFun a6989586621679684501 Bool -> Type) -> TyFun [a6989586621679684501] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (AllSym1 :: (TyFun a6989586621679684502 Bool -> Type) -> TyFun [a6989586621679684502] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsSuffixOfSym1 :: [a6989586621679684483] -> TyFun [a6989586621679684483] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsPrefixOfSym1 :: [a6989586621679684484] -> TyFun [a6989586621679684484] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsInfixOfSym1 :: [a6989586621679684482] -> TyFun [a6989586621679684482] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TFHelper_6989586621679547282Sym1 :: a6989586621679545915 -> TyFun a6989586621679545915 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TFHelper_6989586621679547249Sym1 :: a6989586621679545915 -> TyFun a6989586621679545915 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TFHelper_6989586621679547216Sym1 :: a6989586621679545915 -> TyFun a6989586621679545915 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TFHelper_6989586621679547183Sym1 :: a6989586621679545915 -> TyFun a6989586621679545915 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547335Scrutinee_6989586621679545947Sym1 :: k1 -> TyFun k1 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547302Scrutinee_6989586621679545945Sym1 :: k1 -> TyFun k1 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547136Scrutinee_6989586621679545935Sym1 :: k1 -> TyFun k1 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547126Scrutinee_6989586621679545933Sym1 :: k1 -> TyFun k1 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((>@#@$$) :: a6989586621679545915 -> TyFun a6989586621679545915 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((>=@#@$$) :: a6989586621679545915 -> TyFun a6989586621679545915 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((<@#@$$) :: a6989586621679545915 -> TyFun a6989586621679545915 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((<=@#@$$) :: a6989586621679545915 -> TyFun a6989586621679545915 Bool -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (NotElemSym1 :: a6989586621679684480 -> TyFun [a6989586621679684480] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ElemSym1 :: a6989586621679684481 -> TyFun [a6989586621679684481] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((==@#@$$) :: a6989586621679535122 -> TyFun a6989586621679535122 Bool -> *)

Defined in Data.Singletons.Prelude.Eq

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((/=@#@$$) :: a6989586621679535122 -> TyFun a6989586621679535122 Bool -> *)

Defined in Data.Singletons.Prelude.Eq

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Bool_Sym2 :: a6989586621679532748 -> a6989586621679532748 -> TyFun Bool a6989586621679532748 -> *)

Defined in Data.Singletons.Prelude.Bool

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Bool_Sym1 :: a6989586621679532748 -> TyFun a6989586621679532748 (TyFun Bool a6989586621679532748 -> Type) -> *)

Defined in Data.Singletons.Prelude.Bool

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (UnionBySym0 :: TyFun (TyFun a6989586621679684397 (TyFun a6989586621679684397 Bool -> Type) -> Type) (TyFun [a6989586621679684397] (TyFun [a6989586621679684397] [a6989586621679684397] -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TakeWhileSym0 :: TyFun (TyFun a6989586621679684424 Bool -> Type) (TyFun [a6989586621679684424] [a6989586621679684424] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (SpanSym0 :: TyFun (TyFun a6989586621679684421 Bool -> Type) (TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (SelectSym0 :: TyFun (TyFun a6989586621679684407 Bool -> Type) (TyFun a6989586621679684407 (TyFun ([a6989586621679684407], [a6989586621679684407]) ([a6989586621679684407], [a6989586621679684407]) -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (PartitionSym0 :: TyFun (TyFun a6989586621679684408 Bool -> Type) (TyFun [a6989586621679684408] ([a6989586621679684408], [a6989586621679684408]) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (NubBySym0 :: TyFun (TyFun a6989586621679684399 (TyFun a6989586621679684399 Bool -> Type) -> Type) (TyFun [a6989586621679684399] [a6989586621679684399] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694139X_6989586621679694140Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694046X_6989586621679694047Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IntersectBySym0 :: TyFun (TyFun a6989586621679684425 (TyFun a6989586621679684425 Bool -> Type) -> Type) (TyFun [a6989586621679684425] (TyFun [a6989586621679684425] [a6989586621679684425] -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (GroupBySym0 :: TyFun (TyFun a6989586621679684411 (TyFun a6989586621679684411 Bool -> Type) -> Type) (TyFun [a6989586621679684411] [[a6989586621679684411]] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindSym0 :: TyFun (TyFun a6989586621679684431 Bool -> Type) (TyFun [a6989586621679684431] (Maybe a6989586621679684431) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindIndicesSym0 :: TyFun (TyFun a6989586621679684427 Bool -> Type) (TyFun [a6989586621679684427] [Nat] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindIndexSym0 :: TyFun (TyFun a6989586621679684428 Bool -> Type) (TyFun [a6989586621679684428] (Maybe Nat) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FilterSym0 :: TyFun (TyFun a6989586621679684432 Bool -> Type) (TyFun [a6989586621679684432] [a6989586621679684432] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Elem_bySym0 :: TyFun (TyFun a6989586621679684398 (TyFun a6989586621679684398 Bool -> Type) -> Type) (TyFun a6989586621679684398 (TyFun [a6989586621679684398] Bool -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DropWhileSym0 :: TyFun (TyFun a6989586621679684423 Bool -> Type) (TyFun [a6989586621679684423] [a6989586621679684423] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DropWhileEndSym0 :: TyFun (TyFun a6989586621679684422 Bool -> Type) (TyFun [a6989586621679684422] [a6989586621679684422] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DeleteFirstsBySym0 :: TyFun (TyFun a6989586621679684437 (TyFun a6989586621679684437 Bool -> Type) -> Type) (TyFun [a6989586621679684437] (TyFun [a6989586621679684437] [a6989586621679684437] -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (DeleteBySym0 :: TyFun (TyFun a6989586621679684438 (TyFun a6989586621679684438 Bool -> Type) -> Type) (TyFun a6989586621679684438 (TyFun [a6989586621679684438] [a6989586621679684438] -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (BreakSym0 :: TyFun (TyFun a6989586621679684420 Bool -> Type) (TyFun [a6989586621679684420] ([a6989586621679684420], [a6989586621679684420]) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (AnySym0 :: TyFun (TyFun a6989586621679684501 Bool -> Type) (TyFun [a6989586621679684501] Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (AllSym0 :: TyFun (TyFun a6989586621679684502 Bool -> Type) (TyFun [a6989586621679684502] Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (NullSym0 :: TyFun [a6989586621679684518] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsSuffixOfSym0 :: TyFun [a6989586621679684483] (TyFun [a6989586621679684483] Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsPrefixOfSym0 :: TyFun [a6989586621679684484] (TyFun [a6989586621679684484] Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsInfixOfSym0 :: TyFun [a6989586621679684482] (TyFun [a6989586621679684482] Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsNothingSym0 :: TyFun (Maybe a6989586621679650708) Bool -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsJustSym0 :: TyFun (Maybe a6989586621679650709) Bool -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TFHelper_6989586621679547282Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TFHelper_6989586621679547249Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TFHelper_6989586621679547216Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (TFHelper_6989586621679547183Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547335Scrutinee_6989586621679545947Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547302Scrutinee_6989586621679545945Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547136Scrutinee_6989586621679545935Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547126Scrutinee_6989586621679545933Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((>@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((>=@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((<@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((<=@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (NotElemSym0 :: TyFun a6989586621679684480 (TyFun [a6989586621679684480] Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ElemSym0 :: TyFun a6989586621679684481 (TyFun [a6989586621679684481] Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((==@#@$) :: TyFun a6989586621679535122 (TyFun a6989586621679535122 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Eq

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ((/=@#@$) :: TyFun a6989586621679535122 (TyFun a6989586621679535122 Bool -> Type) -> *)

Defined in Data.Singletons.Prelude.Eq

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Bool_Sym0 :: TyFun a6989586621679532748 (TyFun a6989586621679532748 (TyFun Bool a6989586621679532748 -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.Bool

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693694NubBy'Sym3 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> k -> [k1] -> TyFun [k1] [k1] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693694NubBy'Sym2 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> k -> TyFun [k1] ([k1] ~> [k1]) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693694NubBy'Sym1 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> TyFun k (TyFun [k1] ([k1] ~> [k1]) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693786Scrutinee_6989586621679685099Sym1 :: k1 -> TyFun k Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693694NubBy'Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsRightSym0 :: TyFun (Either a6989586621680064142 b6989586621680064143) Bool -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsLeftSym0 :: TyFun (Either a6989586621680064144 b6989586621680064145) Bool -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693786Scrutinee_6989586621679685099Sym0 :: TyFun k1 (TyFun k Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203ZsSym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] [a6989586621679684421] -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203YsSym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] [a6989586621679684421] -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203X_6989586621679694204Sym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679696582Sym0 :: TyFun (a6989586621679684518 ~> Bool) (TyFun k (TyFun a6989586621679684518 (TyFun [a6989586621679684518] [a6989586621679684518] -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203ZsSym2 :: (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) -> k1 -> TyFun [a6989586621679684421] [a6989586621679684421] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203ZsSym1 :: (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679684421] [a6989586621679684421] -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203YsSym2 :: (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) -> k1 -> TyFun [a6989586621679684421] [a6989586621679684421] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203YsSym1 :: (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679684421] [a6989586621679684421] -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203X_6989586621679694204Sym2 :: (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) -> k1 -> TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679694203X_6989586621679694204Sym1 :: (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679696582Sym3 :: (a6989586621679684518 ~> Bool) -> k -> a6989586621679684518 -> TyFun [a6989586621679684518] [a6989586621679684518] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679696582Sym2 :: (a6989586621679684518 ~> Bool) -> k -> TyFun a6989586621679684518 (TyFun [a6989586621679684518] [a6989586621679684518] -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679696582Sym1 :: (a6989586621679684518 ~> Bool) -> TyFun k (TyFun a6989586621679684518 (TyFun [a6989586621679684518] [a6989586621679684518] -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693718Scrutinee_6989586621679685105Sym4 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> k3 -> k2 -> TyFun [k3] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693718Scrutinee_6989586621679685105Sym3 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> k3 -> TyFun k2 (TyFun [k3] Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693718Scrutinee_6989586621679685105Sym2 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693718Scrutinee_6989586621679685105Sym1 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695049Scrutinee_6989586621679685103Sym3 :: k1 -> k3 -> k2 -> TyFun [k3] Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695049Scrutinee_6989586621679685103Sym2 :: k1 -> k3 -> TyFun k2 (TyFun [k3] Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695049Scrutinee_6989586621679685103Sym1 :: k1 -> TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693978Scrutinee_6989586621679685083Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693978Scrutinee_6989586621679685083Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693950Scrutinee_6989586621679685085Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693950Scrutinee_6989586621679685085Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693916Scrutinee_6989586621679685095Sym3 :: k1 -> k1 -> k2 -> TyFun k3 Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693916Scrutinee_6989586621679685095Sym2 :: k1 -> k1 -> TyFun k2 (TyFun k3 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693916Scrutinee_6989586621679685095Sym1 :: k1 -> TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693759Scrutinee_6989586621679685101Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693759Scrutinee_6989586621679685101Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693718Scrutinee_6989586621679685105Sym0 :: TyFun (TyFun k3 (TyFun k3 Bool -> Type) -> Type) (TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695049Scrutinee_6989586621679685103Sym0 :: TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693978Scrutinee_6989586621679685083Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693950Scrutinee_6989586621679685085Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693916Scrutinee_6989586621679685095Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679693759Scrutinee_6989586621679685101Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679696586Scrutinee_6989586621679685077Sym0 :: TyFun (k1 ~> Bool) (TyFun k1 (TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679696586Scrutinee_6989586621679685077Sym3 :: (k1 ~> Bool) -> k1 -> [a6989586621679684518] -> TyFun k Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679696586Scrutinee_6989586621679685077Sym2 :: (k1 ~> Bool) -> k1 -> TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679696586Scrutinee_6989586621679685077Sym1 :: (k1 ~> Bool) -> TyFun k1 (TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005547Scrutinee_6989586621680005029Sym4 :: k1 -> k2 -> k2 -> k3 -> TyFun k4 Bool -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005547Scrutinee_6989586621680005029Sym3 :: k1 -> k2 -> k2 -> TyFun k3 (TyFun k4 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005547Scrutinee_6989586621680005029Sym2 :: k1 -> k2 -> TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005547Scrutinee_6989586621680005029Sym1 :: k1 -> TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005547Scrutinee_6989586621680005029Sym0 :: TyFun k1 (TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679695671Sym0 :: TyFun (k3 ~> (TyFun a6989586621679684501 Bool -> Type)) (TyFun k1 (TyFun k2 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k3 Bool -> *) -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679695671Sym5 :: (k3 ~> (TyFun a6989586621679684501 Bool -> Type)) -> k1 -> k2 -> a6989586621679684501 -> [a6989586621679684501] -> TyFun k3 Bool -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679695671Sym4 :: (k3 ~> (TyFun a6989586621679684501 Bool -> Type)) -> k1 -> k2 -> a6989586621679684501 -> TyFun [a6989586621679684501] (TyFun k3 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679695671Sym3 :: (k3 ~> (TyFun a6989586621679684501 Bool -> Type)) -> k1 -> k2 -> TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k3 Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679695671Sym2 :: (k3 ~> (TyFun a6989586621679684501 Bool -> Type)) -> k1 -> TyFun k2 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k3 Bool -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Lambda_6989586621679695671Sym1 :: (k3 ~> (TyFun a6989586621679684501 Bool -> Type)) -> TyFun k1 (TyFun k2 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k3 Bool -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005320Scrutinee_6989586621680005043Sym5 :: k2 -> k1 -> k2 -> k3 -> k4 -> TyFun k5 Bool -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005320Scrutinee_6989586621680005043Sym4 :: k2 -> k1 -> k2 -> k3 -> TyFun k4 (TyFun k5 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005320Scrutinee_6989586621680005043Sym3 :: k2 -> k1 -> k2 -> TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005320Scrutinee_6989586621680005043Sym2 :: k2 -> k1 -> TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005320Scrutinee_6989586621680005043Sym1 :: k2 -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005138Scrutinee_6989586621680005053Sym5 :: k2 -> k1 -> k2 -> k3 -> k4 -> TyFun k5 Bool -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005138Scrutinee_6989586621680005053Sym4 :: k2 -> k1 -> k2 -> k3 -> TyFun k4 (TyFun k5 Bool -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005138Scrutinee_6989586621680005053Sym3 :: k2 -> k1 -> k2 -> TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005138Scrutinee_6989586621680005053Sym2 :: k2 -> k1 -> TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005138Scrutinee_6989586621680005053Sym1 :: k2 -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005320Scrutinee_6989586621680005043Sym0 :: TyFun k2 (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621680005138Scrutinee_6989586621680005053Sym0 :: TyFun k2 (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

type Rep Bool

Defined in GHC.Generics

type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) (C1 (MetaCons "False" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "True" PrefixI False) (U1 :: * -> *))

data Sing (a :: Bool)

Defined in GHC.Generics

data Sing (a :: Bool) where

• STrue :: Sing True
• SFalse :: Sing False

type DemoteRep Bool

Defined in GHC.Generics

type DemoteRep Bool = Bool

data Vector Bool

Defined in Data.Vector.Unboxed.Base

data Vector Bool = V_Bool (Vector Word8)

type BitSize Bool

Defined in Clash.Class.BitPack

type BitSize Bool = 1

data Sing (z :: Bool)

Defined in Data.Singletons.Prelude.Instances

data Sing (z :: Bool) where

• SFalse :: Sing False
• STrue :: Sing True

type Demote Bool

Defined in Data.Singletons.Prelude.Instances

type Demote Bool = Bool

type MaxBound

Defined in Data.Singletons.Prelude.Enum

type MaxBound = MaxBound_6989586621680001123Sym0

type MinBound

Defined in Data.Singletons.Prelude.Enum

type MinBound = MinBound_6989586621680001121Sym0

data MVector s Bool

Defined in Data.Vector.Unboxed.Base

data MVector s Bool = MV_Bool (MVector s Word8)

type FromEnum (a :: Bool)

Defined in Data.Singletons.Prelude.Enum

type FromEnum (a :: Bool) = Apply FromEnum_6989586621680024193Sym0 a

type ToEnum a

Defined in Data.Singletons.Prelude.Enum

type ToEnum a = Apply ToEnum_6989586621680024183Sym0 a

type Show_ (arg :: Bool)

Defined in Data.Singletons.Prelude.Show

type Show_ (arg :: Bool) = Apply (Show__6989586621679875032Sym0 :: TyFun Bool Symbol -> *) arg

type Pred (arg :: Bool)

Defined in Data.Singletons.Prelude.Enum

type Pred (arg :: Bool) = Apply (Pred_6989586621680005652Sym0 :: TyFun Bool Bool -> *) arg

type Succ (arg :: Bool)

Defined in Data.Singletons.Prelude.Enum

type Succ (arg :: Bool) = Apply (Succ_6989586621680005639Sym0 :: TyFun Bool Bool -> *) arg

type Unbundled domain Bool

Defined in Clash.Signal.Bundle

type Unbundled domain Bool = Signal domain Bool

type EnumFromTo (arg1 :: Bool) (arg2 :: Bool)

Defined in Data.Singletons.Prelude.Enum

type EnumFromTo (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (EnumFromTo_6989586621680005670Sym0 :: TyFun Bool (TyFun Bool [Bool] -> Type) -> *) arg1) arg2

type (x :: Bool) /= (y :: Bool)

Defined in Data.Singletons.Prelude.Eq

type (x :: Bool) /= (y :: Bool) = Not (x == y)

type (a :: Bool) == (b :: Bool)

Defined in Data.Singletons.Prelude.Eq

type (a :: Bool) == (b :: Bool) = Equals_6989586621679536018 a b

type (arg1 :: Bool) < (arg2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Bool) < (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679547183Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2

type (arg1 :: Bool) <= (arg2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Bool) <= (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679547216Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2

type (arg1 :: Bool) > (arg2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Bool) > (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679547249Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2

type (arg1 :: Bool) >= (arg2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Bool) >= (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679547282Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2

type Compare (a1 :: Bool) (a2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type Compare (a1 :: Bool) (a2 :: Bool) = Apply (Apply Compare_6989586621679554746Sym0 a1) a2

type Max (arg1 :: Bool) (arg2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type Max (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (Max_6989586621679547315Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2

type Min (arg1 :: Bool) (arg2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type Min (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (Min_6989586621679547348Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2

type ShowList (arg1 :: [Bool]) arg2

Defined in Data.Singletons.Prelude.Show

type ShowList (arg1 :: [Bool]) arg2 = Apply (Apply (ShowList_6989586621679875050Sym0 :: TyFun [Bool] (TyFun Symbol Symbol -> Type) -> *) arg1) arg2

type Apply NotSym0 (l :: Bool)

Defined in Data.Singletons.Prelude.Bool

type Apply NotSym0 (l :: Bool) = Not l

type Apply FromEnum_6989586621680024193Sym0 (l :: Bool)

Defined in Data.Singletons.Prelude.Enum

type Apply FromEnum_6989586621680024193Sym0 (l :: Bool) = FromEnum_6989586621680024193 l

type Apply ToEnum_6989586621680024183Sym0 (l :: Nat)

Defined in Data.Singletons.Prelude.Enum

type Apply ToEnum_6989586621680024183Sym0 (l :: Nat) = ToEnum_6989586621680024183 l

type EnumFromThenTo (arg1 :: Bool) (arg2 :: Bool) (arg3 :: Bool)

Defined in Data.Singletons.Prelude.Enum

type EnumFromThenTo (arg1 :: Bool) (arg2 :: Bool) (arg3 :: Bool) = Apply (Apply (Apply (EnumFromThenTo_6989586621680005700Sym0 :: TyFun Bool (TyFun Bool (TyFun Bool [Bool] -> Type) -> Type) -> *) arg1) arg2) arg3

type ShowsPrec a1 (a2 :: Bool) a3

Defined in Data.Singletons.Prelude.Show

type ShowsPrec a1 (a2 :: Bool) a3 = Apply (Apply (Apply ShowsPrec_6989586621679891213Sym0 a1) a2) a3

type Apply ((&&@#@$$) l1 :: TyFun Bool Bool -> *) (l2 :: Bool)

Defined in Data.Singletons.Prelude.Bool

type Apply ((&&@#@$$) l1 :: TyFun Bool Bool -> *) (l2 :: Bool) = l1 && l2

type Apply ((||@#@$$) l1 :: TyFun Bool Bool -> *) (l2 :: Bool)

Defined in Data.Singletons.Prelude.Bool

type Apply ((||@#@$$) l1 :: TyFun Bool Bool -> *) (l2 :: Bool) = l1 || l2

type Apply (Compare_6989586621679554746Sym1 l1 :: TyFun Bool Ordering -> *) (l2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554746Sym1 l1 :: TyFun Bool Ordering -> *) (l2 :: Bool) = Compare_6989586621679554746 l1 l2

type Apply (Let6989586621679547126Scrutinee_6989586621679545933Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547126Scrutinee_6989586621679545933Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1) = Let6989586621679547126Scrutinee_6989586621679545933 l1 l2

type Apply (TFHelper_6989586621679547282Sym1 l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply (TFHelper_6989586621679547282Sym1 l1 :: TyFun a Bool -> *) (l2 :: a) = TFHelper_6989586621679547282 l1 l2

type Apply (TFHelper_6989586621679547249Sym1 l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply (TFHelper_6989586621679547249Sym1 l1 :: TyFun a Bool -> *) (l2 :: a) = TFHelper_6989586621679547249 l1 l2

type Apply (TFHelper_6989586621679547216Sym1 l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply (TFHelper_6989586621679547216Sym1 l1 :: TyFun a Bool -> *) (l2 :: a) = TFHelper_6989586621679547216 l1 l2

type Apply (TFHelper_6989586621679547183Sym1 l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply (TFHelper_6989586621679547183Sym1 l1 :: TyFun a Bool -> *) (l2 :: a) = TFHelper_6989586621679547183 l1 l2

type Apply ((<=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply ((<=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 <= l2

type Apply ((>=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply ((>=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 >= l2

type Apply ((>@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply ((>@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 > l2

type Apply (Let6989586621679547335Scrutinee_6989586621679545947Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547335Scrutinee_6989586621679545947Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1) = Let6989586621679547335Scrutinee_6989586621679545947 l1 l2

type Apply (Let6989586621679547302Scrutinee_6989586621679545945Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547302Scrutinee_6989586621679545945Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1) = Let6989586621679547302Scrutinee_6989586621679545945 l1 l2

type Apply (Let6989586621679547136Scrutinee_6989586621679545935Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547136Scrutinee_6989586621679545935Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1) = Let6989586621679547136Scrutinee_6989586621679545935 l1 l2

type Apply ((<@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply ((<@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 < l2

type Apply ((==@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Eq

type Apply ((==@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 == l2

type Apply ((/=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Eq

type Apply ((/=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 /= l2

type Apply (Bool_Sym2 l1 l2 :: TyFun Bool a -> *) (l3 :: Bool)

Defined in Data.Singletons.Prelude.Bool

type Apply (Bool_Sym2 l1 l2 :: TyFun Bool a -> *) (l3 :: Bool) = Bool_ l1 l2 l3

type Apply (Let6989586621679693786Scrutinee_6989586621679685099Sym1 l1 :: TyFun k Bool -> *) (l2 :: k)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693786Scrutinee_6989586621679685099Sym1 l1 :: TyFun k Bool -> *) (l2 :: k) = Let6989586621679693786Scrutinee_6989586621679685099 l1 l2

type Apply (Let6989586621679693759Scrutinee_6989586621679685101Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693759Scrutinee_6989586621679685101Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3) = Let6989586621679693759Scrutinee_6989586621679685101 l1 l2 l3

type Apply (Let6989586621679693950Scrutinee_6989586621679685085Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693950Scrutinee_6989586621679685085Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3) = Let6989586621679693950Scrutinee_6989586621679685085 l1 l2 l3

type Apply (Let6989586621679693978Scrutinee_6989586621679685083Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693978Scrutinee_6989586621679685083Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3) = Let6989586621679693978Scrutinee_6989586621679685083 l1 l2 l3

type Apply (Let6989586621679693916Scrutinee_6989586621679685095Sym3 l1 l2 l3 :: TyFun k3 Bool -> *) (l4 :: k3)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693916Scrutinee_6989586621679685095Sym3 l1 l2 l3 :: TyFun k3 Bool -> *) (l4 :: k3) = Let6989586621679693916Scrutinee_6989586621679685095 l1 l2 l3 l4

type Apply (Let6989586621679696586Scrutinee_6989586621679685077Sym3 l1 l2 l3 :: TyFun k Bool -> *) (l4 :: k)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679696586Scrutinee_6989586621679685077Sym3 l1 l2 l3 :: TyFun k Bool -> *) (l4 :: k) = Let6989586621679696586Scrutinee_6989586621679685077 l1 l2 l3 l4

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym4 l1 l2 l3 l4 :: TyFun k4 Bool -> *) (l5 :: k4)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym4 l1 l2 l3 l4 :: TyFun k4 Bool -> *) (l5 :: k4) = Let6989586621680005547Scrutinee_6989586621680005029 l1 l2 l3 l4 l5

type Apply (Lambda_6989586621679695671Sym5 l1 l2 l3 l4 l5 :: TyFun k1 Bool -> *) (l6 :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Lambda_6989586621679695671Sym5 l1 l2 l3 l4 l5 :: TyFun k1 Bool -> *) (l6 :: k1) = Lambda_6989586621679695671 l1 l2 l3 l4 l5 l6

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *) (l6 :: k5)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *) (l6 :: k5) = Let6989586621680005138Scrutinee_6989586621680005053 l1 l2 l3 l4 l5 l6

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *) (l6 :: k5)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *) (l6 :: k5) = Let6989586621680005320Scrutinee_6989586621680005043 l1 l2 l3 l4 l5 l6

type Apply (&&@#@$) (l :: Bool)

Defined in Data.Singletons.Prelude.Bool

type Apply (&&@#@$) (l :: Bool) = (&&@#@$$) l

type Apply (||@#@$) (l :: Bool)

Defined in Data.Singletons.Prelude.Bool

type Apply (||@#@$) (l :: Bool) = (||@#@$$) l

type Apply Compare_6989586621679554746Sym0 (l :: Bool)

Defined in Data.Singletons.Prelude.Ord

type Apply Compare_6989586621679554746Sym0 (l :: Bool) = Compare_6989586621679554746Sym1 l

type Apply ShowParenSym0 (l :: Bool)

Defined in Data.Singletons.Prelude.Show

type Apply ShowParenSym0 (l :: Bool) = ShowParenSym1 l

type Apply ShowsPrec_6989586621679891213Sym0 (l :: Nat)

Defined in Data.Singletons.Prelude.Show

type Apply ShowsPrec_6989586621679891213Sym0 (l :: Nat) = ShowsPrec_6989586621679891213Sym1 l

type Apply (ShowsPrec_6989586621679891213Sym1 l1 :: TyFun Bool (TyFun Symbol Symbol -> Type) -> *) (l2 :: Bool)

Defined in Data.Singletons.Prelude.Show

type Apply (ShowsPrec_6989586621679891213Sym1 l1 :: TyFun Bool (TyFun Symbol Symbol -> Type) -> *) (l2 :: Bool) = ShowsPrec_6989586621679891213Sym2 l1 l2

type Apply (Let6989586621679547126Scrutinee_6989586621679545933Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547126Scrutinee_6989586621679545933Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) (l :: k1) = Let6989586621679547126Scrutinee_6989586621679545933Sym1 l

type Apply (TFHelper_6989586621679547282Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply (TFHelper_6989586621679547282Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915) = TFHelper_6989586621679547282Sym1 l

type Apply (TFHelper_6989586621679547249Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply (TFHelper_6989586621679547249Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915) = TFHelper_6989586621679547249Sym1 l

type Apply (TFHelper_6989586621679547216Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply (TFHelper_6989586621679547216Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915) = TFHelper_6989586621679547216Sym1 l

type Apply (TFHelper_6989586621679547183Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply (TFHelper_6989586621679547183Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915) = TFHelper_6989586621679547183Sym1 l

type Apply ((<=@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply ((<=@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915) = (<=@#@$$) l

type Apply ((>=@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply ((>=@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915) = (>=@#@$$) l

type Apply ((>@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply ((>@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915) = (>@#@$$) l

type Apply (Let6989586621679547335Scrutinee_6989586621679545947Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547335Scrutinee_6989586621679545947Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) (l :: k1) = Let6989586621679547335Scrutinee_6989586621679545947Sym1 l

type Apply (Let6989586621679547302Scrutinee_6989586621679545945Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547302Scrutinee_6989586621679545945Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) (l :: k1) = Let6989586621679547302Scrutinee_6989586621679545945Sym1 l

type Apply (Let6989586621679547136Scrutinee_6989586621679545935Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547136Scrutinee_6989586621679545935Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) (l :: k1) = Let6989586621679547136Scrutinee_6989586621679545935Sym1 l

type Apply ((<@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply ((<@#@$) :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Bool -> Type) -> *) (l :: a6989586621679545915) = (<@#@$$) l

type Apply (NotElemSym0 :: TyFun a6989586621679684480 (TyFun [a6989586621679684480] Bool -> Type) -> *) (l :: a6989586621679684480)

Defined in Data.Singletons.Prelude.List

type Apply (NotElemSym0 :: TyFun a6989586621679684480 (TyFun [a6989586621679684480] Bool -> Type) -> *) (l :: a6989586621679684480) = NotElemSym1 l

type Apply (ElemSym0 :: TyFun a6989586621679684481 (TyFun [a6989586621679684481] Bool -> Type) -> *) (l :: a6989586621679684481)

Defined in Data.Singletons.Prelude.List

type Apply (ElemSym0 :: TyFun a6989586621679684481 (TyFun [a6989586621679684481] Bool -> Type) -> *) (l :: a6989586621679684481) = ElemSym1 l

type Apply ((==@#@$) :: TyFun a6989586621679535122 (TyFun a6989586621679535122 Bool -> Type) -> *) (l :: a6989586621679535122)

Defined in Data.Singletons.Prelude.Eq

type Apply ((==@#@$) :: TyFun a6989586621679535122 (TyFun a6989586621679535122 Bool -> Type) -> *) (l :: a6989586621679535122) = (==@#@$$) l

type Apply ((/=@#@$) :: TyFun a6989586621679535122 (TyFun a6989586621679535122 Bool -> Type) -> *) (l :: a6989586621679535122)

Defined in Data.Singletons.Prelude.Eq

type Apply ((/=@#@$) :: TyFun a6989586621679535122 (TyFun a6989586621679535122 Bool -> Type) -> *) (l :: a6989586621679535122) = (/=@#@$$) l

type Apply (Bool_Sym0 :: TyFun a6989586621679532748 (TyFun a6989586621679532748 (TyFun Bool a6989586621679532748 -> Type) -> Type) -> *) (l :: a6989586621679532748)

Defined in Data.Singletons.Prelude.Bool

type Apply (Bool_Sym0 :: TyFun a6989586621679532748 (TyFun a6989586621679532748 (TyFun Bool a6989586621679532748 -> Type) -> Type) -> *) (l :: a6989586621679532748) = Bool_Sym1 l

type Apply (Let6989586621679693786Scrutinee_6989586621679685099Sym0 :: TyFun k1 (TyFun k Bool -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693786Scrutinee_6989586621679685099Sym0 :: TyFun k1 (TyFun k Bool -> *) -> *) (l :: k1) = (Let6989586621679693786Scrutinee_6989586621679685099Sym1 l :: TyFun k Bool -> *)

type Apply (Elem_bySym1 l1 :: TyFun a6989586621679684398 (TyFun [a6989586621679684398] Bool -> Type) -> *) (l2 :: a6989586621679684398)

Defined in Data.Singletons.Prelude.List

type Apply (Elem_bySym1 l1 :: TyFun a6989586621679684398 (TyFun [a6989586621679684398] Bool -> Type) -> *) (l2 :: a6989586621679684398) = Elem_bySym2 l1 l2

type Apply (Bool_Sym1 l1 :: TyFun a6989586621679532748 (TyFun Bool a6989586621679532748 -> Type) -> *) (l2 :: a6989586621679532748)

Defined in Data.Singletons.Prelude.Bool

type Apply (Bool_Sym1 l1 :: TyFun a6989586621679532748 (TyFun Bool a6989586621679532748 -> Type) -> *) (l2 :: a6989586621679532748) = Bool_Sym2 l1 l2

type Apply (Let6989586621679693759Scrutinee_6989586621679685101Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693759Scrutinee_6989586621679685101Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) (l :: k1) = (Let6989586621679693759Scrutinee_6989586621679685101Sym1 l :: TyFun k2 (TyFun k3 Bool -> *) -> *)

type Apply (Let6989586621679693916Scrutinee_6989586621679685095Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693916Scrutinee_6989586621679685095Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) -> *) (l :: k1) = (Let6989586621679693916Scrutinee_6989586621679685095Sym1 l :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *)

type Apply (Let6989586621679693950Scrutinee_6989586621679685085Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693950Scrutinee_6989586621679685085Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) (l :: k1) = (Let6989586621679693950Scrutinee_6989586621679685085Sym1 l :: TyFun k2 (TyFun k3 Bool -> *) -> *)

type Apply (Let6989586621679693978Scrutinee_6989586621679685083Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693978Scrutinee_6989586621679685083Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) (l :: k1) = (Let6989586621679693978Scrutinee_6989586621679685083Sym1 l :: TyFun k2 (TyFun k3 Bool -> *) -> *)

type Apply (Let6989586621679695049Scrutinee_6989586621679685103Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun [k2] Bool -> *) -> *) -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679695049Scrutinee_6989586621679685103Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun [k2] Bool -> *) -> *) -> *) -> *) (l :: k1) = (Let6989586621679695049Scrutinee_6989586621679685103Sym1 l :: TyFun k2 (TyFun k3 (TyFun [k2] Bool -> *) -> *) -> *)

type Apply (Let6989586621679693759Scrutinee_6989586621679685101Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693759Scrutinee_6989586621679685101Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> *) -> *) (l2 :: k1) = (Let6989586621679693759Scrutinee_6989586621679685101Sym2 l1 l2 :: TyFun k3 Bool -> *)

type Apply (Let6989586621679693916Scrutinee_6989586621679685095Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693916Scrutinee_6989586621679685095Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) (l2 :: k1) = (Let6989586621679693916Scrutinee_6989586621679685095Sym2 l1 l2 :: TyFun k2 (TyFun k3 Bool -> *) -> *)

type Apply (Let6989586621679693950Scrutinee_6989586621679685085Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693950Scrutinee_6989586621679685085Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> *) -> *) (l2 :: k1) = (Let6989586621679693950Scrutinee_6989586621679685085Sym2 l1 l2 :: TyFun k3 Bool -> *)

type Apply (Let6989586621679693978Scrutinee_6989586621679685083Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693978Scrutinee_6989586621679685083Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> *) -> *) (l2 :: k1) = (Let6989586621679693978Scrutinee_6989586621679685083Sym2 l1 l2 :: TyFun k3 Bool -> *)

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun [k2] Bool -> *) -> *) -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun [k2] Bool -> *) -> *) -> *) -> *) (l2 :: k1) = (Let6989586621679693718Scrutinee_6989586621679685105Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun [k2] Bool -> *) -> *) -> *)

type Apply (Let6989586621679695049Scrutinee_6989586621679685103Sym1 l1 :: TyFun k1 (TyFun k3 (TyFun [k1] Bool -> *) -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679695049Scrutinee_6989586621679685103Sym1 l1 :: TyFun k1 (TyFun k3 (TyFun [k1] Bool -> *) -> *) -> *) (l2 :: k1) = (Let6989586621679695049Scrutinee_6989586621679685103Sym2 l1 l2 :: TyFun k3 (TyFun [k1] Bool -> *) -> *)

type Apply (Let6989586621679696586Scrutinee_6989586621679685077Sym1 l1 :: TyFun k1 (TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679696586Scrutinee_6989586621679685077Sym1 l1 :: TyFun k1 (TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) -> *) (l2 :: k1) = (Let6989586621679696586Scrutinee_6989586621679685077Sym2 l1 l2 :: TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *)

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym0 :: TyFun k1 (TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym0 :: TyFun k1 (TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *) -> *) (l :: k1) = (Let6989586621680005547Scrutinee_6989586621680005029Sym1 l :: TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *)

type Apply (Let6989586621679693916Scrutinee_6989586621679685095Sym2 l1 l2 :: TyFun k2 (TyFun k3 Bool -> *) -> *) (l3 :: k2)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693916Scrutinee_6989586621679685095Sym2 l1 l2 :: TyFun k2 (TyFun k3 Bool -> *) -> *) (l3 :: k2) = (Let6989586621679693916Scrutinee_6989586621679685095Sym3 l1 l2 l3 :: TyFun k3 Bool -> *)

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun [k2] Bool -> *) -> *) -> *) (l3 :: k2)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun [k2] Bool -> *) -> *) -> *) (l3 :: k2) = (Let6989586621679693718Scrutinee_6989586621679685105Sym3 l1 l2 l3 :: TyFun k3 (TyFun [k2] Bool -> *) -> *)

type Apply (Let6989586621679695049Scrutinee_6989586621679685103Sym2 l1 l2 :: TyFun k3 (TyFun [k1] Bool -> *) -> *) (l3 :: k3)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679695049Scrutinee_6989586621679685103Sym2 l1 l2 :: TyFun k3 (TyFun [k1] Bool -> *) -> *) (l3 :: k3) = Let6989586621679695049Scrutinee_6989586621679685103Sym3 l1 l2 l3

type Apply (Lambda_6989586621679695671Sym1 l1 :: TyFun k2 (TyFun k3 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) -> *) -> *) (l2 :: k2)

Defined in Data.Singletons.Prelude.List

type Apply (Lambda_6989586621679695671Sym1 l1 :: TyFun k2 (TyFun k3 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) -> *) -> *) (l2 :: k2) = (Lambda_6989586621679695671Sym2 l1 l2 :: TyFun k3 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) -> *)

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) -> *) (l :: k1) = (Let6989586621680005138Scrutinee_6989586621680005053Sym1 l :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *)

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) -> *) (l :: k1) = (Let6989586621680005320Scrutinee_6989586621680005043Sym1 l :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *)

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym1 l1 :: TyFun k1 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym1 l1 :: TyFun k1 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *) (l2 :: k1) = (Let6989586621680005547Scrutinee_6989586621680005029Sym2 l1 l2 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *)

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym3 l1 l2 l3 :: TyFun k3 (TyFun [k2] Bool -> *) -> *) (l4 :: k3)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym3 l1 l2 l3 :: TyFun k3 (TyFun [k2] Bool -> *) -> *) (l4 :: k3) = Let6989586621679693718Scrutinee_6989586621679685105Sym4 l1 l2 l3 l4

type Apply (Lambda_6989586621679695671Sym2 l1 l2 :: TyFun k3 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) -> *) (l3 :: k3)

Defined in Data.Singletons.Prelude.List

type Apply (Lambda_6989586621679695671Sym2 l1 l2 :: TyFun k3 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) -> *) (l3 :: k3) = Lambda_6989586621679695671Sym3 l1 l2 l3

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) (l2 :: k1) = (Let6989586621680005138Scrutinee_6989586621680005053Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *)

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) (l2 :: k1) = (Let6989586621680005320Scrutinee_6989586621680005043Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *)

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym2 l1 l2 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) (l3 :: k1)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym2 l1 l2 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) (l3 :: k1) = (Let6989586621680005547Scrutinee_6989586621680005029Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 Bool -> *) -> *)

type Apply (Lambda_6989586621679695671Sym3 l1 l2 l3 :: TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) (l4 :: a6989586621679684501)

Defined in Data.Singletons.Prelude.List

type Apply (Lambda_6989586621679695671Sym3 l1 l2 l3 :: TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) (l4 :: a6989586621679684501) = Lambda_6989586621679695671Sym4 l1 l2 l3 l4

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) (l3 :: k2)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) (l3 :: k2) = (Let6989586621680005138Scrutinee_6989586621680005053Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *)

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) (l3 :: k2)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) (l3 :: k2) = (Let6989586621680005320Scrutinee_6989586621680005043Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *)

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 Bool -> *) -> *) (l4 :: k3)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005547Scrutinee_6989586621680005029Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 Bool -> *) -> *) (l4 :: k3) = (Let6989586621680005547Scrutinee_6989586621680005029Sym4 l1 l2 l3 l4 :: TyFun k4 Bool -> *)

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) (l4 :: k3)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) (l4 :: k3) = (Let6989586621680005138Scrutinee_6989586621680005053Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> *) -> *)

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) (l4 :: k3)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) (l4 :: k3) = (Let6989586621680005320Scrutinee_6989586621680005043Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> *) -> *)

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> *) -> *) (l5 :: k4)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005138Scrutinee_6989586621680005053Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> *) -> *) (l5 :: k4) = (Let6989586621680005138Scrutinee_6989586621680005053Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *)

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> *) -> *) (l5 :: k4)

Defined in Data.Singletons.Prelude.Enum

type Apply (Let6989586621680005320Scrutinee_6989586621680005043Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> *) -> *) (l5 :: k4) = (Let6989586621680005320Scrutinee_6989586621680005043Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *)

type Apply AndSym0 (l :: [Bool])

Defined in Data.Singletons.Prelude.List

type Apply AndSym0 (l :: [Bool]) = And l

type Apply OrSym0 (l :: [Bool])

Defined in Data.Singletons.Prelude.List

type Apply OrSym0 (l :: [Bool]) = Or l

type Apply (NullSym0 :: TyFun [a] Bool -> *) (l :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (NullSym0 :: TyFun [a] Bool -> *) (l :: [a]) = Null l

type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a)

Defined in Data.Singletons.Prelude.Maybe

type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a) = IsNothing l

type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a)

Defined in Data.Singletons.Prelude.Maybe

type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a) = IsJust l

type Apply (NotElemSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (NotElemSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = NotElem l1 l2

type Apply (ElemSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (ElemSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = Elem l1 l2

type Apply (IsPrefixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (IsPrefixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = IsPrefixOf l1 l2

type Apply (AnySym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (AnySym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = Any l1 l2

type Apply (IsInfixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (IsInfixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = IsInfixOf l1 l2

type Apply (AllSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (AllSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = All l1 l2

type Apply (IsSuffixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (IsSuffixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = IsSuffixOf l1 l2

type Apply (Elem_bySym2 l1 l2 :: TyFun [a] Bool -> *) (l3 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (Elem_bySym2 l1 l2 :: TyFun [a] Bool -> *) (l3 :: [a]) = Elem_by l1 l2 l3

type Apply (Let6989586621679695049Scrutinee_6989586621679685103Sym3 l1 l2 l3 :: TyFun [k1] Bool -> *) (l4 :: [k1])

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679695049Scrutinee_6989586621679685103Sym3 l1 l2 l3 :: TyFun [k1] Bool -> *) (l4 :: [k1]) = Let6989586621679695049Scrutinee_6989586621679685103 l1 l2 l3 l4

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym4 l1 l2 l3 l4 :: TyFun [k2] Bool -> *) (l5 :: [k2])

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym4 l1 l2 l3 l4 :: TyFun [k2] Bool -> *) (l5 :: [k2]) = Let6989586621679693718Scrutinee_6989586621679685105 l1 l2 l3 l4 l5

type Apply (IsPrefixOfSym0 :: TyFun [a6989586621679684484] (TyFun [a6989586621679684484] Bool -> Type) -> *) (l :: [a6989586621679684484])

Defined in Data.Singletons.Prelude.List

type Apply (IsPrefixOfSym0 :: TyFun [a6989586621679684484] (TyFun [a6989586621679684484] Bool -> Type) -> *) (l :: [a6989586621679684484]) = IsPrefixOfSym1 l

type Apply (IsInfixOfSym0 :: TyFun [a6989586621679684482] (TyFun [a6989586621679684482] Bool -> Type) -> *) (l :: [a6989586621679684482])

Defined in Data.Singletons.Prelude.List

type Apply (IsInfixOfSym0 :: TyFun [a6989586621679684482] (TyFun [a6989586621679684482] Bool -> Type) -> *) (l :: [a6989586621679684482]) = IsInfixOfSym1 l

type Apply (IsSuffixOfSym0 :: TyFun [a6989586621679684483] (TyFun [a6989586621679684483] Bool -> Type) -> *) (l :: [a6989586621679684483])

Defined in Data.Singletons.Prelude.List

type Apply (IsSuffixOfSym0 :: TyFun [a6989586621679684483] (TyFun [a6989586621679684483] Bool -> Type) -> *) (l :: [a6989586621679684483]) = IsSuffixOfSym1 l

type Apply (Let6989586621679696586Scrutinee_6989586621679685077Sym2 l1 l2 :: TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) (l3 :: [a6989586621679684518])

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679696586Scrutinee_6989586621679685077Sym2 l1 l2 :: TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) (l3 :: [a6989586621679684518]) = (Let6989586621679696586Scrutinee_6989586621679685077Sym3 l1 l2 l3 :: TyFun k Bool -> *)

type Apply (Lambda_6989586621679695671Sym4 l1 l2 l3 l4 :: TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) (l5 :: [a6989586621679684501])

Defined in Data.Singletons.Prelude.List

type Apply (Lambda_6989586621679695671Sym4 l1 l2 l3 l4 :: TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) (l5 :: [a6989586621679684501]) = Lambda_6989586621679695671Sym5 l1 l2 l3 l4 l5

type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b)

Defined in Data.Singletons.Prelude.Either

type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b) = IsRight l

type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b)

Defined in Data.Singletons.Prelude.Either

type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b) = IsLeft l

type Apply (Elem_bySym0 :: TyFun (TyFun a6989586621679684398 (TyFun a6989586621679684398 Bool -> Type) -> Type) (TyFun a6989586621679684398 (TyFun [a6989586621679684398] Bool -> Type) -> Type) -> *) (l :: TyFun a6989586621679684398 (TyFun a6989586621679684398 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Elem_bySym0 :: TyFun (TyFun a6989586621679684398 (TyFun a6989586621679684398 Bool -> Type) -> Type) (TyFun a6989586621679684398 (TyFun [a6989586621679684398] Bool -> Type) -> Type) -> *) (l :: TyFun a6989586621679684398 (TyFun a6989586621679684398 Bool -> Type) -> Type) = Elem_bySym1 l

type Apply (NubBySym0 :: TyFun (TyFun a6989586621679684399 (TyFun a6989586621679684399 Bool -> Type) -> Type) (TyFun [a6989586621679684399] [a6989586621679684399] -> Type) -> *) (l :: TyFun a6989586621679684399 (TyFun a6989586621679684399 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (NubBySym0 :: TyFun (TyFun a6989586621679684399 (TyFun a6989586621679684399 Bool -> Type) -> Type) (TyFun [a6989586621679684399] [a6989586621679684399] -> Type) -> *) (l :: TyFun a6989586621679684399 (TyFun a6989586621679684399 Bool -> Type) -> Type) = NubBySym1 l

type Apply (SelectSym0 :: TyFun (TyFun a6989586621679684407 Bool -> Type) (TyFun a6989586621679684407 (TyFun ([a6989586621679684407], [a6989586621679684407]) ([a6989586621679684407], [a6989586621679684407]) -> Type) -> Type) -> *) (l :: TyFun a6989586621679684407 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (SelectSym0 :: TyFun (TyFun a6989586621679684407 Bool -> Type) (TyFun a6989586621679684407 (TyFun ([a6989586621679684407], [a6989586621679684407]) ([a6989586621679684407], [a6989586621679684407]) -> Type) -> Type) -> *) (l :: TyFun a6989586621679684407 Bool -> Type) = SelectSym1 l

type Apply (PartitionSym0 :: TyFun (TyFun a6989586621679684408 Bool -> Type) (TyFun [a6989586621679684408] ([a6989586621679684408], [a6989586621679684408]) -> Type) -> *) (l :: TyFun a6989586621679684408 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (PartitionSym0 :: TyFun (TyFun a6989586621679684408 Bool -> Type) (TyFun [a6989586621679684408] ([a6989586621679684408], [a6989586621679684408]) -> Type) -> *) (l :: TyFun a6989586621679684408 Bool -> Type) = PartitionSym1 l

type Apply (BreakSym0 :: TyFun (TyFun a6989586621679684420 Bool -> Type) (TyFun [a6989586621679684420] ([a6989586621679684420], [a6989586621679684420]) -> Type) -> *) (l :: TyFun a6989586621679684420 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (BreakSym0 :: TyFun (TyFun a6989586621679684420 Bool -> Type) (TyFun [a6989586621679684420] ([a6989586621679684420], [a6989586621679684420]) -> Type) -> *) (l :: TyFun a6989586621679684420 Bool -> Type) = BreakSym1 l

type Apply (Let6989586621679694046ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) (l :: TyFun k Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694046ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679694046ZsSym1 l

type Apply (Let6989586621679694046YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) (l :: TyFun k Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694046YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679694046YsSym1 l

type Apply (Let6989586621679694046X_6989586621679694047Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> *) -> *) -> *) (l :: TyFun k Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694046X_6989586621679694047Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> *) -> *) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679694046X_6989586621679694047Sym1 l

type Apply (SpanSym0 :: TyFun (TyFun a6989586621679684421 Bool -> Type) (TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> Type) -> *) (l :: TyFun a6989586621679684421 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (SpanSym0 :: TyFun (TyFun a6989586621679684421 Bool -> Type) (TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> Type) -> *) (l :: TyFun a6989586621679684421 Bool -> Type) = SpanSym1 l

type Apply (Let6989586621679694139ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) (l :: TyFun k Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694139ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679694139ZsSym1 l

type Apply (Let6989586621679694139YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) (l :: TyFun k Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694139YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679694139YsSym1 l

type Apply (Let6989586621679694139X_6989586621679694140Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> *) -> *) -> *) (l :: TyFun k Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694139X_6989586621679694140Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> *) -> *) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679694139X_6989586621679694140Sym1 l

type Apply (GroupBySym0 :: TyFun (TyFun a6989586621679684411 (TyFun a6989586621679684411 Bool -> Type) -> Type) (TyFun [a6989586621679684411] [[a6989586621679684411]] -> Type) -> *) (l :: TyFun a6989586621679684411 (TyFun a6989586621679684411 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (GroupBySym0 :: TyFun (TyFun a6989586621679684411 (TyFun a6989586621679684411 Bool -> Type) -> Type) (TyFun [a6989586621679684411] [[a6989586621679684411]] -> Type) -> *) (l :: TyFun a6989586621679684411 (TyFun a6989586621679684411 Bool -> Type) -> Type) = GroupBySym1 l

type Apply (DropWhileSym0 :: TyFun (TyFun a6989586621679684423 Bool -> Type) (TyFun [a6989586621679684423] [a6989586621679684423] -> Type) -> *) (l :: TyFun a6989586621679684423 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (DropWhileSym0 :: TyFun (TyFun a6989586621679684423 Bool -> Type) (TyFun [a6989586621679684423] [a6989586621679684423] -> Type) -> *) (l :: TyFun a6989586621679684423 Bool -> Type) = DropWhileSym1 l

type Apply (TakeWhileSym0 :: TyFun (TyFun a6989586621679684424 Bool -> Type) (TyFun [a6989586621679684424] [a6989586621679684424] -> Type) -> *) (l :: TyFun a6989586621679684424 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (TakeWhileSym0 :: TyFun (TyFun a6989586621679684424 Bool -> Type) (TyFun [a6989586621679684424] [a6989586621679684424] -> Type) -> *) (l :: TyFun a6989586621679684424 Bool -> Type) = TakeWhileSym1 l

type Apply (FilterSym0 :: TyFun (TyFun a6989586621679684432 Bool -> Type) (TyFun [a6989586621679684432] [a6989586621679684432] -> Type) -> *) (l :: TyFun a6989586621679684432 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (FilterSym0 :: TyFun (TyFun a6989586621679684432 Bool -> Type) (TyFun [a6989586621679684432] [a6989586621679684432] -> Type) -> *) (l :: TyFun a6989586621679684432 Bool -> Type) = FilterSym1 l

type Apply (FindSym0 :: TyFun (TyFun a6989586621679684431 Bool -> Type) (TyFun [a6989586621679684431] (Maybe a6989586621679684431) -> Type) -> *) (l :: TyFun a6989586621679684431 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (FindSym0 :: TyFun (TyFun a6989586621679684431 Bool -> Type) (TyFun [a6989586621679684431] (Maybe a6989586621679684431) -> Type) -> *) (l :: TyFun a6989586621679684431 Bool -> Type) = FindSym1 l

type Apply (DeleteBySym0 :: TyFun (TyFun a6989586621679684438 (TyFun a6989586621679684438 Bool -> Type) -> Type) (TyFun a6989586621679684438 (TyFun [a6989586621679684438] [a6989586621679684438] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684438 (TyFun a6989586621679684438 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (DeleteBySym0 :: TyFun (TyFun a6989586621679684438 (TyFun a6989586621679684438 Bool -> Type) -> Type) (TyFun a6989586621679684438 (TyFun [a6989586621679684438] [a6989586621679684438] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684438 (TyFun a6989586621679684438 Bool -> Type) -> Type) = DeleteBySym1 l

type Apply (DeleteFirstsBySym0 :: TyFun (TyFun a6989586621679684437 (TyFun a6989586621679684437 Bool -> Type) -> Type) (TyFun [a6989586621679684437] (TyFun [a6989586621679684437] [a6989586621679684437] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684437 (TyFun a6989586621679684437 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (DeleteFirstsBySym0 :: TyFun (TyFun a6989586621679684437 (TyFun a6989586621679684437 Bool -> Type) -> Type) (TyFun [a6989586621679684437] (TyFun [a6989586621679684437] [a6989586621679684437] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684437 (TyFun a6989586621679684437 Bool -> Type) -> Type) = DeleteFirstsBySym1 l

type Apply (UnionBySym0 :: TyFun (TyFun a6989586621679684397 (TyFun a6989586621679684397 Bool -> Type) -> Type) (TyFun [a6989586621679684397] (TyFun [a6989586621679684397] [a6989586621679684397] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684397 (TyFun a6989586621679684397 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (UnionBySym0 :: TyFun (TyFun a6989586621679684397 (TyFun a6989586621679684397 Bool -> Type) -> Type) (TyFun [a6989586621679684397] (TyFun [a6989586621679684397] [a6989586621679684397] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684397 (TyFun a6989586621679684397 Bool -> Type) -> Type) = UnionBySym1 l

type Apply (FindIndicesSym0 :: TyFun (TyFun a6989586621679684427 Bool -> Type) (TyFun [a6989586621679684427] [Nat] -> Type) -> *) (l :: TyFun a6989586621679684427 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (FindIndicesSym0 :: TyFun (TyFun a6989586621679684427 Bool -> Type) (TyFun [a6989586621679684427] [Nat] -> Type) -> *) (l :: TyFun a6989586621679684427 Bool -> Type) = FindIndicesSym1 l

type Apply (FindIndexSym0 :: TyFun (TyFun a6989586621679684428 Bool -> Type) (TyFun [a6989586621679684428] (Maybe Nat) -> Type) -> *) (l :: TyFun a6989586621679684428 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (FindIndexSym0 :: TyFun (TyFun a6989586621679684428 Bool -> Type) (TyFun [a6989586621679684428] (Maybe Nat) -> Type) -> *) (l :: TyFun a6989586621679684428 Bool -> Type) = FindIndexSym1 l

type Apply (AnySym0 :: TyFun (TyFun a6989586621679684501 Bool -> Type) (TyFun [a6989586621679684501] Bool -> Type) -> *) (l :: TyFun a6989586621679684501 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (AnySym0 :: TyFun (TyFun a6989586621679684501 Bool -> Type) (TyFun [a6989586621679684501] Bool -> Type) -> *) (l :: TyFun a6989586621679684501 Bool -> Type) = AnySym1 l

type Apply (IntersectBySym0 :: TyFun (TyFun a6989586621679684425 (TyFun a6989586621679684425 Bool -> Type) -> Type) (TyFun [a6989586621679684425] (TyFun [a6989586621679684425] [a6989586621679684425] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684425 (TyFun a6989586621679684425 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (IntersectBySym0 :: TyFun (TyFun a6989586621679684425 (TyFun a6989586621679684425 Bool -> Type) -> Type) (TyFun [a6989586621679684425] (TyFun [a6989586621679684425] [a6989586621679684425] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684425 (TyFun a6989586621679684425 Bool -> Type) -> Type) = IntersectBySym1 l

type Apply (AllSym0 :: TyFun (TyFun a6989586621679684502 Bool -> Type) (TyFun [a6989586621679684502] Bool -> Type) -> *) (l :: TyFun a6989586621679684502 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (AllSym0 :: TyFun (TyFun a6989586621679684502 Bool -> Type) (TyFun [a6989586621679684502] Bool -> Type) -> *) (l :: TyFun a6989586621679684502 Bool -> Type) = AllSym1 l

type Apply (DropWhileEndSym0 :: TyFun (TyFun a6989586621679684422 Bool -> Type) (TyFun [a6989586621679684422] [a6989586621679684422] -> Type) -> *) (l :: TyFun a6989586621679684422 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (DropWhileEndSym0 :: TyFun (TyFun a6989586621679684422 Bool -> Type) (TyFun [a6989586621679684422] [a6989586621679684422] -> Type) -> *) (l :: TyFun a6989586621679684422 Bool -> Type) = DropWhileEndSym1 l

type Apply (Let6989586621679693694NubBy'Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> *) -> *) -> *) (l :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693694NubBy'Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> *) -> *) -> *) (l :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) = (Let6989586621679693694NubBy'Sym1 l :: TyFun k (TyFun [k1] ([k1] ~> [k1]) -> *) -> *)

type Apply (Let6989586621679694203ZsSym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] [a6989586621679684421] -> *) -> *) -> *) (l :: k1 ~> (TyFun a6989586621679684421 Bool -> Type))

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694203ZsSym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] [a6989586621679684421] -> *) -> *) -> *) (l :: k1 ~> (TyFun a6989586621679684421 Bool -> Type)) = Let6989586621679694203ZsSym1 l

type Apply (Let6989586621679694203YsSym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] [a6989586621679684421] -> *) -> *) -> *) (l :: k1 ~> (TyFun a6989586621679684421 Bool -> Type))

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694203YsSym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] [a6989586621679684421] -> *) -> *) -> *) (l :: k1 ~> (TyFun a6989586621679684421 Bool -> Type)) = Let6989586621679694203YsSym1 l

type Apply (Let6989586621679694203X_6989586621679694204Sym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> *) -> *) -> *) (l :: k1 ~> (TyFun a6989586621679684421 Bool -> Type))

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679694203X_6989586621679694204Sym0 :: TyFun (k1 ~> (TyFun a6989586621679684421 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679684421] ([a6989586621679684421], [a6989586621679684421]) -> *) -> *) -> *) (l :: k1 ~> (TyFun a6989586621679684421 Bool -> Type)) = Let6989586621679694203X_6989586621679694204Sym1 l

type Apply (Lambda_6989586621679696582Sym0 :: TyFun (a6989586621679684518 ~> Bool) (TyFun k (TyFun a6989586621679684518 (TyFun [a6989586621679684518] [a6989586621679684518] -> *) -> *) -> *) -> *) (l :: a6989586621679684518 ~> Bool)

Defined in Data.Singletons.Prelude.List

type Apply (Lambda_6989586621679696582Sym0 :: TyFun (a6989586621679684518 ~> Bool) (TyFun k (TyFun a6989586621679684518 (TyFun [a6989586621679684518] [a6989586621679684518] -> *) -> *) -> *) -> *) (l :: a6989586621679684518 ~> Bool) = (Lambda_6989586621679696582Sym1 l :: TyFun k (TyFun a6989586621679684518 (TyFun [a6989586621679684518] [a6989586621679684518] -> *) -> *) -> *)

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k2 (TyFun k1 (TyFun k3 (TyFun [k1] Bool -> *) -> *) -> *) -> *) -> *) (l :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679693718Scrutinee_6989586621679685105Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k2 (TyFun k1 (TyFun k3 (TyFun [k1] Bool -> *) -> *) -> *) -> *) -> *) (l :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) = (Let6989586621679693718Scrutinee_6989586621679685105Sym1 l :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun [k1] Bool -> *) -> *) -> *) -> *)

type Apply (Let6989586621679696586Scrutinee_6989586621679685077Sym0 :: TyFun (k1 ~> Bool) (TyFun k1 (TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) -> *) -> *) (l :: k1 ~> Bool)

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679696586Scrutinee_6989586621679685077Sym0 :: TyFun (k1 ~> Bool) (TyFun k1 (TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) -> *) -> *) (l :: k1 ~> Bool) = (Let6989586621679696586Scrutinee_6989586621679685077Sym1 l :: TyFun k1 (TyFun [a6989586621679684518] (TyFun k Bool -> *) -> *) -> *)

type Apply (Lambda_6989586621679695671Sym0 :: TyFun (k1 ~> (TyFun a6989586621679684501 Bool -> Type)) (TyFun k2 (TyFun k3 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) -> *) -> *) -> *) (l :: k1 ~> (TyFun a6989586621679684501 Bool -> Type))

Defined in Data.Singletons.Prelude.List

type Apply (Lambda_6989586621679695671Sym0 :: TyFun (k1 ~> (TyFun a6989586621679684501 Bool -> Type)) (TyFun k2 (TyFun k3 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) -> *) -> *) -> *) (l :: k1 ~> (TyFun a6989586621679684501 Bool -> Type)) = (Lambda_6989586621679695671Sym1 l :: TyFun k2 (TyFun k3 (TyFun a6989586621679684501 (TyFun [a6989586621679684501] (TyFun k1 Bool -> *) -> *) -> *) -> *) -> *)

data Char

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) code points (i.e. characters, see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Instances

Bounded Char

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Char

maxBound :: Char

Enum Char

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Eq Char

Defined in GHC.Classes

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Data Char

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char

toConstr :: Char -> Constr

dataTypeOf :: Char -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char)

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

gmapT :: (forall b. Data b => b -> b) -> Char -> Char

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r

gmapQ :: (forall d. Data d => d -> u) -> Char -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char

Ord Char

Defined in GHC.Classes

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Read Char

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Ix Char

Since: base-2.1

Defined in GHC.Arr

Methods

range :: (Char, Char) -> [Char]

index :: (Char, Char) -> Char -> Int

unsafeIndex :: (Char, Char) -> Char -> Int

inRange :: (Char, Char) -> Char -> Bool

rangeSize :: (Char, Char) -> Int

unsafeRangeSize :: (Char, Char) -> Int

Lift Char

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Char -> Q Exp

Storable Char

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Char -> Int

alignment :: Char -> Int

peekElemOff :: Ptr Char -> Int -> IO Char

pokeElemOff :: Ptr Char -> Int -> Char -> IO ()

peekByteOff :: Ptr b -> Int -> IO Char

pokeByteOff :: Ptr b -> Int -> Char -> IO ()

peek :: Ptr Char -> IO Char

poke :: Ptr Char -> Char -> IO ()

NFData Char

Defined in Control.DeepSeq

Methods

rnf :: Char -> ()

ErrorList Char

Defined in Control.Monad.Trans.Error

Methods

listMsg :: String -> [Char]

ShowX Char

Defined in Clash.XException

Methods

showsPrecX :: Int -> Char -> ShowS

showX :: Char -> String

showListX :: [Char] -> ShowS

ShowX String

Defined in Clash.XException

Methods

showsPrecX :: Int -> String -> ShowS

showX :: String -> String

showListX :: [String] -> ShowS

Arbitrary Char

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Char

shrink :: Char -> [Char]

CoArbitrary Char

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Char -> Gen b -> Gen b

Unbox Char

Defined in Data.Vector.Unboxed.Base

Prim Char

Defined in Data.Primitive.Types

Methods

sizeOf# :: Char -> Int#

alignment# :: Char -> Int#

indexByteArray# :: ByteArray# -> Int# -> Char

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Char#)

writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Char

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Char#)

writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s

Vector Vector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char)

basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char)

basicLength :: Vector Char -> Int

basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char

basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m ()

elemseq :: Vector Char -> Char -> b -> b

MVector MVector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Char -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char

basicOverlaps :: MVector s Char -> MVector s Char -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char)

basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char)

KnownSymbol n => Reifies (n :: Symbol) String

Defined in Data.Reflection

Methods

reflect :: proxy n -> String

Cons Text Text Char Char

Defined in Control.Lens.Cons

Methods

_Cons :: Prism Text Text (Char, Text) (Char, Text)

Cons Text Text Char Char

Defined in Control.Lens.Cons

Methods

_Cons :: Prism Text Text (Char, Text) (Char, Text)

Snoc Text Text Char Char

Defined in Control.Lens.Cons

Methods

_Snoc :: Prism Text Text (Text, Char) (Text, Char)

Snoc Text Text Char Char

Defined in Control.Lens.Cons

Methods

_Snoc :: Prism Text Text (Text, Char) (Text, Char)

() :=> (Bounded Char)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Char

() :=> (Enum Char)

Defined in Data.Constraint

Methods

ins :: () :- Enum Char

() :=> (Ord Char)

Defined in Data.Constraint

Methods

ins :: () :- Ord Char

() :=> (Read Char)

Defined in Data.Constraint

Methods

ins :: () :- Read Char

() :=> (Show Char)

Defined in Data.Constraint

Methods

ins :: () :- Show Char

Generic1 (URec Char :: k -> *)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Char) :: k -> *

Methods

from1 :: URec Char a -> Rep1 (URec Char) a

to1 :: Rep1 (URec Char) a -> URec Char a

Functor (URec Char :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Foldable (URec Char :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Char m -> m

foldMap :: Monoid m => (a -> m) -> URec Char a -> m

foldr :: (a -> b -> b) -> b -> URec Char a -> b

foldr' :: (a -> b -> b) -> b -> URec Char a -> b

foldl :: (b -> a -> b) -> b -> URec Char a -> b

foldl' :: (b -> a -> b) -> b -> URec Char a -> b

foldr1 :: (a -> a -> a) -> URec Char a -> a

foldl1 :: (a -> a -> a) -> URec Char a -> a

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

elem :: Eq a => a -> URec Char a -> Bool

maximum :: Ord a => URec Char a -> a

minimum :: Ord a => URec Char a -> a

sum :: Num a => URec Char a -> a

product :: Num a => URec Char a -> a

Traversable (URec Char :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b)

sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a)

mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b)

sequence :: Monad m => URec Char (m a) -> m (URec Char a)

Eq (URec Char p)

Defined in GHC.Generics

Methods

(==) :: URec Char p -> URec Char p -> Bool

(/=) :: URec Char p -> URec Char p -> Bool

Ord (URec Char p)

Defined in GHC.Generics

Methods

compare :: URec Char p -> URec Char p -> Ordering

(<) :: URec Char p -> URec Char p -> Bool

(<=) :: URec Char p -> URec Char p -> Bool

(>) :: URec Char p -> URec Char p -> Bool

(>=) :: URec Char p -> URec Char p -> Bool

max :: URec Char p -> URec Char p -> URec Char p

min :: URec Char p -> URec Char p -> URec Char p

Show (URec Char p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Generic (URec Char p)

Defined in GHC.Generics

Associated Types

type Rep (URec Char p) :: * -> *

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

data Vector Char

Defined in Data.Vector.Unboxed.Base

data Vector Char = V_Char (Vector Char)

data URec Char (p :: k)

Used for marking occurrences of Char#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Char (p :: k) = UChar {

• uChar# :: Char#

}

data MVector s Char

Defined in Data.Vector.Unboxed.Base

data MVector s Char = MV_Char (MVector s Char)

type Rep1 (URec Char :: k -> *)

Defined in GHC.Generics

type Rep1 (URec Char :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar :: k -> *)))

type Rep (URec Char p)

Defined in GHC.Generics

type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar :: * -> *)))

data Double

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double

Defined in GHC.Classes

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Floating Double

Since: base-2.1

Defined in GHC.Float

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

Data Double

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double

toConstr :: Double -> Constr

dataTypeOf :: Double -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double)

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

gmapT :: (forall b. Data b => b -> b) -> Double -> Double

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r

gmapQ :: (forall d. Data d => d -> u) -> Double -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double

Ord Double

Defined in GHC.Classes

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

Read Double

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

RealFloat Double

Since: base-2.1

Defined in GHC.Float

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

Lift Double

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Double -> Q Exp

Storable Double

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Double -> Int

alignment :: Double -> Int

peekElemOff :: Ptr Double -> Int -> IO Double

pokeElemOff :: Ptr Double -> Int -> Double -> IO ()

peekByteOff :: Ptr b -> Int -> IO Double

pokeByteOff :: Ptr b -> Int -> Double -> IO ()

peek :: Ptr Double -> IO Double

poke :: Ptr Double -> Double -> IO ()

NFData Double

Defined in Control.DeepSeq

Methods

rnf :: Double -> ()

ShowX Double

Defined in Clash.XException

Methods

showsPrecX :: Int -> Double -> ShowS

showX :: Double -> String

showListX :: [Double] -> ShowS

Default Double

Defined in Data.Default.Class

Methods

def :: Double

Arbitrary Double

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Double

shrink :: Double -> [Double]

CoArbitrary Double

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Double -> Gen b -> Gen b

Unbox Double

Defined in Data.Vector.Unboxed.Base

Prim Double

Defined in Data.Primitive.Types

Methods

sizeOf# :: Double -> Int#

alignment# :: Double -> Int#

indexByteArray# :: ByteArray# -> Int# -> Double

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Double#)

writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Double

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Double#)

writeOffAddr# :: Addr# -> Int# -> Double -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Double -> State# s -> State# s

BitPack Double

Defined in Clash.Class.BitPack

Associated Types

type BitSize Double :: Nat

Methods

pack :: Double -> BitVector (BitSize Double)

unpack :: BitVector (BitSize Double) -> Double

Bundle Double

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled domain Double = (res :: *)

Methods

bundle :: Unbundled domain Double -> Signal domain Double

unbundle :: Signal domain Double -> Unbundled domain Double

Vector Vector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double)

basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double)

basicLength :: Vector Double -> Int

basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double

basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m ()

elemseq :: Vector Double -> Double -> b -> b

MVector MVector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Double -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double

basicOverlaps :: MVector s Double -> MVector s Double -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double)

basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Double -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double)

() :=> (Enum Double)

Defined in Data.Constraint

Methods

ins :: () :- Enum Double

() :=> (Eq Double)

Defined in Data.Constraint

Methods

ins :: () :- Eq Double

() :=> (Floating Double)

Defined in Data.Constraint

Methods

ins :: () :- Floating Double

() :=> (Fractional Double)

Defined in Data.Constraint

Methods

ins :: () :- Fractional Double

() :=> (Num Double)

Defined in Data.Constraint

Methods

ins :: () :- Num Double

() :=> (Ord Double)

Defined in Data.Constraint

Methods

ins :: () :- Ord Double

() :=> (Real Double)

Defined in Data.Constraint

Methods

ins :: () :- Real Double

() :=> (RealFloat Double)

Defined in Data.Constraint

Methods

ins :: () :- RealFloat Double

() :=> (RealFrac Double)

Defined in Data.Constraint

Methods

ins :: () :- RealFrac Double

Generic1 (URec Double :: k -> *)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Double) :: k -> *

Methods

from1 :: URec Double a -> Rep1 (URec Double) a

to1 :: Rep1 (URec Double) a -> URec Double a

Functor (URec Double :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Foldable (URec Double :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Double m -> m

foldMap :: Monoid m => (a -> m) -> URec Double a -> m

foldr :: (a -> b -> b) -> b -> URec Double a -> b

foldr' :: (a -> b -> b) -> b -> URec Double a -> b

foldl :: (b -> a -> b) -> b -> URec Double a -> b

foldl' :: (b -> a -> b) -> b -> URec Double a -> b

foldr1 :: (a -> a -> a) -> URec Double a -> a

foldl1 :: (a -> a -> a) -> URec Double a -> a

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

elem :: Eq a => a -> URec Double a -> Bool

maximum :: Ord a => URec Double a -> a

minimum :: Ord a => URec Double a -> a

sum :: Num a => URec Double a -> a

product :: Num a => URec Double a -> a

Traversable (URec Double :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b)

sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a)

mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b)

sequence :: Monad m => URec Double (m a) -> m (URec Double a)

Eq (URec Double p)

Defined in GHC.Generics

Methods

(==) :: URec Double p -> URec Double p -> Bool

(/=) :: URec Double p -> URec Double p -> Bool

Ord (URec Double p)

Defined in GHC.Generics

Methods

compare :: URec Double p -> URec Double p -> Ordering

(<) :: URec Double p -> URec Double p -> Bool

(<=) :: URec Double p -> URec Double p -> Bool

(>) :: URec Double p -> URec Double p -> Bool

(>=) :: URec Double p -> URec Double p -> Bool

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

Show (URec Double p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Generic (URec Double p)

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: * -> *

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

data Vector Double

Defined in Data.Vector.Unboxed.Base

data Vector Double = V_Double (Vector Double)

type BitSize Double

Defined in Clash.Class.BitPack

type BitSize Double = 64

data URec Double (p :: k)

Used for marking occurrences of Double#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Double (p :: k) = UDouble {

• uDouble# :: Double#

}

data MVector s Double

Defined in Data.Vector.Unboxed.Base

data MVector s Double = MV_Double (MVector s Double)

type Unbundled domain Double

Defined in Clash.Signal.Bundle

type Unbundled domain Double = Signal domain Double

type Rep1 (URec Double :: k -> *)

Defined in GHC.Generics

type Rep1 (URec Double :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble :: k -> *)))

type Rep (URec Double p)

Defined in GHC.Generics

type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble :: * -> *)))

data Float

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Instances

Eq Float

Defined in GHC.Classes

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Floating Float

Since: base-2.1

Defined in GHC.Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

Data Float

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float

toConstr :: Float -> Constr

dataTypeOf :: Float -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float)

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

gmapT :: (forall b. Data b => b -> b) -> Float -> Float

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r

gmapQ :: (forall d. Data d => d -> u) -> Float -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float

Ord Float

Defined in GHC.Classes

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Read Float

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

RealFloat Float

Since: base-2.1

Defined in GHC.Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

Lift Float

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Float -> Q Exp

Storable Float

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Float -> Int

alignment :: Float -> Int

peekElemOff :: Ptr Float -> Int -> IO Float

pokeElemOff :: Ptr Float -> Int -> Float -> IO ()

peekByteOff :: Ptr b -> Int -> IO Float

pokeByteOff :: Ptr b -> Int -> Float -> IO ()

peek :: Ptr Float -> IO Float

poke :: Ptr Float -> Float -> IO ()

NFData Float

Defined in Control.DeepSeq

Methods

rnf :: Float -> ()

ShowX Float

Defined in Clash.XException

Methods

showsPrecX :: Int -> Float -> ShowS

showX :: Float -> String

showListX :: [Float] -> ShowS

Default Float

Defined in Data.Default.Class

Methods

def :: Float

Arbitrary Float

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Float

shrink :: Float -> [Float]

CoArbitrary Float

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Float -> Gen b -> Gen b

Unbox Float

Defined in Data.Vector.Unboxed.Base

Prim Float

Defined in Data.Primitive.Types

Methods

sizeOf# :: Float -> Int#

alignment# :: Float -> Int#

indexByteArray# :: ByteArray# -> Int# -> Float

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Float#)

writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Float

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Float#)

writeOffAddr# :: Addr# -> Int# -> Float -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Float -> State# s -> State# s

BitPack Float

Defined in Clash.Class.BitPack

Associated Types

type BitSize Float :: Nat

Methods

pack :: Float -> BitVector (BitSize Float)

unpack :: BitVector (BitSize Float) -> Float

Bundle Float

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled domain Float = (res :: *)

Methods

bundle :: Unbundled domain Float -> Signal domain Float

unbundle :: Signal domain Float -> Unbundled domain Float

Vector Vector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float)

basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float)

basicLength :: Vector Float -> Int

basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float

basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m ()

elemseq :: Vector Float -> Float -> b -> b

MVector MVector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Float -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float

basicOverlaps :: MVector s Float -> MVector s Float -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float)

basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Float -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float)

() :=> (Enum Float)

Defined in Data.Constraint

Methods

ins :: () :- Enum Float

() :=> (Eq Float)

Defined in Data.Constraint

Methods

ins :: () :- Eq Float

() :=> (Floating Float)

Defined in Data.Constraint

Methods

ins :: () :- Floating Float

() :=> (Fractional Float)

Defined in Data.Constraint

Methods

ins :: () :- Fractional Float

() :=> (Num Float)

Defined in Data.Constraint

Methods

ins :: () :- Num Float

() :=> (Ord Float)

Defined in Data.Constraint

Methods

ins :: () :- Ord Float

() :=> (Real Float)

Defined in Data.Constraint

Methods

ins :: () :- Real Float

() :=> (RealFloat Float)

Defined in Data.Constraint

Methods

ins :: () :- RealFloat Float

() :=> (RealFrac Float)

Defined in Data.Constraint

Methods

ins :: () :- RealFrac Float

Generic1 (URec Float :: k -> *)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Float) :: k -> *

Methods

from1 :: URec Float a -> Rep1 (URec Float) a

to1 :: Rep1 (URec Float) a -> URec Float a

Functor (URec Float :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Foldable (URec Float :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Float m -> m

foldMap :: Monoid m => (a -> m) -> URec Float a -> m

foldr :: (a -> b -> b) -> b -> URec Float a -> b

foldr' :: (a -> b -> b) -> b -> URec Float a -> b

foldl :: (b -> a -> b) -> b -> URec Float a -> b

foldl' :: (b -> a -> b) -> b -> URec Float a -> b

foldr1 :: (a -> a -> a) -> URec Float a -> a

foldl1 :: (a -> a -> a) -> URec Float a -> a

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

elem :: Eq a => a -> URec Float a -> Bool

maximum :: Ord a => URec Float a -> a

minimum :: Ord a => URec Float a -> a

sum :: Num a => URec Float a -> a

product :: Num a => URec Float a -> a

Traversable (URec Float :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b)

sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a)

mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b)

sequence :: Monad m => URec Float (m a) -> m (URec Float a)

Eq (URec Float p)

Defined in GHC.Generics

Methods

(==) :: URec Float p -> URec Float p -> Bool

(/=) :: URec Float p -> URec Float p -> Bool

Ord (URec Float p)

Defined in GHC.Generics

Methods

compare :: URec Float p -> URec Float p -> Ordering

(<) :: URec Float p -> URec Float p -> Bool

(<=) :: URec Float p -> URec Float p -> Bool

(>) :: URec Float p -> URec Float p -> Bool

(>=) :: URec Float p -> URec Float p -> Bool

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

Show (URec Float p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Generic (URec Float p)

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: * -> *

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

data Vector Float

Defined in Data.Vector.Unboxed.Base

data Vector Float = V_Float (Vector Float)

type BitSize Float

Defined in Clash.Class.BitPack

type BitSize Float = 32

data URec Float (p :: k)

Used for marking occurrences of Float#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Float (p :: k) = UFloat {

• uFloat# :: Float#

}

data MVector s Float

Defined in Data.Vector.Unboxed.Base

data MVector s Float = MV_Float (MVector s Float)

type Unbundled domain Float

Defined in Clash.Signal.Bundle

type Unbundled domain Float = Signal domain Float

type Rep1 (URec Float :: k -> *)

Defined in GHC.Generics

type Rep1 (URec Float :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat :: k -> *)))

type Rep (URec Float p)

Defined in GHC.Generics

type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat :: * -> *)))

data Int

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Instances

Bounded Int

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Int

maxBound :: Int

Enum Int

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

Eq Int

Defined in GHC.Classes

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Integral Int

Since: base-2.0.1

Defined in GHC.Real

Methods

quot :: Int -> Int -> Int

rem :: Int -> Int -> Int

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

quotRem :: Int -> Int -> (Int, Int)

divMod :: Int -> Int -> (Int, Int)

toInteger :: Int -> Integer

Data Int

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int

toConstr :: Int -> Constr

dataTypeOf :: Int -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int)

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

gmapT :: (forall b. Data b => b -> b) -> Int -> Int

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r

gmapQ :: (forall d. Data d => d -> u) -> Int -> [u]

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

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int

Num Int

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Ord Int

Defined in GHC.Classes

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Read Int

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Real Int

Since: base-2.0.1

Defined in GHC.Real

Methods

toRational :: Int -> Rational

Show Int

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Ix Int

Since: base-2.1

Defined in GHC.Arr

Methods

range :: (Int, Int) -> [Int]

index :: (Int, Int) -> Int -> Int

unsafeIndex :: (Int, Int) -> Int -> Int

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

rangeSize :: (Int, Int) -> Int

unsafeRangeSize :: (Int, Int) -> Int

Lift Int

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Int -> Q Exp

Storable Int

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Int -> Int

alignment :: Int -> Int

peekElemOff :: Ptr Int -> Int -> IO Int

pokeElemOff :: Ptr Int -> Int -> Int -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int

pokeByteOff :: Ptr b -> Int -> Int -> IO ()

peek :: Ptr Int -> IO Int

poke :: Ptr Int -> Int -> IO ()

Bits Int

Since: base-2.1

Defined in Data.Bits

Methods

(.&.) :: Int -> Int -> Int

(.|.) :: Int -> Int -> Int

xor :: Int -> Int -> Int

complement :: Int -> Int

shift :: Int -> Int -> Int

rotate :: Int -> Int -> Int

zeroBits :: Int

bit :: Int -> Int

setBit :: Int -> Int -> Int

clearBit :: Int -> Int -> Int

complementBit :: Int -> Int -> Int

testBit :: Int -> Int -> Bool

bitSizeMaybe :: Int -> Maybe Int

bitSize :: Int -> Int

isSigned :: Int -> Bool

shiftL :: Int -> Int -> Int

unsafeShiftL :: Int -> Int -> Int

shiftR :: Int -> Int -> Int

unsafeShiftR :: Int -> Int -> Int

rotateL :: Int -> Int -> Int

rotateR :: Int -> Int -> Int

popCount :: Int -> Int

FiniteBits Int

Since: base-4.6.0.0

Defined in Data.Bits

Methods

finiteBitSize :: Int -> Int

countLeadingZeros :: Int -> Int

countTrailingZeros :: Int -> Int

NFData Int

Defined in Control.DeepSeq

Methods

rnf :: Int -> ()

ShowX Int

Defined in Clash.XException

Methods

showsPrecX :: Int -> Int -> ShowS

showX :: Int -> String

showListX :: [Int] -> ShowS

Default Int

Defined in Data.Default.Class

Methods

def :: Int

Arbitrary Int

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int

shrink :: Int -> [Int]

CoArbitrary Int

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Int -> Gen b -> Gen b

Unbox Int

Defined in Data.Vector.Unboxed.Base

Prim Int

Defined in Data.Primitive.Types

Methods

sizeOf# :: Int -> Int#

alignment# :: Int -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int#)

writeOffAddr# :: Addr# -> Int# -> Int -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Int -> State# s -> State# s

BitPack Int

Defined in Clash.Class.BitPack

Associated Types

type BitSize Int :: Nat

Methods

pack :: Int -> BitVector (BitSize Int)

unpack :: BitVector (BitSize Int) -> Int

Bundle Int

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled domain Int = (res :: *)

Methods

bundle :: Unbundled domain Int -> Signal domain Int

unbundle :: Signal domain Int -> Unbundled domain Int

FoldableWithIndex Int []

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> [a] -> f [a]

ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b

ifoldl :: (Int -> b -> a -> b) -> b -> [a] -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> [a] -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> [a] -> b

FoldableWithIndex Int ZipList

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> ZipList a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> ZipList a -> f (ZipList a)

ifoldr :: (Int -> a -> b -> b) -> b -> ZipList a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> ZipList a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> ZipList a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> ZipList a -> b

FoldableWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> NonEmpty a -> f (NonEmpty a)

ifoldr :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b

FoldableWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> IntMap a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> IntMap a -> f (IntMap a)

ifoldr :: (Int -> a -> b -> b) -> b -> IntMap a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> IntMap a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> IntMap a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> IntMap a -> b

FoldableWithIndex Int Seq

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> Seq a -> f (Seq a)

ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b

FoldableWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Vector a -> m

ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> Vector a -> f (Vector a)

ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> Vector a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> Vector a -> b

FunctorWithIndex Int []

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> [a] -> [b]

imapped :: (Indexable Int p, Settable f) => p a (f b) -> [a] -> f [b]

FunctorWithIndex Int ZipList

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> ZipList a -> ZipList b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> ZipList a -> f (ZipList b)

FunctorWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> NonEmpty a -> NonEmpty b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> NonEmpty a -> f (NonEmpty b)

FunctorWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> IntMap a -> IntMap b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> IntMap a -> f (IntMap b)

FunctorWithIndex Int Seq

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> Seq a -> Seq b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> Seq a -> f (Seq b)

FunctorWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> Vector a -> Vector b

imapped :: (Indexable Int p, Settable f) => p a (f b) -> Vector a -> f (Vector b)

TraversableWithIndex Int []

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> [a] -> f [b]

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> [a] -> f [b]

TraversableWithIndex Int ZipList

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> ZipList a -> f (ZipList b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> ZipList a -> f (ZipList b)

TraversableWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> NonEmpty a -> f (NonEmpty b)

TraversableWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> IntMap a -> f (IntMap b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> IntMap a -> f (IntMap b)

TraversableWithIndex Int Seq

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> Seq a -> f (Seq b)

TraversableWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Vector a -> f (Vector b)

itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> Vector a -> f (Vector b)

TraverseMax Int IntMap

Defined in Control.Lens.Traversal

Methods

traverseMax :: (Indexable Int p, Applicative f) => p v (f v) -> IntMap v -> f (IntMap v)

TraverseMin Int IntMap

Defined in Control.Lens.Traversal

Methods

traverseMin :: (Indexable Int p, Applicative f) => p v (f v) -> IntMap v -> f (IntMap v)

Vector Vector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int)

basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int)

basicLength :: Vector Int -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int

basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m ()

elemseq :: Vector Int -> Int -> b -> b

MVector MVector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int

basicOverlaps :: MVector s Int -> MVector s Int -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int)

basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Int -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int)

() :=> (Bounded Int)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Int

() :=> (Enum Int)

Defined in Data.Constraint

Methods

ins :: () :- Enum Int

() :=> (Eq Int)

Defined in Data.Constraint

Methods

ins :: () :- Eq Int

() :=> (Integral Int)

Defined in Data.Constraint

Methods

ins :: () :- Integral Int

() :=> (Num Int)

Defined in Data.Constraint

Methods

ins :: () :- Num Int

() :=> (Ord Int)

Defined in Data.Constraint

Methods

ins :: () :- Ord Int

() :=> (Read Int)

Defined in Data.Constraint

Methods

ins :: () :- Read Int

() :=> (Real Int)

Defined in Data.Constraint

Methods

ins :: () :- Real Int

() :=> (Show Int)

Defined in Data.Constraint

Methods

ins :: () :- Show Int

() :=> (Bits Int)

Defined in Data.Constraint

Methods

ins :: () :- Bits Int

Generic1 (URec Int :: k -> *)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Int) :: k -> *

Methods

from1 :: URec Int a -> Rep1 (URec Int) a

to1 :: Rep1 (URec Int) a -> URec Int a

FoldableWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => ([Int] -> a -> m) -> Tree a -> m

ifolded :: (Indexable [Int] p, Contravariant f, Applicative f) => p a (f a) -> Tree a -> f (Tree a)

ifoldr :: ([Int] -> a -> b -> b) -> b -> Tree a -> b

ifoldl :: ([Int] -> b -> a -> b) -> b -> Tree a -> b

ifoldr' :: ([Int] -> a -> b -> b) -> b -> Tree a -> b

ifoldl' :: ([Int] -> b -> a -> b) -> b -> Tree a -> b

FunctorWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

imap :: ([Int] -> a -> b) -> Tree a -> Tree b

imapped :: (Indexable [Int] p, Settable f) => p a (f b) -> Tree a -> f (Tree b)

TraversableWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => ([Int] -> a -> f b) -> Tree a -> f (Tree b)

itraversed :: (Indexable [Int] p, Applicative f) => p a (f b) -> Tree a -> f (Tree b)

Bizarre (Indexed Int) Mafic

Defined in Control.Lens.Internal.Magma

Methods

bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t

Reifies Z Int

Defined in Data.Reflection

Methods

reflect :: proxy Z -> Int

Reifies n Int => Reifies (D n :: *) Int

Defined in Data.Reflection

Methods

reflect :: proxy (D n) -> Int

Reifies n Int => Reifies (PD n :: *) Int

Defined in Data.Reflection

Methods

reflect :: proxy (PD n) -> Int

Reifies n Int => Reifies (SD n :: *) Int

Defined in Data.Reflection

Methods

reflect :: proxy (SD n) -> Int

Functor (URec Int :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Foldable (URec Int :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Int m -> m

foldMap :: Monoid m => (a -> m) -> URec Int a -> m

foldr :: (a -> b -> b) -> b -> URec Int a -> b

foldr' :: (a -> b -> b) -> b -> URec Int a -> b

foldl :: (b -> a -> b) -> b -> URec Int a -> b

foldl' :: (b -> a -> b) -> b -> URec Int a -> b

foldr1 :: (a -> a -> a) -> URec Int a -> a

foldl1 :: (a -> a -> a) -> URec Int a -> a

toList :: URec Int a -> [a]

null :: URec Int a -> Bool

length :: URec Int a -> Int

elem :: Eq a => a -> URec Int a -> Bool

maximum :: Ord a => URec Int a -> a

minimum :: Ord a => URec Int a -> a

sum :: Num a => URec Int a -> a

product :: Num a => URec Int a -> a

Traversable (URec Int :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b)

sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a)

mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b)

sequence :: Monad m => URec Int (m a) -> m (URec Int a)

Eq (URec Int p)

Defined in GHC.Generics

Methods

(==) :: URec Int p -> URec Int p -> Bool

(/=) :: URec Int p -> URec Int p -> Bool

Ord (URec Int p)

Defined in GHC.Generics

Methods

compare :: URec Int p -> URec Int p -> Ordering

(<) :: URec Int p -> URec Int p -> Bool

(<=) :: URec Int p -> URec Int p -> Bool

(>) :: URec Int p -> URec Int p -> Bool

(>=) :: URec Int p -> URec Int p -> Bool

max :: URec Int p -> URec Int p -> URec Int p

min :: URec Int p -> URec Int p -> URec Int p

Show (URec Int p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Generic (URec Int p)

Defined in GHC.Generics

Associated Types

type Rep (URec Int p) :: * -> *

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

data Vector Int

Defined in Data.Vector.Unboxed.Base

data Vector Int = V_Int (Vector Int)

type BitSize Int

Defined in Clash.Class.BitPack

type BitSize Int = 64

data URec Int (p :: k)

Used for marking occurrences of Int#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Int (p :: k) = UInt {

• uInt# :: Int#

}

data MVector s Int

Defined in Data.Vector.Unboxed.Base

data MVector s Int = MV_Int (MVector s Int)

type Unbundled domain Int

Defined in Clash.Signal.Bundle

type Unbundled domain Int = Signal domain Int

type Rep1 (URec Int :: k -> *)

Defined in GHC.Generics

type Rep1 (URec Int :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt :: k -> *)))

type Rep (URec Int p)

Defined in GHC.Generics

type Rep (URec Int p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt :: * -> *)))

data Integer

Invariant: Jn# and Jp# are used iff value doesn't fit in S#

Useful properties resulting from the invariants:

• abs (S# _) <= abs (Jp# _)

• abs (S# _) <  abs (Jn# _)

Instances

Enum Integer

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Integer -> Integer

pred :: Integer -> Integer

toEnum :: Int -> Integer

fromEnum :: Integer -> Int

enumFrom :: Integer -> [Integer]

enumFromThen :: Integer -> Integer -> [Integer]

enumFromTo :: Integer -> Integer -> [Integer]

enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]

Eq Integer

Defined in GHC.Integer.Type

Methods

(==) :: Integer -> Integer -> Bool

(/=) :: Integer -> Integer -> Bool

Integral Integer

Since: base-2.0.1

Defined in GHC.Real

Methods

quot :: Integer -> Integer -> Integer

rem :: Integer -> Integer -> Integer

div :: Integer -> Integer -> Integer

mod :: Integer -> Integer -> Integer

quotRem :: Integer -> Integer -> (Integer, Integer)

divMod :: Integer -> Integer -> (Integer, Integer)

toInteger :: Integer -> Integer

Data Integer

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer

toConstr :: Integer -> Constr

dataTypeOf :: Integer -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer)

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

gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r

gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer

Num Integer

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

(*) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

abs :: Integer -> Integer

signum :: Integer -> Integer

fromInteger :: Integer -> Integer

Ord Integer

Defined in GHC.Integer.Type

Methods

compare :: Integer -> Integer -> Ordering

(<) :: Integer -> Integer -> Bool

(<=) :: Integer -> Integer -> Bool

(>) :: Integer -> Integer -> Bool

(>=) :: Integer -> Integer -> Bool

max :: Integer -> Integer -> Integer

min :: Integer -> Integer -> Integer

Read Integer

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Integer

readList :: ReadS [Integer]

readPrec :: ReadPrec Integer

readListPrec :: ReadPrec [Integer]

Real Integer

Since: base-2.0.1

Defined in GHC.Real

Methods

toRational :: Integer -> Rational

Show Integer

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

Ix Integer

Since: base-2.1

Defined in GHC.Arr

Methods

range :: (Integer, Integer) -> [Integer]

index :: (Integer, Integer) -> Integer -> Int

unsafeIndex :: (Integer, Integer) -> Integer -> Int

inRange :: (Integer, Integer) -> Integer -> Bool

rangeSize :: (Integer, Integer) -> Int

unsafeRangeSize :: (Integer, Integer) -> Int

Lift Integer

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Integer -> Q Exp

Bits Integer

Since: base-2.1

Defined in Data.Bits

Methods

(.&.) :: Integer -> Integer -> Integer

(.|.) :: Integer -> Integer -> Integer

xor :: Integer -> Integer -> Integer

complement :: Integer -> Integer

shift :: Integer -> Int -> Integer

rotate :: Integer -> Int -> Integer

zeroBits :: Integer

bit :: Int -> Integer

setBit :: Integer -> Int -> Integer

clearBit :: Integer -> Int -> Integer

complementBit :: Integer -> Int -> Integer

testBit :: Integer -> Int -> Bool

bitSizeMaybe :: Integer -> Maybe Int

bitSize :: Integer -> Int

isSigned :: Integer -> Bool

shiftL :: Integer -> Int -> Integer

unsafeShiftL :: Integer -> Int -> Integer

shiftR :: Integer -> Int -> Integer

unsafeShiftR :: Integer -> Int -> Integer

rotateL :: Integer -> Int -> Integer

rotateR :: Integer -> Int -> Integer

popCount :: Integer -> Int

NFData Integer

Defined in Control.DeepSeq

Methods

rnf :: Integer -> ()

ShowX Integer

Defined in Clash.XException

Methods

showsPrecX :: Int -> Integer -> ShowS

showX :: Integer -> String

showListX :: [Integer] -> ShowS

Default Integer

Defined in Data.Default.Class

Methods

def :: Integer

Arbitrary Integer

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Integer

shrink :: Integer -> [Integer]

CoArbitrary Integer

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Integer -> Gen b -> Gen b

Bundle Integer

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled domain Integer = (res :: *)

Methods

bundle :: Unbundled domain Integer -> Signal domain Integer

unbundle :: Signal domain Integer -> Unbundled domain Integer

KnownNat n => Reifies (n :: Nat) Integer

Defined in Data.Reflection

Methods

reflect :: proxy n -> Integer

() :=> (Enum Integer)

Defined in Data.Constraint

Methods

ins :: () :- Enum Integer

() :=> (Eq Integer)

Defined in Data.Constraint

Methods

ins :: () :- Eq Integer

() :=> (Integral Integer)

Defined in Data.Constraint

Methods

ins :: () :- Integral Integer

() :=> (Num Integer)

Defined in Data.Constraint

Methods

ins :: () :- Num Integer

() :=> (Ord Integer)

Defined in Data.Constraint

Methods

ins :: () :- Ord Integer

() :=> (Real Integer)

Defined in Data.Constraint

Methods

ins :: () :- Real Integer

() :=> (Bits Integer)

Defined in Data.Constraint

Methods

ins :: () :- Bits Integer

type Unbundled domain Integer

Defined in Clash.Signal.Bundle

type Unbundled domain Integer = Signal domain Integer

data Maybe a

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

Constructors

Nothing

Just a

Instances

Monad Maybe

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b

(>>) :: Maybe a -> Maybe b -> Maybe b

return :: a -> Maybe a

fail :: String -> Maybe a

Functor Maybe

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b

(<$) :: a -> Maybe b -> Maybe a

Applicative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Foldable Maybe

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => Maybe m -> m

foldMap :: Monoid m => (a -> m) -> Maybe a -> m

foldr :: (a -> b -> b) -> b -> Maybe a -> b

foldr' :: (a -> b -> b) -> b -> Maybe a -> b

foldl :: (b -> a -> b) -> b -> Maybe a -> b

foldl' :: (b -> a -> b) -> b -> Maybe a -> b

foldr1 :: (a -> a -> a) -> Maybe a -> a

foldl1 :: (a -> a -> a) -> Maybe a -> a

toList :: Maybe a -> [a]

null :: Maybe a -> Bool

length :: Maybe a -> Int

elem :: Eq a => a -> Maybe a -> Bool

maximum :: Ord a => Maybe a -> a

minimum :: Ord a => Maybe a -> a

sum :: Num a => Maybe a -> a

product :: Num a => Maybe a -> a

Traversable Maybe

Since: base-2.1

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b)

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a)

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)

sequence :: Monad m => Maybe (m a) -> m (Maybe a)

Eq1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool

Ord1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering

Read1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a]

Show1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS

Alternative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

empty :: Maybe a

(<|>) :: Maybe a -> Maybe a -> Maybe a

some :: Maybe a -> Maybe [a]

many :: Maybe a -> Maybe [a]

MonadPlus Maybe

Since: base-2.1

Defined in GHC.Base

Methods

mzero :: Maybe a

mplus :: Maybe a -> Maybe a -> Maybe a

NFData1 Maybe

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> Maybe a -> ()

Arbitrary1 Maybe

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Maybe a)

liftShrink :: (a -> [a]) -> Maybe a -> [Maybe a]

FoldableWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (() -> a -> m) -> Maybe a -> m

ifolded :: (Indexable () p, Contravariant f, Applicative f) => p a (f a) -> Maybe a -> f (Maybe a)

ifoldr :: (() -> a -> b -> b) -> b -> Maybe a -> b

ifoldl :: (() -> b -> a -> b) -> b -> Maybe a -> b

ifoldr' :: (() -> a -> b -> b) -> b -> Maybe a -> b

ifoldl' :: (() -> b -> a -> b) -> b -> Maybe a -> b

FunctorWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

imap :: (() -> a -> b) -> Maybe a -> Maybe b

imapped :: (Indexable () p, Settable f) => p a (f b) -> Maybe a -> f (Maybe b)

TraversableWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (() -> a -> f b) -> Maybe a -> f (Maybe b)

itraversed :: (Indexable () p, Applicative f) => p a (f b) -> Maybe a -> f (Maybe b)

() :=> (Functor Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Functor Maybe

() :=> (Applicative Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Applicative Maybe

() :=> (Alternative Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Alternative Maybe

() :=> (MonadPlus Maybe)

Defined in Data.Constraint

Methods

ins :: () :- MonadPlus Maybe

Eq a => Eq (Maybe a)

Defined in GHC.Base

Methods

(==) :: Maybe a -> Maybe a -> Bool

(/=) :: Maybe a -> Maybe a -> Bool

Data a => Data (Maybe a)

Since: base-4.0.0.0

Defined in Data.Data

Methods

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

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

toConstr :: Maybe a -> Constr

dataTypeOf :: Maybe a -> DataType

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (Maybe a)

Defined in GHC.Base

Methods

compare :: Maybe a -> Maybe a -> Ordering

(<) :: Maybe a -> Maybe a -> Bool

(<=) :: Maybe a -> Maybe a -> Bool

(>) :: Maybe a -> Maybe a -> Bool

(>=) :: Maybe a -> Maybe a -> Bool

max :: Maybe a -> Maybe a -> Maybe a

min :: Maybe a -> Maybe a -> Maybe a

Read a => Read (Maybe a)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (Maybe a)

readList :: ReadS [Maybe a]

readPrec :: ReadPrec (Maybe a)

readListPrec :: ReadPrec [Maybe a]

Show a => Show (Maybe a)

Defined in GHC.Show

Methods

showsPrec :: Int -> Maybe a -> ShowS

show :: Maybe a -> String

showList :: [Maybe a] -> ShowS

Generic (Maybe a)

Defined in GHC.Generics

Associated Types

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

Methods

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

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

Semigroup a => Semigroup (Maybe a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: Maybe a -> Maybe a -> Maybe a

sconcat :: NonEmpty (Maybe a) -> Maybe a

stimes :: Integral b => b -> Maybe a -> Maybe a

Semigroup a => Monoid (Maybe a)

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S."

Since 4.11.0: constraint on inner a value generalised from Monoid to Semigroup.

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Maybe a

mappend :: Maybe a -> Maybe a -> Maybe a

mconcat :: [Maybe a] -> Maybe a

Lift a => Lift (Maybe a)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Maybe a -> Q Exp

SingKind a => SingKind (Maybe a)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type DemoteRep (Maybe a) :: *

Methods

fromSing :: Sing a0 -> DemoteRep (Maybe a)

NFData a => NFData (Maybe a)

Defined in Control.DeepSeq

Methods

rnf :: Maybe a -> ()

ShowX a => ShowX (Maybe a)

Defined in Clash.XException

Methods

showsPrecX :: Int -> Maybe a -> ShowS

showX :: Maybe a -> String

showListX :: [Maybe a] -> ShowS

At (Maybe a)

Defined in Control.Lens.At

Methods

at :: Index (Maybe a) -> Lens' (Maybe a) (Maybe (IxValue (Maybe a)))

Ixed (Maybe a)

Defined in Control.Lens.At

Methods

ix :: Index (Maybe a) -> Traversal' (Maybe a) (IxValue (Maybe a))

AsEmpty (Maybe a)

Defined in Control.Lens.Empty

Methods

_Empty :: Prism' (Maybe a) ()

Default (Maybe a)

Defined in Data.Default.Class

Methods

def :: Maybe a

Arbitrary a => Arbitrary (Maybe a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Maybe a)

shrink :: Maybe a -> [Maybe a]

CoArbitrary a => CoArbitrary (Maybe a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Maybe a -> Gen b -> Gen b

(BitPack a, KnownNat (BitSize a)) => BitPack (Maybe a)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (Maybe a) :: Nat

Methods

pack :: Maybe a -> BitVector (BitSize (Maybe a))

unpack :: BitVector (BitSize (Maybe a)) -> Maybe a

PEq (Maybe a)

Defined in Data.Singletons.Prelude.Eq

Associated Types

type x == y :: Bool

type x /= y :: Bool

SEq a => SEq (Maybe a)

Defined in Data.Singletons.Prelude.Eq

Methods

(%==) :: Sing a0 -> Sing b -> Sing (a0 == b)

(%/=) :: Sing a0 -> Sing b -> Sing (a0 /= b)

POrd (Maybe a)

Defined in Data.Singletons.Prelude.Ord

Associated Types

type Compare arg arg1 :: Ordering

type arg < arg1 :: Bool

type arg <= arg1 :: Bool

type arg > arg1 :: Bool

type arg >= arg1 :: Bool

type Max arg arg1 :: a

type Min arg arg1 :: a

SOrd a => SOrd (Maybe a)

Defined in Data.Singletons.Prelude.Ord

Methods

sCompare :: Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2)

(%<) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2)

(%<=) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2)

(%>) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2)

(%>=) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2)

sMax :: Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2)

sMin :: Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2)

PShow (Maybe a)

Defined in Data.Singletons.Prelude.Show

Associated Types

type ShowsPrec arg arg1 arg2 :: Symbol

type Show_ arg :: Symbol

type ShowList arg arg1 :: Symbol

SShow a => SShow (Maybe a)

Defined in Data.Singletons.Prelude.Show

Methods

sShowsPrec :: Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3)

sShow_ :: Sing t -> Sing (Apply Show_Sym0 t)

sShowList :: Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2)

ShowSing a => ShowSing (Maybe a)

Defined in Data.Singletons.ShowSing

Methods

showsSingPrec :: Int -> Sing a0 -> ShowS

Bundle (Maybe a)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled domain (Maybe a) = (res :: *)

Methods

bundle :: Unbundled domain (Maybe a) -> Signal domain (Maybe a)

unbundle :: Signal domain (Maybe a) -> Unbundled domain (Maybe a)

Generic1 Maybe

Defined in GHC.Generics

Associated Types

type Rep1 Maybe :: k -> *

Methods

from1 :: Maybe a -> Rep1 Maybe a

to1 :: Rep1 Maybe a -> Maybe a

SingI (Nothing :: Maybe a)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing Nothing

(Eq a) :=> (Eq (Maybe a))

Defined in Data.Constraint

Methods

ins :: Eq a :- Eq (Maybe a)

(Ord a) :=> (Ord (Maybe a))

Defined in Data.Constraint

Methods

ins :: Ord a :- Ord (Maybe a)

(Read a) :=> (Read (Maybe a))

Defined in Data.Constraint

Methods

ins :: Read a :- Read (Maybe a)

(Show a) :=> (Show (Maybe a))

Defined in Data.Constraint

Methods

ins :: Show a :- Show (Maybe a)

(Semigroup a) :=> (Semigroup (Maybe a))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (Maybe a)

(Monoid a) :=> (Monoid (Maybe a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (Maybe a)

Each (Maybe a) (Maybe b) a b

Defined in Control.Lens.Each

Methods

each :: Traversal (Maybe a) (Maybe b) a b

SingI a2 => SingI (Just a2 :: Maybe a1)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing (Just a2)

SuppressUnusedWarnings (FindSym1 :: (TyFun a6989586621679684431 Bool -> Type) -> TyFun [a6989586621679684431] (Maybe a6989586621679684431) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindIndexSym1 :: (TyFun a6989586621679684428 Bool -> Type) -> TyFun [a6989586621679684428] (Maybe Nat) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554226Sym1 :: Maybe a3530822107858468865 -> TyFun (Maybe a3530822107858468865) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ShowsPrec_6989586621679891063Sym2 :: Nat -> Maybe a3530822107858468865 -> TyFun Symbol Symbol -> *)

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ShowsPrec_6989586621679891063Sym1 :: Nat -> TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> *)

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FromMaybeSym1 :: a6989586621679650706 -> TyFun (Maybe a6989586621679650706) a6989586621679650706 -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ElemIndexSym1 :: a6989586621679684430 -> TyFun [a6989586621679684430] (Maybe Nat) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindSym0 :: TyFun (TyFun a6989586621679684431 Bool -> Type) (TyFun [a6989586621679684431] (Maybe a6989586621679684431) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FindIndexSym0 :: TyFun (TyFun a6989586621679684428 Bool -> Type) (TyFun [a6989586621679684428] (Maybe Nat) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (CatMaybesSym0 :: TyFun [Maybe a6989586621679650703] [a6989586621679650703] -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ListToMaybeSym0 :: TyFun [a6989586621679650704] (Maybe a6989586621679650704) -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554226Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (MaybeToListSym0 :: TyFun (Maybe a6989586621679650705) [a6989586621679650705] -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsNothingSym0 :: TyFun (Maybe a6989586621679650708) Bool -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsJustSym0 :: TyFun (Maybe a6989586621679650709) Bool -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FromJustSym0 :: TyFun (Maybe a6989586621679650707) a6989586621679650707 -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ShowsPrec_6989586621679891063Sym0 :: TyFun Nat (TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (FromMaybeSym0 :: TyFun a6989586621679650706 (TyFun (Maybe a6989586621679650706) a6989586621679650706 -> Type) -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ElemIndexSym0 :: TyFun a6989586621679684430 (TyFun [a6989586621679684430] (Maybe Nat) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (JustSym0 :: TyFun a3530822107858468865 (Maybe a3530822107858468865) -> *)

Defined in Data.Singletons.Prelude.Instances

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (MapMaybeSym1 :: (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) -> TyFun [a6989586621679650701] [b6989586621679650702] -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679650880RsSym2 :: (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) -> a6989586621679650701 -> TyFun [a6989586621679650701] [b6989586621679650702] -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679650880RsSym1 :: (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) -> TyFun a6989586621679650701 (TyFun [a6989586621679650701] [b6989586621679650702] -> *) -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (UnfoldrSym1 :: (TyFun b6989586621679684487 (Maybe (a6989586621679684488, b6989586621679684487)) -> Type) -> TyFun b6989586621679684487 [a6989586621679684488] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Maybe_Sym2 :: b6989586621679649578 -> (TyFun a6989586621679649579 b6989586621679649578 -> Type) -> TyFun (Maybe a6989586621679649579) b6989586621679649578 -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Maybe_Sym1 :: b6989586621679649578 -> TyFun (TyFun a6989586621679649579 b6989586621679649578 -> Type) (TyFun (Maybe a6989586621679649579) b6989586621679649578 -> Type) -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (LookupSym1 :: a6989586621679684409 -> TyFun [(a6989586621679684409, b6989586621679684410)] (Maybe b6989586621679684410) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (MapMaybeSym0 :: TyFun (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) (TyFun [a6989586621679650701] [b6989586621679650702] -> Type) -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679650880RsSym0 :: TyFun (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) (TyFun a6989586621679650701 (TyFun [a6989586621679650701] [b6989586621679650702] -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (UnfoldrSym0 :: TyFun (TyFun b6989586621679684487 (Maybe (a6989586621679684488, b6989586621679684487)) -> Type) (TyFun b6989586621679684487 [a6989586621679684488] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Maybe_Sym0 :: TyFun b6989586621679649578 (TyFun (TyFun a6989586621679649579 b6989586621679649578 -> Type) (TyFun (Maybe a6989586621679649579) b6989586621679649578 -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.Maybe

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (LookupSym0 :: TyFun a6989586621679684409 (TyFun [(a6989586621679684409, b6989586621679684410)] (Maybe b6989586621679684410) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

type Unbundled domain (Maybe a)

Defined in Clash.Signal.Bundle

type Unbundled domain (Maybe a) = Signal domain (Maybe a)

type Apply (JustSym0 :: TyFun a (Maybe a) -> *) (l :: a)

Defined in Data.Singletons.Prelude.Instances

type Apply (JustSym0 :: TyFun a (Maybe a) -> *) (l :: a) = Just l

type Apply (ShowsPrec_6989586621679891063Sym0 :: TyFun Nat (TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> Type) -> *) (l :: Nat)

Defined in Data.Singletons.Prelude.Show

type Apply (ShowsPrec_6989586621679891063Sym0 :: TyFun Nat (TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> Type) -> *) (l :: Nat) = (ShowsPrec_6989586621679891063Sym1 l :: TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> *)

type Apply (FromMaybeSym0 :: TyFun a6989586621679650706 (TyFun (Maybe a6989586621679650706) a6989586621679650706 -> Type) -> *) (l :: a6989586621679650706)

Defined in Data.Singletons.Prelude.Maybe

type Apply (FromMaybeSym0 :: TyFun a6989586621679650706 (TyFun (Maybe a6989586621679650706) a6989586621679650706 -> Type) -> *) (l :: a6989586621679650706) = FromMaybeSym1 l

type Apply (ElemIndexSym0 :: TyFun a6989586621679684430 (TyFun [a6989586621679684430] (Maybe Nat) -> Type) -> *) (l :: a6989586621679684430)

Defined in Data.Singletons.Prelude.List

type Apply (ElemIndexSym0 :: TyFun a6989586621679684430 (TyFun [a6989586621679684430] (Maybe Nat) -> Type) -> *) (l :: a6989586621679684430) = ElemIndexSym1 l

type Apply (Maybe_Sym0 :: TyFun b6989586621679649578 (TyFun (TyFun a6989586621679649579 b6989586621679649578 -> Type) (TyFun (Maybe a6989586621679649579) b6989586621679649578 -> Type) -> Type) -> *) (l :: b6989586621679649578)

Defined in Data.Singletons.Prelude.Maybe

type Apply (Maybe_Sym0 :: TyFun b6989586621679649578 (TyFun (TyFun a6989586621679649579 b6989586621679649578 -> Type) (TyFun (Maybe a6989586621679649579) b6989586621679649578 -> Type) -> Type) -> *) (l :: b6989586621679649578) = (Maybe_Sym1 l :: TyFun (TyFun a6989586621679649579 b6989586621679649578 -> Type) (TyFun (Maybe a6989586621679649579) b6989586621679649578 -> Type) -> *)

type Apply (LookupSym0 :: TyFun a6989586621679684409 (TyFun [(a6989586621679684409, b6989586621679684410)] (Maybe b6989586621679684410) -> Type) -> *) (l :: a6989586621679684409)

Defined in Data.Singletons.Prelude.List

type Apply (LookupSym0 :: TyFun a6989586621679684409 (TyFun [(a6989586621679684409, b6989586621679684410)] (Maybe b6989586621679684410) -> Type) -> *) (l :: a6989586621679684409) = (LookupSym1 l :: TyFun [(a6989586621679684409, b6989586621679684410)] (Maybe b6989586621679684410) -> *)

type Rep (Maybe a)

Defined in GHC.Generics

type Rep (Maybe a) = D1 (MetaData "Maybe" "GHC.Base" "base" False) (C1 (MetaCons "Nothing" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "Just" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

data Sing (b :: Maybe a)

Defined in GHC.Generics

data Sing (b :: Maybe a) where

• SNothing :: Sing (Nothing :: Maybe a)
• SJust :: Sing (Just a1)

type DemoteRep (Maybe a)

Defined in GHC.Generics

type DemoteRep (Maybe a) = Maybe (DemoteRep a)

type Index (Maybe a)

Defined in Control.Lens.At

type Index (Maybe a) = ()

type IxValue (Maybe a)

Defined in Control.Lens.At

type IxValue (Maybe a) = a

type BitSize (Maybe a)

Defined in Clash.Class.BitPack

type BitSize (Maybe a) = 1 + BitSize a

data Sing (z :: Maybe a)

Defined in Data.Singletons.Prelude.Instances

data Sing (z :: Maybe a) where

• SNothing :: Sing (Nothing :: Maybe a)
• SJust :: Sing (Just n)

type Demote (Maybe a)

Defined in Data.Singletons.Prelude.Instances

type Demote (Maybe a) = Maybe (Demote a)

type Rep1 Maybe

Defined in GHC.Generics

type Rep1 Maybe = D1 (MetaData "Maybe" "GHC.Base" "base" False) (C1 (MetaCons "Nothing" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "Just" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Show_ (arg :: Maybe a)

Defined in Data.Singletons.Prelude.Show

type Show_ (arg :: Maybe a) = Apply (Show__6989586621679875032Sym0 :: TyFun (Maybe a) Symbol -> *) arg

type (x :: Maybe a) /= (y :: Maybe a)

Defined in Data.Singletons.Prelude.Eq

type (x :: Maybe a) /= (y :: Maybe a) = Not (x == y)

type (a2 :: Maybe a1) == (b :: Maybe a1)

Defined in Data.Singletons.Prelude.Eq

type (a2 :: Maybe a1) == (b :: Maybe a1) = Equals_6989586621679535734 a2 b

type (arg1 :: Maybe a) < (arg2 :: Maybe a)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Maybe a) < (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679547183Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) Bool -> Type) -> *) arg1) arg2

type (arg1 :: Maybe a) <= (arg2 :: Maybe a)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Maybe a) <= (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679547216Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) Bool -> Type) -> *) arg1) arg2

type (arg1 :: Maybe a) > (arg2 :: Maybe a)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Maybe a) > (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679547249Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) Bool -> Type) -> *) arg1) arg2

type (arg1 :: Maybe a) >= (arg2 :: Maybe a)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Maybe a) >= (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679547282Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) Bool -> Type) -> *) arg1) arg2

type Compare (a2 :: Maybe a1) (a3 :: Maybe a1)

Defined in Data.Singletons.Prelude.Ord

type Compare (a2 :: Maybe a1) (a3 :: Maybe a1) = Apply (Apply (Compare_6989586621679554226Sym0 :: TyFun (Maybe a1) (TyFun (Maybe a1) Ordering -> Type) -> *) a2) a3

type Max (arg1 :: Maybe a) (arg2 :: Maybe a)

Defined in Data.Singletons.Prelude.Ord

type Max (arg1 :: Maybe a) (arg2 :: Maybe a) = Apply (Apply (Max_6989586621679547315Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) (Maybe a) -> Type) -> *) arg1) arg2

type Min (arg1 :: Maybe a) (arg2 :: Maybe a)

Defined in Data.Singletons.Prelude.Ord

type Min (arg1 :: Maybe a) (arg2 :: Maybe a) = Apply (Apply (Min_6989586621679547348Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) (Maybe a) -> Type) -> *) arg1) arg2

type ShowList (arg1 :: [Maybe a]) arg2

Defined in Data.Singletons.Prelude.Show

type ShowList (arg1 :: [Maybe a]) arg2 = Apply (Apply (ShowList_6989586621679875050Sym0 :: TyFun [Maybe a] (TyFun Symbol Symbol -> Type) -> *) arg1) arg2

type ShowsPrec a2 (a3 :: Maybe a1) a4

Defined in Data.Singletons.Prelude.Show

type ShowsPrec a2 (a3 :: Maybe a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621679891063Sym0 :: TyFun Nat (TyFun (Maybe a1) (TyFun Symbol Symbol -> Type) -> Type) -> *) a2) a3) a4

type Apply (FromJustSym0 :: TyFun (Maybe a) a -> *) (l :: Maybe a)

Defined in Data.Singletons.Prelude.Maybe

type Apply (FromJustSym0 :: TyFun (Maybe a) a -> *) (l :: Maybe a) = FromJust l

type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a)

Defined in Data.Singletons.Prelude.Maybe

type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a) = IsNothing l

type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a)

Defined in Data.Singletons.Prelude.Maybe

type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a) = IsJust l

type Apply (Compare_6989586621679554226Sym1 l1 :: TyFun (Maybe a) Ordering -> *) (l2 :: Maybe a)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554226Sym1 l1 :: TyFun (Maybe a) Ordering -> *) (l2 :: Maybe a) = Compare_6989586621679554226 l1 l2

type Apply (FromMaybeSym1 l1 :: TyFun (Maybe a) a -> *) (l2 :: Maybe a)

Defined in Data.Singletons.Prelude.Maybe

type Apply (FromMaybeSym1 l1 :: TyFun (Maybe a) a -> *) (l2 :: Maybe a) = FromMaybe l1 l2

type Apply (Maybe_Sym2 l1 l2 :: TyFun (Maybe a) b -> *) (l3 :: Maybe a)

Defined in Data.Singletons.Prelude.Maybe

type Apply (Maybe_Sym2 l1 l2 :: TyFun (Maybe a) b -> *) (l3 :: Maybe a) = Maybe_ l1 l2 l3

type Apply (CatMaybesSym0 :: TyFun [Maybe a] [a] -> *) (l :: [Maybe a])

Defined in Data.Singletons.Prelude.Maybe

type Apply (CatMaybesSym0 :: TyFun [Maybe a] [a] -> *) (l :: [Maybe a]) = CatMaybes l

type Apply (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> *) (l :: [a])

Defined in Data.Singletons.Prelude.Maybe

type Apply (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> *) (l :: [a]) = ListToMaybe l

type Apply (MaybeToListSym0 :: TyFun (Maybe a) [a] -> *) (l :: Maybe a)

Defined in Data.Singletons.Prelude.Maybe

type Apply (MaybeToListSym0 :: TyFun (Maybe a) [a] -> *) (l :: Maybe a) = MaybeToList l

type Apply (FindSym1 l1 :: TyFun [a] (Maybe a) -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (FindSym1 l1 :: TyFun [a] (Maybe a) -> *) (l2 :: [a]) = Find l1 l2

type Apply (FindIndexSym1 l1 :: TyFun [a] (Maybe Nat) -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (FindIndexSym1 l1 :: TyFun [a] (Maybe Nat) -> *) (l2 :: [a]) = FindIndex l1 l2

type Apply (ElemIndexSym1 l1 :: TyFun [a] (Maybe Nat) -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.List

type Apply (ElemIndexSym1 l1 :: TyFun [a] (Maybe Nat) -> *) (l2 :: [a]) = ElemIndex l1 l2

type Apply (LookupSym1 l1 :: TyFun [(a, b)] (Maybe b) -> *) (l2 :: [(a, b)])

Defined in Data.Singletons.Prelude.List

type Apply (LookupSym1 l1 :: TyFun [(a, b)] (Maybe b) -> *) (l2 :: [(a, b)]) = Lookup l1 l2

type Apply (Compare_6989586621679554226Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *) (l :: Maybe a3530822107858468865)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554226Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *) (l :: Maybe a3530822107858468865) = Compare_6989586621679554226Sym1 l

type Apply (ShowsPrec_6989586621679891063Sym1 l1 :: TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> *) (l2 :: Maybe a3530822107858468865)

Defined in Data.Singletons.Prelude.Show

type Apply (ShowsPrec_6989586621679891063Sym1 l1 :: TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> *) (l2 :: Maybe a3530822107858468865) = ShowsPrec_6989586621679891063Sym2 l1 l2

type Apply (FindSym0 :: TyFun (TyFun a6989586621679684431 Bool -> Type) (TyFun [a6989586621679684431] (Maybe a6989586621679684431) -> Type) -> *) (l :: TyFun a6989586621679684431 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (FindSym0 :: TyFun (TyFun a6989586621679684431 Bool -> Type) (TyFun [a6989586621679684431] (Maybe a6989586621679684431) -> Type) -> *) (l :: TyFun a6989586621679684431 Bool -> Type) = FindSym1 l

type Apply (FindIndexSym0 :: TyFun (TyFun a6989586621679684428 Bool -> Type) (TyFun [a6989586621679684428] (Maybe Nat) -> Type) -> *) (l :: TyFun a6989586621679684428 Bool -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (FindIndexSym0 :: TyFun (TyFun a6989586621679684428 Bool -> Type) (TyFun [a6989586621679684428] (Maybe Nat) -> Type) -> *) (l :: TyFun a6989586621679684428 Bool -> Type) = FindIndexSym1 l

type Apply (MapMaybeSym0 :: TyFun (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) (TyFun [a6989586621679650701] [b6989586621679650702] -> Type) -> *) (l :: TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type)

Defined in Data.Singletons.Prelude.Maybe

type Apply (MapMaybeSym0 :: TyFun (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) (TyFun [a6989586621679650701] [b6989586621679650702] -> Type) -> *) (l :: TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) = MapMaybeSym1 l

type Apply (Let6989586621679650880RsSym0 :: TyFun (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) (TyFun a6989586621679650701 (TyFun [a6989586621679650701] [b6989586621679650702] -> *) -> *) -> *) (l :: TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type)

Defined in Data.Singletons.Prelude.Maybe

type Apply (Let6989586621679650880RsSym0 :: TyFun (TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) (TyFun a6989586621679650701 (TyFun [a6989586621679650701] [b6989586621679650702] -> *) -> *) -> *) (l :: TyFun a6989586621679650701 (Maybe b6989586621679650702) -> Type) = Let6989586621679650880RsSym1 l

type Apply (UnfoldrSym0 :: TyFun (TyFun b6989586621679684487 (Maybe (a6989586621679684488, b6989586621679684487)) -> Type) (TyFun b6989586621679684487 [a6989586621679684488] -> Type) -> *) (l :: TyFun b6989586621679684487 (Maybe (a6989586621679684488, b6989586621679684487)) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (UnfoldrSym0 :: TyFun (TyFun b6989586621679684487 (Maybe (a6989586621679684488, b6989586621679684487)) -> Type) (TyFun b6989586621679684487 [a6989586621679684488] -> Type) -> *) (l :: TyFun b6989586621679684487 (Maybe (a6989586621679684488, b6989586621679684487)) -> Type) = UnfoldrSym1 l

type Apply (Maybe_Sym1 l1 :: TyFun (TyFun a6989586621679649579 b6989586621679649578 -> Type) (TyFun (Maybe a6989586621679649579) b6989586621679649578 -> Type) -> *) (l2 :: TyFun a6989586621679649579 b6989586621679649578 -> Type)

Defined in Data.Singletons.Prelude.Maybe

type Apply (Maybe_Sym1 l1 :: TyFun (TyFun a6989586621679649579 b6989586621679649578 -> Type) (TyFun (Maybe a6989586621679649579) b6989586621679649578 -> Type) -> *) (l2 :: TyFun a6989586621679649579 b6989586621679649578 -> Type) = Maybe_Sym2 l1 l2

data Ordering

Constructors

LT

EQ

GT

Instances

Bounded Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Ordering

maxBound :: Ordering

Enum Ordering

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Ordering -> Ordering

pred :: Ordering -> Ordering

toEnum :: Int -> Ordering

fromEnum :: Ordering -> Int

enumFrom :: Ordering -> [Ordering]

enumFromThen :: Ordering -> Ordering -> [Ordering]

enumFromTo :: Ordering -> Ordering -> [Ordering]

enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering]

Eq Ordering

Defined in GHC.Classes

Methods

(==) :: Ordering -> Ordering -> Bool

(/=) :: Ordering -> Ordering -> Bool

Data Ordering

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering

toConstr :: Ordering -> Constr

dataTypeOf :: Ordering -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering)

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

gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r

gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering

Ord Ordering

Defined in GHC.Classes

Methods

compare :: Ordering -> Ordering -> Ordering

(<) :: Ordering -> Ordering -> Bool

(<=) :: Ordering -> Ordering -> Bool

(>) :: Ordering -> Ordering -> Bool

(>=) :: Ordering -> Ordering -> Bool

max :: Ordering -> Ordering -> Ordering

min :: Ordering -> Ordering -> Ordering

Read Ordering

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Ordering

readList :: ReadS [Ordering]

readPrec :: ReadPrec Ordering

readListPrec :: ReadPrec [Ordering]

Show Ordering

Defined in GHC.Show

Methods

showsPrec :: Int -> Ordering -> ShowS

show :: Ordering -> String

showList :: [Ordering] -> ShowS

Ix Ordering

Since: base-2.1

Defined in GHC.Arr

Methods

range :: (Ordering, Ordering) -> [Ordering]

index :: (Ordering, Ordering) -> Ordering -> Int

unsafeIndex :: (Ordering, Ordering) -> Ordering -> Int

inRange :: (Ordering, Ordering) -> Ordering -> Bool

rangeSize :: (Ordering, Ordering) -> Int

unsafeRangeSize :: (Ordering, Ordering) -> Int

Generic Ordering

Defined in GHC.Generics

Associated Types

type Rep Ordering :: * -> *

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Semigroup Ordering

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: Ordering -> Ordering -> Ordering

sconcat :: NonEmpty Ordering -> Ordering

stimes :: Integral b => b -> Ordering -> Ordering

Monoid Ordering

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

NFData Ordering

Defined in Control.DeepSeq

Methods

rnf :: Ordering -> ()

AsEmpty Ordering

Defined in Control.Lens.Empty

Methods

_Empty :: Prism' Ordering ()

Default Ordering

Defined in Data.Default.Class

Methods

def :: Ordering

Arbitrary Ordering

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Ordering

shrink :: Ordering -> [Ordering]

CoArbitrary Ordering

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Ordering -> Gen b -> Gen b

PBounded Ordering

Defined in Data.Singletons.Prelude.Enum

Associated Types

type MinBound :: a

type MaxBound :: a

PEnum Ordering

Defined in Data.Singletons.Prelude.Enum

Associated Types

type Succ arg :: a

type Pred arg :: a

type ToEnum arg :: a

type FromEnum arg :: Nat

type EnumFromTo arg arg1 :: [a]

type EnumFromThenTo arg arg1 arg2 :: [a]

SBounded Ordering

Defined in Data.Singletons.Prelude.Enum

Methods

sMinBound :: Sing MinBoundSym0

sMaxBound :: Sing MaxBoundSym0

SEnum Ordering

Defined in Data.Singletons.Prelude.Enum

Methods

sSucc :: Sing t -> Sing (Apply SuccSym0 t)

sPred :: Sing t -> Sing (Apply PredSym0 t)

sToEnum :: Sing t -> Sing (Apply ToEnumSym0 t)

sFromEnum :: Sing t -> Sing (Apply FromEnumSym0 t)

sEnumFromTo :: Sing t1 -> Sing t2 -> Sing (Apply (Apply EnumFromToSym0 t1) t2)

sEnumFromThenTo :: Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply EnumFromThenToSym0 t1) t2) t3)

PEq Ordering

Defined in Data.Singletons.Prelude.Eq

Associated Types

type x == y :: Bool

type x /= y :: Bool

SEq Ordering

Defined in Data.Singletons.Prelude.Eq

Methods

(%==) :: Sing a -> Sing b -> Sing (a == b)

(%/=) :: Sing a -> Sing b -> Sing (a /= b)

POrd Ordering

Defined in Data.Singletons.Prelude.Ord

Associated Types

type Compare arg arg1 :: Ordering

type arg < arg1 :: Bool

type arg <= arg1 :: Bool

type arg > arg1 :: Bool

type arg >= arg1 :: Bool

type Max arg arg1 :: a

type Min arg arg1 :: a

SOrd Ordering

Defined in Data.Singletons.Prelude.Ord

Methods

sCompare :: Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2)

(%<) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2)

(%<=) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2)

(%>) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2)

(%>=) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2)

sMax :: Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2)

sMin :: Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2)

PShow Ordering

Defined in Data.Singletons.Prelude.Show

Associated Types

type ShowsPrec arg arg1 arg2 :: Symbol

type Show_ arg :: Symbol

type ShowList arg arg1 :: Symbol

SShow Ordering

Defined in Data.Singletons.Prelude.Show

Methods

sShowsPrec :: Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3)

sShow_ :: Sing t -> Sing (Apply Show_Sym0 t)

sShowList :: Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2)

ShowSing Ordering

Defined in Data.Singletons.ShowSing

Methods

showsSingPrec :: Int -> Sing a -> ShowS

() :=> (Bounded Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Ordering

() :=> (Enum Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Enum Ordering

() :=> (Read Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Read Ordering

() :=> (Show Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Show Ordering

() :=> (Semigroup Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Semigroup Ordering

() :=> (Monoid Ordering)

Defined in Data.Constraint

Methods

ins :: () :- Monoid Ordering

SuppressUnusedWarnings Compare_6989586621679554746Sym1

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ThenCmpSym1

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554766Sym1

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ShowsPrec_6989586621679891258Sym2

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ShowsPrec_6989586621679891258Sym1

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554786Sym1

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554363Sym1

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554746Sym0

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ThenCmpSym0

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554766Sym0

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings FromEnum_6989586621680024225Sym0

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ShowsPrec_6989586621679891258Sym0

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings ToEnum_6989586621680024215Sym0

Defined in Data.Singletons.Prelude.Enum

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554786Sym0

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings Compare_6989586621679554363Sym0

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (SortBySym1 :: (TyFun a6989586621679684436 (TyFun a6989586621679684436 Ordering -> Type) -> Type) -> TyFun [a6989586621679684436] [a6989586621679684436] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (MinimumBySym1 :: (TyFun a6989586621679684433 (TyFun a6989586621679684433 Ordering -> Type) -> Type) -> TyFun [a6989586621679684433] a6989586621679684433 -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (MaximumBySym1 :: (TyFun a6989586621679684434 (TyFun a6989586621679684434 Ordering -> Type) -> Type) -> TyFun [a6989586621679684434] a6989586621679684434 -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (InsertBySym2 :: (TyFun a6989586621679684435 (TyFun a6989586621679684435 Ordering -> Type) -> Type) -> a6989586621679684435 -> TyFun [a6989586621679684435] [a6989586621679684435] -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (InsertBySym1 :: (TyFun a6989586621679684435 (TyFun a6989586621679684435 Ordering -> Type) -> Type) -> TyFun a6989586621679684435 (TyFun [a6989586621679684435] [a6989586621679684435] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554262Sym1 :: [a3530822107858468865] -> TyFun [a3530822107858468865] Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554226Sym1 :: Maybe a3530822107858468865 -> TyFun (Maybe a3530822107858468865) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547269Scrutinee_6989586621679545943Sym1 :: k1 -> TyFun k1 Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547236Scrutinee_6989586621679545941Sym1 :: k1 -> TyFun k1 Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547203Scrutinee_6989586621679545939Sym1 :: k1 -> TyFun k1 Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547170Scrutinee_6989586621679545937Sym1 :: k1 -> TyFun k1 Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679547150Sym1 :: a6989586621679545915 -> TyFun a6989586621679545915 Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (CompareSym1 :: a6989586621679545915 -> TyFun a6989586621679545915 Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554339Sym1 :: NonEmpty a6989586621679060091 -> TyFun (NonEmpty a6989586621679060091) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (SortBySym0 :: TyFun (TyFun a6989586621679684436 (TyFun a6989586621679684436 Ordering -> Type) -> Type) (TyFun [a6989586621679684436] [a6989586621679684436] -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (MinimumBySym0 :: TyFun (TyFun a6989586621679684433 (TyFun a6989586621679684433 Ordering -> Type) -> Type) (TyFun [a6989586621679684433] a6989586621679684433 -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (MaximumBySym0 :: TyFun (TyFun a6989586621679684434 (TyFun a6989586621679684434 Ordering -> Type) -> Type) (TyFun [a6989586621679684434] a6989586621679684434 -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (InsertBySym0 :: TyFun (TyFun a6989586621679684435 (TyFun a6989586621679684435 Ordering -> Type) -> Type) (TyFun a6989586621679684435 (TyFun [a6989586621679684435] [a6989586621679684435] -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554262Sym0 :: TyFun [a3530822107858468865] (TyFun [a3530822107858468865] Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554226Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547269Scrutinee_6989586621679545943Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547236Scrutinee_6989586621679545941Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547203Scrutinee_6989586621679545939Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679547170Scrutinee_6989586621679545937Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679547150Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (CompareSym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554339Sym0 :: TyFun (NonEmpty a6989586621679060091) (TyFun (NonEmpty a6989586621679060091) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ComparingSym2 :: (TyFun b6989586621679545905 a6989586621679545904 -> Type) -> b6989586621679545905 -> TyFun b6989586621679545905 Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ComparingSym1 :: (TyFun b6989586621679545905 a6989586621679545904 -> Type) -> TyFun b6989586621679545905 (TyFun b6989586621679545905 Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554302Sym1 :: Either a6989586621679081283 b6989586621679081284 -> TyFun (Either a6989586621679081283 b6989586621679081284) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554397Sym1 :: (a3530822107858468865, b3530822107858468866) -> TyFun (a3530822107858468865, b3530822107858468866) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ComparingSym0 :: TyFun (TyFun b6989586621679545905 a6989586621679545904 -> Type) (TyFun b6989586621679545905 (TyFun b6989586621679545905 Ordering -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554302Sym0 :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun (Either a6989586621679081283 b6989586621679081284) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554397Sym0 :: TyFun (a3530822107858468865, b3530822107858468866) (TyFun (a3530822107858468865, b3530822107858468866) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554442Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554442Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695921MinBySym0 :: TyFun (k3 ~> (k3 ~> Ordering)) (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k3 k3 -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695837MaxBySym0 :: TyFun (k3 ~> (k3 ~> Ordering)) (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k3 k3 -> *) -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695921MinBySym4 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> k2 -> k3 -> TyFun k3 k3 -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695921MinBySym3 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> k2 -> TyFun k3 (TyFun k3 k3 -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695921MinBySym2 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> TyFun k2 (TyFun k3 (TyFun k3 k3 -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695921MinBySym1 :: (k3 ~> (k3 ~> Ordering)) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k3 k3 -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695837MaxBySym4 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> k2 -> k3 -> TyFun k3 k3 -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695837MaxBySym3 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> k2 -> TyFun k3 (TyFun k3 k3 -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695837MaxBySym2 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> TyFun k2 (TyFun k3 (TyFun k3 k3 -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Let6989586621679695837MaxBySym1 :: (k3 ~> (k3 ~> Ordering)) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k3 k3 -> *) -> *) -> *) -> *)

Defined in Data.Singletons.Prelude.List

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554496Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554496Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554559Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554559Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554631Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554631Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554712Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554712Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

type Rep Ordering

Defined in GHC.Generics

type Rep Ordering = D1 (MetaData "Ordering" "GHC.Types" "ghc-prim" False) (C1 (MetaCons "LT" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "EQ" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "GT" PrefixI False) (U1 :: * -> *)))

data Sing (z :: Ordering)

Defined in Data.Singletons.Prelude.Instances

data Sing (z :: Ordering) where

• SLT :: Sing LT
• SEQ :: Sing EQ
• SGT :: Sing GT

type Demote Ordering

Defined in Data.Singletons.Prelude.Instances

type Demote Ordering = Ordering

type MaxBound

Defined in Data.Singletons.Prelude.Enum

type MaxBound = MaxBound_6989586621680001127Sym0

type MinBound

Defined in Data.Singletons.Prelude.Enum

type MinBound = MinBound_6989586621680001125Sym0

type FromEnum (a :: Ordering)

Defined in Data.Singletons.Prelude.Enum

type FromEnum (a :: Ordering) = Apply FromEnum_6989586621680024225Sym0 a

type ToEnum a

Defined in Data.Singletons.Prelude.Enum

type ToEnum a = Apply ToEnum_6989586621680024215Sym0 a

type Show_ (arg :: Ordering)

Defined in Data.Singletons.Prelude.Show

type Show_ (arg :: Ordering) = Apply (Show__6989586621679875032Sym0 :: TyFun Ordering Symbol -> *) arg

type Pred (arg :: Ordering)

Defined in Data.Singletons.Prelude.Enum

type Pred (arg :: Ordering) = Apply (Pred_6989586621680005652Sym0 :: TyFun Ordering Ordering -> *) arg

type Succ (arg :: Ordering)

Defined in Data.Singletons.Prelude.Enum

type Succ (arg :: Ordering) = Apply (Succ_6989586621680005639Sym0 :: TyFun Ordering Ordering -> *) arg

type EnumFromTo (arg1 :: Ordering) (arg2 :: Ordering)

Defined in Data.Singletons.Prelude.Enum

type EnumFromTo (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (EnumFromTo_6989586621680005670Sym0 :: TyFun Ordering (TyFun Ordering [Ordering] -> Type) -> *) arg1) arg2

type (x :: Ordering) /= (y :: Ordering)

Defined in Data.Singletons.Prelude.Eq

type (x :: Ordering) /= (y :: Ordering) = Not (x == y)

type (a :: Ordering) == (b :: Ordering)

Defined in Data.Singletons.Prelude.Eq

type (a :: Ordering) == (b :: Ordering) = Equals_6989586621679536022 a b

type (arg1 :: Ordering) < (arg2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Ordering) < (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679547183Sym0 :: TyFun Ordering (TyFun Ordering Bool -> Type) -> *) arg1) arg2

type (arg1 :: Ordering) <= (arg2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Ordering) <= (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679547216Sym0 :: TyFun Ordering (TyFun Ordering Bool -> Type) -> *) arg1) arg2

type (arg1 :: Ordering) > (arg2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Ordering) > (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679547249Sym0 :: TyFun Ordering (TyFun Ordering Bool -> Type) -> *) arg1) arg2

type (arg1 :: Ordering) >= (arg2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Ordering) >= (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679547282Sym0 :: TyFun Ordering (TyFun Ordering Bool -> Type) -> *) arg1) arg2

type Compare (a1 :: Ordering) (a2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type Compare (a1 :: Ordering) (a2 :: Ordering) = Apply (Apply Compare_6989586621679554766Sym0 a1) a2

type Max (arg1 :: Ordering) (arg2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type Max (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (Max_6989586621679547315Sym0 :: TyFun Ordering (TyFun Ordering Ordering -> Type) -> *) arg1) arg2

type Min (arg1 :: Ordering) (arg2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type Min (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (Min_6989586621679547348Sym0 :: TyFun Ordering (TyFun Ordering Ordering -> Type) -> *) arg1) arg2

type ShowList (arg1 :: [Ordering]) arg2

Defined in Data.Singletons.Prelude.Show

type ShowList (arg1 :: [Ordering]) arg2 = Apply (Apply (ShowList_6989586621679875050Sym0 :: TyFun [Ordering] (TyFun Symbol Symbol -> Type) -> *) arg1) arg2

type Apply FromEnum_6989586621680024225Sym0 (l :: Ordering)

Defined in Data.Singletons.Prelude.Enum

type Apply FromEnum_6989586621680024225Sym0 (l :: Ordering) = FromEnum_6989586621680024225 l

type Apply ToEnum_6989586621680024215Sym0 (l :: Nat)

Defined in Data.Singletons.Prelude.Enum

type Apply ToEnum_6989586621680024215Sym0 (l :: Nat) = ToEnum_6989586621680024215 l

type EnumFromThenTo (arg1 :: Ordering) (arg2 :: Ordering) (arg3 :: Ordering)

Defined in Data.Singletons.Prelude.Enum

type EnumFromThenTo (arg1 :: Ordering) (arg2 :: Ordering) (arg3 :: Ordering) = Apply (Apply (Apply (EnumFromThenTo_6989586621680005700Sym0 :: TyFun Ordering (TyFun Ordering (TyFun Ordering [Ordering] -> Type) -> Type) -> *) arg1) arg2) arg3

type ShowsPrec a1 (a2 :: Ordering) a3

Defined in Data.Singletons.Prelude.Show

type ShowsPrec a1 (a2 :: Ordering) a3 = Apply (Apply (Apply ShowsPrec_6989586621679891258Sym0 a1) a2) a3

type Apply (Compare_6989586621679554746Sym1 l1 :: TyFun Bool Ordering -> *) (l2 :: Bool)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554746Sym1 l1 :: TyFun Bool Ordering -> *) (l2 :: Bool) = Compare_6989586621679554746 l1 l2

type Apply (ThenCmpSym1 l1 :: TyFun Ordering Ordering -> *) (l2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type Apply (ThenCmpSym1 l1 :: TyFun Ordering Ordering -> *) (l2 :: Ordering) = ThenCmp l1 l2

type Apply (Compare_6989586621679554766Sym1 l1 :: TyFun Ordering Ordering -> *) (l2 :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554766Sym1 l1 :: TyFun Ordering Ordering -> *) (l2 :: Ordering) = Compare_6989586621679554766 l1 l2

type Apply (Compare_6989586621679554786Sym1 l1 :: TyFun () Ordering -> *) (l2 :: ())

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554786Sym1 l1 :: TyFun () Ordering -> *) (l2 :: ()) = Compare_6989586621679554786 l1 l2

type Apply (Compare_6989586621679554363Sym1 l1 :: TyFun Void Ordering -> *) (l2 :: Void)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554363Sym1 l1 :: TyFun Void Ordering -> *) (l2 :: Void) = Compare_6989586621679554363 l1 l2

type Apply (Compare_6989586621679547150Sym1 l1 :: TyFun a Ordering -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679547150Sym1 l1 :: TyFun a Ordering -> *) (l2 :: a) = Compare_6989586621679547150 l1 l2

type Apply (CompareSym1 l1 :: TyFun a Ordering -> *) (l2 :: a)

Defined in Data.Singletons.Prelude.Ord

type Apply (CompareSym1 l1 :: TyFun a Ordering -> *) (l2 :: a) = Compare l1 l2

type Apply (Let6989586621679547269Scrutinee_6989586621679545943Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547269Scrutinee_6989586621679545943Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1) = Let6989586621679547269Scrutinee_6989586621679545943 l1 l2

type Apply (Let6989586621679547236Scrutinee_6989586621679545941Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547236Scrutinee_6989586621679545941Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1) = Let6989586621679547236Scrutinee_6989586621679545941 l1 l2

type Apply (Let6989586621679547203Scrutinee_6989586621679545939Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547203Scrutinee_6989586621679545939Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1) = Let6989586621679547203Scrutinee_6989586621679545939 l1 l2

type Apply (Let6989586621679547170Scrutinee_6989586621679545937Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547170Scrutinee_6989586621679545937Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1) = Let6989586621679547170Scrutinee_6989586621679545937 l1 l2

type Apply (ComparingSym2 l1 l2 :: TyFun b Ordering -> *) (l3 :: b)

Defined in Data.Singletons.Prelude.Ord

type Apply (ComparingSym2 l1 l2 :: TyFun b Ordering -> *) (l3 :: b) = Comparing l1 l2 l3

type Apply Compare_6989586621679554746Sym0 (l :: Bool)

Defined in Data.Singletons.Prelude.Ord

type Apply Compare_6989586621679554746Sym0 (l :: Bool) = Compare_6989586621679554746Sym1 l

type Apply ThenCmpSym0 (l :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type Apply ThenCmpSym0 (l :: Ordering) = ThenCmpSym1 l

type Apply Compare_6989586621679554766Sym0 (l :: Ordering)

Defined in Data.Singletons.Prelude.Ord

type Apply Compare_6989586621679554766Sym0 (l :: Ordering) = Compare_6989586621679554766Sym1 l

type Apply ShowsPrec_6989586621679891258Sym0 (l :: Nat)

Defined in Data.Singletons.Prelude.Show

type Apply ShowsPrec_6989586621679891258Sym0 (l :: Nat) = ShowsPrec_6989586621679891258Sym1 l

type Apply Compare_6989586621679554786Sym0 (l :: ())

Defined in Data.Singletons.Prelude.Ord

type Apply Compare_6989586621679554786Sym0 (l :: ()) = Compare_6989586621679554786Sym1 l

type Apply Compare_6989586621679554363Sym0 (l :: Void)

Defined in Data.Singletons.Prelude.Ord

type Apply Compare_6989586621679554363Sym0 (l :: Void) = Compare_6989586621679554363Sym1 l

type Apply (ShowsPrec_6989586621679891258Sym1 l1 :: TyFun Ordering (TyFun Symbol Symbol -> Type) -> *) (l2 :: Ordering)

Defined in Data.Singletons.Prelude.Show

type Apply (ShowsPrec_6989586621679891258Sym1 l1 :: TyFun Ordering (TyFun Symbol Symbol -> Type) -> *) (l2 :: Ordering) = ShowsPrec_6989586621679891258Sym2 l1 l2

type Apply (Compare_6989586621679547150Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Ordering -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679547150Sym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Ordering -> Type) -> *) (l :: a6989586621679545915) = Compare_6989586621679547150Sym1 l

type Apply (CompareSym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Ordering -> Type) -> *) (l :: a6989586621679545915)

Defined in Data.Singletons.Prelude.Ord

type Apply (CompareSym0 :: TyFun a6989586621679545915 (TyFun a6989586621679545915 Ordering -> Type) -> *) (l :: a6989586621679545915) = CompareSym1 l

type Apply (Let6989586621679547269Scrutinee_6989586621679545943Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547269Scrutinee_6989586621679545943Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *) (l :: k1) = Let6989586621679547269Scrutinee_6989586621679545943Sym1 l

type Apply (Let6989586621679547236Scrutinee_6989586621679545941Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547236Scrutinee_6989586621679545941Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *) (l :: k1) = Let6989586621679547236Scrutinee_6989586621679545941Sym1 l

type Apply (Let6989586621679547203Scrutinee_6989586621679545939Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547203Scrutinee_6989586621679545939Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *) (l :: k1) = Let6989586621679547203Scrutinee_6989586621679545939Sym1 l

type Apply (Let6989586621679547170Scrutinee_6989586621679545937Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *) (l :: k1)

Defined in Data.Singletons.Prelude.Ord

type Apply (Let6989586621679547170Scrutinee_6989586621679545937Sym0 :: TyFun k1 (TyFun k1 Ordering -> *) -> *) (l :: k1) = Let6989586621679547170Scrutinee_6989586621679545937Sym1 l

type Apply (ComparingSym1 l1 :: TyFun b6989586621679545905 (TyFun b6989586621679545905 Ordering -> Type) -> *) (l2 :: b6989586621679545905)

Defined in Data.Singletons.Prelude.Ord

type Apply (ComparingSym1 l1 :: TyFun b6989586621679545905 (TyFun b6989586621679545905 Ordering -> Type) -> *) (l2 :: b6989586621679545905) = ComparingSym2 l1 l2

type Apply (Compare_6989586621679554262Sym1 l1 :: TyFun [a] Ordering -> *) (l2 :: [a])

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554262Sym1 l1 :: TyFun [a] Ordering -> *) (l2 :: [a]) = Compare_6989586621679554262 l1 l2

type Apply (Compare_6989586621679554226Sym1 l1 :: TyFun (Maybe a) Ordering -> *) (l2 :: Maybe a)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554226Sym1 l1 :: TyFun (Maybe a) Ordering -> *) (l2 :: Maybe a) = Compare_6989586621679554226 l1 l2

type Apply (Compare_6989586621679554339Sym1 l1 :: TyFun (NonEmpty a) Ordering -> *) (l2 :: NonEmpty a)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554339Sym1 l1 :: TyFun (NonEmpty a) Ordering -> *) (l2 :: NonEmpty a) = Compare_6989586621679554339 l1 l2

type Apply (Compare_6989586621679554262Sym0 :: TyFun [a3530822107858468865] (TyFun [a3530822107858468865] Ordering -> Type) -> *) (l :: [a3530822107858468865])

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554262Sym0 :: TyFun [a3530822107858468865] (TyFun [a3530822107858468865] Ordering -> Type) -> *) (l :: [a3530822107858468865]) = Compare_6989586621679554262Sym1 l

type Apply (Compare_6989586621679554226Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *) (l :: Maybe a3530822107858468865)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554226Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *) (l :: Maybe a3530822107858468865) = Compare_6989586621679554226Sym1 l

type Apply (Compare_6989586621679554339Sym0 :: TyFun (NonEmpty a6989586621679060091) (TyFun (NonEmpty a6989586621679060091) Ordering -> Type) -> *) (l :: NonEmpty a6989586621679060091)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554339Sym0 :: TyFun (NonEmpty a6989586621679060091) (TyFun (NonEmpty a6989586621679060091) Ordering -> Type) -> *) (l :: NonEmpty a6989586621679060091) = Compare_6989586621679554339Sym1 l

type Apply (Compare_6989586621679554302Sym1 l1 :: TyFun (Either a b) Ordering -> *) (l2 :: Either a b)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554302Sym1 l1 :: TyFun (Either a b) Ordering -> *) (l2 :: Either a b) = Compare_6989586621679554302 l1 l2

type Apply (Compare_6989586621679554397Sym1 l1 :: TyFun (a, b) Ordering -> *) (l2 :: (a, b))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554397Sym1 l1 :: TyFun (a, b) Ordering -> *) (l2 :: (a, b)) = Compare_6989586621679554397 l1 l2

type Apply (InsertBySym0 :: TyFun (TyFun a6989586621679684435 (TyFun a6989586621679684435 Ordering -> Type) -> Type) (TyFun a6989586621679684435 (TyFun [a6989586621679684435] [a6989586621679684435] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684435 (TyFun a6989586621679684435 Ordering -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (InsertBySym0 :: TyFun (TyFun a6989586621679684435 (TyFun a6989586621679684435 Ordering -> Type) -> Type) (TyFun a6989586621679684435 (TyFun [a6989586621679684435] [a6989586621679684435] -> Type) -> Type) -> *) (l :: TyFun a6989586621679684435 (TyFun a6989586621679684435 Ordering -> Type) -> Type) = InsertBySym1 l

type Apply (SortBySym0 :: TyFun (TyFun a6989586621679684436 (TyFun a6989586621679684436 Ordering -> Type) -> Type) (TyFun [a6989586621679684436] [a6989586621679684436] -> Type) -> *) (l :: TyFun a6989586621679684436 (TyFun a6989586621679684436 Ordering -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (SortBySym0 :: TyFun (TyFun a6989586621679684436 (TyFun a6989586621679684436 Ordering -> Type) -> Type) (TyFun [a6989586621679684436] [a6989586621679684436] -> Type) -> *) (l :: TyFun a6989586621679684436 (TyFun a6989586621679684436 Ordering -> Type) -> Type) = SortBySym1 l

type Apply (MaximumBySym0 :: TyFun (TyFun a6989586621679684434 (TyFun a6989586621679684434 Ordering -> Type) -> Type) (TyFun [a6989586621679684434] a6989586621679684434 -> Type) -> *) (l :: TyFun a6989586621679684434 (TyFun a6989586621679684434 Ordering -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (MaximumBySym0 :: TyFun (TyFun a6989586621679684434 (TyFun a6989586621679684434 Ordering -> Type) -> Type) (TyFun [a6989586621679684434] a6989586621679684434 -> Type) -> *) (l :: TyFun a6989586621679684434 (TyFun a6989586621679684434 Ordering -> Type) -> Type) = MaximumBySym1 l

type Apply (MinimumBySym0 :: TyFun (TyFun a6989586621679684433 (TyFun a6989586621679684433 Ordering -> Type) -> Type) (TyFun [a6989586621679684433] a6989586621679684433 -> Type) -> *) (l :: TyFun a6989586621679684433 (TyFun a6989586621679684433 Ordering -> Type) -> Type)

Defined in Data.Singletons.Prelude.List

type Apply (MinimumBySym0 :: TyFun (TyFun a6989586621679684433 (TyFun a6989586621679684433 Ordering -> Type) -> Type) (TyFun [a6989586621679684433] a6989586621679684433 -> Type) -> *) (l :: TyFun a6989586621679684433 (TyFun a6989586621679684433 Ordering -> Type) -> Type) = MinimumBySym1 l

type Apply (ComparingSym0 :: TyFun (TyFun b6989586621679545905 a6989586621679545904 -> Type) (TyFun b6989586621679545905 (TyFun b6989586621679545905 Ordering -> Type) -> Type) -> *) (l :: TyFun b6989586621679545905 a6989586621679545904 -> Type)

Defined in Data.Singletons.Prelude.Ord

type Apply (ComparingSym0 :: TyFun (TyFun b6989586621679545905 a6989586621679545904 -> Type) (TyFun b6989586621679545905 (TyFun b6989586621679545905 Ordering -> Type) -> Type) -> *) (l :: TyFun b6989586621679545905 a6989586621679545904 -> Type) = ComparingSym1 l

type Apply (Compare_6989586621679554302Sym0 :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun (Either a6989586621679081283 b6989586621679081284) Ordering -> Type) -> *) (l :: Either a6989586621679081283 b6989586621679081284)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554302Sym0 :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun (Either a6989586621679081283 b6989586621679081284) Ordering -> Type) -> *) (l :: Either a6989586621679081283 b6989586621679081284) = Compare_6989586621679554302Sym1 l

type Apply (Compare_6989586621679554397Sym0 :: TyFun (a3530822107858468865, b3530822107858468866) (TyFun (a3530822107858468865, b3530822107858468866) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554397Sym0 :: TyFun (a3530822107858468865, b3530822107858468866) (TyFun (a3530822107858468865, b3530822107858468866) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866)) = Compare_6989586621679554397Sym1 l

type Apply (Let6989586621679695837MaxBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> *) -> *) -> *) -> *) -> *) (l :: k1 ~> (k1 ~> Ordering))

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679695837MaxBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> *) -> *) -> *) -> *) -> *) (l :: k1 ~> (k1 ~> Ordering)) = (Let6989586621679695837MaxBySym1 l :: TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> *) -> *) -> *) -> *)

type Apply (Let6989586621679695921MinBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> *) -> *) -> *) -> *) -> *) (l :: k1 ~> (k1 ~> Ordering))

Defined in Data.Singletons.Prelude.List

type Apply (Let6989586621679695921MinBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> *) -> *) -> *) -> *) -> *) (l :: k1 ~> (k1 ~> Ordering)) = (Let6989586621679695921MinBySym1 l :: TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> *) -> *) -> *) -> *)

type Apply (Compare_6989586621679554442Sym1 l1 :: TyFun (a, b, c) Ordering -> *) (l2 :: (a, b, c))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554442Sym1 l1 :: TyFun (a, b, c) Ordering -> *) (l2 :: (a, b, c)) = Compare_6989586621679554442 l1 l2

type Apply (Compare_6989586621679554442Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554442Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867)) = Compare_6989586621679554442Sym1 l

type Apply (Compare_6989586621679554496Sym1 l1 :: TyFun (a, b, c, d) Ordering -> *) (l2 :: (a, b, c, d))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554496Sym1 l1 :: TyFun (a, b, c, d) Ordering -> *) (l2 :: (a, b, c, d)) = Compare_6989586621679554496 l1 l2

type Apply (Compare_6989586621679554496Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554496Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868)) = Compare_6989586621679554496Sym1 l

type Apply (Compare_6989586621679554559Sym1 l1 :: TyFun (a, b, c, d, e) Ordering -> *) (l2 :: (a, b, c, d, e))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554559Sym1 l1 :: TyFun (a, b, c, d, e) Ordering -> *) (l2 :: (a, b, c, d, e)) = Compare_6989586621679554559 l1 l2

type Apply (Compare_6989586621679554559Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554559Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869)) = Compare_6989586621679554559Sym1 l

type Apply (Compare_6989586621679554631Sym1 l1 :: TyFun (a, b, c, d, e, f) Ordering -> *) (l2 :: (a, b, c, d, e, f))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554631Sym1 l1 :: TyFun (a, b, c, d, e, f) Ordering -> *) (l2 :: (a, b, c, d, e, f)) = Compare_6989586621679554631 l1 l2

type Apply (Compare_6989586621679554631Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554631Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870)) = Compare_6989586621679554631Sym1 l

type Apply (Compare_6989586621679554712Sym1 l1 :: TyFun (a, b, c, d, e, f, g) Ordering -> *) (l2 :: (a, b, c, d, e, f, g))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554712Sym1 l1 :: TyFun (a, b, c, d, e, f, g) Ordering -> *) (l2 :: (a, b, c, d, e, f, g)) = Compare_6989586621679554712 l1 l2

type Apply (Compare_6989586621679554712Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871))

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554712Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871)) = Compare_6989586621679554712Sym1 l

type Rational = Ratio Integer

Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.

data IO a

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Instances

Monad IO

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b

(>>) :: IO a -> IO b -> IO b

return :: a -> IO a

fail :: String -> IO a

Functor IO

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> IO a -> IO b

(<$) :: a -> IO b -> IO a

Applicative IO

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> IO a

(<*>) :: IO (a -> b) -> IO a -> IO b

liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c

(*>) :: IO a -> IO b -> IO b

(<*) :: IO a -> IO b -> IO a

Alternative IO

Since: base-4.9.0.0

Defined in GHC.Base

Methods

empty :: IO a

(<|>) :: IO a -> IO a -> IO a

some :: IO a -> IO [a]

many :: IO a -> IO [a]

MonadPlus IO

Since: base-4.9.0.0

Defined in GHC.Base

Methods

mzero :: IO a

mplus :: IO a -> IO a -> IO a

Quasi IO

Defined in Language.Haskell.TH.Syntax

Methods

qNewName :: String -> IO Name

qReport :: Bool -> String -> IO ()

qRecover :: IO a -> IO a -> IO a

qLookupName :: Bool -> String -> IO (Maybe Name)

qReify :: Name -> IO Info

qReifyFixity :: Name -> IO (Maybe Fixity)

qReifyInstances :: Name -> [Type] -> IO [Dec]

qReifyRoles :: Name -> IO [Role]

qReifyAnnotations :: Data a => AnnLookup -> IO [a]

qReifyModule :: Module -> IO ModuleInfo

qReifyConStrictness :: Name -> IO [DecidedStrictness]

qLocation :: IO Loc

qRunIO :: IO a -> IO a

qAddDependentFile :: FilePath -> IO ()

qAddTopDecls :: [Dec] -> IO ()

qAddForeignFile :: ForeignSrcLang -> String -> IO ()

qAddModFinalizer :: Q () -> IO ()

qAddCorePlugin :: String -> IO ()

qGetQ :: Typeable a => IO (Maybe a)

qPutQ :: Typeable a => a -> IO ()

qIsExtEnabled :: Extension -> IO Bool

qExtsEnabled :: IO [Extension]

PrimMonad IO

Defined in Control.Monad.Primitive

Associated Types

type PrimState IO :: *

Methods

primitive :: (State# (PrimState IO) -> (#State# (PrimState IO), a#)) -> IO a

PrimBase IO

Defined in Control.Monad.Primitive

Methods

internal :: IO a -> State# (PrimState IO) -> (#State# (PrimState IO), a#)

() :=> (Monad IO)

Defined in Data.Constraint

Methods

ins :: () :- Monad IO

() :=> (Functor IO)

Defined in Data.Constraint

Methods

ins :: () :- Functor IO

() :=> (Applicative IO)

Defined in Data.Constraint

Methods

ins :: () :- Applicative IO

Semigroup a => Semigroup (IO a)

Since: base-4.10.0.0

Defined in GHC.Base

Methods

(<>) :: IO a -> IO a -> IO a

sconcat :: NonEmpty (IO a) -> IO a

stimes :: Integral b => b -> IO a -> IO a

Monoid a => Monoid (IO a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

mempty :: IO a

mappend :: IO a -> IO a -> IO a

mconcat :: [IO a] -> IO a

Default a => Default (IO a)

Defined in Data.Default.Class

Methods

def :: IO a

(Semigroup a) :=> (Semigroup (IO a))

Defined in Data.Constraint

Methods

ins :: Semigroup a :- Semigroup (IO a)

(Monoid a) :=> (Monoid (IO a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Monoid (IO a)

type PrimState IO

Defined in Control.Monad.Primitive

type PrimState IO = RealWorld

data Word

A Word is an unsigned integral type, with the same size as Int.

Instances

Bounded Word

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Word

maxBound :: Word

Enum Word

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Word -> Word

pred :: Word -> Word

toEnum :: Int -> Word

fromEnum :: Word -> Int

enumFrom :: Word -> [Word]

enumFromThen :: Word -> Word -> [Word]

enumFromTo :: Word -> Word -> [Word]

enumFromThenTo :: Word -> Word -> Word -> [Word]

Eq Word

Defined in GHC.Classes

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Integral Word

Since: base-2.1

Defined in GHC.Real

Methods

quot :: Word -> Word -> Word

rem :: Word -> Word -> Word

div :: Word -> Word -> Word

mod :: Word -> Word -> Word

quotRem :: Word -> Word -> (Word, Word)

divMod :: Word -> Word -> (Word, Word)

toInteger :: Word -> Integer

Data Word

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word

toConstr :: Word -> Constr

dataTypeOf :: Word -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word)

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

gmapT :: (forall b. Data b => b -> b) -> Word -> Word

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word

Num Word

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Word -> Word -> Word

(-) :: Word -> Word -> Word

(*) :: Word -> Word -> Word

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Ord Word

Defined in GHC.Classes

Methods

compare :: Word -> Word -> Ordering

(<) :: Word -> Word -> Bool

(<=) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(>=) :: Word -> Word -> Bool

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Read Word

Since: base-4.5.0.0

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Real Word

Since: base-2.1

Defined in GHC.Real

Methods

toRational :: Word -> Rational

Show Word

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Ix Word

Since: base-4.6.0.0

Defined in GHC.Arr

Methods

range :: (Word, Word) -> [Word]

index :: (Word, Word) -> Word -> Int

unsafeIndex :: (Word, Word) -> Word -> Int

inRange :: (Word, Word) -> Word -> Bool

rangeSize :: (Word, Word) -> Int

unsafeRangeSize :: (Word, Word) -> Int

Lift Word

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Word -> Q Exp

Storable Word

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Word -> Int

alignment :: Word -> Int

peekElemOff :: Ptr Word -> Int -> IO Word

pokeElemOff :: Ptr Word -> Int -> Word -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word

pokeByteOff :: Ptr b -> Int -> Word -> IO ()

peek :: Ptr Word -> IO Word

poke :: Ptr Word -> Word -> IO ()

Bits Word

Since: base-2.1

Defined in Data.Bits

Methods

(.&.) :: Word -> Word -> Word

(.|.) :: Word -> Word -> Word

xor :: Word -> Word -> Word

complement :: Word -> Word

shift :: Word -> Int -> Word

rotate :: Word -> Int -> Word

zeroBits :: Word

bit :: Int -> Word

setBit :: Word -> Int -> Word

clearBit :: Word -> Int -> Word

complementBit :: Word -> Int -> Word

testBit :: Word -> Int -> Bool

bitSizeMaybe :: Word -> Maybe Int

bitSize :: Word -> Int

isSigned :: Word -> Bool

shiftL :: Word -> Int -> Word

unsafeShiftL :: Word -> Int -> Word

shiftR :: Word -> Int -> Word

unsafeShiftR :: Word -> Int -> Word

rotateL :: Word -> Int -> Word

rotateR :: Word -> Int -> Word

popCount :: Word -> Int

FiniteBits Word

Since: base-4.6.0.0

Defined in Data.Bits

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

NFData Word

Defined in Control.DeepSeq

Methods

rnf :: Word -> ()

ShowX Word

Defined in Clash.XException

Methods

showsPrecX :: Int -> Word -> ShowS

showX :: Word -> String

showListX :: [Word] -> ShowS

Default Word

Defined in Data.Default.Class

Methods

def :: Word

Arbitrary Word

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word

shrink :: Word -> [Word]

CoArbitrary Word

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Word -> Gen b -> Gen b

Unbox Word

Defined in Data.Vector.Unboxed.Base

Prim Word

Defined in Data.Primitive.Types

Methods

sizeOf# :: Word -> Int#

alignment# :: Word -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word#)

writeOffAddr# :: Addr# -> Int# -> Word -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Word -> State# s -> State# s

BitPack Word

Defined in Clash.Class.BitPack

Associated Types

type BitSize Word :: Nat

Methods

pack :: Word -> BitVector (BitSize Word)

unpack :: BitVector (BitSize Word) -> Word

Vector Vector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word)

basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word)

basicLength :: Vector Word -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word

basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m ()

elemseq :: Vector Word -> Word -> b -> b

MVector MVector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word

basicOverlaps :: MVector s Word -> MVector s Word -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word)

basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Word -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word)

() :=> (Bounded Word)

Defined in Data.Constraint

Methods

ins :: () :- Bounded Word

() :=> (Enum Word)

Defined in Data.Constraint

Methods

ins :: () :- Enum Word

() :=> (Eq Word)

Defined in Data.Constraint

Methods

ins :: () :- Eq Word

() :=> (Integral Word)

Defined in Data.Constraint

Methods

ins :: () :- Integral Word

() :=> (Num Word)

Defined in Data.Constraint

Methods

ins :: () :- Num Word

() :=> (Ord Word)

Defined in Data.Constraint

Methods

ins :: () :- Ord Word

() :=> (Read Word)

Defined in Data.Constraint

Methods

ins :: () :- Read Word

() :=> (Real Word)

Defined in Data.Constraint

Methods

ins :: () :- Real Word

() :=> (Show Word)

Defined in Data.Constraint

Methods

ins :: () :- Show Word

() :=> (Bits Word)

Defined in Data.Constraint

Methods

ins :: () :- Bits Word

Generic1 (URec Word :: k -> *)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Word) :: k -> *

Methods

from1 :: URec Word a -> Rep1 (URec Word) a

to1 :: Rep1 (URec Word) a -> URec Word a

Functor (URec Word :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Foldable (URec Word :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Word m -> m

foldMap :: Monoid m => (a -> m) -> URec Word a -> m

foldr :: (a -> b -> b) -> b -> URec Word a -> b

foldr' :: (a -> b -> b) -> b -> URec Word a -> b

foldl :: (b -> a -> b) -> b -> URec Word a -> b

foldl' :: (b -> a -> b) -> b -> URec Word a -> b

foldr1 :: (a -> a -> a) -> URec Word a -> a

foldl1 :: (a -> a -> a) -> URec Word a -> a

toList :: URec Word a -> [a]

null :: URec Word a -> Bool

length :: URec Word a -> Int

elem :: Eq a => a -> URec Word a -> Bool

maximum :: Ord a => URec Word a -> a

minimum :: Ord a => URec Word a -> a

sum :: Num a => URec Word a -> a

product :: Num a => URec Word a -> a

Traversable (URec Word :: * -> *)

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b)

sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a)

mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b)

sequence :: Monad m => URec Word (m a) -> m (URec Word a)

Eq (URec Word p)

Defined in GHC.Generics

Methods

(==) :: URec Word p -> URec Word p -> Bool

(/=) :: URec Word p -> URec Word p -> Bool

Ord (URec Word p)

Defined in GHC.Generics

Methods

compare :: URec Word p -> URec Word p -> Ordering

(<) :: URec Word p -> URec Word p -> Bool

(<=) :: URec Word p -> URec Word p -> Bool

(>) :: URec Word p -> URec Word p -> Bool

(>=) :: URec Word p -> URec Word p -> Bool

max :: URec Word p -> URec Word p -> URec Word p

min :: URec Word p -> URec Word p -> URec Word p

Show (URec Word p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Word p -> ShowS

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

Generic (URec Word p)

Defined in GHC.Generics

Associated Types

type Rep (URec Word p) :: * -> *

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

data Vector Word

Defined in Data.Vector.Unboxed.Base

data Vector Word = V_Word (Vector Word)

type BitSize Word

Defined in Clash.Class.BitPack

type BitSize Word = 64

data URec Word (p :: k)

Used for marking occurrences of Word#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Word (p :: k) = UWord {

• uWord# :: Word#

}

data MVector s Word

Defined in Data.Vector.Unboxed.Base

data MVector s Word = MV_Word (MVector s Word)

type Rep1 (URec Word :: k -> *)

Defined in GHC.Generics

type Rep1 (URec Word :: k -> *) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord :: k -> *)))

type Rep (URec Word p)

Defined in GHC.Generics

type Rep (URec Word p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UWord" PrefixI True) (S1 (MetaSel (Just "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord :: * -> *)))

data Either a b

The Either type represents values with two possibilities: a value of type Either a b is either Left a or Right b.

The Either type is sometimes used to represent a value which is either correct or an error; by convention, the Left constructor is used to hold an error value and the Right constructor is used to hold a correct value (mnemonic: "right" also means "correct").

Examples

The type Either String Int is the type of values which can be either a String or an Int. The Left constructor can be used only on Strings, and the Right constructor can be used only on Ints:

>>> let s = Left "foo" :: Either String Int
>>> s
Left "foo"
>>> let n = Right 3 :: Either String Int
>>> n
Right 3
>>> :type s
s :: Either String Int
>>> :type n
n :: Either String Int

The fmap from our Functor instance will ignore Left values, but will apply the supplied function to values contained in a Right:

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> fmap (*2) s
Left "foo"
>>> fmap (*2) n
Right 6

The Monad instance for Either allows us to chain together multiple actions which may fail, and fail overall if any of the individual steps failed. First we'll write a function that can either parse an Int from a Char, or fail.

>>> import Data.Char ( digitToInt, isDigit )
>>> :{
    let parseEither :: Char -> Either String Int
        parseEither c
          | isDigit c = Right (digitToInt c)
          | otherwise = Left "parse error"
>>> :}

The following should work, since both '1' and '2' can be parsed as Ints.

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither '1'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Right 3

But the following should fail overall, since the first operation where we attempt to parse 'm' as an Int will fail:

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither 'm'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Left "parse error"

Constructors

Left a

Right b

Instances

Bifoldable Either

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => Either m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Either a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Either a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Either a b -> c

Bifunctor Either

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d

first :: (a -> b) -> Either a c -> Either b c

second :: (b -> c) -> Either a b -> Either a c

Eq2 Either

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Either a c -> Either b d -> Bool

Ord2 Either

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Either a c -> Either b d -> Ordering

Read2 Either

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b)

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b]

liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b)

liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b]

Show2 Either

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Either a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Either a b] -> ShowS

NFData2 Either

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf2 :: (a -> ()) -> (b -> ()) -> Either a b -> ()

Swapped Either

Defined in Control.Lens.Iso

Methods

swapped :: (Profunctor p, Functor f) => p (Either b a) (f (Either d c)) -> p (Either a b) (f (Either c d))

Arbitrary2 Either

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary2 :: Gen a -> Gen b -> Gen (Either a b)

liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Either a b -> [Either a b]

Bitraversable1 Either

Defined in Data.Semigroup.Traversable.Class

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Either a c -> f (Either b d)

bisequence1 :: Apply f => Either (f a) (f b) -> f (Either a b)

() :=> (Monad (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Monad (Either a)

() :=> (Functor (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Either a)

() :=> (Applicative (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Applicative (Either a)

Monad (Either e)

Since: base-4.4.0.0

Defined in Data.Either

Methods

(>>=) :: Either e a -> (a -> Either e b) -> Either e b

(>>) :: Either e a -> Either e b -> Either e b

return :: a -> Either e a

fail :: String -> Either e a

Functor (Either a)

Since: base-3.0

Defined in Data.Either

Methods

fmap :: (a0 -> b) -> Either a a0 -> Either a b

(<$) :: a0 -> Either a b -> Either a a0

Applicative (Either e)

Since: base-3.0

Defined in Data.Either

Methods

pure :: a -> Either e a

(<*>) :: Either e (a -> b) -> Either e a -> Either e b

liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c

(*>) :: Either e a -> Either e b -> Either e b

(<*) :: Either e a -> Either e b -> Either e a

Foldable (Either a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Either a m -> m

foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0

toList :: Either a a0 -> [a0]

null :: Either a a0 -> Bool

length :: Either a a0 -> Int

elem :: Eq a0 => a0 -> Either a a0 -> Bool

maximum :: Ord a0 => Either a a0 -> a0

minimum :: Ord a0 => Either a a0 -> a0

sum :: Num a0 => Either a a0 -> a0

product :: Num a0 => Either a a0 -> a0

Traversable (Either a)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b)

sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0)

mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b)

sequence :: Monad m => Either a (m a0) -> m (Either a a0)

Eq a => Eq1 (Either a)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a0 -> b -> Bool) -> Either a a0 -> Either a b -> Bool

Ord a => Ord1 (Either a)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering

Read a => Read1 (Either a)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0)

liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0]

liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0)

liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0]

Show a => Show1 (Either a)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Either a a0 -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Either a a0] -> ShowS

NFData a => NFData1 (Either a)

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a0 -> ()) -> Either a a0 -> ()

Arbitrary a => Arbitrary1 (Either a)

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a0 -> Gen (Either a a0)

liftShrink :: (a0 -> [a0]) -> Either a a0 -> [Either a a0]

Generic1 (Either a :: * -> *)

Defined in GHC.Generics

Associated Types

type Rep1 (Either a) :: k -> *

Methods

from1 :: Either a a0 -> Rep1 (Either a) a0

to1 :: Rep1 (Either a) a0 -> Either a a0

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

Defined in Data.Either

Methods

(==) :: Either a b -> Either a b -> Bool

(/=) :: Either a b -> Either a b -> Bool

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

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b)

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b)

toConstr :: Either a b -> Constr

dataTypeOf :: Either a b -> DataType

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

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

gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r

gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b)

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

Defined in Data.Either

Methods

compare :: Either a b -> Either a b -> Ordering

(<) :: Either a b -> Either a b -> Bool

(<=) :: Either a b -> Either a b -> Bool

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

(>=) :: Either a b -> Either a b -> Bool

max :: Either a b -> Either a b -> Either a b

min :: Either a b -> Either a b -> Either a b

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

Defined in Data.Either

Methods

readsPrec :: Int -> ReadS (Either a b)

readList :: ReadS [Either a b]

readPrec :: ReadPrec (Either a b)

readListPrec :: ReadPrec [Either a b]

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

Defined in Data.Either

Methods

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

show :: Either a b -> String

showList :: [Either a b] -> ShowS

Generic (Either a b)

Defined in GHC.Generics

Associated Types

type Rep (Either a b) :: * -> *

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Semigroup (Either a b)

Since: base-4.9.0.0

Defined in Data.Either

Methods

(<>) :: Either a b -> Either a b -> Either a b

sconcat :: NonEmpty (Either a b) -> Either a b

stimes :: Integral b0 => b0 -> Either a b -> Either a b

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

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Either a b -> Q Exp

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

Defined in Control.DeepSeq

Methods

rnf :: Either a b -> ()

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

Defined in Clash.XException

Methods

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

showX :: Either a b -> String

showListX :: [Either a b] -> ShowS

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

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Either a b)

shrink :: Either a b -> [Either a b]

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

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Either a b -> Gen b0 -> Gen b0

PEq (Either a b)

Defined in Data.Singletons.Prelude.Eq

Associated Types

type x == y :: Bool

type x /= y :: Bool

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

Defined in Data.Singletons.Prelude.Eq

Methods

(%==) :: Sing a0 -> Sing b0 -> Sing (a0 == b0)

(%/=) :: Sing a0 -> Sing b0 -> Sing (a0 /= b0)

POrd (Either a b)

Defined in Data.Singletons.Prelude.Ord

Associated Types

type Compare arg arg1 :: Ordering

type arg < arg1 :: Bool

type arg <= arg1 :: Bool

type arg > arg1 :: Bool

type arg >= arg1 :: Bool

type Max arg arg1 :: a

type Min arg arg1 :: a

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

Defined in Data.Singletons.Prelude.Ord

Methods

sCompare :: Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2)

(%<) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2)

(%<=) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2)

(%>) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2)

(%>=) :: Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2)

sMax :: Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2)

sMin :: Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2)

PShow (Either a b)

Defined in Data.Singletons.Prelude.Show

Associated Types

type ShowsPrec arg arg1 arg2 :: Symbol

type Show_ arg :: Symbol

type ShowList arg arg1 :: Symbol

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

Defined in Data.Singletons.Prelude.Show

Methods

sShowsPrec :: Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3)

sShow_ :: Sing t -> Sing (Apply Show_Sym0 t)

sShowList :: Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2)

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

Defined in Data.Singletons.ShowSing

Methods

showsSingPrec :: Int -> Sing a0 -> ShowS

Bundle (Either a b)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled domain (Either a b) = (res :: *)

Methods

bundle :: Unbundled domain (Either a b) -> Signal domain (Either a b)

unbundle :: Signal domain (Either a b) -> Unbundled domain (Either a b)

(Eq a, Eq b) :=> (Eq (Either a b))

Defined in Data.Constraint

Methods

ins :: (Eq a, Eq b) :- Eq (Either a b)

(Ord a, Ord b) :=> (Ord (Either a b))

Defined in Data.Constraint

Methods

ins :: (Ord a, Ord b) :- Ord (Either a b)

(Read a, Read b) :=> (Read (Either a b))

Defined in Data.Constraint

Methods

ins :: (Read a, Read b) :- Read (Either a b)

(Show a, Show b) :=> (Show (Either a b))

Defined in Data.Constraint

Methods

ins :: (Show a, Show b) :- Show (Either a b)

SuppressUnusedWarnings (Compare_6989586621679554302Sym1 :: Either a6989586621679081283 b6989586621679081284 -> TyFun (Either a6989586621679081283 b6989586621679081284) Ordering -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ShowsPrec_6989586621679891119Sym2 :: Nat -> Either a6989586621679081283 b6989586621679081284 -> TyFun Symbol Symbol -> *)

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ShowsPrec_6989586621679891119Sym1 :: Nat -> TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun Symbol Symbol -> Type) -> *)

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (RightsSym0 :: TyFun [Either a6989586621680064148 b6989586621680064149] [b6989586621680064149] -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (PartitionEithersSym0 :: TyFun [Either a6989586621680064146 b6989586621680064147] ([a6989586621680064146], [b6989586621680064147]) -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (LeftsSym0 :: TyFun [Either a6989586621680064150 b6989586621680064151] [a6989586621680064150] -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Compare_6989586621679554302Sym0 :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun (Either a6989586621679081283 b6989586621679081284) Ordering -> Type) -> *)

Defined in Data.Singletons.Prelude.Ord

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsRightSym0 :: TyFun (Either a6989586621680064142 b6989586621680064143) Bool -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (IsLeftSym0 :: TyFun (Either a6989586621680064144 b6989586621680064145) Bool -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (ShowsPrec_6989586621679891119Sym0 :: TyFun Nat (TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun Symbol Symbol -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.Show

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (RightSym0 :: TyFun b6989586621679081284 (Either a6989586621679081283 b6989586621679081284) -> *)

Defined in Data.Singletons.Prelude.Instances

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (LeftSym0 :: TyFun a6989586621679081283 (Either a6989586621679081283 b6989586621679081284) -> *)

Defined in Data.Singletons.Prelude.Instances

Methods

suppressUnusedWarnings :: ()

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Sum f g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Either i j -> a -> m) -> Sum f g a -> m

ifolded :: (Indexable (Either i j) p, Contravariant f0, Applicative f0) => p a (f0 a) -> Sum f g a -> f0 (Sum f g a)

ifoldr :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b

ifoldl :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b

ifoldr' :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b

ifoldl' :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Product f g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Either i j -> a -> m) -> Product f g a -> m

ifolded :: (Indexable (Either i j) p, Contravariant f0, Applicative f0) => p a (f0 a) -> Product f g a -> f0 (Product f g a)

ifoldr :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b

ifoldl :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b

ifoldr' :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b

ifoldl' :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :+: g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :+: g) a -> m

ifolded :: (Indexable (Either i j) p, Contravariant f0, Applicative f0) => p a (f0 a) -> (f :+: g) a -> f0 ((f :+: g) a)

ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b

ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b

ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b

ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :*: g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :*: g) a -> m

ifolded :: (Indexable (Either i j) p, Contravariant f0, Applicative f0) => p a (f0 a) -> (f :*: g) a -> f0 ((f :*: g) a)

ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :*: g) a -> b

ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :*: g) a -> b

ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :*: g) a -> b

ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :*: g) a -> b

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Sum f g)

Defined in Control.Lens.Indexed

Methods

imap :: (Either i j -> a -> b) -> Sum f g a -> Sum f g b

imapped :: (Indexable (Either i j) p, Settable f0) => p a (f0 b) -> Sum f g a -> f0 (Sum f g b)

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Product f g)

Defined in Control.Lens.Indexed

Methods

imap :: (Either i j -> a -> b) -> Product f g a -> Product f g b

imapped :: (Indexable (Either i j) p, Settable f0) => p a (f0 b) -> Product f g a -> f0 (Product f g b)

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :+: g)

Defined in Control.Lens.Indexed

Methods

imap :: (Either i j -> a -> b) -> (f :+: g) a -> (f :+: g) b

imapped :: (Indexable (Either i j) p, Settable f0) => p a (f0 b) -> (f :+: g) a -> f0 ((f :+: g) b)

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :*: g)

Defined in Control.Lens.Indexed

Methods

imap :: (Either i j -> a -> b) -> (f :*: g) a -> (f :*: g) b

imapped :: (Indexable (Either i j) p, Settable f0) => p a (f0 b) -> (f :*: g) a -> f0 ((f :*: g) b)

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Sum f g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Sum f g a -> f0 (Sum f g b)

itraversed :: (Indexable (Either i j) p, Applicative f0) => p a (f0 b) -> Sum f g a -> f0 (Sum f g b)

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Product f g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Product f g a -> f0 (Product f g b)

itraversed :: (Indexable (Either i j) p, Applicative f0) => p a (f0 b) -> Product f g a -> f0 (Product f g b)

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :+: g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b)

itraversed :: (Indexable (Either i j) p, Applicative f0) => p a (f0 b) -> (f :+: g) a -> f0 ((f :+: g) b)

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :*: g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :*: g) a -> f0 ((f :*: g) b)

itraversed :: (Indexable (Either i j) p, Applicative f0) => p a (f0 b) -> (f :*: g) a -> f0 ((f :*: g) b)

SuppressUnusedWarnings (Either_Sym2 :: (TyFun a6989586621680063014 c6989586621680063015 -> Type) -> (TyFun b6989586621680063016 c6989586621680063015 -> Type) -> TyFun (Either a6989586621680063014 b6989586621680063016) c6989586621680063015 -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Either_Sym1 :: (TyFun a6989586621680063014 c6989586621680063015 -> Type) -> TyFun (TyFun b6989586621680063016 c6989586621680063015 -> Type) (TyFun (Either a6989586621680063014 b6989586621680063016) c6989586621680063015 -> Type) -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

SuppressUnusedWarnings (Either_Sym0 :: TyFun (TyFun a6989586621680063014 c6989586621680063015 -> Type) (TyFun (TyFun b6989586621680063016 c6989586621680063015 -> Type) (TyFun (Either a6989586621680063014 b6989586621680063016) c6989586621680063015 -> Type) -> Type) -> *)

Defined in Data.Singletons.Prelude.Either

Methods

suppressUnusedWarnings :: ()

type Unbundled domain (Either a b)

Defined in Clash.Signal.Bundle

type Unbundled domain (Either a b) = Signal domain (Either a b)

type Apply (ShowsPrec_6989586621679891119Sym0 :: TyFun Nat (TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun Symbol Symbol -> Type) -> Type) -> *) (l :: Nat)

Defined in Data.Singletons.Prelude.Show

type Apply (ShowsPrec_6989586621679891119Sym0 :: TyFun Nat (TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun Symbol Symbol -> Type) -> Type) -> *) (l :: Nat) = (ShowsPrec_6989586621679891119Sym1 l :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun Symbol Symbol -> Type) -> *)

type Apply (LeftSym0 :: TyFun a (Either a b6989586621679081284) -> *) (l :: a)

Defined in Data.Singletons.Prelude.Instances

type Apply (LeftSym0 :: TyFun a (Either a b6989586621679081284) -> *) (l :: a) = (Left l :: Either a b6989586621679081284)

type Apply (RightSym0 :: TyFun b (Either a6989586621679081283 b) -> *) (l :: b)

Defined in Data.Singletons.Prelude.Instances

type Apply (RightSym0 :: TyFun b (Either a6989586621679081283 b) -> *) (l :: b) = (Right l :: Either a6989586621679081283 b)

type Rep1 (Either a :: * -> *)

Defined in GHC.Generics

type Rep1 (Either a :: * -> *) = D1 (MetaData "Either" "Data.Either" "base" False) (C1 (MetaCons "Left" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) :+: C1 (MetaCons "Right" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Apply (RightsSym0 :: TyFun [Either a b] [b] -> *) (l :: [Either a b])

Defined in Data.Singletons.Prelude.Either

type Apply (RightsSym0 :: TyFun [Either a b] [b] -> *) (l :: [Either a b]) = Rights l

type Apply (LeftsSym0 :: TyFun [Either a b] [a] -> *) (l :: [Either a b])

Defined in Data.Singletons.Prelude.Either

type Apply (LeftsSym0 :: TyFun [Either a b] [a] -> *) (l :: [Either a b]) = Lefts l

type Apply (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> *) (l :: [Either a b])

Defined in Data.Singletons.Prelude.Either

type Apply (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> *) (l :: [Either a b]) = PartitionEithers l

type Rep (Either a b)

Defined in GHC.Generics

type Rep (Either a b) = D1 (MetaData "Either" "Data.Either" "base" False) (C1 (MetaCons "Left" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) :+: C1 (MetaCons "Right" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)))

data Sing (z :: Either a b)

Defined in Data.Singletons.Prelude.Instances

data Sing (z :: Either a b) where

• SLeft :: Sing (Left n :: Either a b)
• SRight :: Sing (Right n :: Either a b)

type Demote (Either a b)

Defined in Data.Singletons.Prelude.Instances

type Demote (Either a b) = Either (Demote a) (Demote b)

type Show_ (arg :: Either a b)

Defined in Data.Singletons.Prelude.Show

type Show_ (arg :: Either a b) = Apply (Show__6989586621679875032Sym0 :: TyFun (Either a b) Symbol -> *) arg

type (x :: Either a b) /= (y :: Either a b)

Defined in Data.Singletons.Prelude.Eq

type (x :: Either a b) /= (y :: Either a b) = Not (x == y)

type (a2 :: Either a1 b1) == (b2 :: Either a1 b1)

Defined in Data.Singletons.Prelude.Eq

type (a2 :: Either a1 b1) == (b2 :: Either a1 b1) = Equals_6989586621679535767 a2 b2

type (arg1 :: Either a b) < (arg2 :: Either a b)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Either a b) < (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679547183Sym0 :: TyFun (Either a b) (TyFun (Either a b) Bool -> Type) -> *) arg1) arg2

type (arg1 :: Either a b) <= (arg2 :: Either a b)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Either a b) <= (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679547216Sym0 :: TyFun (Either a b) (TyFun (Either a b) Bool -> Type) -> *) arg1) arg2

type (arg1 :: Either a b) > (arg2 :: Either a b)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Either a b) > (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679547249Sym0 :: TyFun (Either a b) (TyFun (Either a b) Bool -> Type) -> *) arg1) arg2

type (arg1 :: Either a b) >= (arg2 :: Either a b)

Defined in Data.Singletons.Prelude.Ord

type (arg1 :: Either a b) >= (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679547282Sym0 :: TyFun (Either a b) (TyFun (Either a b) Bool -> Type) -> *) arg1) arg2

type Compare (a2 :: Either a1 b) (a3 :: Either a1 b)

Defined in Data.Singletons.Prelude.Ord

type Compare (a2 :: Either a1 b) (a3 :: Either a1 b) = Apply (Apply (Compare_6989586621679554302Sym0 :: TyFun (Either a1 b) (TyFun (Either a1 b) Ordering -> Type) -> *) a2) a3

type Max (arg1 :: Either a b) (arg2 :: Either a b)

Defined in Data.Singletons.Prelude.Ord

type Max (arg1 :: Either a b) (arg2 :: Either a b) = Apply (Apply (Max_6989586621679547315Sym0 :: TyFun (Either a b) (TyFun (Either a b) (Either a b) -> Type) -> *) arg1) arg2

type Min (arg1 :: Either a b) (arg2 :: Either a b)

Defined in Data.Singletons.Prelude.Ord

type Min (arg1 :: Either a b) (arg2 :: Either a b) = Apply (Apply (Min_6989586621679547348Sym0 :: TyFun (Either a b) (TyFun (Either a b) (Either a b) -> Type) -> *) arg1) arg2

type ShowList (arg1 :: [Either a b]) arg2

Defined in Data.Singletons.Prelude.Show

type ShowList (arg1 :: [Either a b]) arg2 = Apply (Apply (ShowList_6989586621679875050Sym0 :: TyFun [Either a b] (TyFun Symbol Symbol -> Type) -> *) arg1) arg2

type ShowsPrec a2 (a3 :: Either a1 b) a4

Defined in Data.Singletons.Prelude.Show

type ShowsPrec a2 (a3 :: Either a1 b) a4 = Apply (Apply (Apply (ShowsPrec_6989586621679891119Sym0 :: TyFun Nat (TyFun (Either a1 b) (TyFun Symbol Symbol -> Type) -> Type) -> *) a2) a3) a4

type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b)

Defined in Data.Singletons.Prelude.Either

type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b) = IsRight l

type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b)

Defined in Data.Singletons.Prelude.Either

type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b) = IsLeft l

type Apply (Compare_6989586621679554302Sym1 l1 :: TyFun (Either a b) Ordering -> *) (l2 :: Either a b)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554302Sym1 l1 :: TyFun (Either a b) Ordering -> *) (l2 :: Either a b) = Compare_6989586621679554302 l1 l2

type Apply (Either_Sym2 l1 l2 :: TyFun (Either a b) c -> *) (l3 :: Either a b)

Defined in Data.Singletons.Prelude.Either

type Apply (Either_Sym2 l1 l2 :: TyFun (Either a b) c -> *) (l3 :: Either a b) = Either_ l1 l2 l3

type Apply (Compare_6989586621679554302Sym0 :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun (Either a6989586621679081283 b6989586621679081284) Ordering -> Type) -> *) (l :: Either a6989586621679081283 b6989586621679081284)

Defined in Data.Singletons.Prelude.Ord

type Apply (Compare_6989586621679554302Sym0 :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun (Either a6989586621679081283 b6989586621679081284) Ordering -> Type) -> *) (l :: Either a6989586621679081283 b6989586621679081284) = Compare_6989586621679554302Sym1 l

type Apply (Either_Sym0 :: TyFun (TyFun a6989586621680063014 c6989586621680063015 -> Type) (TyFun (TyFun b6989586621680063016 c6989586621680063015 -> Type) (TyFun (Either a6989586621680063014 b6989586621680063016) c6989586621680063015 -> Type) -> Type) -> *) (l :: TyFun a6989586621680063014 c6989586621680063015 -> Type)

Defined in Data.Singletons.Prelude.Either

type Apply (Either_Sym0 :: TyFun (TyFun a6989586621680063014 c6989586621680063015 -> Type) (TyFun (TyFun b6989586621680063016 c6989586621680063015 -> Type) (TyFun (Either a6989586621680063014 b6989586621680063016) c6989586621680063015 -> Type) -> Type) -> *) (l :: TyFun a6989586621680063014 c6989586621680063015 -> Type) = (Either_Sym1 l :: TyFun (TyFun b6989586621680063016 c6989586621680063015 -> Type) (TyFun (Either a6989586621680063014 b6989586621680063016) c6989586621680063015 -> Type) -> *)

type Apply (ShowsPrec_6989586621679891119Sym1 l1 :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun Symbol Symbol -> Type) -> *) (l2 :: Either a6989586621679081283 b6989586621679081284)

Defined in Data.Singletons.Prelude.Show

type Apply (ShowsPrec_6989586621679891119Sym1 l1 :: TyFun (Either a6989586621679081283 b6989586621679081284) (TyFun Symbol Symbol -> Type) -> *) (l2 :: Either a6989586621679081283 b6989586621679081284) = ShowsPrec_6989586621679891119Sym2 l1 l2

type Apply (Either_Sym1 l1 :: TyFun (TyFun b6989586621680063016 c6989586621680063015 -> Type) (TyFun (Either a6989586621680063014 b6989586621680063016) c6989586621680063015 -> Type) -> *) (l2 :: TyFun b6989586621680063016 c6989586621680063015 -> Type)

Defined in Data.Singletons.Prelude.Either

type Apply (Either_Sym1 l1 :: TyFun (TyFun b6989586621680063016 c6989586621680063015 -> Type) (TyFun (Either a6989586621680063014 b6989586621680063016) c6989586621680063015 -> Type) -> *) (l2 :: TyFun b6989586621680063016 c6989586621680063015 -> Type) = Either_Sym2 l1 l2

readIO :: Read a => String -> IO a

The readIO function is similar to read except that it signals parse failure to the IO monad instead of terminating the program.

readLn :: Read a => IO a

The readLn function combines getLine and readIO.

appendFile :: FilePath -> String -> IO ()

The computation appendFile file str function appends the string str, to the file file.

Note that writeFile and appendFile write a literal string to a file. To write a value of any printable type, as with print, use the show function to convert the value to a string first.

main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])

writeFile :: FilePath -> String -> IO ()

The computation writeFile file str function writes the string str, to the file file.

readFile :: FilePath -> IO String

The readFile function reads a file and returns the contents of the file as a string. The file is read lazily, on demand, as with getContents.

interact :: (String -> String) -> IO ()

The interact function takes a function of type String->String as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.

getContents :: IO String

The getContents operation returns all user input as a single string, which is read lazily as it is needed (same as hGetContents stdin).

getLine :: IO String

Read a line from the standard input device (same as hGetLine stdin).

getChar :: IO Char

Read a character from the standard input device (same as hGetChar stdin).

putStrLn :: String -> IO ()

The same as putStr, but adds a newline character.

putStr :: String -> IO ()

Write a string to the standard output device (same as hPutStr stdout).

putChar :: Char -> IO ()

Write a character to the standard output device (same as hPutChar stdout).

ioError :: IOError -> IO a

Raise an IOError in the IO monad.

type FilePath = String

File and directory names are values of type String, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.

userError :: String -> IOError

Construct an IOError value with a string describing the error. The fail method of the IO instance of the Monad class raises a userError, thus:

instance Monad IO where
  ...
  fail s = ioError (userError s)

type IOError = IOException

The Haskell 2010 type for exceptions in the IO monad. Any I/O operation may raise an IOError instead of returning a result. For a more general type of exception, including also those that arise in pure code, see Exception.

In Haskell 2010, this is an opaque type.

notElem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4

notElem is the negation of elem.

all :: Foldable t => (a -> Bool) -> t a -> Bool

Determines whether all elements of the structure satisfy the predicate.

any :: Foldable t => (a -> Bool) -> t a -> Bool

Determines whether any element of the structure satisfies the predicate.

or :: Foldable t => t Bool -> Bool

or returns the disjunction of a container of Bools. For the result to be False, the container must be finite; True, however, results from a True value finitely far from the left end.

and :: Foldable t => t Bool -> Bool

and returns the conjunction of a container of Bools. For the result to be True, the container must be finite; False, however, results from a False value finitely far from the left end.

concatMap :: Foldable t => (a -> [b]) -> t a -> [b]

Map a function over all the elements of a container and concatenate the resulting lists.

sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence.

As of base 4.8.0.0, sequence_ is just sequenceA_, specialized to Monad.

mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()

Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see mapM.

As of base 4.8.0.0, mapM_ is just traverse_, specialized to Monad.

unwords :: [String] -> String

unwords is an inverse operation to words. It joins words with separating spaces.

>>> unwords ["Lorem", "ipsum", "dolor"]
"Lorem ipsum dolor"

words :: String -> [String]

words breaks a string up into a list of words, which were delimited by white space.

>>> words "Lorem ipsum\ndolor"
["Lorem","ipsum","dolor"]

unlines :: [String] -> String

unlines is an inverse operation to lines. It joins lines, after appending a terminating newline to each.

>>> unlines ["Hello", "World", "!"]
"Hello\nWorld\n!\n"

lines :: String -> [String]

lines breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines.

Note that after splitting the string at newline characters, the last part of the string is considered a line even if it doesn't end with a newline. For example,

>>> lines ""
[]

>>> lines "\n"
[""]

>>> lines "one"
["one"]

>>> lines "one\n"
["one"]

>>> lines "one\n\n"
["one",""]

>>> lines "one\ntwo"
["one","two"]

>>> lines "one\ntwo\n"
["one","two"]

Thus lines s contains at least as many elements as newlines in s.

read :: Read a => String -> a

The read function reads input from a string, which must be completely consumed by the input process. read fails with an error if the parse is unsuccessful, and it is therefore discouraged from being used in real applications. Use readMaybe or readEither for safe alternatives.

>>> read "123" :: Int
123

>>> read "hello" :: Int
*** Exception: Prelude.read: no parse

reads :: Read a => ReadS a

equivalent to readsPrec with a precedence of 0.

either :: (a -> c) -> (b -> c) -> Either a b -> c

Case analysis for the Either type. If the value is Left a, apply the first function to a; if it is Right b, apply the second function to b.

Examples

We create two values of type Either String Int, one using the Left constructor and another using the Right constructor. Then we apply "either" the length function (if we have a String) or the "times-two" function (if we have an Int):

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> either length (*2) s
3
>>> either length (*2) n
6

lex :: ReadS String

The lex function reads a single lexeme from the input, discarding initial white space, and returning the characters that constitute the lexeme. If the input string contains only white space, lex returns a single successful `lexeme' consisting of the empty string. (Thus lex "" = [("","")].) If there is no legal lexeme at the beginning of the input string, lex fails (i.e. returns []).

This lexer is not completely faithful to the Haskell lexical syntax in the following respects:

• Qualified names are not handled properly
• Octal and hexadecimal numerics are not recognized as a single token
• Comments are not treated properly

readParen :: Bool -> ReadS a -> ReadS a

readParen True p parses what p parses, but surrounded with parentheses.

readParen False p parses what p parses, but optionally surrounded with parentheses.

type ReadS a = String -> [(a, String)]

A parser for a type a, represented as a function that takes a String and returns a list of possible parses as (a,String) pairs.

Note that this kind of backtracking parser is very inefficient; reading a large structure may be quite slow (cf ReadP).

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

Double each element of a list:

>>> (*2) <$> [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)
(2,True)

lcm :: Integral a => a -> a -> a

lcm x y is the smallest positive integer that both x and y divide.

gcd :: Integral a => a -> a -> a

gcd x y is the non-negative factor of both x and y of which every common factor of x and y is also a factor; for example gcd 4 2 = 2, gcd (-4) 6 = 2, gcd 0 4 = 4. gcd 0 0 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)

Note: Since for signed fixed-width integer types, abs minBound < 0, the result may be negative if one of the arguments is minBound (and necessarily is if the other is 0 or minBound) for such types.

(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8

raise a number to an integral power

(^) :: (Num a, Integral b) => a -> b -> a infixr 8

raise a number to a non-negative integral power

odd :: Integral a => a -> Bool

even :: Integral a => a -> Bool

showParen :: Bool -> ShowS -> ShowS

utility function that surrounds the inner show function with parentheses when the Bool parameter is True.

showString :: String -> ShowS

utility function converting a String to a show function that simply prepends the string unchanged.

showChar :: Char -> ShowS

utility function converting a Char to a show function that simply prepends the character unchanged.

shows :: Show a => a -> ShowS

equivalent to showsPrec with a precedence of 0.

type ShowS = String -> String

The shows functions return a function that prepends the output String to an existing String. This allows constant-time concatenation of results using function composition.

lookup :: Eq a => a -> [(a, b)] -> Maybe b

lookup key assocs looks up a key in an association list.

break :: (a -> Bool) -> [a] -> ([a], [a])

break, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p and second element is the remainder of the list:

break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
break (< 9) [1,2,3] == ([],[1,2,3])
break (> 9) [1,2,3] == ([1,2,3],[])

break p is equivalent to span (not . p).

span :: (a -> Bool) -> [a] -> ([a], [a])

span, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list:

span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
span (< 9) [1,2,3] == ([1,2,3],[])
span (< 0) [1,2,3] == ([],[1,2,3])

span p xs is equivalent to (takeWhile p xs, dropWhile p xs)

dropWhile :: (a -> Bool) -> [a] -> [a]

dropWhile p xs returns the suffix remaining after takeWhile p xs:

dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
dropWhile (< 9) [1,2,3] == []
dropWhile (< 0) [1,2,3] == [1,2,3]

takeWhile :: (a -> Bool) -> [a] -> [a]

takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p:

takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []

cycle :: [a] -> [a]

cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.

scanr1 :: (a -> a -> a) -> [a] -> [a]

scanr1 is a variant of scanr that has no starting value argument.

scanl1 :: (a -> a -> a) -> [a] -> [a]

scanl1 is a variant of scanl that has no starting value argument:

scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

maybe :: b -> (a -> b) -> Maybe a -> b

The maybe function takes a default value, a function, and a Maybe value. If the Maybe value is Nothing, the function returns the default value. Otherwise, it applies the function to the value inside the Just and returns the result.

Examples

Basic usage:

>>> maybe False odd (Just 3)
True

>>> maybe False odd Nothing
False

Read an integer from a string using readMaybe. If we succeed, return twice the integer; that is, apply (*2) to it. If instead we fail to parse an integer, return 0 by default:

>>> import Text.Read ( readMaybe )
>>> maybe 0 (*2) (readMaybe "5")
10
>>> maybe 0 (*2) (readMaybe "")
0

Apply show to a Maybe Int. If we have Just n, we want to show the underlying Int n. But if we have Nothing, we return the empty string instead of (for example) "Nothing":

>>> maybe "" show (Just 5)
"5"
>>> maybe "" show Nothing
""

uncurry :: (a -> b -> c) -> (a, b) -> c

uncurry converts a curried function to a function on pairs.

Examples

>>> uncurry (+) (1,2)
3

>>> uncurry ($) (show, 1)
"1"

>>> map (uncurry max) [(1,2), (3,4), (6,8)]
[2,4,8]

curry :: ((a, b) -> c) -> a -> b -> c

curry converts an uncurried function to a curried function.

Examples

>>> curry fst 1 2
1

subtract :: Num a => a -> a -> a

the same as flip (-).

Because - is treated specially in the Haskell grammar, (- e) is not a section, but an application of prefix negation. However, (subtract exp) is equivalent to the disallowed section.

asTypeOf :: a -> a -> a

asTypeOf is a type-restricted version of const. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.

until :: (a -> Bool) -> (a -> a) -> a -> a

until p f yields the result of applying f until p holds.

($!) :: (a -> b) -> a -> b infixr 0

Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.

flip :: (a -> b -> c) -> b -> a -> c

flip f takes its (first) two arguments in the reverse order of f.

>>> flip (++) "hello" "world"
"worldhello"

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9

Function composition.

const :: a -> b -> a

const x is a unary function which evaluates to x for all inputs.

>>> const 42 "hello"
42

>>> map (const 42) [0..3]
[42,42,42,42]

id :: a -> a

Identity function.

id x = x

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1

Same as >>=, but with the arguments interchanged.

type String = [Char]

A String is a list of characters. String constants in Haskell are values of type String.

errorWithoutStackTrace :: [Char] -> a

A variant of error that does not produce a stack trace.

Since: base-4.9.0.0

error :: HasCallStack => [Char] -> a

error stops execution and displays an error message.

(&&) :: Bool -> Bool -> Bool infixr 3

Boolean "and"

(||) :: Bool -> Bool -> Bool infixr 2

Boolean "or"

not :: Bool -> Bool

Boolean "not"