Copyright	(C) 2013-2016 University of Twente 2017 Myrtle Software Ltd Google Inc.
License	BSD2 (see the file LICENSE)
Maintainer	Christiaan Baaij <christiaan.baaij@gmail.com>
Safe Haskell	Unsafe
Language	Haskell2010
Extensions	Cpp DataKinds FlexibleContexts TypeOperators ExplicitNamespaces

Clash.Prelude

Contents

Creating synchronous sequential circuits
ROMs
- ROMs initialised with a data file
RAM primitives with a combinational read port
BlockRAM primitives
- BlockRAM primitives initialised with a data file
- BlockRAM read/write conflict resolution
Utility functions
Exported modules

Description

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

This package provides:

Prelude library containing datatypes and functions for circuit design

To use the library:

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

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

Synopsis

mealy :: HiddenClockReset domain gated synchronous => (s -> i -> (s, o)) -> s -> Signal domain i -> Signal domain o
mealyB :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) => (s -> i -> (s, o)) -> s -> Unbundled domain i -> Unbundled domain o
(<^>) :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) => (s -> i -> (s, o)) -> s -> Unbundled domain i -> Unbundled domain o
moore :: HiddenClockReset domain gated synchronous => (s -> i -> s) -> (s -> o) -> s -> Signal domain i -> Signal domain o
mooreB :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) => (s -> i -> s) -> (s -> o) -> s -> Unbundled domain i -> Unbundled domain o
registerB :: (HiddenClockReset domain gated synchronous, Bundle a) => a -> Unbundled domain a -> Unbundled domain a
asyncRom :: (KnownNat n, Enum addr) => Vec n a -> addr -> a
asyncRomPow2 :: KnownNat n => Vec (2 ^ n) a -> Unsigned n -> a
rom :: (KnownNat n, KnownNat m, HiddenClock domain gated) => Vec n a -> Signal domain (Unsigned m) -> Signal domain a
romPow2 :: (KnownNat n, HiddenClock domain gated) => Vec (2 ^ n) a -> Signal domain (Unsigned n) -> Signal domain a
asyncRomFile :: (KnownNat m, Enum addr) => SNat n -> FilePath -> addr -> BitVector m
asyncRomFilePow2 :: forall n m. (KnownNat m, KnownNat n) => FilePath -> Unsigned n -> BitVector m
romFile :: (KnownNat m, KnownNat n, HiddenClock domain gated) => SNat n -> FilePath -> Signal domain (Unsigned n) -> Signal domain (BitVector m)
romFilePow2 :: forall n m domain gated. (KnownNat m, KnownNat n, HiddenClock domain gated) => FilePath -> Signal domain (Unsigned n) -> Signal domain (BitVector m)
asyncRam :: (Enum addr, HiddenClock domain gated, HasCallStack) => SNat n -> Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a
asyncRamPow2 :: (KnownNat n, HiddenClock domain gated, HasCallStack) => Signal domain (Unsigned n) -> Signal domain (Maybe (Unsigned n, a)) -> Signal domain a
blockRam :: (Enum addr, HiddenClock domain gated, HasCallStack) => Vec n a -> Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a
blockRamPow2 :: (KnownNat n, HiddenClock domain gated, HasCallStack) => Vec (2 ^ n) a -> Signal domain (Unsigned n) -> Signal domain (Maybe (Unsigned n, a)) -> Signal domain a
blockRamFile :: (KnownNat m, Enum addr, HiddenClock domain gated, HasCallStack) => SNat n -> FilePath -> Signal domain addr -> Signal domain (Maybe (addr, BitVector m)) -> Signal domain (BitVector m)
blockRamFilePow2 :: forall domain gated n m. (KnownNat m, KnownNat n, HiddenClock domain gated, HasCallStack) => FilePath -> Signal domain (Unsigned n) -> Signal domain (Maybe (Unsigned n, BitVector m)) -> Signal domain (BitVector m)
readNew :: (Eq addr, HiddenClockReset domain gated synchronous) => (Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a) -> Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a
window :: (KnownNat n, Default a, HiddenClockReset domain gated synchronous) => Signal domain a -> Vec (n + 1) (Signal domain a)
windowD :: (KnownNat n, Default a, HiddenClockReset domain gated synchronous) => Signal domain a -> Vec (n + 1) (Signal domain a)
isRising :: (HiddenClockReset domain gated synchronous, Bounded a, Eq a) => a -> Signal domain a -> Signal domain Bool
isFalling :: (HiddenClockReset domain gated synchronous, Bounded a, Eq a) => a -> Signal domain a -> Signal domain Bool
riseEvery :: HiddenClockReset domain gated synchronous => SNat n -> Signal domain Bool
oscillate :: HiddenClockReset domain gated synchronous => Bool -> SNat n -> Signal domain Bool
module Clash.Signal
module Clash.Signal.Delayed
module Clash.Prelude.DataFlow
module Clash.Sized.BitVector
module Clash.Prelude.BitIndex
module Clash.Prelude.BitReduction
module Clash.Sized.Signed
module Clash.Sized.Unsigned
module Clash.Sized.Index
module Clash.Sized.Fixed
module Clash.Sized.Vector
module Clash.Sized.RTree
module Clash.Annotations.TopEntity
module GHC.TypeLits
module Clash.Promoted.Nat
module Clash.Promoted.Nat.Literals
module Clash.Promoted.Nat.TH
module Clash.Promoted.Symbol
class Lift t where
module Clash.Class.BitPack
module Clash.Class.Num
module Clash.Class.Resize
module Control.Applicative
module Data.Bits
module Clash.XException
undefined :: HasCallStack => a
module Clash.NamedTypes
module Clash.Hidden
seq :: a -> b -> b
filter :: (a -> Bool) -> [a] -> [a]
print :: Show a => a -> IO ()
fst :: (a, b) -> a
snd :: (a, b) -> b
otherwise :: Bool
($) :: (a -> b) -> a -> b
fromIntegral :: (Integral a, Num b) => a -> b
realToFrac :: (Real a, Fractional b) => a -> b
class Bounded a where
class Enum a where
class Eq a where
class Fractional a => Floating a where
class Num a => Fractional a where
class (Real a, Enum a) => Integral a where
class Applicative m => Monad (m :: * -> *) where
class Functor (f :: * -> *) where
class Num a where
class Eq a => Ord a where
class Read a where
class (Num a, Ord a) => Real a where
class (RealFrac a, Floating a) => RealFloat a where
class (Real a, Fractional a) => RealFrac a where
class Show a where
class Functor f => Applicative (f :: * -> *) where
class Foldable (t :: * -> *) where
class (Functor t, Foldable t) => Traversable (t :: * -> *) where
class Semigroup a where
class Semigroup a => Monoid a where
data Bool
- = False
- | True
data Char
data Double
data Float
data Int
data Integer
data Maybe a
- = Nothing
- | Just a
data Ordering
- = LT
- | EQ
- | GT
type Rational = Ratio Integer
data IO a
data Word
data Either a b
- = Left a
- | Right b
readIO :: Read a => String -> IO a
readLn :: Read a => IO a
appendFile :: FilePath -> String -> IO ()
writeFile :: FilePath -> String -> IO ()
readFile :: FilePath -> IO String
interact :: (String -> String) -> IO ()
getContents :: IO String
getLine :: IO String
getChar :: IO Char
putStrLn :: String -> IO ()
putStr :: String -> IO ()
putChar :: Char -> IO ()
ioError :: IOError -> IO a
type FilePath = String
userError :: String -> IOError
type IOError = IOException
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
all :: Foldable t => (a -> Bool) -> t a -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
or :: Foldable t => t Bool -> Bool
and :: Foldable t => t Bool -> Bool
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
unwords :: [String] -> String
words :: String -> [String]
unlines :: [String] -> String
lines :: String -> [String]
read :: Read a => String -> a
reads :: Read a => ReadS a
either :: (a -> c) -> (b -> c) -> Either a b -> c
lex :: ReadS String
readParen :: Bool -> ReadS a -> ReadS a
type ReadS a = String -> [(a, String)]
(<$>) :: Functor f => (a -> b) -> f a -> f b
lcm :: Integral a => a -> a -> a
gcd :: Integral a => a -> a -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
(^) :: (Num a, Integral b) => a -> b -> a
odd :: Integral a => a -> Bool
even :: Integral a => a -> Bool
showParen :: Bool -> ShowS -> ShowS
showString :: String -> ShowS
showChar :: Char -> ShowS
shows :: Show a => a -> ShowS
type ShowS = String -> String
lookup :: Eq a => a -> [(a, b)] -> Maybe b
break :: (a -> Bool) -> [a] -> ([a], [a])
span :: (a -> Bool) -> [a] -> ([a], [a])
dropWhile :: (a -> Bool) -> [a] -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
cycle :: [a] -> [a]
scanr1 :: (a -> a -> a) -> [a] -> [a]
scanl1 :: (a -> a -> a) -> [a] -> [a]
maybe :: b -> (a -> b) -> Maybe a -> b
uncurry :: (a -> b -> c) -> (a, b) -> c
curry :: ((a, b) -> c) -> a -> b -> c
subtract :: Num a => a -> a -> a
asTypeOf :: a -> a -> a
until :: (a -> Bool) -> (a -> a) -> a -> a
($!) :: (a -> b) -> a -> b
flip :: (a -> b -> c) -> b -> a -> c
(.) :: (b -> c) -> (a -> b) -> a -> c
const :: a -> b -> a
id :: a -> a
(=<<) :: Monad m => (a -> m b) -> m a -> m b
type String = [Char]
errorWithoutStackTrace :: [Char] -> a
error :: HasCallStack => [Char] -> a
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool

Creating synchronous sequential circuits

mealy Source #

Arguments

:: HiddenClockReset domain gated synchronous
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Signal domain i -> Signal domain o	Synchronous sequential function with input and output matching that of the mealy machine

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

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

mac :: HiddenClockReset domain gated synchronous => Signal domain (Int, Int) -> Signal domain Int
mac = mealy macT 0

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

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

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

mealyB Source #

Arguments

:: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous)
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Unbundled domain i -> Unbundled domain o	Synchronous sequential function with input and output matching that of the mealy machine

A version of mealy that does automatic Bundleing

Given a function f of type:

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

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

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

Using mealyB however we can write:

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

(<^>) Source #

Arguments

:: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous)
=> (s -> i -> (s, o))	Transfer function in mealy machine form: `state -> input -> (newstate,output)`
-> s	Initial state
-> Unbundled domain i -> Unbundled domain o	Synchronous sequential function with input and output matching that of the mealy machine

Infix version of mealyB

moore Source #

Arguments

:: HiddenClockReset domain gated 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        -- Updated state
macT s (x,y) = x * y + s

mac :: HiddenClockReset domain gated synchronous => Signal domain (Int, Int) -> Signal domain Int
mac = moore mac id 0

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

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

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

mooreB Source #

Arguments

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

Using mooreB however we can write:

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

registerB :: (HiddenClockReset domain gated synchronous, Bundle a) => a -> Unbundled domain a -> Unbundled domain a infixr 3 Source #

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

rP :: HiddenClockReset domain gated synchronous
   => (Signal domain Int, Signal domain Int)
   -> (Signal domain Int, Signal domain Int)
rP = registerB (8,8)

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

ROMs

asyncRom Source #

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

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

Arguments

:: (KnownNat n, KnownNat m, HiddenClock domain gated)
=> Vec n a	ROM content NB: must be a constant
-> Signal domain (Unsigned m)	Read address `rd`
-> Signal domain a	The value of the ROM at address `rd`

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

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

Additional helpful information:

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

romPow2 Source #

Arguments

:: (KnownNat n, HiddenClock domain gated)
=> 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.Prelude.BlockRam for ideas on how to use ROMs and RAMs

ROMs initialised with a data file

asyncRomFile Source #

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

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

Arguments

:: (KnownNat m, KnownNat n, HiddenClock domain gated)
=> SNat n	Size of the ROM
-> 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 n elements

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

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

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

Additional helpful information:

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

romFilePow2 Source #

Arguments

:: (KnownNat m, KnownNat n, HiddenClock domain gated)
=> 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.Prelude.ROM.File for more information on how to instantiate a ROM with the contents of a data file.
See Clash.Sized.Fixed for ideas on how to create your own data files.

RAM primitives with a combinational read port

asyncRam Source #

Arguments

:: (Enum addr, HiddenClock domain gated, HasCallStack)
=> SNat n	Size `n` of the RAM
-> 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`

Create a RAM with space for n elements.

NB: Initial content of the RAM is undefined

Additional helpful information:

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

asyncRamPow2 Source #

Arguments

:: (KnownNat n, HiddenClock domain gated, HasCallStack)
=> Signal domain (Unsigned n)	Read address `r`
-> Signal domain (Maybe (Unsigned n, a))	(write address `w`, value to write)
-> Signal domain 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 Source #

Arguments

:: (Enum addr, HiddenClock domain gated, HasCallStack)
=> Vec n a	Initial content of the BRAM, also determines the size, `n`, of the BRAM. NB: MUST be a constant.
-> Signal domain addr	Read address `r`
-> Signal domain (Maybe (addr, a))	(write address `w`, value to write)
-> Signal domain a	Value of the `blockRAM` at address `r` from the previous clock cycle

Create a blockRAM with space for n elements.

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

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

Additional helpful information:

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

blockRamPow2 Source #

Arguments

:: (KnownNat n, HiddenClock domain gated, HasCallStack)
=> Vec (2 ^ n) a	Initial content of the BRAM, also determines the size, `2^n`, of the BRAM. NB: MUST be a constant.
-> Signal domain (Unsigned n)	Read address `r`
-> Signal domain (Maybe (Unsigned n, a))	(write address `w`, value to write)
-> Signal domain a	Value of the `blockRAM` at address `r` from the previous clock cycle

Create a blockRAM with space for 2^n elements

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

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

Additional helpful information:

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

BlockRAM primitives initialised with a data file

blockRamFile Source #

Arguments

:: (KnownNat m, Enum addr, HiddenClock domain gated, HasCallStack)
=> SNat n	Size of the blockRAM
-> FilePath	File describing the initial content of the blockRAM
-> Signal domain addr	Read address `r`
-> Signal domain (Maybe (addr, BitVector m))	(write address `w`, value to write)
-> Signal domain (BitVector m)	Value of the `blockRAM` at address `r` from the previous clock cycle

Create a blockRAM with space for n elements

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

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

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

Additional helpful information:

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

blockRamFilePow2 Source #

Arguments

:: (KnownNat m, KnownNat n, HiddenClock domain gated, HasCallStack)
=> FilePath	File describing the initial content of the blockRAM
-> Signal domain (Unsigned n)	Read address `r`
-> Signal domain (Maybe (Unsigned n, BitVector m))	(write address `w`, value to write)
-> Signal domain (BitVector m)	Value of the `blockRAM` at address `r` from the previous clock cycle

Create a blockRAM with space for 2^n elements

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

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

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

Additional helpful information:

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

BlockRAM read/write conflict resolution

readNew Source #

Arguments

:: (Eq addr, HiddenClockReset domain gated synchronous)
=> (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 (synchronised to system clock)

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

Utility functions

window Source #

Arguments

:: (KnownNat n, Default a, HiddenClockReset domain gated 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 :: HiddenClockReset domain gated synchronous
        => Signal domain Int -> Vec 4 (Signal domain Int)
window4 = window

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

windowD Source #

Arguments

:: (KnownNat n, Default a, HiddenClockReset domain gated 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 :: HiddenClockReset domain gated synchronous
         => Signal domain Int -> Vec 3 (Signal domain Int)
windowD3 = windowD

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

isRising Source #

Arguments

:: (HiddenClockReset domain gated synchronous, Bounded a, Eq a)
=> a	Starting value
-> Signal domain a
-> Signal domain Bool

Give a pulse when the Signal goes from minBound to maxBound

isFalling Source #

Arguments

:: (HiddenClockReset domain gated synchronous, Bounded a, Eq a)
=> a	Starting value
-> Signal domain a
-> Signal domain Bool

Give a pulse when the Signal goes from maxBound to minBound

riseEvery :: HiddenClockReset domain gated synchronous => SNat n -> Signal domain Bool Source #

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

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

>>> Prelude.last (sampleN 1024 (riseEvery d1024)) == True
True
>>> Prelude.or (sampleN 1023 (riseEvery d1024)) == False
True

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

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

oscillate :: HiddenClockReset domain gated synchronous => Bool -> SNat n -> Signal domain Bool Source #

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

To oscillate on an interval of 5 cycles:

>>> sampleN 10 (oscillate False d5)
[False,False,False,False,False,True,True,True,True,True]

To oscillate between True and False:

>>> sampleN 10 (oscillate False d1)
[False,True,False,True,False,True,False,True,False,True]

An alternative definition for the above could be:

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

Exported modules

Synchronous signals

module Clash.Signal

module Clash.Signal.Delayed

DataFlow interface

module Clash.Prelude.DataFlow

Datatypes

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
Instance details Methods lift :: Bool -> Q Exp #
Lift Char
Instance details Methods lift :: Char -> Q Exp #
Lift Double
Instance details Methods lift :: Double -> Q Exp #
Lift Float
Instance details Methods lift :: Float -> Q Exp #
Lift Int
Instance details Methods lift :: Int -> Q Exp #
Lift Int8
Instance details Methods lift :: Int8 -> Q Exp #
Lift Int16
Instance details Methods lift :: Int16 -> Q Exp #
Lift Int32
Instance details Methods lift :: Int32 -> Q Exp #
Lift Int64
Instance details Methods lift :: Int64 -> Q Exp #
Lift Integer
Instance details Methods lift :: Integer -> Q Exp #
Lift Natural
Instance details Methods lift :: Natural -> Q Exp #
Lift Word
Instance details Methods lift :: Word -> Q Exp #
Lift Word8
Instance details Methods lift :: Word8 -> Q Exp #
Lift Word16
Instance details Methods lift :: Word16 -> Q Exp #
Lift Word32
Instance details Methods lift :: Word32 -> Q Exp #
Lift Word64
Instance details Methods lift :: Word64 -> Q Exp #
Lift ()
Instance details Methods lift :: () -> Q Exp #
Lift PortName #
Instance details Methods lift :: PortName -> Q Exp #
Lift TopEntity #
Instance details Methods lift :: TopEntity -> Q Exp #
Lift Bit #
Instance details Methods lift :: Bit -> Q Exp #
Lift Half
Instance details Methods lift :: Half -> Q Exp #
Lift a => Lift [a]
Instance details Methods lift :: [a] -> Q Exp #
Lift a => Lift (Maybe a)
Instance details Methods lift :: Maybe a -> Q Exp #
Integral a => Lift (Ratio a)
Instance details Methods lift :: Ratio a -> Q Exp #
KnownNat n => Lift (BitVector n) #
Instance details Methods lift :: BitVector n -> Q Exp #
KnownNat n => Lift (Index n) #
Instance details Methods lift :: Index n -> Q Exp #
Lift (SNat n) #
Instance details Methods lift :: SNat n -> Q Exp #
KnownNat n => Lift (Unsigned n) #
Instance details Methods lift :: Unsigned n -> Q Exp #
KnownNat n => Lift (Signed n) #
Instance details Methods lift :: Signed n -> Q Exp #
(Lift a, Lift b) => Lift (Either a b)
Instance details Methods lift :: Either a b -> Q Exp #
(Lift a, Lift b) => Lift (a, b)
Instance details Methods lift :: (a, b) -> Q Exp #
Lift a => Lift (Vec n a) #
Instance details Methods lift :: Vec n a -> Q Exp #
Lift a => Lift (Signal domain a) #
Instance details Methods lift :: Signal domain a -> Q Exp #
Lift a => Lift (RTree d a) #
Instance details Methods lift :: RTree d a -> Q Exp #
(Lift a, Lift b, Lift c) => Lift (a, b, c)
Instance details Methods lift :: (a, b, c) -> Q Exp #
(Lift (rep (int + frac)), KnownNat frac, KnownNat int, Typeable rep) => Lift (Fixed rep int frac) #
Instance details Methods lift :: Fixed rep int frac -> Q Exp #
Lift a => Lift (DSignal domain delay a) #
Instance details Methods lift :: DSignal domain delay a -> Q Exp #
(Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d)
Instance details Methods lift :: (a, b, c, d) -> Q Exp #
(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift (a, b, c, d, e)
Instance details 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)
Instance details 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)
Instance details 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 Source #

Named types

module Clash.NamedTypes

Hidden arguments

module Clash.Hidden

Haskell Prelude

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

It instead exports the identically named functions defined in terms of Vec at Clash.Sized.Vector.

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: 2.1
Instance details Methods minBound :: Bool # maxBound :: Bool #
Bounded Char	Since: 2.1
Instance details Methods minBound :: Char # maxBound :: Char #
Bounded Int	Since: 2.1
Instance details Methods minBound :: Int # maxBound :: Int #
Bounded Int8	Since: 2.1
Instance details Methods minBound :: Int8 # maxBound :: Int8 #
Bounded Int16	Since: 2.1
Instance details Methods minBound :: Int16 # maxBound :: Int16 #
Bounded Int32	Since: 2.1
Instance details Methods minBound :: Int32 # maxBound :: Int32 #
Bounded Int64	Since: 2.1
Instance details Methods minBound :: Int64 # maxBound :: Int64 #
Bounded Ordering	Since: 2.1
Instance details Methods minBound :: Ordering # maxBound :: Ordering #
Bounded Word	Since: 2.1
Instance details Methods minBound :: Word # maxBound :: Word #
Bounded Word8	Since: 2.1
Instance details Methods minBound :: Word8 # maxBound :: Word8 #
Bounded Word16	Since: 2.1
Instance details Methods minBound :: Word16 # maxBound :: Word16 #
Bounded Word32	Since: 2.1
Instance details Methods minBound :: Word32 # maxBound :: Word32 #
Bounded Word64	Since: 2.1
Instance details Methods minBound :: Word64 # maxBound :: Word64 #
Bounded VecCount	Since: 4.10.0.0
Instance details Methods minBound :: VecCount # maxBound :: VecCount #
Bounded VecElem	Since: 4.10.0.0
Instance details Methods minBound :: VecElem # maxBound :: VecElem #
Bounded ()	Since: 2.1
Instance details Methods minBound :: () # maxBound :: () #
Bounded All
Instance details Methods minBound :: All # maxBound :: All #
Bounded Any
Instance details Methods minBound :: Any # maxBound :: Any #
Bounded Associativity
Instance details Methods minBound :: Associativity # maxBound :: Associativity #
Bounded SourceUnpackedness
Instance details Methods minBound :: SourceUnpackedness # maxBound :: SourceUnpackedness #
Bounded SourceStrictness
Instance details Methods minBound :: SourceStrictness # maxBound :: SourceStrictness #
Bounded DecidedStrictness
Instance details Methods minBound :: DecidedStrictness # maxBound :: DecidedStrictness #
Bounded CChar
Instance details Methods minBound :: CChar # maxBound :: CChar #
Bounded CSChar
Instance details Methods minBound :: CSChar # maxBound :: CSChar #
Bounded CUChar
Instance details Methods minBound :: CUChar # maxBound :: CUChar #
Bounded CShort
Instance details Methods minBound :: CShort # maxBound :: CShort #
Bounded CUShort
Instance details Methods minBound :: CUShort # maxBound :: CUShort #
Bounded CInt
Instance details Methods minBound :: CInt # maxBound :: CInt #
Bounded CUInt
Instance details Methods minBound :: CUInt # maxBound :: CUInt #
Bounded CLong
Instance details Methods minBound :: CLong # maxBound :: CLong #
Bounded CULong
Instance details Methods minBound :: CULong # maxBound :: CULong #
Bounded CLLong
Instance details Methods minBound :: CLLong # maxBound :: CLLong #
Bounded CULLong
Instance details Methods minBound :: CULLong # maxBound :: CULLong #
Bounded CBool
Instance details Methods minBound :: CBool # maxBound :: CBool #
Bounded CPtrdiff
Instance details Methods minBound :: CPtrdiff # maxBound :: CPtrdiff #
Bounded CSize
Instance details Methods minBound :: CSize # maxBound :: CSize #
Bounded CWchar
Instance details Methods minBound :: CWchar # maxBound :: CWchar #
Bounded CSigAtomic
Instance details Methods minBound :: CSigAtomic # maxBound :: CSigAtomic #
Bounded CIntPtr
Instance details Methods minBound :: CIntPtr # maxBound :: CIntPtr #
Bounded CUIntPtr
Instance details Methods minBound :: CUIntPtr # maxBound :: CUIntPtr #
Bounded CIntMax
Instance details Methods minBound :: CIntMax # maxBound :: CIntMax #
Bounded CUIntMax
Instance details Methods minBound :: CUIntMax # maxBound :: CUIntMax #
Bounded GeneralCategory
Instance details Methods minBound :: GeneralCategory # maxBound :: GeneralCategory #
Bounded Bit #
Instance details Methods minBound :: Bit # maxBound :: Bit #
a :=> (Bounded (Dict a))
Instance details Methods ins :: a :- Bounded (Dict a)
() :=> (Bounded Bool)
Instance details Methods ins :: () :- Bounded Bool
() :=> (Bounded Char)
Instance details Methods ins :: () :- Bounded Char
() :=> (Bounded Int)
Instance details Methods ins :: () :- Bounded Int
() :=> (Bounded Ordering)
Instance details Methods ins :: () :- Bounded Ordering
() :=> (Bounded Word)
Instance details Methods ins :: () :- Bounded Word
() :=> (Bounded ())
Instance details Methods ins :: () :- Bounded ()
Class () (Bounded a)
Instance details Methods cls :: Bounded a :- ()
Bounded a => Bounded (Min a)
Instance details Methods minBound :: Min a # maxBound :: Min a #
Bounded a => Bounded (Max a)
Instance details Methods minBound :: Max a # maxBound :: Max a #
Bounded a => Bounded (First a)
Instance details Methods minBound :: First a # maxBound :: First a #
Bounded a => Bounded (Last a)
Instance details Methods minBound :: Last a # maxBound :: Last a #
Bounded m => Bounded (WrappedMonoid m)
Instance details Methods minBound :: WrappedMonoid m # maxBound :: WrappedMonoid m #
Bounded a => Bounded (Identity a)
Instance details Methods minBound :: Identity a # maxBound :: Identity a #
Bounded a => Bounded (Dual a)
Instance details Methods minBound :: Dual a # maxBound :: Dual a #
Bounded a => Bounded (Sum a)
Instance details Methods minBound :: Sum a # maxBound :: Sum a #
Bounded a => Bounded (Product a)
Instance details Methods minBound :: Product a # maxBound :: Product a #
KnownNat n => Bounded (BitVector n) #
Instance details Methods minBound :: BitVector n # maxBound :: BitVector n #
KnownNat n => Bounded (Index n) #
Instance details Methods minBound :: Index n # maxBound :: Index n #
(Ord a, Num a) => Bounded (Bounds a)
Instance details Methods minBound :: Bounds a # maxBound :: Bounds a #
KnownNat n => Bounded (Unsigned n) #
Instance details Methods minBound :: Unsigned n # maxBound :: Unsigned n #
KnownNat n => Bounded (Signed n) #
Instance details Methods minBound :: Signed n # maxBound :: Signed n #
a => Bounded (Dict a)
Instance details Methods minBound :: Dict a # maxBound :: Dict a #
(Bounded a) :=> (Bounded (Identity a))
Instance details Methods ins :: Bounded a :- Bounded (Identity a)
(Bounded a) :=> (Bounded (Const a b))
Instance details Methods ins :: Bounded a :- Bounded (Const a b)
(Bounded a, Bounded b) => Bounded (a, b)	Since: 2.1
Instance details Methods minBound :: (a, b) # maxBound :: (a, b) #
Bounded (Proxy t)
Instance details Methods minBound :: Proxy t # maxBound :: Proxy t #
(Bounded a, Bounded b) :=> (Bounded (a, b))
Instance details Methods ins :: (Bounded a, Bounded b) :- Bounded (a, b)
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)	Since: 2.1
Instance details Methods minBound :: (a, b, c) # maxBound :: (a, b, c) #
Bounded a => Bounded (Const a b)
Instance details Methods minBound :: Const a b # maxBound :: Const a b #
a ~ b => Bounded (a :~: b)	Since: 4.7.0.0
Instance details Methods minBound :: a :~: b # maxBound :: a :~: b #
Bounded b => Bounded (Tagged s b)
Instance details Methods minBound :: Tagged s b # maxBound :: Tagged s b #
Bounded (rep (int + frac)) => Bounded (Fixed rep int frac) #
Instance details 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: 2.1
Instance details Methods minBound :: (a, b, c, d) # maxBound :: (a, b, c, d) #
a ~~ b => Bounded (a :~~: b)	Since: 4.10.0.0
Instance details Methods minBound :: a :~~: b # maxBound :: a :~~: b #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e)	Since: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 4.8.0.0
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 4.10.0.0
Instance details 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: 4.10.0.0
Instance details 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: 2.1
Instance details Methods succ :: () -> () # pred :: () -> () # toEnum :: Int -> () # fromEnum :: () -> Int # enumFrom :: () -> [()] # enumFromThen :: () -> () -> [()] # enumFromTo :: () -> () -> [()] # enumFromThenTo :: () -> () -> () -> [()] #
Enum Associativity
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 #
Instance details 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))
Instance details Methods ins :: a :- Enum (Dict a)
() :=> (Enum Bool)
Instance details Methods ins :: () :- Enum Bool
() :=> (Enum Char)
Instance details Methods ins :: () :- Enum Char
() :=> (Enum Double)
Instance details Methods ins :: () :- Enum Double
() :=> (Enum Float)
Instance details Methods ins :: () :- Enum Float
() :=> (Enum Int)
Instance details Methods ins :: () :- Enum Int
() :=> (Enum Integer)
Instance details Methods ins :: () :- Enum Integer
() :=> (Enum Natural)
Instance details Methods ins :: () :- Enum Natural
() :=> (Enum Ordering)
Instance details Methods ins :: () :- Enum Ordering
() :=> (Enum Word)
Instance details Methods ins :: () :- Enum Word
() :=> (Enum ())
Instance details Methods ins :: () :- Enum ()
Class () (Enum a)
Instance details Methods cls :: Enum a :- ()
Integral a => Enum (Ratio a)	Since: 2.0.1
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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.
Instance details 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.
Instance details 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)
Instance details 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.
Instance details 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.
Instance details 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)
Instance details 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))
Instance details Methods ins :: Enum a :- Enum (Identity a)
(Enum a) :=> (Enum (Const a b))
Instance details Methods ins :: Enum a :- Enum (Const a b)
(Integral a) :=> (Enum (Ratio a))
Instance details Methods ins :: Integral a :- Enum (Ratio a)
Enum (Proxy s)	Since: 4.7.0.0
Instance details 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)
Instance details Methods cls :: Integral a :- (Real a, Enum a)
Enum a => Enum (Const a b)
Instance details 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)
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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) #
Instance details 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: 4.10.0.0
Instance details 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
Instance details Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Eq Char
Instance details Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Eq Double
Instance details Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Eq Float
Instance details Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Eq Int
Instance details Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Eq Int8	Since: 2.1
Instance details Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq Int16	Since: 2.1
Instance details Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32	Since: 2.1
Instance details Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64	Since: 2.1
Instance details Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Integer
Instance details Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Natural
Instance details Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Eq Ordering
Instance details Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq Word
Instance details Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Eq Word8	Since: 2.1
Instance details Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Word16	Since: 2.1
Instance details Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32	Since: 2.1
Instance details Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64	Since: 2.1
Instance details Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq SomeTypeRep
Instance details Methods (==) :: SomeTypeRep -> SomeTypeRep -> Bool # (/=) :: SomeTypeRep -> SomeTypeRep -> Bool #
Eq Exp
Instance details Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Eq Match
Instance details Methods (==) :: Match -> Match -> Bool # (/=) :: Match -> Match -> Bool #
Eq Clause
Instance details Methods (==) :: Clause -> Clause -> Bool # (/=) :: Clause -> Clause -> Bool #
Eq Pat
Instance details Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Eq Type
Instance details Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Eq Dec
Instance details Methods (==) :: Dec -> Dec -> Bool # (/=) :: Dec -> Dec -> Bool #
Eq Name
Instance details Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Eq FunDep
Instance details Methods (==) :: FunDep -> FunDep -> Bool # (/=) :: FunDep -> FunDep -> Bool #
Eq InjectivityAnn
Instance details Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool #
Eq Overlap
Instance details Methods (==) :: Overlap -> Overlap -> Bool # (/=) :: Overlap -> Overlap -> Bool #
Eq DerivStrategy
Instance details Methods (==) :: DerivStrategy -> DerivStrategy -> Bool # (/=) :: DerivStrategy -> DerivStrategy -> Bool #
Eq ()
Instance details Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq TyCon
Instance details Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq Module
Instance details Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq TrName
Instance details Methods (==) :: TrName -> TrName -> Bool # (/=) :: TrName -> TrName -> Bool #
Eq BigNat
Instance details Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq Void	Since: 4.8.0.0
Instance details Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq SpecConstrAnnotation
Instance details Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Constr	Equality of constructors Since: 4.0.0.0
Instance details Methods (==) :: Constr -> Constr -> Bool # (/=) :: Constr -> Constr -> Bool #
Eq DataRep
Instance details Methods (==) :: DataRep -> DataRep -> Bool # (/=) :: DataRep -> DataRep -> Bool #
Eq ConstrRep
Instance details Methods (==) :: ConstrRep -> ConstrRep -> Bool # (/=) :: ConstrRep -> ConstrRep -> Bool #
Eq Fixity
Instance details Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Unique
Instance details Methods (==) :: Unique -> Unique -> Bool # (/=) :: Unique -> Unique -> Bool #
Eq Version	Since: 2.1
Instance details Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq ThreadId	Since: 4.2.0.0
Instance details Methods (==) :: ThreadId -> ThreadId -> Bool # (/=) :: ThreadId -> ThreadId -> Bool #
Eq BlockReason
Instance details Methods (==) :: BlockReason -> BlockReason -> Bool # (/=) :: BlockReason -> BlockReason -> Bool #
Eq ThreadStatus
Instance details Methods (==) :: ThreadStatus -> ThreadStatus -> Bool # (/=) :: ThreadStatus -> ThreadStatus -> Bool #
Eq AsyncException
Instance details Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Eq ArrayException
Instance details Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Eq ExitCode
Instance details Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Eq IOErrorType	Since: 4.1.0.0
Instance details Methods (==) :: IOErrorType -> IOErrorType -> Bool # (/=) :: IOErrorType -> IOErrorType -> Bool #
Eq MaskingState
Instance details Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #
Eq IOException	Since: 4.1.0.0
Instance details Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Eq ErrorCall
Instance details Methods (==) :: ErrorCall -> ErrorCall -> Bool # (/=) :: ErrorCall -> ErrorCall -> Bool #
Eq ArithException
Instance details Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool #
Eq All
Instance details Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Eq Any
Instance details Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Eq Fixity
Instance details Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Associativity
Instance details Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Eq SourceUnpackedness
Instance details Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness
Instance details Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness
Instance details Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq SomeSymbol	Since: 4.7.0.0
Instance details Methods (==) :: SomeSymbol -> SomeSymbol -> Bool # (/=) :: SomeSymbol -> SomeSymbol -> Bool #
Eq SomeNat	Since: 4.7.0.0
Instance details Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Eq CChar
Instance details Methods (==) :: CChar -> CChar -> Bool # (/=) :: CChar -> CChar -> Bool #
Eq CSChar
Instance details Methods (==) :: CSChar -> CSChar -> Bool # (/=) :: CSChar -> CSChar -> Bool #
Eq CUChar
Instance details Methods (==) :: CUChar -> CUChar -> Bool # (/=) :: CUChar -> CUChar -> Bool #
Eq CShort
Instance details Methods (==) :: CShort -> CShort -> Bool # (/=) :: CShort -> CShort -> Bool #
Eq CUShort
Instance details Methods (==) :: CUShort -> CUShort -> Bool # (/=) :: CUShort -> CUShort -> Bool #
Eq CInt
Instance details Methods (==) :: CInt -> CInt -> Bool # (/=) :: CInt -> CInt -> Bool #
Eq CUInt
Instance details Methods (==) :: CUInt -> CUInt -> Bool # (/=) :: CUInt -> CUInt -> Bool #
Eq CLong
Instance details Methods (==) :: CLong -> CLong -> Bool # (/=) :: CLong -> CLong -> Bool #
Eq CULong
Instance details Methods (==) :: CULong -> CULong -> Bool # (/=) :: CULong -> CULong -> Bool #
Eq CLLong
Instance details Methods (==) :: CLLong -> CLLong -> Bool # (/=) :: CLLong -> CLLong -> Bool #
Eq CULLong
Instance details Methods (==) :: CULLong -> CULLong -> Bool # (/=) :: CULLong -> CULLong -> Bool #
Eq CBool
Instance details Methods (==) :: CBool -> CBool -> Bool # (/=) :: CBool -> CBool -> Bool #
Eq CFloat
Instance details Methods (==) :: CFloat -> CFloat -> Bool # (/=) :: CFloat -> CFloat -> Bool #
Eq CDouble
Instance details Methods (==) :: CDouble -> CDouble -> Bool # (/=) :: CDouble -> CDouble -> Bool #
Eq CPtrdiff
Instance details Methods (==) :: CPtrdiff -> CPtrdiff -> Bool # (/=) :: CPtrdiff -> CPtrdiff -> Bool #
Eq CSize
Instance details Methods (==) :: CSize -> CSize -> Bool # (/=) :: CSize -> CSize -> Bool #
Eq CWchar
Instance details Methods (==) :: CWchar -> CWchar -> Bool # (/=) :: CWchar -> CWchar -> Bool #
Eq CSigAtomic
Instance details Methods (==) :: CSigAtomic -> CSigAtomic -> Bool # (/=) :: CSigAtomic -> CSigAtomic -> Bool #
Eq CClock
Instance details Methods (==) :: CClock -> CClock -> Bool # (/=) :: CClock -> CClock -> Bool #
Eq CTime
Instance details Methods (==) :: CTime -> CTime -> Bool # (/=) :: CTime -> CTime -> Bool #
Eq CUSeconds
Instance details Methods (==) :: CUSeconds -> CUSeconds -> Bool # (/=) :: CUSeconds -> CUSeconds -> Bool #
Eq CSUSeconds
Instance details Methods (==) :: CSUSeconds -> CSUSeconds -> Bool # (/=) :: CSUSeconds -> CSUSeconds -> Bool #
Eq CIntPtr
Instance details Methods (==) :: CIntPtr -> CIntPtr -> Bool # (/=) :: CIntPtr -> CIntPtr -> Bool #
Eq CUIntPtr
Instance details Methods (==) :: CUIntPtr -> CUIntPtr -> Bool # (/=) :: CUIntPtr -> CUIntPtr -> Bool #
Eq CIntMax
Instance details Methods (==) :: CIntMax -> CIntMax -> Bool # (/=) :: CIntMax -> CIntMax -> Bool #
Eq CUIntMax
Instance details Methods (==) :: CUIntMax -> CUIntMax -> Bool # (/=) :: CUIntMax -> CUIntMax -> Bool #
Eq Fingerprint
Instance details Methods (==) :: Fingerprint -> Fingerprint -> Bool # (/=) :: Fingerprint -> Fingerprint -> Bool #
Eq Lexeme
Instance details Methods (==) :: Lexeme -> Lexeme -> Bool # (/=) :: Lexeme -> Lexeme -> Bool #
Eq Number
Instance details Methods (==) :: Number -> Number -> Bool # (/=) :: Number -> Number -> Bool #
Eq GeneralCategory
Instance details Methods (==) :: GeneralCategory -> GeneralCategory -> Bool # (/=) :: GeneralCategory -> GeneralCategory -> Bool #
Eq SrcLoc
Instance details Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Eq ByteString
Instance details Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq ByteString
Instance details Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq IntSet
Instance details Methods (==) :: IntSet -> IntSet -> Bool # (/=) :: IntSet -> IntSet -> Bool #
Eq TyVarBndr
Instance details Methods (==) :: TyVarBndr -> TyVarBndr -> Bool # (/=) :: TyVarBndr -> TyVarBndr -> Bool #
Eq Extension
Instance details Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Eq ForeignSrcLang
Instance details Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool #
Eq Doc
Instance details Methods (==) :: Doc -> Doc -> Bool # (/=) :: Doc -> Doc -> Bool #
Eq TextDetails
Instance details Methods (==) :: TextDetails -> TextDetails -> Bool # (/=) :: TextDetails -> TextDetails -> Bool #
Eq Style
Instance details Methods (==) :: Style -> Style -> Bool # (/=) :: Style -> Style -> Bool #
Eq Mode
Instance details Methods (==) :: Mode -> Mode -> Bool # (/=) :: Mode -> Mode -> Bool #
Eq ModName
Instance details Methods (==) :: ModName -> ModName -> Bool # (/=) :: ModName -> ModName -> Bool #
Eq PkgName
Instance details Methods (==) :: PkgName -> PkgName -> Bool # (/=) :: PkgName -> PkgName -> Bool #
Eq Module
Instance details Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq OccName
Instance details Methods (==) :: OccName -> OccName -> Bool # (/=) :: OccName -> OccName -> Bool #
Eq NameFlavour
Instance details Methods (==) :: NameFlavour -> NameFlavour -> Bool # (/=) :: NameFlavour -> NameFlavour -> Bool #
Eq NameSpace
Instance details Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Eq Loc
Instance details Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Eq Info
Instance details Methods (==) :: Info -> Info -> Bool # (/=) :: Info -> Info -> Bool #
Eq ModuleInfo
Instance details Methods (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool #
Eq Fixity
Instance details Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq FixityDirection
Instance details Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Eq Lit
Instance details Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Eq Body
Instance details Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Eq Guard
Instance details Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Eq Stmt
Instance details Methods (==) :: Stmt -> Stmt -> Bool # (/=) :: Stmt -> Stmt -> Bool #
Eq Range
Instance details Methods (==) :: Range -> Range -> Bool # (/=) :: Range -> Range -> Bool #
Eq DerivClause
Instance details Methods (==) :: DerivClause -> DerivClause -> Bool # (/=) :: DerivClause -> DerivClause -> Bool #
Eq TypeFamilyHead
Instance details Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool #
Eq TySynEqn
Instance details Methods (==) :: TySynEqn -> TySynEqn -> Bool # (/=) :: TySynEqn -> TySynEqn -> Bool #
Eq Foreign
Instance details Methods (==) :: Foreign -> Foreign -> Bool # (/=) :: Foreign -> Foreign -> Bool #
Eq Callconv
Instance details Methods (==) :: Callconv -> Callconv -> Bool # (/=) :: Callconv -> Callconv -> Bool #
Eq Safety
Instance details Methods (==) :: Safety -> Safety -> Bool # (/=) :: Safety -> Safety -> Bool #
Eq Pragma
Instance details Methods (==) :: Pragma -> Pragma -> Bool # (/=) :: Pragma -> Pragma -> Bool #
Eq Inline
Instance details Methods (==) :: Inline -> Inline -> Bool # (/=) :: Inline -> Inline -> Bool #
Eq RuleMatch
Instance details Methods (==) :: RuleMatch -> RuleMatch -> Bool # (/=) :: RuleMatch -> RuleMatch -> Bool #
Eq Phases
Instance details Methods (==) :: Phases -> Phases -> Bool # (/=) :: Phases -> Phases -> Bool #
Eq RuleBndr
Instance details Methods (==) :: RuleBndr -> RuleBndr -> Bool # (/=) :: RuleBndr -> RuleBndr -> Bool #
Eq AnnTarget
Instance details Methods (==) :: AnnTarget -> AnnTarget -> Bool # (/=) :: AnnTarget -> AnnTarget -> Bool #
Eq SourceUnpackedness
Instance details Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness
Instance details Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness
Instance details Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq Con
Instance details Methods (==) :: Con -> Con -> Bool # (/=) :: Con -> Con -> Bool #
Eq Bang
Instance details Methods (==) :: Bang -> Bang -> Bool # (/=) :: Bang -> Bang -> Bool #
Eq PatSynDir
Instance details Methods (==) :: PatSynDir -> PatSynDir -> Bool # (/=) :: PatSynDir -> PatSynDir -> Bool #
Eq PatSynArgs
Instance details Methods (==) :: PatSynArgs -> PatSynArgs -> Bool # (/=) :: PatSynArgs -> PatSynArgs -> Bool #
Eq FamilyResultSig
Instance details Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool #
Eq TyLit
Instance details Methods (==) :: TyLit -> TyLit -> Bool # (/=) :: TyLit -> TyLit -> Bool #
Eq Role
Instance details Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Eq AnnLookup
Instance details Methods (==) :: AnnLookup -> AnnLookup -> Bool # (/=) :: AnnLookup -> AnnLookup -> Bool #
Eq LocalTime
Instance details Methods (==) :: LocalTime -> LocalTime -> Bool # (/=) :: LocalTime -> LocalTime -> Bool #
Eq UniversalTime
Instance details Methods (==) :: UniversalTime -> UniversalTime -> Bool # (/=) :: UniversalTime -> UniversalTime -> Bool #
Eq UTCTime
Instance details Methods (==) :: UTCTime -> UTCTime -> Bool # (/=) :: UTCTime -> UTCTime -> Bool #
Eq Day
Instance details Methods (==) :: Day -> Day -> Bool # (/=) :: Day -> Day -> Bool #
Eq HDL #
Instance details Methods (==) :: HDL -> HDL -> Bool # (/=) :: HDL -> HDL -> Bool #
Eq SaturationMode #
Instance details Methods (==) :: SaturationMode -> SaturationMode -> Bool # (/=) :: SaturationMode -> SaturationMode -> Bool #
Eq Bit #
Instance details Methods (==) :: Bit -> Bit -> Bool # (/=) :: Bit -> Bit -> Bool #
Eq DefName
Instance details Methods (==) :: DefName -> DefName -> Bool # (/=) :: DefName -> DefName -> Bool #
Eq TimeLocale
Instance details Methods (==) :: TimeLocale -> TimeLocale -> Bool # (/=) :: TimeLocale -> TimeLocale -> Bool #
Eq ByteArray
Instance details Methods (==) :: ByteArray -> ByteArray -> Bool # (/=) :: ByteArray -> ByteArray -> Bool #
Eq Addr
Instance details Methods (==) :: Addr -> Addr -> Bool # (/=) :: Addr -> Addr -> Bool #
Eq ConstructorInfo
Instance details Methods (==) :: ConstructorInfo -> ConstructorInfo -> Bool # (/=) :: ConstructorInfo -> ConstructorInfo -> Bool #
Eq ConstructorVariant
Instance details Methods (==) :: ConstructorVariant -> ConstructorVariant -> Bool # (/=) :: ConstructorVariant -> ConstructorVariant -> Bool #
Eq DatatypeInfo
Instance details Methods (==) :: DatatypeInfo -> DatatypeInfo -> Bool # (/=) :: DatatypeInfo -> DatatypeInfo -> Bool #
Eq DatatypeVariant
Instance details Methods (==) :: DatatypeVariant -> DatatypeVariant -> Bool # (/=) :: DatatypeVariant -> DatatypeVariant -> Bool #
Eq FieldStrictness
Instance details Methods (==) :: FieldStrictness -> FieldStrictness -> Bool # (/=) :: FieldStrictness -> FieldStrictness -> Bool #
Eq Strictness
Instance details Methods (==) :: Strictness -> Strictness -> Bool # (/=) :: Strictness -> Strictness -> Bool #
Eq Unpackedness
Instance details Methods (==) :: Unpackedness -> Unpackedness -> Bool # (/=) :: Unpackedness -> Unpackedness -> Bool #
Eq Half
Instance details Methods (==) :: Half -> Half -> Bool # (/=) :: Half -> Half -> Bool #
Eq ResetKind #
Instance details Methods (==) :: ResetKind -> ResetKind -> Bool # (/=) :: ResetKind -> ResetKind -> Bool #
Eq ClockKind #
Instance details Methods (==) :: ClockKind -> ClockKind -> Bool # (/=) :: ClockKind -> ClockKind -> Bool #
Eq NewOrData
Instance details Methods (==) :: NewOrData -> NewOrData -> Bool # (/=) :: NewOrData -> NewOrData -> Bool #
() :=> (Eq Bool)
Instance details Methods ins :: () :- Eq Bool
() :=> (Eq Double)
Instance details Methods ins :: () :- Eq Double
() :=> (Eq Float)
Instance details Methods ins :: () :- Eq Float
() :=> (Eq Int)
Instance details Methods ins :: () :- Eq Int
() :=> (Eq Integer)
Instance details Methods ins :: () :- Eq Integer
() :=> (Eq Natural)
Instance details Methods ins :: () :- Eq Natural
() :=> (Eq Word)
Instance details Methods ins :: () :- Eq Word
() :=> (Eq ())
Instance details Methods ins :: () :- Eq ()
() :=> (Eq (a :- b))
Instance details Methods ins :: () :- Eq (a :- b)
() :=> (Eq (Dict a))
Instance details Methods ins :: () :- Eq (Dict a)
Class () (Eq a)
Instance details Methods cls :: Eq a :- ()
Eq a => Eq [a]
Instance details Methods (==) :: [a] -> [a] -> Bool # (/=) :: [a] -> [a] -> Bool #
Eq a => Eq (Maybe a)
Instance details Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Eq a => Eq (Ratio a)
Instance details Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Eq (Ptr a)
Instance details Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Eq (FunPtr a)
Instance details Methods (==) :: FunPtr a -> FunPtr a -> Bool # (/=) :: FunPtr a -> FunPtr a -> Bool #
Eq p => Eq (Par1 p)
Instance details Methods (==) :: Par1 p -> Par1 p -> Bool # (/=) :: Par1 p -> Par1 p -> Bool #
Eq a => Eq (Complex a)
Instance details Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
Eq (Fixed a)
Instance details Methods (==) :: Fixed a -> Fixed a -> Bool # (/=) :: Fixed a -> Fixed a -> Bool #
Eq a => Eq (Min a)
Instance details Methods (==) :: Min a -> Min a -> Bool # (/=) :: Min a -> Min a -> Bool #
Eq a => Eq (Max a)
Instance details Methods (==) :: Max a -> Max a -> Bool # (/=) :: Max a -> Max a -> Bool #
Eq a => Eq (First a)
Instance details Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)
Instance details Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq m => Eq (WrappedMonoid m)
Instance details Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Eq a => Eq (Option a)
Instance details Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Eq (StableName a)	Since: 2.1
Instance details Methods (==) :: StableName a -> StableName a -> Bool # (/=) :: StableName a -> StableName a -> Bool #
Eq a => Eq (ZipList a)
Instance details Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Eq a => Eq (Identity a)
Instance details Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq (TVar a)	Since: 4.8.0.0
Instance details Methods (==) :: TVar a -> TVar a -> Bool # (/=) :: TVar a -> TVar a -> Bool #
Eq (IORef a)	Pointer equality. Since: 4.1.0.0
Instance details Methods (==) :: IORef a -> IORef a -> Bool # (/=) :: IORef a -> IORef a -> Bool #
Eq a => Eq (First a)
Instance details Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)
Instance details Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq a => Eq (Dual a)
Instance details Methods (==) :: Dual a -> Dual a -> Bool # (/=) :: Dual a -> Dual a -> Bool #
Eq a => Eq (Sum a)
Instance details Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Eq a => Eq (Product a)
Instance details Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Eq a => Eq (Down a)
Instance details Methods (==) :: Down a -> Down a -> Bool # (/=) :: Down a -> Down a -> Bool #
Eq (MVar a)	Since: 4.1.0.0
Instance details Methods (==) :: MVar a -> MVar a -> Bool # (/=) :: MVar a -> MVar a -> Bool #
Eq a => Eq (NonEmpty a)
Instance details Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq a => Eq (IntMap a)
Instance details Methods (==) :: IntMap a -> IntMap a -> Bool # (/=) :: IntMap a -> IntMap a -> Bool #
Eq a => Eq (Tree a)
Instance details Methods (==) :: Tree a -> Tree a -> Bool # (/=) :: Tree a -> Tree a -> Bool #
Eq a => Eq (Seq a)
Instance details Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Eq a => Eq (ViewL a)
Instance details Methods (==) :: ViewL a -> ViewL a -> Bool # (/=) :: ViewL a -> ViewL a -> Bool #
Eq a => Eq (ViewR a)
Instance details Methods (==) :: ViewR a -> ViewR a -> Bool # (/=) :: ViewR a -> ViewR a -> Bool #
Eq a => Eq (Set a)
Instance details Methods (==) :: Set a -> Set a -> Bool # (/=) :: Set a -> Set a -> Bool #
Eq (Doc a)
Instance details Methods (==) :: Doc a -> Doc a -> Bool # (/=) :: Doc a -> Doc a -> Bool #
Eq a => Eq (AnnotDetails a)
Instance details Methods (==) :: AnnotDetails a -> AnnotDetails a -> Bool # (/=) :: AnnotDetails a -> AnnotDetails a -> Bool #
Eq a => Eq (Span a)
Instance details Methods (==) :: Span a -> Span a -> Bool # (/=) :: Span a -> Span a -> Bool #
Eq (BitVector n) #
Instance details Methods (==) :: BitVector n -> BitVector n -> Bool # (/=) :: BitVector n -> BitVector n -> Bool #
Eq (Index n) #
Instance details Methods (==) :: Index n -> Index n -> Bool # (/=) :: Index n -> Index n -> Bool #
Eq a => Eq (Bounds a)
Instance details Methods (==) :: Bounds a -> Bounds a -> Bool # (/=) :: Bounds a -> Bounds a -> Bool #
Eq a => Eq (DList a)
Instance details Methods (==) :: DList a -> DList a -> Bool # (/=) :: DList a -> DList a -> Bool #
Eq a => Eq (HashSet a)
Instance details Methods (==) :: HashSet a -> HashSet a -> Bool # (/=) :: HashSet a -> HashSet a -> Bool #
(Storable a, Eq a) => Eq (Vector a)
Instance details Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
(Prim a, Eq a) => Eq (Vector a)
Instance details Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
Eq a => Eq (Vector a)
Instance details Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
Eq a => Eq (Array a)
Instance details Methods (==) :: Array a -> Array a -> Bool # (/=) :: Array a -> Array a -> Bool #
Eq (Unsigned n) #
Instance details Methods (==) :: Unsigned n -> Unsigned n -> Bool # (/=) :: Unsigned n -> Unsigned n -> Bool #
Eq (Signed n) #
Instance details Methods (==) :: Signed n -> Signed n -> Bool # (/=) :: Signed n -> Signed n -> Bool #
Eq (Dict a)
Instance details Methods (==) :: Dict a -> Dict a -> Bool # (/=) :: Dict a -> Dict a -> Bool #
(Eq a) :=> (Eq [a])
Instance details Methods ins :: Eq a :- Eq [a]
(Eq a) :=> (Eq (Maybe a))
Instance details Methods ins :: Eq a :- Eq (Maybe a)
(Eq a) :=> (Eq (Complex a))
Instance details Methods ins :: Eq a :- Eq (Complex a)
(Eq a) :=> (Eq (Ratio a))
Instance details Methods ins :: Eq a :- Eq (Ratio a)
(Eq a) :=> (Eq (Identity a))
Instance details Methods ins :: Eq a :- Eq (Identity a)
(Eq a) :=> (Eq (Const a b))
Instance details Methods ins :: Eq a :- Eq (Const a b)
Class (Eq a) (Ord a)
Instance details Methods cls :: Ord a :- Eq a
Class (Eq a) (Bits a)
Instance details Methods cls :: Bits a :- Eq a
(Eq a, Eq b) => Eq (Either a b)
Instance details Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
Eq (V1 p)	Since: 4.9.0.0
Instance details Methods (==) :: V1 p -> V1 p -> Bool # (/=) :: V1 p -> V1 p -> Bool #
Eq (U1 p)	Since: 4.9.0.0
Instance details Methods (==) :: U1 p -> U1 p -> Bool # (/=) :: U1 p -> U1 p -> Bool #
Eq (TypeRep a)	Since: 2.1
Instance details Methods (==) :: TypeRep a -> TypeRep a -> Bool # (/=) :: TypeRep a -> TypeRep a -> Bool #
(Eq a, Eq b) => Eq (a, b)
Instance details Methods (==) :: (a, b) -> (a, b) -> Bool # (/=) :: (a, b) -> (a, b) -> Bool #
(Ix i, Eq e) => Eq (Array i e)	Since: 2.1
Instance details Methods (==) :: Array i e -> Array i e -> Bool # (/=) :: Array i e -> Array i e -> Bool #
Eq a => Eq (Arg a b)	Since: 4.9.0.0
Instance details Methods (==) :: Arg a b -> Arg a b -> Bool # (/=) :: Arg a b -> Arg a b -> Bool #
Eq (Proxy s)	Since: 4.7.0.0
Instance details Methods (==) :: Proxy s -> Proxy s -> Bool # (/=) :: Proxy s -> Proxy s -> Bool #
Eq (STRef s a)	Pointer equality. Since: 2.1
Instance details Methods (==) :: STRef s a -> STRef s a -> Bool # (/=) :: STRef s a -> STRef s a -> Bool #
(Eq k, Eq a) => Eq (Map k a)
Instance details Methods (==) :: Map k a -> Map k a -> Bool # (/=) :: Map k a -> Map k a -> Bool #
(KnownNat n, Eq a) => Eq (Vec n a) #
Instance details Methods (==) :: Vec n a -> Vec n a -> Bool # (/=) :: Vec n a -> Vec n a -> Bool #
(Eq i, Eq a) => Eq (Level i a)
Instance details Methods (==) :: Level i a -> Level i a -> Bool # (/=) :: Level i a -> Level i a -> Bool #
(Eq1 f, Eq a) => Eq (Cofree f a)
Instance details Methods (==) :: Cofree f a -> Cofree f a -> Bool # (/=) :: Cofree f a -> Cofree f a -> Bool #
(Eq1 f, Eq a) => Eq (Free f a)
Instance details Methods (==) :: Free f a -> Free f a -> Bool # (/=) :: Free f a -> Free f a -> Bool #
(Eq1 f, Eq a) => Eq (Yoneda f a)
Instance details Methods (==) :: Yoneda f a -> Yoneda f a -> Bool # (/=) :: Yoneda f a -> Yoneda f a -> Bool #
(Eq k, Eq v) => Eq (HashMap k v)
Instance details Methods (==) :: HashMap k v -> HashMap k v -> Bool # (/=) :: HashMap k v -> HashMap k v -> Bool #
Eq (MutableArray s a)
Instance details Methods (==) :: MutableArray s a -> MutableArray s a -> Bool # (/=) :: MutableArray s a -> MutableArray s a -> Bool #
(Eq k, Eq v) => Eq (Leaf k v)
Instance details Methods (==) :: Leaf k v -> Leaf k v -> Bool # (/=) :: Leaf k v -> Leaf k v -> Bool #
(KnownNat d, Eq a) => Eq (RTree d a) #
Instance details Methods (==) :: RTree d a -> RTree d a -> Bool # (/=) :: RTree d a -> RTree d a -> Bool #
Eq (a :- b)
Instance details Methods (==) :: (a :- b) -> (a :- b) -> Bool # (/=) :: (a :- b) -> (a :- b) -> Bool #
(Eq a, Eq b) :=> (Eq (a, b))
Instance details Methods ins :: (Eq a, Eq b) :- Eq (a, b)
(Eq a, Eq b) :=> (Eq (Either a b))
Instance details Methods ins :: (Eq a, Eq b) :- Eq (Either a b)
Eq (f p) => Eq (Rec1 f p)
Instance details Methods (==) :: Rec1 f p -> Rec1 f p -> Bool # (/=) :: Rec1 f p -> Rec1 f p -> Bool #
Eq (URec (Ptr ()) p)
Instance details Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
Eq (URec Char p)
Instance details Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Eq (URec Double p)
Instance details Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Eq (URec Float p)
Instance details Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Eq (URec Int p)
Instance details Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Eq (URec Word p)
Instance details 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)
Instance details Methods (==) :: (a, b, c) -> (a, b, c) -> Bool # (/=) :: (a, b, c) -> (a, b, c) -> Bool #
Eq (STArray s i e)	Since: 2.1
Instance details 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)
Instance details Methods (==) :: Const a b -> Const a b -> Bool # (/=) :: Const a b -> Const a b -> Bool #
Eq (f a) => Eq (Alt f a)
Instance details Methods (==) :: Alt f a -> Alt f a -> Bool # (/=) :: Alt f a -> Alt f a -> Bool #
Eq (a :~: b)
Instance details Methods (==) :: (a :~: b) -> (a :~: b) -> Bool # (/=) :: (a :~: b) -> (a :~: b) -> Bool #
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a)
Instance details 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)
Instance details Methods (==) :: Constant a b -> Constant a b -> Bool # (/=) :: Constant a b -> Constant a b -> Bool #
Eq b => Eq (Tagged s b)
Instance details 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)
Instance details Methods (==) :: Fix p a -> Fix p a -> Bool # (/=) :: Fix p a -> Fix p a -> Bool #
Eq (p a a) => Eq (Join p a)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details Methods (==) :: Sum f g a -> Sum f g a -> Bool # (/=) :: Sum f g a -> Sum f g a -> Bool #
Eq (a :~~: b)	Since: 4.10.0.0
Instance details Methods (==) :: (a :~~: b) -> (a :~~: b) -> Bool # (/=) :: (a :~~: b) -> (a :~~: b) -> Bool #
Eq (f p) => Eq (M1 i c f p)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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
Instance details 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
Instance details 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
Instance details 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)
Instance details Methods ins :: () :- Floating Double
() :=> (Floating Float)
Instance details Methods ins :: () :- Floating Float
RealFloat a => Floating (Complex a)	Since: 2.1
Instance details 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)
Instance details 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))
Instance details Methods ins :: Floating a :- Floating (Identity a)
(Floating a) :=> (Floating (Const a b))
Instance details Methods ins :: Floating a :- Floating (Const a b)
(RealFloat a) :=> (Floating (Complex a))
Instance details Methods ins :: RealFloat a :- Floating (Complex a)
Class (Fractional a) (Floating a)
Instance details Methods cls :: Floating a :- Fractional a
Floating a => Floating (Op a b)
Instance details 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)
Instance details Methods cls :: RealFloat a :- (RealFrac a, Floating a)
Floating a => Floating (Const a b)
Instance details 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)
Instance details 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
Instance details Methods (/) :: CFloat -> CFloat -> CFloat # recip :: CFloat -> CFloat # fromRational :: Rational -> CFloat #
Fractional CDouble
Instance details Methods (/) :: CDouble -> CDouble -> CDouble # recip :: CDouble -> CDouble # fromRational :: Rational -> CDouble #
Fractional Half
Instance details Methods (/) :: Half -> Half -> Half # recip :: Half -> Half # fromRational :: Rational -> Half #
() :=> (Fractional Double)
Instance details Methods ins :: () :- Fractional Double
() :=> (Fractional Float)
Instance details Methods ins :: () :- Fractional Float
Integral a => Fractional (Ratio a)	Since: 2.0.1
Instance details Methods (/) :: Ratio a -> Ratio a -> Ratio a # recip :: Ratio a -> Ratio a # fromRational :: Rational -> Ratio a #
RealFloat a => Fractional (Complex a)	Since: 2.1
Instance details Methods (/) :: Complex a -> Complex a -> Complex a # recip :: Complex a -> Complex a # fromRational :: Rational -> Complex a #
HasResolution a => Fractional (Fixed a)	Since: 2.1
Instance details Methods (/) :: Fixed a -> Fixed a -> Fixed a # recip :: Fixed a -> Fixed a # fromRational :: Rational -> Fixed a #
Fractional a => Fractional (Identity a)
Instance details Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
(Fractional a) :=> (Fractional (Identity a))
Instance details Methods ins :: Fractional a :- Fractional (Identity a)
(Fractional a) :=> (Fractional (Const a b))
Instance details Methods ins :: Fractional a :- Fractional (Const a b)
(Integral a) :=> (Fractional (Ratio a))
Instance details Methods ins :: Integral a :- Fractional (Ratio a)
(RealFloat a) :=> (Fractional (Complex a))
Instance details Methods ins :: RealFloat a :- Fractional (Complex a)
Class (Fractional a) (Floating a)
Instance details Methods cls :: Floating a :- Fractional a
Class (Num a) (Fractional a)
Instance details Methods cls :: Fractional a :- Num a
Fractional a => Fractional (Op a b)
Instance details 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) #
Instance details 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)
Instance details Methods cls :: RealFrac a :- (Real a, Fractional a)
Fractional a => Fractional (Const a b)
Instance details 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)
Instance details 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`
Instance details 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) #
Instance details 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: 2.0.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.0.1
Instance details 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: 4.8.0.0
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 #
Instance details 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)
Instance details Methods ins :: () :- Integral Int
() :=> (Integral Integer)
Instance details Methods ins :: () :- Integral Integer
() :=> (Integral Natural)
Instance details Methods ins :: () :- Integral Natural
() :=> (Integral Word)
Instance details Methods ins :: () :- Integral Word
Integral a => Integral (Identity a)
Instance details 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) #
Instance details 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) #
Instance details 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)
Instance details 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) #
Instance details 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) #
Instance details 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))
Instance details Methods ins :: Integral a :- RealFrac (Ratio a)
(Integral a) :=> (Real (Ratio a))
Instance details Methods ins :: Integral a :- Real (Ratio a)
(Integral a) :=> (Ord (Ratio a))
Instance details Methods ins :: Integral a :- Ord (Ratio a)
(Integral a) :=> (Num (Ratio a))
Instance details Methods ins :: Integral a :- Num (Ratio a)
(Integral a) :=> (Integral (Identity a))
Instance details Methods ins :: Integral a :- Integral (Identity a)
(Integral a) :=> (Integral (Const a b))
Instance details Methods ins :: Integral a :- Integral (Const a b)
(Integral a) :=> (Fractional (Ratio a))
Instance details Methods ins :: Integral a :- Fractional (Ratio a)
(Integral a) :=> (Enum (Ratio a))
Instance details Methods ins :: Integral a :- Enum (Ratio a)
(Integral a, Show a) :=> (Show (Ratio a))
Instance details Methods ins :: (Integral a, Show a) :- Show (Ratio a)
(Integral a, Read a) :=> (Read (Ratio a))
Instance details Methods ins :: (Integral a, Read a) :- Read (Ratio a)
Class (Real a, Enum a) (Integral a)
Instance details Methods cls :: Integral a :- (Real a, Enum a)
Integral a => Integral (Const a b)
Instance details 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)
Instance details 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: 2.1
Instance details Methods (>>=) :: [a] -> (a -> [b]) -> [b] # (>>) :: [a] -> [b] -> [b] # return :: a -> [a] # fail :: String -> [a] #
Monad Maybe	Since: 2.1
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b # (>>) :: Par1 a -> Par1 b -> Par1 b # return :: a -> Par1 a # fail :: String -> Par1 a #
Monad Q
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.3.0.0
Instance details Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a # fail :: String -> STM a #
Monad First
Instance details Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a # fail :: String -> First a #
Monad Last
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.11.0.0
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a # fail :: String -> NonEmpty a #
Monad Tree
Instance details Methods (>>=) :: Tree a -> (a -> Tree b) -> Tree b # (>>) :: Tree a -> Tree b -> Tree b # return :: a -> Tree a # fail :: String -> Tree a #
Monad Seq
Instance details 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: 2.1
Instance details Methods (>>=) :: P a -> (a -> P b) -> P b # (>>) :: P a -> P b -> P b # return :: a -> P a # fail :: String -> P a #
Monad Gen
Instance details Methods (>>=) :: Gen a -> (a -> Gen b) -> Gen b # (>>) :: Gen a -> Gen b -> Gen b # return :: a -> Gen a # fail :: String -> Gen a #
Monad Id
Instance details Methods (>>=) :: Id a -> (a -> Id b) -> Id b # (>>) :: Id a -> Id b -> Id b # return :: a -> Id a # fail :: String -> Id a #
Monad Box
Instance details Methods (>>=) :: Box a -> (a -> Box b) -> Box b # (>>) :: Box a -> Box b -> Box b # return :: a -> Box a # fail :: String -> Box a #
Monad DList
Instance details Methods (>>=) :: DList a -> (a -> DList b) -> DList b # (>>) :: DList a -> DList b -> DList b # return :: a -> DList a # fail :: String -> DList a #
Monad Vector
Instance details Methods (>>=) :: Vector a -> (a -> Vector b) -> Vector b # (>>) :: Vector a -> Vector b -> Vector b # return :: a -> Vector a # fail :: String -> Vector a #
Monad Array
Instance details Methods (>>=) :: Array a -> (a -> Array b) -> Array b # (>>) :: Array a -> Array b -> Array b # return :: a -> Array a # fail :: String -> Array a #
Monad Rose
Instance details Methods (>>=) :: Rose a -> (a -> Rose b) -> Rose b # (>>) :: Rose a -> Rose b -> Rose b # return :: a -> Rose a # fail :: String -> Rose a #
() :=> (Monad ((->) a :: * -> *))
Instance details Methods ins :: () :- Monad ((->) a)
() :=> (Monad [])
Instance details Methods ins :: () :- Monad []
() :=> (Monad IO)
Instance details Methods ins :: () :- Monad IO
() :=> (Monad (Either a))
Instance details Methods ins :: () :- Monad (Either a)
() :=> (Monad Identity)
Instance details Methods ins :: () :- Monad Identity
Monad (Either e)	Since: 4.4.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 2.1
Instance details 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)
Instance details 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: 2.1
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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))
Instance details Methods ins :: Monad m :- Functor (WrappedMonad m)
(Monad m) :=> (Applicative (WrappedMonad m))
Instance details Methods ins :: Monad m :- Applicative (WrappedMonad m)
Class (Applicative f) (Monad f)
Instance details Methods cls :: Monad f :- Applicative f
Monad f => Monad (Rec1 f)	Since: 4.9.0.0
Instance details 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)
Instance details 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: 0.5.9
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Methods cls :: MonadPlus f :- (Monad f, Alternative f)
Monad ((->) r :: * -> *)	Since: 2.1
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 0.5.9
Instance details 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: 0.5.9
Instance details 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: 4.9.0.0
Instance details 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: 0.5.9
Instance details 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: 2.1
Instance details Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a] #
Functor Maybe	Since: 2.1
Instance details Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor IO	Since: 2.1
Instance details Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Functor Par1
Instance details Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a #
Functor Q
Instance details Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Functor Complex
Instance details Methods fmap :: (a -> b) -> Complex a -> Complex b # (<$) :: a -> Complex b -> Complex a #
Functor Min	Since: 4.9.0.0
Instance details Methods fmap :: (a -> b) -> Min a -> Min b # (<$) :: a -> Min b -> Min a #
Functor Max	Since: 4.9.0.0
Instance details Methods fmap :: (a -> b) -> Max a -> Max b # (<$) :: a -> Max b -> Max a #
Functor First	Since: 4.9.0.0
Instance details Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last	Since: 4.9.0.0
Instance details Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Option	Since: 4.9.0.0
Instance details Methods fmap :: (a -> b) -> Option a -> Option b # (<$) :: a -> Option b -> Option a #
Functor ZipList
Instance details Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Functor Identity	Since: 4.8.0.0
Instance details Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Functor Handler	Since: 4.6.0.0
Instance details Methods fmap :: (a -> b) -> Handler a -> Handler b # (<$) :: a -> Handler b -> Handler a #
Functor STM	Since: 4.3.0.0
Instance details Methods fmap :: (a -> b) -> STM a -> STM b # (<$) :: a -> STM b -> STM a #
Functor First
Instance details Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last
Instance details Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Dual	Since: 4.8.0.0
Instance details Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a #
Functor Sum	Since: 4.8.0.0
Instance details Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
Functor Product	Since: 4.8.0.0
Instance details Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a #
Functor Down	Since: 4.11.0.0
Instance details Methods fmap :: (a -> b) -> Down a -> Down b # (<$) :: a -> Down b -> Down a #
Functor ReadPrec	Since: 2.1
Instance details Methods fmap :: (a -> b) -> ReadPrec a -> ReadPrec b # (<$) :: a -> ReadPrec b -> ReadPrec a #
Functor ReadP	Since: 2.1
Instance details Methods fmap :: (a -> b) -> ReadP a -> ReadP b # (<$) :: a -> ReadP b -> ReadP a #
Functor NonEmpty	Since: 4.9.0.0
Instance details Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Functor IntMap
Instance details Methods fmap :: (a -> b) -> IntMap a -> IntMap b # (<$) :: a -> IntMap b -> IntMap a #
Functor Tree
Instance details Methods fmap :: (a -> b) -> Tree a -> Tree b # (<$) :: a -> Tree b -> Tree a #
Functor Seq
Instance details Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Functor FingerTree
Instance details Methods fmap :: (a -> b) -> FingerTree a -> FingerTree b # (<$) :: a -> FingerTree b -> FingerTree a #
Functor Digit
Instance details Methods fmap :: (a -> b) -> Digit a -> Digit b # (<$) :: a -> Digit b -> Digit a #
Functor Node
Instance details Methods fmap :: (a -> b) -> Node a -> Node b # (<$) :: a -> Node b -> Node a #
Functor Elem
Instance details Methods fmap :: (a -> b) -> Elem a -> Elem b # (<$) :: a -> Elem b -> Elem a #
Functor ViewL
Instance details Methods fmap :: (a -> b) -> ViewL a -> ViewL b # (<$) :: a -> ViewL b -> ViewL a #
Functor ViewR
Instance details Methods fmap :: (a -> b) -> ViewR a -> ViewR b # (<$) :: a -> ViewR b -> ViewR a #
Functor Doc
Instance details Methods fmap :: (a -> b) -> Doc a -> Doc b # (<$) :: a -> Doc b -> Doc a #
Functor AnnotDetails
Instance details Methods fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b # (<$) :: a -> AnnotDetails b -> AnnotDetails a #
Functor Span
Instance details Methods fmap :: (a -> b) -> Span a -> Span b # (<$) :: a -> Span b -> Span a #
Functor P
Instance details Methods fmap :: (a -> b) -> P a -> P b # (<$) :: a -> P b -> P a #
Functor Gen
Instance details Methods fmap :: (a -> b) -> Gen a -> Gen b # (<$) :: a -> Gen b -> Gen a #
Functor Id
Instance details Methods fmap :: (a -> b) -> Id a -> Id b # (<$) :: a -> Id b -> Id a #
Functor Box
Instance details Methods fmap :: (a -> b) -> Box a -> Box b # (<$) :: a -> Box b -> Box a #
Functor DList
Instance details Methods fmap :: (a -> b) -> DList a -> DList b # (<$) :: a -> DList b -> DList a #
Functor Vector
Instance details Methods fmap :: (a -> b) -> Vector a -> Vector b # (<$) :: a -> Vector b -> Vector a #
Functor Array
Instance details Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Functor Rose
Instance details Methods fmap :: (a -> b) -> Rose a -> Rose b # (<$) :: a -> Rose b -> Rose a #
() :=> (Functor ((->) a :: * -> *))
Instance details Methods ins :: () :- Functor ((->) a)
() :=> (Functor [])
Instance details Methods ins :: () :- Functor []
() :=> (Functor Maybe)
Instance details Methods ins :: () :- Functor Maybe
() :=> (Functor IO)
Instance details Methods ins :: () :- Functor IO
() :=> (Functor (Either a))
Instance details Methods ins :: () :- Functor (Either a)
() :=> (Functor ((,) a))
Instance details Methods ins :: () :- Functor ((,) a)
() :=> (Functor Identity)
Instance details Methods ins :: () :- Functor Identity
() :=> (Functor (Const a :: * -> *))
Instance details Methods ins :: () :- Functor (Const a)
Class () (Functor f)
Instance details Methods cls :: Functor f :- ()
Functor (Either a)	Since: 3.0
Instance details Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Functor (V1 :: * -> *)	Since: 4.9.0.0
Instance details Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Functor (U1 :: * -> *)	Since: 4.9.0.0
Instance details Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a #
Functor ((,) a)	Since: 2.1
Instance details Methods fmap :: (a0 -> b) -> (a, a0) -> (a, b) # (<$) :: a0 -> (a, b) -> (a, a0) #
Functor (ST s)	Since: 2.1
Instance details Methods fmap :: (a -> b) -> ST s a -> ST s b # (<$) :: a -> ST s b -> ST s a #
Functor (Array i)	Since: 2.1
Instance details Methods fmap :: (a -> b) -> Array i a -> Array i b # (<$) :: a -> Array i b -> Array i a #
Functor (Arg a)	Since: 4.9.0.0
Instance details Methods fmap :: (a0 -> b) -> Arg a a0 -> Arg a b # (<$) :: a0 -> Arg a b -> Arg a a0 #
Monad m => Functor (WrappedMonad m)	Since: 2.1
Instance details Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Functor (ArrowMonad a)	Since: 4.6.0.0
Instance details Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Functor (Proxy :: * -> *)	Since: 4.7.0.0
Instance details Methods fmap :: (a -> b) -> Proxy a -> Proxy b # (<$) :: a -> Proxy b -> Proxy a #
Functor (Map k)
Instance details Methods fmap :: (a -> b) -> Map k a -> Map k b # (<$) :: a -> Map k b -> Map k a #
Functor (Vec n) #
Instance details Methods fmap :: (a -> b) -> Vec n a -> Vec n b # (<$) :: a -> Vec n b -> Vec n a #
Functor (Level i)
Instance details Methods fmap :: (a -> b) -> Level i a -> Level i b # (<$) :: a -> Level i b -> Level i a #
Functor (ReifiedFold s)
Instance details Methods fmap :: (a -> b) -> ReifiedFold s a -> ReifiedFold s b # (<$) :: a -> ReifiedFold s b -> ReifiedFold s a #
Functor (ReifiedGetter s)
Instance details Methods fmap :: (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b # (<$) :: a -> ReifiedGetter s b -> ReifiedGetter s a #
Functor f => Functor (Co f)
Instance details Methods fmap :: (a -> b) -> Co f a -> Co f b # (<$) :: a -> Co f b -> Co f a #
Functor f => Functor (Cofree f)
Instance details Methods fmap :: (a -> b) -> Cofree f a -> Cofree f b # (<$) :: a -> Cofree f b -> Cofree f a #
Functor f => Functor (Free f)
Instance details Methods fmap :: (a -> b) -> Free f a -> Free f b # (<$) :: a -> Free f b -> Free f a #
Functor (Yoneda f)
Instance details Methods fmap :: (a -> b) -> Yoneda f a -> Yoneda f b # (<$) :: a -> Yoneda f b -> Yoneda f a #
Functor (HashMap k)
Instance details Methods fmap :: (a -> b) -> HashMap k a -> HashMap k b # (<$) :: a -> HashMap k b -> HashMap k a #
Functor f => Functor (Indexing f)
Instance details Methods fmap :: (a -> b) -> Indexing f a -> Indexing f b # (<$) :: a -> Indexing f b -> Indexing f a #
Functor f => Functor (Indexing64 f)
Instance details Methods fmap :: (a -> b) -> Indexing64 f a -> Indexing64 f b # (<$) :: a -> Indexing64 f b -> Indexing64 f a #
Profunctor p => Functor (Coprep p)
Instance details Methods fmap :: (a -> b) -> Coprep p a -> Coprep p b # (<$) :: a -> Coprep p b -> Coprep p a #
Profunctor p => Functor (Prep p)
Instance details Methods fmap :: (a -> b) -> Prep p a -> Prep p b # (<$) :: a -> Prep p b -> Prep p a #
Functor (Signal domain) #
Instance details Methods fmap :: (a -> b) -> Signal domain a -> Signal domain b # (<$) :: a -> Signal domain b -> Signal domain a #
KnownNat d => Functor (RTree d) #
Instance details Methods fmap :: (a -> b) -> RTree d a -> RTree d b # (<$) :: a -> RTree d b -> RTree d a #
(Monad m) :=> (Functor (WrappedMonad m))
Instance details Methods ins :: Monad m :- Functor (WrappedMonad m)
Class (Functor f) (Applicative f)
Instance details Methods cls :: Applicative f :- Functor f
Functor f => Functor (Rec1 f)
Instance details Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a #
Functor (URec Char :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Functor (URec Double :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Functor (URec Float :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Functor (URec Int :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Functor (URec Word :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Functor (URec (Ptr ()) :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Arrow a => Functor (WrappedArrow a b)	Since: 2.1
Instance details 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: 2.1
Instance details Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
Functor f => Functor (Alt f)
Instance details 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: 0.5.9
Instance details 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)
Instance details 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)
Instance details Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor (Constant a :: * -> *)
Instance details Methods fmap :: (a0 -> b) -> Constant a a0 -> Constant a b # (<$) :: a0 -> Constant a b -> Constant a a0 #
Functor (Context a b)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Methods fmap :: (a -> b) -> Bundle m v a -> Bundle m v b # (<$) :: a -> Bundle m v b -> Bundle m v a #
Functor (Tagged s)
Instance details Methods fmap :: (a -> b) -> Tagged s a -> Tagged s b # (<$) :: a -> Tagged s b -> Tagged s a #
Bifunctor p => Functor (Fix p)
Instance details Methods fmap :: (a -> b) -> Fix p a -> Fix p b # (<$) :: a -> Fix p b -> Fix p a #
Bifunctor p => Functor (Join p)
Instance details Methods fmap :: (a -> b) -> Join p a -> Join p b # (<$) :: a -> Join p b -> Join p a #
Functor f => Functor (CofreeF f a)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Methods fmap :: (a0 -> b) -> TambaraSum p a a0 -> TambaraSum p a b # (<$) :: a0 -> TambaraSum p a b -> TambaraSum p a a0 #
Functor ((->) r :: * -> *)	Since: 2.1
Instance details Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
Functor (K1 i c :: * -> *)
Instance details 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)
Instance details Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a #
(Functor f, Functor g) => Functor (f :*: g)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 0.5.9
Instance details 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: 0.5.9
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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: 0.5.9
Instance details 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)
Instance details 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 :: * -> *)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 4.8.0.0
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Num CChar
Instance details Methods (+) :: CChar -> CChar -> CChar # (-) :: CChar -> CChar -> CChar # (*) :: CChar -> CChar -> CChar # negate :: CChar -> CChar # abs :: CChar -> CChar # signum :: CChar -> CChar # fromInteger :: Integer -> CChar #
Num CSChar
Instance details Methods (+) :: CSChar -> CSChar -> CSChar # (-) :: CSChar -> CSChar -> CSChar # (*) :: CSChar -> CSChar -> CSChar # negate :: CSChar -> CSChar # abs :: CSChar -> CSChar # signum :: CSChar -> CSChar # fromInteger :: Integer -> CSChar #
Num CUChar
Instance details Methods (+) :: CUChar -> CUChar -> CUChar # (-) :: CUChar -> CUChar -> CUChar # (*) :: CUChar -> CUChar -> CUChar # negate :: CUChar -> CUChar # abs :: CUChar -> CUChar # signum :: CUChar -> CUChar # fromInteger :: Integer -> CUChar #
Num CShort
Instance details Methods (+) :: CShort -> CShort -> CShort # (-) :: CShort -> CShort -> CShort # (*) :: CShort -> CShort -> CShort # negate :: CShort -> CShort # abs :: CShort -> CShort # signum :: CShort -> CShort # fromInteger :: Integer -> CShort #
Num CUShort
Instance details Methods (+) :: CUShort -> CUShort -> CUShort # (-) :: CUShort -> CUShort -> CUShort # (*) :: CUShort -> CUShort -> CUShort # negate :: CUShort -> CUShort # abs :: CUShort -> CUShort # signum :: CUShort -> CUShort # fromInteger :: Integer -> CUShort #
Num CInt
Instance details Methods (+) :: CInt -> CInt -> CInt # (-) :: CInt -> CInt -> CInt # (*) :: CInt -> CInt -> CInt # negate :: CInt -> CInt # abs :: CInt -> CInt # signum :: CInt -> CInt # fromInteger :: Integer -> CInt #
Num CUInt
Instance details Methods (+) :: CUInt -> CUInt -> CUInt # (-) :: CUInt -> CUInt -> CUInt # (*) :: CUInt -> CUInt -> CUInt # negate :: CUInt -> CUInt # abs :: CUInt -> CUInt # signum :: CUInt -> CUInt # fromInteger :: Integer -> CUInt #
Num CLong
Instance details Methods (+) :: CLong -> CLong -> CLong # (-) :: CLong -> CLong -> CLong # (*) :: CLong -> CLong -> CLong # negate :: CLong -> CLong # abs :: CLong -> CLong # signum :: CLong -> CLong # fromInteger :: Integer -> CLong #
Num CULong
Instance details Methods (+) :: CULong -> CULong -> CULong # (-) :: CULong -> CULong -> CULong # (*) :: CULong -> CULong -> CULong # negate :: CULong -> CULong # abs :: CULong -> CULong # signum :: CULong -> CULong # fromInteger :: Integer -> CULong #
Num CLLong
Instance details Methods (+) :: CLLong -> CLLong -> CLLong # (-) :: CLLong -> CLLong -> CLLong # (*) :: CLLong -> CLLong -> CLLong # negate :: CLLong -> CLLong # abs :: CLLong -> CLLong # signum :: CLLong -> CLLong # fromInteger :: Integer -> CLLong #
Num CULLong
Instance details Methods (+) :: CULLong -> CULLong -> CULLong # (-) :: CULLong -> CULLong -> CULLong # (*) :: CULLong -> CULLong -> CULLong # negate :: CULLong -> CULLong # abs :: CULLong -> CULLong # signum :: CULLong -> CULLong # fromInteger :: Integer -> CULLong #
Num CBool
Instance details Methods (+) :: CBool -> CBool -> CBool # (-) :: CBool -> CBool -> CBool # (*) :: CBool -> CBool -> CBool # negate :: CBool -> CBool # abs :: CBool -> CBool # signum :: CBool -> CBool # fromInteger :: Integer -> CBool #
Num CFloat
Instance details Methods (+) :: CFloat -> CFloat -> CFloat # (-) :: CFloat -> CFloat -> CFloat # (*) :: CFloat -> CFloat -> CFloat # negate :: CFloat -> CFloat # abs :: CFloat -> CFloat # signum :: CFloat -> CFloat # fromInteger :: Integer -> CFloat #
Num CDouble
Instance details Methods (+) :: CDouble -> CDouble -> CDouble # (-) :: CDouble -> CDouble -> CDouble # (*) :: CDouble -> CDouble -> CDouble # negate :: CDouble -> CDouble # abs :: CDouble -> CDouble # signum :: CDouble -> CDouble # fromInteger :: Integer -> CDouble #
Num CPtrdiff
Instance details Methods (+) :: CPtrdiff -> CPtrdiff -> CPtrdiff # (-) :: CPtrdiff -> CPtrdiff -> CPtrdiff # (*) :: CPtrdiff -> CPtrdiff -> CPtrdiff # negate :: CPtrdiff -> CPtrdiff # abs :: CPtrdiff -> CPtrdiff # signum :: CPtrdiff -> CPtrdiff # fromInteger :: Integer -> CPtrdiff #
Num CSize
Instance details Methods (+) :: CSize -> CSize -> CSize # (-) :: CSize -> CSize -> CSize # (*) :: CSize -> CSize -> CSize # negate :: CSize -> CSize # abs :: CSize -> CSize # signum :: CSize -> CSize # fromInteger :: Integer -> CSize #
Num CWchar
Instance details Methods (+) :: CWchar -> CWchar -> CWchar # (-) :: CWchar -> CWchar -> CWchar # (*) :: CWchar -> CWchar -> CWchar # negate :: CWchar -> CWchar # abs :: CWchar -> CWchar # signum :: CWchar -> CWchar # fromInteger :: Integer -> CWchar #
Num CSigAtomic
Instance details Methods (+) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (-) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (*) :: CSigAtomic -> CSigAtomic -> CSigAtomic # negate :: CSigAtomic -> CSigAtomic # abs :: CSigAtomic -> CSigAtomic # signum :: CSigAtomic -> CSigAtomic # fromInteger :: Integer -> CSigAtomic #
Num CClock
Instance details Methods (+) :: CClock -> CClock -> CClock # (-) :: CClock -> CClock -> CClock # (*) :: CClock -> CClock -> CClock # negate :: CClock -> CClock # abs :: CClock -> CClock # signum :: CClock -> CClock # fromInteger :: Integer -> CClock #
Num CTime
Instance details Methods (+) :: CTime -> CTime -> CTime # (-) :: CTime -> CTime -> CTime # (*) :: CTime -> CTime -> CTime # negate :: CTime -> CTime # abs :: CTime -> CTime # signum :: CTime -> CTime # fromInteger :: Integer -> CTime #
Num CUSeconds
Instance details Methods (+) :: CUSeconds -> CUSeconds -> CUSeconds # (-) :: CUSeconds -> CUSeconds -> CUSeconds # (*) :: CUSeconds -> CUSeconds -> CUSeconds # negate :: CUSeconds -> CUSeconds # abs :: CUSeconds -> CUSeconds # signum :: CUSeconds -> CUSeconds # fromInteger :: Integer -> CUSeconds #
Num CSUSeconds
Instance details Methods (+) :: CSUSeconds -> CSUSeconds -> CSUSeconds # (-) :: CSUSeconds -> CSUSeconds -> CSUSeconds # (*) :: CSUSeconds -> CSUSeconds -> CSUSeconds # negate :: CSUSeconds -> CSUSeconds # abs :: CSUSeconds -> CSUSeconds # signum :: CSUSeconds -> CSUSeconds # fromInteger :: Integer -> CSUSeconds #
Num CIntPtr
Instance details Methods (+) :: CIntPtr -> CIntPtr -> CIntPtr # (-) :: CIntPtr -> CIntPtr -> CIntPtr # (*) :: CIntPtr -> CIntPtr -> CIntPtr # negate :: CIntPtr -> CIntPtr # abs :: CIntPtr -> CIntPtr # signum :: CIntPtr -> CIntPtr # fromInteger :: Integer -> CIntPtr #
Num CUIntPtr
Instance details Methods (+) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (-) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (*) :: CUIntPtr -> CUIntPtr -> CUIntPtr # negate :: CUIntPtr -> CUIntPtr # abs :: CUIntPtr -> CUIntPtr # signum :: CUIntPtr -> CUIntPtr # fromInteger :: Integer -> CUIntPtr #
Num CIntMax
Instance details Methods (+) :: CIntMax -> CIntMax -> CIntMax # (-) :: CIntMax -> CIntMax -> CIntMax # (*) :: CIntMax -> CIntMax -> CIntMax # negate :: CIntMax -> CIntMax # abs :: CIntMax -> CIntMax # signum :: CIntMax -> CIntMax # fromInteger :: Integer -> CIntMax #
Num CUIntMax
Instance details Methods (+) :: CUIntMax -> CUIntMax -> CUIntMax # (-) :: CUIntMax -> CUIntMax -> CUIntMax # (*) :: CUIntMax -> CUIntMax -> CUIntMax # negate :: CUIntMax -> CUIntMax # abs :: CUIntMax -> CUIntMax # signum :: CUIntMax -> CUIntMax # fromInteger :: Integer -> CUIntMax #
Num Bit #
Instance details Methods (+) :: Bit -> Bit -> Bit # (-) :: Bit -> Bit -> Bit # (*) :: Bit -> Bit -> Bit # negate :: Bit -> Bit # abs :: Bit -> Bit # signum :: Bit -> Bit # fromInteger :: Integer -> Bit #
Num Half
Instance details Methods (+) :: Half -> Half -> Half # (-) :: Half -> Half -> Half # (*) :: Half -> Half -> Half # negate :: Half -> Half # abs :: Half -> Half # signum :: Half -> Half # fromInteger :: Integer -> Half #
() :=> (Num Double)
Instance details Methods ins :: () :- Num Double
() :=> (Num Float)
Instance details Methods ins :: () :- Num Float
() :=> (Num Int)
Instance details Methods ins :: () :- Num Int
() :=> (Num Integer)
Instance details Methods ins :: () :- Num Integer
() :=> (Num Natural)
Instance details Methods ins :: () :- Num Natural
() :=> (Num Word)
Instance details Methods ins :: () :- Num Word
Class () (Num a)
Instance details Methods cls :: Num a :- ()
Integral a => Num (Ratio a)	Since: 2.0.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.11.0.0
Instance details 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) #
Instance details 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
Instance details 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)
Instance details 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) #
Instance details 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
Instance details 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))
Instance details Methods ins :: Integral a :- Num (Ratio a)
(Num a) :=> (Num (Identity a))
Instance details Methods ins :: Num a :- Num (Identity a)
(Num a) :=> (Num (Const a b))
Instance details Methods ins :: Num a :- Num (Const a b)
(RealFloat a) :=> (Num (Complex a))
Instance details Methods ins :: RealFloat a :- Num (Complex a)
Class (Num a) (Fractional a)
Instance details Methods cls :: Fractional a :- Num a
Num a => Num (Op a b)
Instance details 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) #
Instance details 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)
Instance details Methods cls :: Real a :- (Num a, Ord a)
Num a => Num (Const a b)
Instance details 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)
Instance details 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)
Instance details 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`
Instance details 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) #
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 ()
Instance details Methods compare :: () -> () -> Ordering # (<) :: () -> () -> Bool # (<=) :: () -> () -> Bool # (>) :: () -> () -> Bool # (>=) :: () -> () -> Bool # max :: () -> () -> () # min :: () -> () -> () #
Ord TyCon
Instance details 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
Instance details 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: 4.8.0.0
Instance details 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
Instance details 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: 2.1
Instance details 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: 4.2.0.0
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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: 4.7.0.0
Instance details 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: 4.7.0.0
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 #
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 #
Instance details 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 #
Instance details 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)
Instance details Methods ins :: () :- Ord Bool
() :=> (Ord Char)
Instance details Methods ins :: () :- Ord Char
() :=> (Ord Double)
Instance details Methods ins :: () :- Ord Double
() :=> (Ord Float)
Instance details Methods ins :: () :- Ord Float
() :=> (Ord Int)
Instance details Methods ins :: () :- Ord Int
() :=> (Ord Integer)
Instance details Methods ins :: () :- Ord Integer
() :=> (Ord Natural)
Instance details Methods ins :: () :- Ord Natural
() :=> (Ord Word)
Instance details Methods ins :: () :- Ord Word
() :=> (Ord ())
Instance details Methods ins :: () :- Ord ()
() :=> (Ord (a :- b))
Instance details Methods ins :: () :- Ord (a :- b)
() :=> (Ord (Dict a))
Instance details Methods ins :: () :- Ord (Dict a)
Ord a => Ord [a]
Instance details 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)
Instance details 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: 2.0.1
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.6.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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 (Unsigned n) #
Instance details 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) #
Instance details 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)
Instance details 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))
Instance details Methods ins :: Integral a :- Ord (Ratio a)
(Ord a) :=> (Ord (Maybe a))
Instance details Methods ins :: Ord a :- Ord (Maybe a)
(Ord a) :=> (Ord [a])
Instance details Methods ins :: Ord a :- Ord [a]
(Ord a) :=> (Ord (Identity a))
Instance details Methods ins :: Ord a :- Ord (Identity a)
(Ord a) :=> (Ord (Const a b))
Instance details Methods ins :: Ord a :- Ord (Const a b)
Class (Eq a) (Ord a)
Instance details Methods cls :: Ord a :- Eq a
(Ord a, Ord b) => Ord (Either a b)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.4.0.0
Instance details 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)
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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)
Instance details 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))
Instance details Methods ins :: (Ord a, Ord b) :- Ord (a, b)
(Ord a, Ord b) :=> (Ord (Either a b))
Instance details Methods ins :: (Ord a, Ord b) :- Ord (Either a b)
Class (Num a, Ord a) (Real a)
Instance details Methods cls :: Real a :- (Num a, Ord a)
Ord (f p) => Ord (Rec1 f p)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.10.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Read Char	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Read Double	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
Read Float	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
Read Int	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Read Int8	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Int8 # readList :: ReadS [Int8] # readPrec :: ReadPrec Int8 # readListPrec :: ReadPrec [Int8] #
Read Int16	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Int16 # readList :: ReadS [Int16] # readPrec :: ReadPrec Int16 # readListPrec :: ReadPrec [Int16] #
Read Int32	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Read Int64	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Read Integer	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] # readPrec :: ReadPrec Integer # readListPrec :: ReadPrec [Integer] #
Read Natural	Since: 4.8.0.0
Instance details Methods readsPrec :: Int -> ReadS Natural # readList :: ReadS [Natural] # readPrec :: ReadPrec Natural # readListPrec :: ReadPrec [Natural] #
Read Ordering	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] # readPrec :: ReadPrec Ordering # readListPrec :: ReadPrec [Ordering] #
Read Word	Since: 4.5.0.0
Instance details Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] # readPrec :: ReadPrec Word # readListPrec :: ReadPrec [Word] #
Read Word8	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Word8 # readList :: ReadS [Word8] # readPrec :: ReadPrec Word8 # readListPrec :: ReadPrec [Word8] #
Read Word16	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Word16 # readList :: ReadS [Word16] # readPrec :: ReadPrec Word16 # readListPrec :: ReadPrec [Word16] #
Read Word32	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Read Word64	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Read ()	Since: 2.1
Instance details 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: 4.8.0.0
Instance details Methods readsPrec :: Int -> ReadS Void # readList :: ReadS [Void] # readPrec :: ReadPrec Void # readListPrec :: ReadPrec [Void] #
Read Version
Instance details Methods readsPrec :: Int -> ReadS Version # readList :: ReadS [Version] # readPrec :: ReadPrec Version # readListPrec :: ReadPrec [Version] #
Read ExitCode
Instance details Methods readsPrec :: Int -> ReadS ExitCode # readList :: ReadS [ExitCode] # readPrec :: ReadPrec ExitCode # readListPrec :: ReadPrec [ExitCode] #
Read All
Instance details Methods readsPrec :: Int -> ReadS All # readList :: ReadS [All] # readPrec :: ReadPrec All # readListPrec :: ReadPrec [All] #
Read Any
Instance details Methods readsPrec :: Int -> ReadS Any # readList :: ReadS [Any] # readPrec :: ReadPrec Any # readListPrec :: ReadPrec [Any] #
Read Fixity
Instance details Methods readsPrec :: Int -> ReadS Fixity # readList :: ReadS [Fixity] # readPrec :: ReadPrec Fixity # readListPrec :: ReadPrec [Fixity] #
Read Associativity
Instance details Methods readsPrec :: Int -> ReadS Associativity # readList :: ReadS [Associativity] # readPrec :: ReadPrec Associativity # readListPrec :: ReadPrec [Associativity] #
Read SourceUnpackedness
Instance details Methods readsPrec :: Int -> ReadS SourceUnpackedness # readList :: ReadS [SourceUnpackedness] # readPrec :: ReadPrec SourceUnpackedness # readListPrec :: ReadPrec [SourceUnpackedness] #
Read SourceStrictness
Instance details Methods readsPrec :: Int -> ReadS SourceStrictness # readList :: ReadS [SourceStrictness] # readPrec :: ReadPrec SourceStrictness # readListPrec :: ReadPrec [SourceStrictness] #
Read DecidedStrictness
Instance details Methods readsPrec :: Int -> ReadS DecidedStrictness # readList :: ReadS [DecidedStrictness] # readPrec :: ReadPrec DecidedStrictness # readListPrec :: ReadPrec [DecidedStrictness] #
Read SomeSymbol	Since: 4.7.0.0
Instance details Methods readsPrec :: Int -> ReadS SomeSymbol # readList :: ReadS [SomeSymbol] # readPrec :: ReadPrec SomeSymbol # readListPrec :: ReadPrec [SomeSymbol] #
Read SomeNat	Since: 4.7.0.0
Instance details Methods readsPrec :: Int -> ReadS SomeNat # readList :: ReadS [SomeNat] # readPrec :: ReadPrec SomeNat # readListPrec :: ReadPrec [SomeNat] #
Read CChar
Instance details Methods readsPrec :: Int -> ReadS CChar # readList :: ReadS [CChar] # readPrec :: ReadPrec CChar # readListPrec :: ReadPrec [CChar] #
Read CSChar
Instance details Methods readsPrec :: Int -> ReadS CSChar # readList :: ReadS [CSChar] # readPrec :: ReadPrec CSChar # readListPrec :: ReadPrec [CSChar] #
Read CUChar
Instance details Methods readsPrec :: Int -> ReadS CUChar # readList :: ReadS [CUChar] # readPrec :: ReadPrec CUChar # readListPrec :: ReadPrec [CUChar] #
Read CShort
Instance details Methods readsPrec :: Int -> ReadS CShort # readList :: ReadS [CShort] # readPrec :: ReadPrec CShort # readListPrec :: ReadPrec [CShort] #
Read CUShort
Instance details Methods readsPrec :: Int -> ReadS CUShort # readList :: ReadS [CUShort] # readPrec :: ReadPrec CUShort # readListPrec :: ReadPrec [CUShort] #
Read CInt
Instance details Methods readsPrec :: Int -> ReadS CInt # readList :: ReadS [CInt] # readPrec :: ReadPrec CInt # readListPrec :: ReadPrec [CInt] #
Read CUInt
Instance details Methods readsPrec :: Int -> ReadS CUInt # readList :: ReadS [CUInt] # readPrec :: ReadPrec CUInt # readListPrec :: ReadPrec [CUInt] #
Read CLong
Instance details Methods readsPrec :: Int -> ReadS CLong # readList :: ReadS [CLong] # readPrec :: ReadPrec CLong # readListPrec :: ReadPrec [CLong] #
Read CULong
Instance details Methods readsPrec :: Int -> ReadS CULong # readList :: ReadS [CULong] # readPrec :: ReadPrec CULong # readListPrec :: ReadPrec [CULong] #
Read CLLong
Instance details Methods readsPrec :: Int -> ReadS CLLong # readList :: ReadS [CLLong] # readPrec :: ReadPrec CLLong # readListPrec :: ReadPrec [CLLong] #
Read CULLong
Instance details Methods readsPrec :: Int -> ReadS CULLong # readList :: ReadS [CULLong] # readPrec :: ReadPrec CULLong # readListPrec :: ReadPrec [CULLong] #
Read CBool
Instance details Methods readsPrec :: Int -> ReadS CBool # readList :: ReadS [CBool] # readPrec :: ReadPrec CBool # readListPrec :: ReadPrec [CBool] #
Read CFloat
Instance details Methods readsPrec :: Int -> ReadS CFloat # readList :: ReadS [CFloat] # readPrec :: ReadPrec CFloat # readListPrec :: ReadPrec [CFloat] #
Read CDouble
Instance details Methods readsPrec :: Int -> ReadS CDouble # readList :: ReadS [CDouble] # readPrec :: ReadPrec CDouble # readListPrec :: ReadPrec [CDouble] #
Read CPtrdiff
Instance details Methods readsPrec :: Int -> ReadS CPtrdiff # readList :: ReadS [CPtrdiff] # readPrec :: ReadPrec CPtrdiff # readListPrec :: ReadPrec [CPtrdiff] #
Read CSize
Instance details Methods readsPrec :: Int -> ReadS CSize # readList :: ReadS [CSize] # readPrec :: ReadPrec CSize # readListPrec :: ReadPrec [CSize] #
Read CWchar
Instance details Methods readsPrec :: Int -> ReadS CWchar # readList :: ReadS [CWchar] # readPrec :: ReadPrec CWchar # readListPrec :: ReadPrec [CWchar] #
Read CSigAtomic
Instance details Methods readsPrec :: Int -> ReadS CSigAtomic # readList :: ReadS [CSigAtomic] # readPrec :: ReadPrec CSigAtomic # readListPrec :: ReadPrec [CSigAtomic] #
Read CClock
Instance details Methods readsPrec :: Int -> ReadS CClock # readList :: ReadS [CClock] # readPrec :: ReadPrec CClock # readListPrec :: ReadPrec [CClock] #
Read CTime
Instance details Methods readsPrec :: Int -> ReadS CTime # readList :: ReadS [CTime] # readPrec :: ReadPrec CTime # readListPrec :: ReadPrec [CTime] #
Read CUSeconds
Instance details Methods readsPrec :: Int -> ReadS CUSeconds # readList :: ReadS [CUSeconds] # readPrec :: ReadPrec CUSeconds # readListPrec :: ReadPrec [CUSeconds] #
Read CSUSeconds
Instance details Methods readsPrec :: Int -> ReadS CSUSeconds # readList :: ReadS [CSUSeconds] # readPrec :: ReadPrec CSUSeconds # readListPrec :: ReadPrec [CSUSeconds] #
Read CIntPtr
Instance details Methods readsPrec :: Int -> ReadS CIntPtr # readList :: ReadS [CIntPtr] # readPrec :: ReadPrec CIntPtr # readListPrec :: ReadPrec [CIntPtr] #
Read CUIntPtr
Instance details Methods readsPrec :: Int -> ReadS CUIntPtr # readList :: ReadS [CUIntPtr] # readPrec :: ReadPrec CUIntPtr # readListPrec :: ReadPrec [CUIntPtr] #
Read CIntMax
Instance details Methods readsPrec :: Int -> ReadS CIntMax # readList :: ReadS [CIntMax] # readPrec :: ReadPrec CIntMax # readListPrec :: ReadPrec [CIntMax] #
Read CUIntMax
Instance details Methods readsPrec :: Int -> ReadS CUIntMax # readList :: ReadS [CUIntMax] # readPrec :: ReadPrec CUIntMax # readListPrec :: ReadPrec [CUIntMax] #
Read Lexeme	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS Lexeme # readList :: ReadS [Lexeme] # readPrec :: ReadPrec Lexeme # readListPrec :: ReadPrec [Lexeme] #
Read GeneralCategory
Instance details Methods readsPrec :: Int -> ReadS GeneralCategory # readList :: ReadS [GeneralCategory] # readPrec :: ReadPrec GeneralCategory # readListPrec :: ReadPrec [GeneralCategory] #
Read ByteString
Instance details Methods readsPrec :: Int -> ReadS ByteString # readList :: ReadS [ByteString] # readPrec :: ReadPrec ByteString # readListPrec :: ReadPrec [ByteString] #
Read ByteString
Instance details Methods readsPrec :: Int -> ReadS ByteString # readList :: ReadS [ByteString] # readPrec :: ReadPrec ByteString # readListPrec :: ReadPrec [ByteString] #
Read IntSet
Instance details Methods readsPrec :: Int -> ReadS IntSet # readList :: ReadS [IntSet] # readPrec :: ReadPrec IntSet # readListPrec :: ReadPrec [IntSet] #
Read Primitive #
Instance details Methods readsPrec :: Int -> ReadS Primitive # readList :: ReadS [Primitive] # readPrec :: ReadPrec Primitive # readListPrec :: ReadPrec [Primitive] #
Read HDL #
Instance details Methods readsPrec :: Int -> ReadS HDL # readList :: ReadS [HDL] # readPrec :: ReadPrec HDL # readListPrec :: ReadPrec [HDL] #
Read QCGen
Instance details Methods readsPrec :: Int -> ReadS QCGen # readList :: ReadS [QCGen] # readPrec :: ReadPrec QCGen # readListPrec :: ReadPrec [QCGen] #
Read DatatypeVariant
Instance details Methods readsPrec :: Int -> ReadS DatatypeVariant # readList :: ReadS [DatatypeVariant] # readPrec :: ReadPrec DatatypeVariant # readListPrec :: ReadPrec [DatatypeVariant] #
Read Half
Instance details Methods readsPrec :: Int -> ReadS Half # readList :: ReadS [Half] # readPrec :: ReadPrec Half # readListPrec :: ReadPrec [Half] #
a :=> (Read (Dict a))
Instance details Methods ins :: a :- Read (Dict a)
() :=> (Read Bool)
Instance details Methods ins :: () :- Read Bool
() :=> (Read Char)
Instance details Methods ins :: () :- Read Char
() :=> (Read Int)
Instance details Methods ins :: () :- Read Int
() :=> (Read Natural)
Instance details Methods ins :: () :- Read Natural
() :=> (Read Ordering)
Instance details Methods ins :: () :- Read Ordering
() :=> (Read Word)
Instance details Methods ins :: () :- Read Word
() :=> (Read ())
Instance details Methods ins :: () :- Read ()
Class () (Read a)
Instance details Methods cls :: Read a :- ()
Read a => Read [a]	Since: 2.1
Instance details Methods readsPrec :: Int -> ReadS [a] # readList :: ReadS [[a]] # readPrec :: ReadPrec [a] # readListPrec :: ReadPrec [[a]] #
Read a => Read (Maybe a)	Since: 2.1
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS (Ratio a) # readList :: ReadS [Ratio a] # readPrec :: ReadPrec (Ratio a) # readListPrec :: ReadPrec [Ratio a] #
Read p => Read (Par1 p)
Instance details Methods readsPrec :: Int -> ReadS (Par1 p) # readList :: ReadS [Par1 p] # readPrec :: ReadPrec (Par1 p) # readListPrec :: ReadPrec [Par1 p] #
Read a => Read (Complex a)
Instance details Methods readsPrec :: Int -> ReadS (Complex a) # readList :: ReadS [Complex a] # readPrec :: ReadPrec (Complex a) # readListPrec :: ReadPrec [Complex a] #
HasResolution a => Read (Fixed a)	Since: 4.3.0.0
Instance details Methods readsPrec :: Int -> ReadS (Fixed a) # readList :: ReadS [Fixed a] # readPrec :: ReadPrec (Fixed a) # readListPrec :: ReadPrec [Fixed a] #
Read a => Read (Min a)
Instance details Methods readsPrec :: Int -> ReadS (Min a) # readList :: ReadS [Min a] # readPrec :: ReadPrec (Min a) # readListPrec :: ReadPrec [Min a] #
Read a => Read (Max a)
Instance details Methods readsPrec :: Int -> ReadS (Max a) # readList :: ReadS [Max a] # readPrec :: ReadPrec (Max a) # readListPrec :: ReadPrec [Max a] #
Read a => Read (First a)
Instance details Methods readsPrec :: Int -> ReadS (First a) # readList :: ReadS [First a] # readPrec :: ReadPrec (First a) # readListPrec :: ReadPrec [First a] #
Read a => Read (Last a)
Instance details Methods readsPrec :: Int -> ReadS (Last a) # readList :: ReadS [Last a] # readPrec :: ReadPrec (Last a) # readListPrec :: ReadPrec [Last a] #
Read m => Read (WrappedMonoid m)
Instance details Methods readsPrec :: Int -> ReadS (WrappedMonoid m) # readList :: ReadS [WrappedMonoid m] # readPrec :: ReadPrec (WrappedMonoid m) # readListPrec :: ReadPrec [WrappedMonoid m] #
Read a => Read (Option a)
Instance details Methods readsPrec :: Int -> ReadS (Option a) # readList :: ReadS [Option a] # readPrec :: ReadPrec (Option a) # readListPrec :: ReadPrec [Option a] #
Read a => Read (ZipList a)
Instance details 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: 4.8.0.0
Instance details Methods readsPrec :: Int -> ReadS (Identity a) # readList :: ReadS [Identity a] # readPrec :: ReadPrec (Identity a) # readListPrec :: ReadPrec [Identity a] #
Read a => Read (First a)
Instance details Methods readsPrec :: Int -> ReadS (First a) # readList :: ReadS [First a] # readPrec :: ReadPrec (First a) # readListPrec :: ReadPrec [First a] #
Read a => Read (Last a)
Instance details Methods readsPrec :: Int -> ReadS (Last a) # readList :: ReadS [Last a] # readPrec :: ReadPrec (Last a) # readListPrec :: ReadPrec [Last a] #
Read a => Read (Dual a)
Instance details Methods readsPrec :: Int -> ReadS (Dual a) # readList :: ReadS [Dual a] # readPrec :: ReadPrec (Dual a) # readListPrec :: ReadPrec [Dual a] #
Read a => Read (Sum a)
Instance details Methods readsPrec :: Int -> ReadS (Sum a) # readList :: ReadS [Sum a] # readPrec :: ReadPrec (Sum a) # readListPrec :: ReadPrec [Sum a] #
Read a => Read (Product a)
Instance details Methods readsPrec :: Int -> ReadS (Product a) # readList :: ReadS [Product a] # readPrec :: ReadPrec (Product a) # readListPrec :: ReadPrec [Product a] #
Read a => Read (Down a)	Since: 4.7.0.0
Instance details Methods readsPrec :: Int -> ReadS (Down a) # readList :: ReadS [Down a] # readPrec :: ReadPrec (Down a) # readListPrec :: ReadPrec [Down a] #
Read a => Read (NonEmpty a)
Instance details Methods readsPrec :: Int -> ReadS (NonEmpty a) # readList :: ReadS [NonEmpty a] # readPrec :: ReadPrec (NonEmpty a) # readListPrec :: ReadPrec [NonEmpty a] #
Read e => Read (IntMap e)
Instance details Methods readsPrec :: Int -> ReadS (IntMap e) # readList :: ReadS [IntMap e] # readPrec :: ReadPrec (IntMap e) # readListPrec :: ReadPrec [IntMap e] #
Read a => Read (Tree a)
Instance details Methods readsPrec :: Int -> ReadS (Tree a) # readList :: ReadS [Tree a] # readPrec :: ReadPrec (Tree a) # readListPrec :: ReadPrec [Tree a] #
Read a => Read (Seq a)
Instance details Methods readsPrec :: Int -> ReadS (Seq a) # readList :: ReadS [Seq a] # readPrec :: ReadPrec (Seq a) # readListPrec :: ReadPrec [Seq a] #
Read a => Read (ViewL a)
Instance details Methods readsPrec :: Int -> ReadS (ViewL a) # readList :: ReadS [ViewL a] # readPrec :: ReadPrec (ViewL a) # readListPrec :: ReadPrec [ViewL a] #
Read a => Read (ViewR a)
Instance details 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)
Instance details 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.
Instance details Methods readsPrec :: Int -> ReadS (Index n) # readList :: ReadS [Index n] # readPrec :: ReadPrec (Index n) # readListPrec :: ReadPrec [Index n] #
Read a => Read (DList a)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
Read a => Read (Vector a)
Instance details Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
Read a => Read (Array a)
Instance details Methods readsPrec :: Int -> ReadS (Array a) # readList :: ReadS [Array a] # readPrec :: ReadPrec (Array a) # readListPrec :: ReadPrec [Array a] #
KnownNat n => Read (Unsigned n) #	None of the `Read` class' methods are synthesisable.
Instance details 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.
Instance details Methods readsPrec :: Int -> ReadS (Signed n) # readList :: ReadS [Signed n] # readPrec :: ReadPrec (Signed n) # readListPrec :: ReadPrec [Signed n] #
a => Read (Dict a)
Instance details Methods readsPrec :: Int -> ReadS (Dict a) # readList :: ReadS [Dict a] # readPrec :: ReadPrec (Dict a) # readListPrec :: ReadPrec [Dict a] #
(Read a) :=> (Read (Complex a))
Instance details Methods ins :: Read a :- Read (Complex a)
(Read a) :=> (Read [a])
Instance details Methods ins :: Read a :- Read [a]
(Read a) :=> (Read (Maybe a))
Instance details Methods ins :: Read a :- Read (Maybe a)
(Read a) :=> (Read (Identity a))
Instance details Methods ins :: Read a :- Read (Identity a)
(Read a) :=> (Read (Const a b))
Instance details Methods ins :: Read a :- Read (Const a b)
(Read a, Read b) => Read (Either a b)
Instance details 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: 4.9.0.0
Instance details Methods readsPrec :: Int -> ReadS (V1 p) # readList :: ReadS [V1 p] # readPrec :: ReadPrec (V1 p) # readListPrec :: ReadPrec [V1 p] #
Read (U1 p)	Since: 4.9.0.0
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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)
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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))
Instance details Methods ins :: (Integral a, Read a) :- Read (Ratio a)
(Read a, Read b) :=> (Read (a, b))
Instance details Methods ins :: (Read a, Read b) :- Read (a, b)
(Read a, Read b) :=> (Read (Either a b))
Instance details Methods ins :: (Read a, Read b) :- Read (Either a b)
Read (f p) => Read (Rec1 f p)
Instance details 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: 2.1
Instance details 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: 4.8.0.0
Instance details 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)
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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.
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.10.0.0
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.0.1
Instance details Methods toRational :: Int -> Rational #
Real Int8	Since: 2.1
Instance details Methods toRational :: Int8 -> Rational #
Real Int16	Since: 2.1
Instance details Methods toRational :: Int16 -> Rational #
Real Int32	Since: 2.1
Instance details Methods toRational :: Int32 -> Rational #
Real Int64	Since: 2.1
Instance details Methods toRational :: Int64 -> Rational #
Real Integer	Since: 2.0.1
Instance details Methods toRational :: Integer -> Rational #
Real Natural	Since: 4.8.0.0
Instance details Methods toRational :: Natural -> Rational #
Real Word	Since: 2.1
Instance details Methods toRational :: Word -> Rational #
Real Word8	Since: 2.1
Instance details Methods toRational :: Word8 -> Rational #
Real Word16	Since: 2.1
Instance details Methods toRational :: Word16 -> Rational #
Real Word32	Since: 2.1
Instance details Methods toRational :: Word32 -> Rational #
Real Word64	Since: 2.1
Instance details Methods toRational :: Word64 -> Rational #
Real CChar
Instance details Methods toRational :: CChar -> Rational #
Real CSChar
Instance details Methods toRational :: CSChar -> Rational #
Real CUChar
Instance details Methods toRational :: CUChar -> Rational #
Real CShort
Instance details Methods toRational :: CShort -> Rational #
Real CUShort
Instance details Methods toRational :: CUShort -> Rational #
Real CInt
Instance details Methods toRational :: CInt -> Rational #
Real CUInt
Instance details Methods toRational :: CUInt -> Rational #
Real CLong
Instance details Methods toRational :: CLong -> Rational #
Real CULong
Instance details Methods toRational :: CULong -> Rational #
Real CLLong
Instance details Methods toRational :: CLLong -> Rational #
Real CULLong
Instance details Methods toRational :: CULLong -> Rational #
Real CBool
Instance details Methods toRational :: CBool -> Rational #
Real CFloat
Instance details Methods toRational :: CFloat -> Rational #
Real CDouble
Instance details Methods toRational :: CDouble -> Rational #
Real CPtrdiff
Instance details Methods toRational :: CPtrdiff -> Rational #
Real CSize
Instance details Methods toRational :: CSize -> Rational #
Real CWchar
Instance details Methods toRational :: CWchar -> Rational #
Real CSigAtomic
Instance details Methods toRational :: CSigAtomic -> Rational #
Real CClock
Instance details Methods toRational :: CClock -> Rational #
Real CTime
Instance details Methods toRational :: CTime -> Rational #
Real CUSeconds
Instance details Methods toRational :: CUSeconds -> Rational #
Real CSUSeconds
Instance details Methods toRational :: CSUSeconds -> Rational #
Real CIntPtr
Instance details Methods toRational :: CIntPtr -> Rational #
Real CUIntPtr
Instance details Methods toRational :: CUIntPtr -> Rational #
Real CIntMax
Instance details Methods toRational :: CIntMax -> Rational #
Real CUIntMax
Instance details Methods toRational :: CUIntMax -> Rational #
Real Bit #
Instance details Methods toRational :: Bit -> Rational #
Real Half
Instance details Methods toRational :: Half -> Rational #
() :=> (Real Double)
Instance details Methods ins :: () :- Real Double
() :=> (Real Float)
Instance details Methods ins :: () :- Real Float
() :=> (Real Int)
Instance details Methods ins :: () :- Real Int
() :=> (Real Integer)
Instance details Methods ins :: () :- Real Integer
() :=> (Real Natural)
Instance details Methods ins :: () :- Real Natural
() :=> (Real Word)
Instance details Methods ins :: () :- Real Word
Integral a => Real (Ratio a)	Since: 2.0.1
Instance details Methods toRational :: Ratio a -> Rational #
HasResolution a => Real (Fixed a)	Since: 2.1
Instance details Methods toRational :: Fixed a -> Rational #
Real a => Real (Identity a)
Instance details Methods toRational :: Identity a -> Rational #
KnownNat n => Real (BitVector n) #
Instance details Methods toRational :: BitVector n -> Rational #
KnownNat n => Real (Index n) #
Instance details Methods toRational :: Index n -> Rational #
Real a => Real (Bounds a)
Instance details Methods toRational :: Bounds a -> Rational #
KnownNat n => Real (Unsigned n) #
Instance details Methods toRational :: Unsigned n -> Rational #
KnownNat n => Real (Signed n) #
Instance details Methods toRational :: Signed n -> Rational #
(Integral a) :=> (Real (Ratio a))
Instance details Methods ins :: Integral a :- Real (Ratio a)
(Real a) :=> (Real (Identity a))
Instance details Methods ins :: Real a :- Real (Identity a)
(Real a) :=> (Real (Const a b))
Instance details Methods ins :: Real a :- Real (Const a b)
Class (Num a, Ord a) (Real a)
Instance details Methods cls :: Real a :- (Num a, Ord a)
Class (Real a, Fractional a) (RealFrac a)
Instance details Methods cls :: RealFrac a :- (Real a, Fractional a)
Class (Real a, Enum a) (Integral a)
Instance details Methods cls :: Integral a :- (Real a, Enum a)
Real a => Real (Const a b)
Instance details Methods toRational :: Const a b -> Rational #
Real a => Real (Tagged s a)
Instance details Methods toRational :: Tagged s a -> Rational #
(NumFixedC rep int frac, Integral (rep (int + frac))) => Real (Fixed rep int frac) #
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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
Instance details 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
Instance details 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
Instance details 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)
Instance details Methods ins :: () :- RealFloat Double
() :=> (RealFloat Float)
Instance details Methods ins :: () :- RealFloat Float
RealFloat a => RealFloat (Identity a)
Instance details 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))
Instance details Methods ins :: RealFloat a :- RealFloat (Identity a)
(RealFloat a) :=> (RealFloat (Const a b))
Instance details Methods ins :: RealFloat a :- RealFloat (Const a b)
(RealFloat a) :=> (Num (Complex a))
Instance details Methods ins :: RealFloat a :- Num (Complex a)
(RealFloat a) :=> (Fractional (Complex a))
Instance details Methods ins :: RealFloat a :- Fractional (Complex a)
(RealFloat a) :=> (Floating (Complex a))
Instance details Methods ins :: RealFloat a :- Floating (Complex a)
Class (RealFrac a, Floating a) (RealFloat a)
Instance details Methods cls :: RealFloat a :- (RealFrac a, Floating a)
RealFloat a => RealFloat (Const a b)
Instance details 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)
Instance details 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
Instance details 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
Instance details 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
Instance details 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)
Instance details Methods ins :: () :- RealFrac Double
() :=> (RealFrac Float)
Instance details Methods ins :: () :- RealFrac Float
Integral a => RealFrac (Ratio a)	Since: 2.0.1
Instance details 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: 2.1
Instance details 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)
Instance details 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))
Instance details Methods ins :: Integral a :- RealFrac (Ratio a)
(RealFrac a) :=> (RealFrac (Identity a))
Instance details Methods ins :: RealFrac a :- RealFrac (Identity a)
(RealFrac a) :=> (RealFrac (Const a b))
Instance details Methods ins :: RealFrac a :- RealFrac (Const a b)
Class (Real a, Fractional a) (RealFrac a)
Instance details Methods cls :: RealFrac a :- (Real a, Fractional a)
Class (RealFrac a, Floating a) (RealFloat a)
Instance details Methods cls :: RealFloat a :- (RealFrac a, Floating a)
RealFrac a => RealFrac (Const a b)
Instance details 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)
Instance details 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
Instance details Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Show Char	Since: 2.1
Instance details Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Show Int	Since: 2.1
Instance details Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Show Int8	Since: 2.1
Instance details Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Show Int16	Since: 2.1
Instance details Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Show Int32	Since: 2.1
Instance details Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Show Int64	Since: 2.1
Instance details Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Show Integer	Since: 2.1
Instance details Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Show Natural	Since: 4.8.0.0
Instance details Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Show Ordering
Instance details Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Show Word	Since: 2.1
Instance details Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Show Word8	Since: 2.1
Instance details Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Show Word16	Since: 2.1
Instance details Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Show Word32	Since: 2.1
Instance details Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Show Word64	Since: 2.1
Instance details Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Show RuntimeRep
Instance details Methods showsPrec :: Int -> RuntimeRep -> ShowS # show :: RuntimeRep -> String # showList :: [RuntimeRep] -> ShowS #
Show VecCount
Instance details Methods showsPrec :: Int -> VecCount -> ShowS # show :: VecCount -> String # showList :: [VecCount] -> ShowS #
Show VecElem
Instance details Methods showsPrec :: Int -> VecElem -> ShowS # show :: VecElem -> String # showList :: [VecElem] -> ShowS #
Show CallStack	Since: 4.9.0.0
Instance details Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
Show SomeTypeRep	Since: 4.10.0.0
Instance details Methods showsPrec :: Int -> SomeTypeRep -> ShowS # show :: SomeTypeRep -> String # showList :: [SomeTypeRep] -> ShowS #
Show Exp
Instance details Methods showsPrec :: Int -> Exp -> ShowS # show :: Exp -> String # showList :: [Exp] -> ShowS #
Show Match
Instance details Methods showsPrec :: Int -> Match -> ShowS # show :: Match -> String # showList :: [Match] -> ShowS #
Show Clause
Instance details Methods showsPrec :: Int -> Clause -> ShowS # show :: Clause -> String # showList :: [Clause] -> ShowS #
Show Pat
Instance details Methods showsPrec :: Int -> Pat -> ShowS # show :: Pat -> String # showList :: [Pat] -> ShowS #
Show Type
Instance details Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #
Show Dec
Instance details Methods showsPrec :: Int -> Dec -> ShowS # show :: Dec -> String # showList :: [Dec] -> ShowS #
Show Name
Instance details Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
Show FunDep
Instance details Methods showsPrec :: Int -> FunDep -> ShowS # show :: FunDep -> String # showList :: [FunDep] -> ShowS #
Show InjectivityAnn
Instance details Methods showsPrec :: Int -> InjectivityAnn -> ShowS # show :: InjectivityAnn -> String # showList :: [InjectivityAnn] -> ShowS #
Show Overlap
Instance details Methods showsPrec :: Int -> Overlap -> ShowS # show :: Overlap -> String # showList :: [Overlap] -> ShowS #
Show DerivStrategy
Instance details Methods showsPrec :: Int -> DerivStrategy -> ShowS # show :: DerivStrategy -> String # showList :: [DerivStrategy] -> ShowS #
Show ()
Instance details Methods showsPrec :: Int -> () -> ShowS # show :: () -> String # showList :: [()] -> ShowS #
Show TyCon	Since: 2.1
Instance details Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Show Module	Since: 4.9.0.0
Instance details Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show TrName	Since: 4.9.0.0
Instance details Methods showsPrec :: Int -> TrName -> ShowS # show :: TrName -> String # showList :: [TrName] -> ShowS #
Show KindRep
Instance details Methods showsPrec :: Int -> KindRep -> ShowS # show :: KindRep -> String # showList :: [KindRep] -> ShowS #
Show TypeLitSort
Instance details Methods showsPrec :: Int -> TypeLitSort -> ShowS # show :: TypeLitSort -> String # showList :: [TypeLitSort] -> ShowS #
Show Void	Since: 4.8.0.0
Instance details Methods showsPrec :: Int -> Void -> ShowS # show :: Void -> String # showList :: [Void] -> ShowS #
Show DataType
Instance details Methods showsPrec :: Int -> DataType -> ShowS # show :: DataType -> String # showList :: [DataType] -> ShowS #
Show Constr	Since: 4.0.0.0
Instance details Methods showsPrec :: Int -> Constr -> ShowS # show :: Constr -> String # showList :: [Constr] -> ShowS #
Show DataRep
Instance details Methods showsPrec :: Int -> DataRep -> ShowS # show :: DataRep -> String # showList :: [DataRep] -> ShowS #
Show ConstrRep
Instance details Methods showsPrec :: Int -> ConstrRep -> ShowS # show :: ConstrRep -> String # showList :: [ConstrRep] -> ShowS #
Show Fixity
Instance details Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show Version
Instance details Methods showsPrec :: Int -> Version -> ShowS # show :: Version -> String # showList :: [Version] -> ShowS #
Show ThreadId	Since: 4.2.0.0
Instance details Methods showsPrec :: Int -> ThreadId -> ShowS # show :: ThreadId -> String # showList :: [ThreadId] -> ShowS #
Show BlockReason
Instance details Methods showsPrec :: Int -> BlockReason -> ShowS # show :: BlockReason -> String # showList :: [BlockReason] -> ShowS #
Show ThreadStatus
Instance details Methods showsPrec :: Int -> ThreadStatus -> ShowS # show :: ThreadStatus -> String # showList :: [ThreadStatus] -> ShowS #
Show BlockedIndefinitelyOnMVar	Since: 4.1.0.0
Instance details Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS # show :: BlockedIndefinitelyOnMVar -> String # showList :: [BlockedIndefinitelyOnMVar] -> ShowS #
Show BlockedIndefinitelyOnSTM	Since: 4.1.0.0
Instance details Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS # show :: BlockedIndefinitelyOnSTM -> String # showList :: [BlockedIndefinitelyOnSTM] -> ShowS #
Show Deadlock	Since: 4.1.0.0
Instance details Methods showsPrec :: Int -> Deadlock -> ShowS # show :: Deadlock -> String # showList :: [Deadlock] -> ShowS #
Show AllocationLimitExceeded	Since: 4.7.1.0
Instance details Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS # show :: AllocationLimitExceeded -> String # showList :: [AllocationLimitExceeded] -> ShowS #
Show CompactionFailed	Since: 4.10.0.0
Instance details Methods showsPrec :: Int -> CompactionFailed -> ShowS # show :: CompactionFailed -> String # showList :: [CompactionFailed] -> ShowS #
Show AssertionFailed	Since: 4.1.0.0
Instance details Methods showsPrec :: Int -> AssertionFailed -> ShowS # show :: AssertionFailed -> String # showList :: [AssertionFailed] -> ShowS #
Show SomeAsyncException	Since: 4.7.0.0
Instance details Methods showsPrec :: Int -> SomeAsyncException -> ShowS # show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> ShowS #
Show AsyncException	Since: 4.1.0.0
Instance details Methods showsPrec :: Int -> AsyncException -> ShowS # show :: AsyncException -> String # showList :: [AsyncException] -> ShowS #
Show ArrayException	Since: 4.1.0.0
Instance details Methods showsPrec :: Int -> ArrayException -> ShowS # show :: ArrayException -> String # showList :: [ArrayException] -> ShowS #
Show FixIOException
Instance details Methods showsPrec :: Int -> FixIOException -> ShowS # show :: FixIOException -> String # showList :: [FixIOException] -> ShowS #
Show ExitCode
Instance details Methods showsPrec :: Int -> ExitCode -> ShowS # show :: ExitCode -> String # showList :: [ExitCode] -> ShowS #
Show IOErrorType	Since: 4.1.0.0
Instance details Methods showsPrec :: Int -> IOErrorType -> ShowS # show :: IOErrorType -> String # showList :: [IOErrorType] -> ShowS #
Show MaskingState
Instance details Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
Show IOException	Since: 4.1.0.0
Instance details Methods showsPrec :: Int -> IOException -> ShowS # show :: IOException -> String # showList :: [IOException] -> ShowS #
Show ErrorCall	Since: 4.0.0.0
Instance details Methods showsPrec :: Int -> ErrorCall -> ShowS # show :: ErrorCall -> String # showList :: [ErrorCall] -> ShowS #
Show ArithException	Since: 4.0.0.0
Instance details Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS #
Show All
Instance details Methods showsPrec :: Int -> All -> ShowS # show :: All -> String # showList :: [All] -> ShowS #
Show Any
Instance details Methods showsPrec :: Int -> Any -> ShowS # show :: Any -> String # showList :: [Any] -> ShowS #
Show Fixity
Instance details Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show Associativity
Instance details Methods showsPrec :: Int -> Associativity -> ShowS # show :: Associativity -> String # showList :: [Associativity] -> ShowS #
Show SourceUnpackedness
Instance details Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show SourceStrictness
Instance details Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show DecidedStrictness
Instance details Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show SomeSymbol	Since: 4.7.0.0
Instance details Methods showsPrec :: Int -> SomeSymbol -> ShowS # show :: SomeSymbol -> String # showList :: [SomeSymbol] -> ShowS #
Show SomeNat	Since: 4.7.0.0
Instance details Methods showsPrec :: Int -> SomeNat -> ShowS # show :: SomeNat -> String # showList :: [SomeNat] -> ShowS #
Show CChar
Instance details Methods showsPrec :: Int -> CChar -> ShowS # show :: CChar -> String # showList :: [CChar] -> ShowS #
Show CSChar
Instance details Methods showsPrec :: Int -> CSChar -> ShowS # show :: CSChar -> String # showList :: [CSChar] -> ShowS #
Show CUChar
Instance details Methods showsPrec :: Int -> CUChar -> ShowS # show :: CUChar -> String # showList :: [CUChar] -> ShowS #
Show CShort
Instance details Methods showsPrec :: Int -> CShort -> ShowS # show :: CShort -> String # showList :: [CShort] -> ShowS #
Show CUShort
Instance details Methods showsPrec :: Int -> CUShort -> ShowS # show :: CUShort -> String # showList :: [CUShort] -> ShowS #
Show CInt
Instance details Methods showsPrec :: Int -> CInt -> ShowS # show :: CInt -> String # showList :: [CInt] -> ShowS #
Show CUInt
Instance details Methods showsPrec :: Int -> CUInt -> ShowS # show :: CUInt -> String # showList :: [CUInt] -> ShowS #
Show CLong
Instance details Methods showsPrec :: Int -> CLong -> ShowS # show :: CLong -> String # showList :: [CLong] -> ShowS #
Show CULong
Instance details Methods showsPrec :: Int -> CULong -> ShowS # show :: CULong -> String # showList :: [CULong] -> ShowS #
Show CLLong
Instance details Methods showsPrec :: Int -> CLLong -> ShowS # show :: CLLong -> String # showList :: [CLLong] -> ShowS #
Show CULLong
Instance details Methods showsPrec :: Int -> CULLong -> ShowS # show :: CULLong -> String # showList :: [CULLong] -> ShowS #
Show CBool
Instance details Methods showsPrec :: Int -> CBool -> ShowS # show :: CBool -> String # showList :: [CBool] -> ShowS #
Show CFloat
Instance details Methods showsPrec :: Int -> CFloat -> ShowS # show :: CFloat -> String # showList :: [CFloat] -> ShowS #
Show CDouble
Instance details Methods showsPrec :: Int -> CDouble -> ShowS # show :: CDouble -> String # showList :: [CDouble] -> ShowS #
Show CPtrdiff
Instance details Methods showsPrec :: Int -> CPtrdiff -> ShowS # show :: CPtrdiff -> String # showList :: [CPtrdiff] -> ShowS #
Show CSize
Instance details Methods showsPrec :: Int -> CSize -> ShowS # show :: CSize -> String # showList :: [CSize] -> ShowS #
Show CWchar
Instance details Methods showsPrec :: Int -> CWchar -> ShowS # show :: CWchar -> String # showList :: [CWchar] -> ShowS #
Show CSigAtomic
Instance details Methods showsPrec :: Int -> CSigAtomic -> ShowS # show :: CSigAtomic -> String # showList :: [CSigAtomic] -> ShowS #
Show CClock
Instance details Methods showsPrec :: Int -> CClock -> ShowS # show :: CClock -> String # showList :: [CClock] -> ShowS #
Show CTime
Instance details Methods showsPrec :: Int -> CTime -> ShowS # show :: CTime -> String # showList :: [CTime] -> ShowS #
Show CUSeconds
Instance details Methods showsPrec :: Int -> CUSeconds -> ShowS # show :: CUSeconds -> String # showList :: [CUSeconds] -> ShowS #
Show CSUSeconds
Instance details Methods showsPrec :: Int -> CSUSeconds -> ShowS # show :: CSUSeconds -> String # showList :: [CSUSeconds] -> ShowS #
Show CIntPtr
Instance details Methods showsPrec :: Int -> CIntPtr -> ShowS # show :: CIntPtr -> String # showList :: [CIntPtr] -> ShowS #
Show CUIntPtr
Instance details Methods showsPrec :: Int -> CUIntPtr -> ShowS # show :: CUIntPtr -> String # showList :: [CUIntPtr] -> ShowS #
Show CIntMax
Instance details Methods showsPrec :: Int -> CIntMax -> ShowS # show :: CIntMax -> String # showList :: [CIntMax] -> ShowS #
Show CUIntMax
Instance details Methods showsPrec :: Int -> CUIntMax -> ShowS # show :: CUIntMax -> String # showList :: [CUIntMax] -> ShowS #
Show Fingerprint	Since: 4.7.0.0
Instance details Methods showsPrec :: Int -> Fingerprint -> ShowS # show :: Fingerprint -> String # showList :: [Fingerprint] -> ShowS #
Show Lexeme
Instance details Methods showsPrec :: Int -> Lexeme -> ShowS # show :: Lexeme -> String # showList :: [Lexeme] -> ShowS #
Show Number
Instance details Methods showsPrec :: Int -> Number -> ShowS # show :: Number -> String # showList :: [Number] -> ShowS #
Show GeneralCategory
Instance details Methods showsPrec :: Int -> GeneralCategory -> ShowS # show :: GeneralCategory -> String # showList :: [GeneralCategory] -> ShowS #
Show SomeException	Since: 3.0
Instance details Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #
Show SrcLoc
Instance details Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Show ByteString
Instance details Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show ByteString
Instance details Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show IntSet
Instance details Methods showsPrec :: Int -> IntSet -> ShowS # show :: IntSet -> String # showList :: [IntSet] -> ShowS #
Show TyVarBndr
Instance details Methods showsPrec :: Int -> TyVarBndr -> ShowS # show :: TyVarBndr -> String # showList :: [TyVarBndr] -> ShowS #
Show Extension
Instance details Methods showsPrec :: Int -> Extension -> ShowS # show :: Extension -> String # showList :: [Extension] -> ShowS #
Show ForeignSrcLang
Instance details Methods showsPrec :: Int -> ForeignSrcLang -> ShowS # show :: ForeignSrcLang -> String # showList :: [ForeignSrcLang] -> ShowS #
Show Doc
Instance details Methods showsPrec :: Int -> Doc -> ShowS # show :: Doc -> String # showList :: [Doc] -> ShowS #
Show TextDetails
Instance details Methods showsPrec :: Int -> TextDetails -> ShowS # show :: TextDetails -> String # showList :: [TextDetails] -> ShowS #
Show Style
Instance details Methods showsPrec :: Int -> Style -> ShowS # show :: Style -> String # showList :: [Style] -> ShowS #
Show Mode
Instance details Methods showsPrec :: Int -> Mode -> ShowS # show :: Mode -> String # showList :: [Mode] -> ShowS #
Show ModName
Instance details Methods showsPrec :: Int -> ModName -> ShowS # show :: ModName -> String # showList :: [ModName] -> ShowS #
Show PkgName
Instance details Methods showsPrec :: Int -> PkgName -> ShowS # show :: PkgName -> String # showList :: [PkgName] -> ShowS #
Show Module
Instance details Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show OccName
Instance details Methods showsPrec :: Int -> OccName -> ShowS # show :: OccName -> String # showList :: [OccName] -> ShowS #
Show NameFlavour
Instance details Methods showsPrec :: Int -> NameFlavour -> ShowS # show :: NameFlavour -> String # showList :: [NameFlavour] -> ShowS #
Show NameSpace
Instance details Methods showsPrec :: Int -> NameSpace -> ShowS # show :: NameSpace -> String # showList :: [NameSpace] -> ShowS #
Show Loc
Instance details Methods showsPrec :: Int -> Loc -> ShowS # show :: Loc -> String # showList :: [Loc] -> ShowS #
Show Info
Instance details Methods showsPrec :: Int -> Info -> ShowS # show :: Info -> String # showList :: [Info] -> ShowS #
Show ModuleInfo
Instance details Methods showsPrec :: Int -> ModuleInfo -> ShowS # show :: ModuleInfo -> String # showList :: [ModuleInfo] -> ShowS #
Show Fixity
Instance details Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show FixityDirection
Instance details Methods showsPrec :: Int -> FixityDirection -> ShowS # show :: FixityDirection -> String # showList :: [FixityDirection] -> ShowS #
Show Lit
Instance details Methods showsPrec :: Int -> Lit -> ShowS # show :: Lit -> String # showList :: [Lit] -> ShowS #
Show Body
Instance details Methods showsPrec :: Int -> Body -> ShowS # show :: Body -> String # showList :: [Body] -> ShowS #
Show Guard
Instance details Methods showsPrec :: Int -> Guard -> ShowS # show :: Guard -> String # showList :: [Guard] -> ShowS #
Show Stmt
Instance details Methods showsPrec :: Int -> Stmt -> ShowS # show :: Stmt -> String # showList :: [Stmt] -> ShowS #
Show Range
Instance details Methods showsPrec :: Int -> Range -> ShowS # show :: Range -> String # showList :: [Range] -> ShowS #
Show DerivClause
Instance details Methods showsPrec :: Int -> DerivClause -> ShowS # show :: DerivClause -> String # showList :: [DerivClause] -> ShowS #
Show TypeFamilyHead
Instance details Methods showsPrec :: Int -> TypeFamilyHead -> ShowS # show :: TypeFamilyHead -> String # showList :: [TypeFamilyHead] -> ShowS #
Show TySynEqn
Instance details Methods showsPrec :: Int -> TySynEqn -> ShowS # show :: TySynEqn -> String # showList :: [TySynEqn] -> ShowS #
Show Foreign
Instance details Methods showsPrec :: Int -> Foreign -> ShowS # show :: Foreign -> String # showList :: [Foreign] -> ShowS #
Show Callconv
Instance details Methods showsPrec :: Int -> Callconv -> ShowS # show :: Callconv -> String # showList :: [Callconv] -> ShowS #
Show Safety
Instance details Methods showsPrec :: Int -> Safety -> ShowS # show :: Safety -> String # showList :: [Safety] -> ShowS #
Show Pragma
Instance details Methods showsPrec :: Int -> Pragma -> ShowS # show :: Pragma -> String # showList :: [Pragma] -> ShowS #
Show Inline
Instance details Methods showsPrec :: Int -> Inline -> ShowS # show :: Inline -> String # showList :: [Inline] -> ShowS #
Show RuleMatch
Instance details Methods showsPrec :: Int -> RuleMatch -> ShowS # show :: RuleMatch -> String # showList :: [RuleMatch] -> ShowS #
Show Phases
Instance details Methods showsPrec :: Int -> Phases -> ShowS # show :: Phases -> String # showList :: [Phases] -> ShowS #
Show RuleBndr
Instance details Methods showsPrec :: Int -> RuleBndr -> ShowS # show :: RuleBndr -> String # showList :: [RuleBndr] -> ShowS #
Show AnnTarget
Instance details Methods showsPrec :: Int -> AnnTarget -> ShowS # show :: AnnTarget -> String # showList :: [AnnTarget] -> ShowS #
Show SourceUnpackedness
Instance details Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show SourceStrictness
Instance details Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show DecidedStrictness
Instance details Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show Con
Instance details Methods showsPrec :: Int -> Con -> ShowS # show :: Con -> String # showList :: [Con] -> ShowS #
Show Bang
Instance details Methods showsPrec :: Int -> Bang -> ShowS # show :: Bang -> String # showList :: [Bang] -> ShowS #
Show PatSynDir
Instance details Methods showsPrec :: Int -> PatSynDir -> ShowS # show :: PatSynDir -> String # showList :: [PatSynDir] -> ShowS #
Show PatSynArgs
Instance details Methods showsPrec :: Int -> PatSynArgs -> ShowS # show :: PatSynArgs -> String # showList :: [PatSynArgs] -> ShowS #
Show FamilyResultSig
Instance details Methods showsPrec :: Int -> FamilyResultSig -> ShowS # show :: FamilyResultSig -> String # showList :: [FamilyResultSig] -> ShowS #
Show TyLit
Instance details Methods showsPrec :: Int -> TyLit -> ShowS # show :: TyLit -> String # showList :: [TyLit] -> ShowS #
Show Role
Instance details Methods showsPrec :: Int -> Role -> ShowS # show :: Role -> String # showList :: [Role] -> ShowS #
Show AnnLookup
Instance details Methods showsPrec :: Int -> AnnLookup -> ShowS # show :: AnnLookup -> String # showList :: [AnnLookup] -> ShowS #
Show ZonedTime
Instance details Methods showsPrec :: Int -> ZonedTime -> ShowS # show :: ZonedTime -> String # showList :: [ZonedTime] -> ShowS #
Show LocalTime
Instance details Methods showsPrec :: Int -> LocalTime -> ShowS # show :: LocalTime -> String # showList :: [LocalTime] -> ShowS #
Show Primitive #
Instance details Methods showsPrec :: Int -> Primitive -> ShowS # show :: Primitive -> String # showList :: [Primitive] -> ShowS #
Show HDL #
Instance details Methods showsPrec :: Int -> HDL -> ShowS # show :: HDL -> String # showList :: [HDL] -> ShowS #
Show PortName #
Instance details Methods showsPrec :: Int -> PortName -> ShowS # show :: PortName -> String # showList :: [PortName] -> ShowS #
Show TopEntity #
Instance details Methods showsPrec :: Int -> TopEntity -> ShowS # show :: TopEntity -> String # showList :: [TopEntity] -> ShowS #
Show Bit #
Instance details Methods showsPrec :: Int -> Bit -> ShowS # show :: Bit -> String # showList :: [Bit] -> ShowS #
Show XException #
Instance details Methods showsPrec :: Int -> XException -> ShowS # show :: XException -> String # showList :: [XException] -> ShowS #
Show DefName
Instance details Methods showsPrec :: Int -> DefName -> ShowS # show :: DefName -> String # showList :: [DefName] -> ShowS #
Show QCGen
Instance details Methods showsPrec :: Int -> QCGen -> ShowS # show :: QCGen -> String # showList :: [QCGen] -> ShowS #
Show TimeLocale
Instance details Methods showsPrec :: Int -> TimeLocale -> ShowS # show :: TimeLocale -> String # showList :: [TimeLocale] -> ShowS #
Show DateFormatSpec
Instance details Methods showsPrec :: Int -> DateFormatSpec -> ShowS # show :: DateFormatSpec -> String # showList :: [DateFormatSpec] -> ShowS #
Show Padding
Instance details Methods showsPrec :: Int -> Padding -> ShowS # show :: Padding -> String # showList :: [Padding] -> ShowS #
Show ByteArray
Instance details Methods showsPrec :: Int -> ByteArray -> ShowS # show :: ByteArray -> String # showList :: [ByteArray] -> ShowS #
Show ConstructorInfo
Instance details Methods showsPrec :: Int -> ConstructorInfo -> ShowS # show :: ConstructorInfo -> String # showList :: [ConstructorInfo] -> ShowS #
Show ConstructorVariant
Instance details Methods showsPrec :: Int -> ConstructorVariant -> ShowS # show :: ConstructorVariant -> String # showList :: [ConstructorVariant] -> ShowS #
Show DatatypeInfo
Instance details Methods showsPrec :: Int -> DatatypeInfo -> ShowS # show :: DatatypeInfo -> String # showList :: [DatatypeInfo] -> ShowS #
Show DatatypeVariant
Instance details Methods showsPrec :: Int -> DatatypeVariant -> ShowS # show :: DatatypeVariant -> String # showList :: [DatatypeVariant] -> ShowS #
Show FieldStrictness
Instance details Methods showsPrec :: Int -> FieldStrictness -> ShowS # show :: FieldStrictness -> String # showList :: [FieldStrictness] -> ShowS #
Show Strictness
Instance details Methods showsPrec :: Int -> Strictness -> ShowS # show :: Strictness -> String # showList :: [Strictness] -> ShowS #
Show Unpackedness
Instance details Methods showsPrec :: Int -> Unpackedness -> ShowS # show :: Unpackedness -> String # showList :: [Unpackedness] -> ShowS #
Show Half
Instance details Methods showsPrec :: Int -> Half -> ShowS # show :: Half -> String # showList :: [Half] -> ShowS #
Show ResetKind #
Instance details Methods showsPrec :: Int -> ResetKind -> ShowS # show :: ResetKind -> String # showList :: [ResetKind] -> ShowS #
Show ClockKind #
Instance details Methods showsPrec :: Int -> ClockKind -> ShowS # show :: ClockKind -> String # showList :: [ClockKind] -> ShowS #
Show DType
Instance details Methods showsPrec :: Int -> DType -> ShowS # show :: DType -> String # showList :: [DType] -> ShowS #
Show DPat
Instance details Methods showsPrec :: Int -> DPat -> ShowS # show :: DPat -> String # showList :: [DPat] -> ShowS #
Show DTyVarBndr
Instance details Methods showsPrec :: Int -> DTyVarBndr -> ShowS # show :: DTyVarBndr -> String # showList :: [DTyVarBndr] -> ShowS #
Show NewOrData
Instance details Methods showsPrec :: Int -> NewOrData -> ShowS # show :: NewOrData -> String # showList :: [NewOrData] -> ShowS #
Show DCon
Instance details Methods showsPrec :: Int -> DCon -> ShowS # show :: DCon -> String # showList :: [DCon] -> ShowS #
Show DPred
Instance details Methods showsPrec :: Int -> DPred -> ShowS # show :: DPred -> String # showList :: [DPred] -> ShowS #
Show DClause
Instance details Methods showsPrec :: Int -> DClause -> ShowS # show :: DClause -> String # showList :: [DClause] -> ShowS #
Show DExp
Instance details Methods showsPrec :: Int -> DExp -> ShowS # show :: DExp -> String # showList :: [DExp] -> ShowS #
Show DLetDec
Instance details Methods showsPrec :: Int -> DLetDec -> ShowS # show :: DLetDec -> String # showList :: [DLetDec] -> ShowS #
Show DConFields
Instance details Methods showsPrec :: Int -> DConFields -> ShowS # show :: DConFields -> String # showList :: [DConFields] -> ShowS #
Show DDec
Instance details Methods showsPrec :: Int -> DDec -> ShowS # show :: DDec -> String # showList :: [DDec] -> ShowS #
Show DDerivClause
Instance details Methods showsPrec :: Int -> DDerivClause -> ShowS # show :: DDerivClause -> String # showList :: [DDerivClause] -> ShowS #
Show DFamilyResultSig
Instance details Methods showsPrec :: Int -> DFamilyResultSig -> ShowS # show :: DFamilyResultSig -> String # showList :: [DFamilyResultSig] -> ShowS #
Show DForeign
Instance details Methods showsPrec :: Int -> DForeign -> ShowS # show :: DForeign -> String # showList :: [DForeign] -> ShowS #
Show DInfo
Instance details Methods showsPrec :: Int -> DInfo -> ShowS # show :: DInfo -> String # showList :: [DInfo] -> ShowS #
Show DMatch
Instance details Methods showsPrec :: Int -> DMatch -> ShowS # show :: DMatch -> String # showList :: [DMatch] -> ShowS #
Show DPatSynDir
Instance details Methods showsPrec :: Int -> DPatSynDir -> ShowS # show :: DPatSynDir -> String # showList :: [DPatSynDir] -> ShowS #
Show DPragma
Instance details Methods showsPrec :: Int -> DPragma -> ShowS # show :: DPragma -> String # showList :: [DPragma] -> ShowS #
Show DRuleBndr
Instance details Methods showsPrec :: Int -> DRuleBndr -> ShowS # show :: DRuleBndr -> String # showList :: [DRuleBndr] -> ShowS #
Show DTySynEqn
Instance details Methods showsPrec :: Int -> DTySynEqn -> ShowS # show :: DTySynEqn -> String # showList :: [DTySynEqn] -> ShowS #
Show DTypeFamilyHead
Instance details Methods showsPrec :: Int -> DTypeFamilyHead -> ShowS # show :: DTypeFamilyHead -> String # showList :: [DTypeFamilyHead] -> ShowS #
() :=> (Show Bool)
Instance details Methods ins :: () :- Show Bool
() :=> (Show Char)
Instance details Methods ins :: () :- Show Char
() :=> (Show Int)
Instance details Methods ins :: () :- Show Int
() :=> (Show Natural)
Instance details Methods ins :: () :- Show Natural
() :=> (Show Ordering)
Instance details Methods ins :: () :- Show Ordering
() :=> (Show Word)
Instance details Methods ins :: () :- Show Word
() :=> (Show ())
Instance details Methods ins :: () :- Show ()
() :=> (Show (a :- b))
Instance details Methods ins :: () :- Show (a :- b)
() :=> (Show (Dict a))
Instance details Methods ins :: () :- Show (Dict a)
Class () (Show a)
Instance details Methods cls :: Show a :- ()
Show a => Show [a]	Since: 2.1
Instance details Methods showsPrec :: Int -> [a] -> ShowS # show :: [a] -> String # showList :: [[a]] -> ShowS #
Show a => Show (Maybe a)
Instance details Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Show a => Show (Ratio a)	Since: 2.0.1
Instance details Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Show (Ptr a)	Since: 2.1
Instance details Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
Show (FunPtr a)	Since: 2.1
Instance details Methods showsPrec :: Int -> FunPtr a -> ShowS # show :: FunPtr a -> String # showList :: [FunPtr a] -> ShowS #
Show p => Show (Par1 p)
Instance details Methods showsPrec :: Int -> Par1 p -> ShowS # show :: Par1 p -> String # showList :: [Par1 p] -> ShowS #
Show a => Show (Complex a)
Instance details Methods showsPrec :: Int -> Complex a -> ShowS # show :: Complex a -> String # showList :: [Complex a] -> ShowS #
HasResolution a => Show (Fixed a)	Since: 2.1
Instance details Methods showsPrec :: Int -> Fixed a -> ShowS # show :: Fixed a -> String # showList :: [Fixed a] -> ShowS #
Show a => Show (Min a)
Instance details Methods showsPrec :: Int -> Min a -> ShowS # show :: Min a -> String # showList :: [Min a] -> ShowS #
Show a => Show (Max a)
Instance details Methods showsPrec :: Int -> Max a -> ShowS # show :: Max a -> String # showList :: [Max a] -> ShowS #
Show a => Show (First a)
Instance details Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a)
Instance details Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show m => Show (WrappedMonoid m)
Instance details Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS #
Show a => Show (Option a)
Instance details Methods showsPrec :: Int -> Option a -> ShowS # show :: Option a -> String # showList :: [Option a] -> ShowS #
Show a => Show (ZipList a)
Instance details 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: 4.8.0.0
Instance details Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Show a => Show (First a)
Instance details Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a)
Instance details Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show a => Show (Dual a)
Instance details Methods showsPrec :: Int -> Dual a -> ShowS # show :: Dual a -> String # showList :: [Dual a] -> ShowS #
Show a => Show (Sum a)
Instance details Methods showsPrec :: Int -> Sum a -> ShowS # show :: Sum a -> String # showList :: [Sum a] -> ShowS #
Show a => Show (Product a)
Instance details Methods showsPrec :: Int -> Product a -> ShowS # show :: Product a -> String # showList :: [Product a] -> ShowS #
Show a => Show (Down a)	Since: 4.7.0.0
Instance details Methods showsPrec :: Int -> Down a -> ShowS # show :: Down a -> String # showList :: [Down a] -> ShowS #
Show a => Show (NonEmpty a)
Instance details Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Show a => Show (IntMap a)
Instance details Methods showsPrec :: Int -> IntMap a -> ShowS # show :: IntMap a -> String # showList :: [IntMap a] -> ShowS #
Show a => Show (Tree a)
Instance details Methods showsPrec :: Int -> Tree a -> ShowS # show :: Tree a -> String # showList :: [Tree a] -> ShowS #
Show a => Show (Seq a)
Instance details Methods showsPrec :: Int -> Seq a -> ShowS # show :: Seq a -> String # showList :: [Seq a] -> ShowS #
Show a => Show (ViewL a)
Instance details Methods showsPrec :: Int -> ViewL a -> ShowS # show :: ViewL a -> String # showList :: [ViewL a] -> ShowS #
Show a => Show (ViewR a)
Instance details Methods showsPrec :: Int -> ViewR a -> ShowS # show :: ViewR a -> String # showList :: [ViewR a] -> ShowS #
Show a => Show (Set a)
Instance details Methods showsPrec :: Int -> Set a -> ShowS # show :: Set a -> String # showList :: [Set a] -> ShowS #
Show (Doc a)
Instance details Methods showsPrec :: Int -> Doc a -> ShowS # show :: Doc a -> String # showList :: [Doc a] -> ShowS #
Show a => Show (AnnotDetails a)
Instance details Methods showsPrec :: Int -> AnnotDetails a -> ShowS # show :: AnnotDetails a -> String # showList :: [AnnotDetails a] -> ShowS #
Show a => Show (Span a)
Instance details Methods showsPrec :: Int -> Span a -> ShowS # show :: Span a -> String # showList :: [Span a] -> ShowS #
Show (SSymbol s) #
Instance details Methods showsPrec :: Int -> SSymbol s -> ShowS # show :: SSymbol s -> String # showList :: [SSymbol s] -> ShowS #
KnownNat n => Show (BitVector n) #
Instance details Methods showsPrec :: Int -> BitVector n -> ShowS # show :: BitVector n -> String # showList :: [BitVector n] -> ShowS #
Show (Index n) #
Instance details Methods showsPrec :: Int -> Index n -> ShowS # show :: Index n -> String # showList :: [Index n] -> ShowS #
KnownNat n => Show (BNat n) #
Instance details Methods showsPrec :: Int -> BNat n -> ShowS # show :: BNat n -> String # showList :: [BNat n] -> ShowS #
KnownNat n => Show (UNat n) #
Instance details Methods showsPrec :: Int -> UNat n -> ShowS # show :: UNat n -> String # showList :: [UNat n] -> ShowS #
Show (SNat n) #
Instance details Methods showsPrec :: Int -> SNat n -> ShowS # show :: SNat n -> String # showList :: [SNat n] -> ShowS #
Show a => Show (Bounds a)
Instance details Methods showsPrec :: Int -> Bounds a -> ShowS # show :: Bounds a -> String # showList :: [Bounds a] -> ShowS #
Show a => Show (DList a)
Instance details Methods showsPrec :: Int -> DList a -> ShowS # show :: DList a -> String # showList :: [DList a] -> ShowS #
Show a => Show (HashSet a)
Instance details Methods showsPrec :: Int -> HashSet a -> ShowS # show :: HashSet a -> String # showList :: [HashSet a] -> ShowS #
(Show a, Storable a) => Show (Vector a)
Instance details Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
(Show a, Prim a) => Show (Vector a)
Instance details Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
Show a => Show (Vector a)
Instance details Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
Show a => Show (Array a)
Instance details Methods showsPrec :: Int -> Array a -> ShowS # show :: Array a -> String # showList :: [Array a] -> ShowS #
Show (Unsigned n) #
Instance details Methods showsPrec :: Int -> Unsigned n -> ShowS # show :: Unsigned n -> String # showList :: [Unsigned n] -> ShowS #
Show (Signed n) #
Instance details Methods showsPrec :: Int -> Signed n -> ShowS # show :: Signed n -> String # showList :: [Signed n] -> ShowS #
Show (Dict a)
Instance details Methods showsPrec :: Int -> Dict a -> ShowS # show :: Dict a -> String # showList :: [Dict a] -> ShowS #
(Show a) :=> (Show (Complex a))
Instance details Methods ins :: Show a :- Show (Complex a)
(Show a) :=> (Show [a])
Instance details Methods ins :: Show a :- Show [a]
(Show a) :=> (Show (Maybe a))
Instance details Methods ins :: Show a :- Show (Maybe a)
(Show a) :=> (Show (Identity a))
Instance details Methods ins :: Show a :- Show (Identity a)
(Show a) :=> (Show (Const a b))
Instance details Methods ins :: Show a :- Show (Const a b)
(Show a, Show b) => Show (Either a b)
Instance details Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
Show (V1 p)	Since: 4.9.0.0
Instance details Methods showsPrec :: Int -> V1 p -> ShowS # show :: V1 p -> String # showList :: [V1 p] -> ShowS #
Show (U1 p)	Since: 4.9.0.0
Instance details Methods showsPrec :: Int -> U1 p -> ShowS # show :: U1 p -> String # showList :: [U1 p] -> ShowS #
Show (TypeRep a)
Instance details Methods showsPrec :: Int -> TypeRep a -> ShowS # show :: TypeRep a -> String # showList :: [TypeRep a] -> ShowS #
(Show a, Show b) => Show (a, b)	Since: 2.1
Instance details Methods showsPrec :: Int -> (a, b) -> ShowS # show :: (a, b) -> String # showList :: [(a, b)] -> ShowS #
Show (ST s a)	Since: 2.1
Instance details 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: 2.1
Instance details 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)
Instance details Methods showsPrec :: Int -> Arg a b -> ShowS # show :: Arg a b -> String # showList :: [Arg a b] -> ShowS #
Show (Proxy s)	Since: 4.7.0.0
Instance details Methods showsPrec :: Int -> Proxy s -> ShowS # show :: Proxy s -> String # showList :: [Proxy s] -> ShowS #
(Show k, Show a) => Show (Map k a)
Instance details Methods showsPrec :: Int -> Map k a -> ShowS # show :: Map k a -> String # showList :: [Map k a] -> ShowS #
Show a => Show (Vec n a) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Methods showsPrec :: Int -> Free f a -> ShowS # show :: Free f a -> String # showList :: [Free f a] -> ShowS #
Show (f a) => Show (Yoneda f a)
Instance details 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)
Instance details Methods showsPrec :: Int -> HashMap k v -> ShowS # show :: HashMap k v -> String # showList :: [HashMap k v] -> ShowS #
Show (Clock domain gated) #
Instance details Methods showsPrec :: Int -> Clock domain gated -> ShowS # show :: Clock domain gated -> String # showList :: [Clock domain gated] -> ShowS #
Show a => Show (Signal domain a) #
Instance details Methods showsPrec :: Int -> Signal domain a -> ShowS # show :: Signal domain a -> String # showList :: [Signal domain a] -> ShowS #
Show a => Show (RTree n a) #
Instance details Methods showsPrec :: Int -> RTree n a -> ShowS # show :: RTree n a -> String # showList :: [RTree n a] -> ShowS #
Show (a :- b)
Instance details Methods showsPrec :: Int -> (a :- b) -> ShowS # show :: (a :- b) -> String # showList :: [a :- b] -> ShowS #
(Integral a, Show a) :=> (Show (Ratio a))
Instance details Methods ins :: (Integral a, Show a) :- Show (Ratio a)
(Show a, Show b) :=> (Show (a, b))
Instance details Methods ins :: (Show a, Show b) :- Show (a, b)
(Show a, Show b) :=> (Show (Either a b))
Instance details Methods ins :: (Show a, Show b) :- Show (Either a b)
Show (f p) => Show (Rec1 f p)
Instance details Methods showsPrec :: Int -> Rec1 f p -> ShowS # show :: Rec1 f p -> String # showList :: [Rec1 f p] -> ShowS #
Show (URec Char p)
Instance details Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Show (URec Double p)
Instance details Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Show (URec Float p)
Instance details Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Show (URec Int p)
Instance details Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Show (URec Word p)
Instance details 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: 2.1
Instance details 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: 4.8.0.0
Instance details Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
Show (f a) => Show (Alt f a)
Instance details Methods showsPrec :: Int -> Alt f a -> ShowS # show :: Alt f a -> String # showList :: [Alt f a] -> ShowS #
Show (a :~: b)
Instance details 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)
Instance details 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)
Instance details Methods showsPrec :: Int -> Constant a b -> ShowS # show :: Constant a b -> String # showList :: [Constant a b] -> ShowS #
Show b => Show (Tagged s b)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details Methods showsPrec :: Int -> Sum f g a -> ShowS # show :: Sum f g a -> String # showList :: [Sum f g a] -> ShowS #
Show (a :~~: b)	Since: 4.10.0.0
Instance details Methods showsPrec :: Int -> (a :~~: b) -> ShowS # show :: (a :~~: b) -> String # showList :: [a :~~: b] -> ShowS #
(Show i, Show a) => Show (Magma i t b a)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details Methods pure :: a -> [a] # (<>) :: [a -> b] -> [a] -> [b] # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] # (>) :: [a] -> [b] -> [b] # (<*) :: [a] -> [b] -> [a] #
Applicative Maybe	Since: 2.1
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 2.1
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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
Instance details 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
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.11.0.0
Instance details 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: 4.6.0.0
Instance details 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: 4.6.0.0
Instance details 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: 4.9.0.0
Instance details 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
Instance details 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: 0.5.4
Instance details 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: 4.5.0.0
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 Rose
Instance details 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 :: * -> *))
Instance details Methods ins :: () :- Applicative ((->) a)
() :=> (Applicative [])
Instance details Methods ins :: () :- Applicative []
() :=> (Applicative Maybe)
Instance details Methods ins :: () :- Applicative Maybe
() :=> (Applicative IO)
Instance details Methods ins :: () :- Applicative IO
() :=> (Applicative (Either a))
Instance details Methods ins :: () :- Applicative (Either a)
Applicative (Either e)	Since: 3.0
Instance details 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: 4.9.0.0
Instance details 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, `String`s concatenate: ("hello ", (+15)) <> ("world!", 2002) ("hello world!",2017) Since: 2.1*
Instance details 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: 4.4.0.0
Instance details 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: 2.1
Instance details 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: 4.6.0.0
Instance details 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: 4.7.0.0
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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) #
Instance details 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))
Instance details Methods ins :: Monad m :- Applicative (WrappedMonad m)
(Monoid a) :=> (Applicative ((,) a))
Instance details Methods ins :: Monoid a :- Applicative ((,) a)
(Monoid a) :=> (Applicative (Const a :: * -> *))
Instance details Methods ins :: Monoid a :- Applicative (Const a)
Class (Functor f) (Applicative f)
Instance details Methods cls :: Applicative f :- Functor f
Class (Applicative f) (Monad f)
Instance details Methods cls :: Monad f :- Applicative f
Class (Applicative f) (Alternative f)
Instance details Methods cls :: Alternative f :- Applicative f
Applicative f => Applicative (Rec1 f)	Since: 4.9.0.0
Instance details 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: 2.1
Instance details 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: 2.0.1
Instance details 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)
Instance details 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: 0.5.9
Instance details 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)
Instance details 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)
Instance details 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 :: * -> *)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 0.5.9
Instance details 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: 0.5.9
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 0.5.9
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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
Instance details 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
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.9.0.0
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 (Either a)	Since: 4.7.0.0
Instance details 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 :: * -> *)
Instance details 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: 4.9.0.0
Instance details 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: 4.7.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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.
Instance details 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) #
Instance details 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)
Instance details 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 :: * -> *)
Instance details 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 :: * -> *)
Instance details 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 :: * -> *)
Instance details 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 :: * -> *)
Instance details 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 :: * -> *)
Instance details 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 ()) :: * -> *)
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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 :: * -> *)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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 :: * -> *)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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 :: * -> *)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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
Instance details 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
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.9.0.0
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 (Either a)	Since: 4.7.0.0
Instance details 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 :: * -> *)
Instance details 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: 4.9.0.0
Instance details 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: 4.7.0.0
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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) #
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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) #
Instance details 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)
Instance details 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 :: * -> *)
Instance details 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 :: * -> *)
Instance details 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 :: * -> *)
Instance details 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 :: * -> *)
Instance details 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 :: * -> *)
Instance details 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 ()) :: * -> *)
Instance details 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: 4.7.0.0
Instance details 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)
Instance details 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 :: * -> *)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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) #
Instance details 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 :: * -> *)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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 :: * -> *)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0

Minimal complete definition

(<>)

Methods

(<>) :: a -> a -> a infixr 6 #

An associative operation.

Instances

Semigroup Ordering	Since: 4.9.0.0
Instance details Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Semigroup ()	Since: 4.9.0.0
Instance details Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # stimes :: Integral b => b -> () -> () #
Semigroup Void	Since: 4.9.0.0
Instance details Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Semigroup All	Since: 4.9.0.0
Instance details Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Semigroup Any	Since: 4.9.0.0
Instance details Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # stimes :: Integral b => b -> Any -> Any #
Semigroup ByteString
Instance details Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup ByteString
Instance details Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup IntSet	Since: 0.5.7
Instance details Methods (<>) :: IntSet -> IntSet -> IntSet # sconcat :: NonEmpty IntSet -> IntSet # stimes :: Integral b => b -> IntSet -> IntSet #
Semigroup Doc
Instance details Methods (<>) :: Doc -> Doc -> Doc # sconcat :: NonEmpty Doc -> Doc # stimes :: Integral b => b -> Doc -> Doc #
Semigroup ULetDecEnv
Instance details Methods (<>) :: ULetDecEnv -> ULetDecEnv -> ULetDecEnv # sconcat :: NonEmpty ULetDecEnv -> ULetDecEnv # stimes :: Integral b => b -> ULetDecEnv -> ULetDecEnv #
() :=> (Semigroup [a])
Instance details Methods ins :: () :- Semigroup [a]
() :=> (Semigroup Ordering)
Instance details Methods ins :: () :- Semigroup Ordering
() :=> (Semigroup ())
Instance details Methods ins :: () :- Semigroup ()
() :=> (Semigroup (Dict a))
Instance details Methods ins :: () :- Semigroup (Dict a)
Class () (Semigroup a)
Instance details Methods cls :: Semigroup a :- ()
Semigroup [a]	Since: 4.9.0.0
Instance details Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # stimes :: Integral b => b -> [a] -> [a] #
Semigroup a => Semigroup (Maybe a)	Since: 4.9.0.0
Instance details 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: 4.10.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.11.0.0
Instance details 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: 4.9.0.0
Instance details 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: 0.5.7
Instance details 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: 0.5.7
Instance details 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: 0.5.7
Instance details Methods (<>) :: Set a -> Set a -> Set a # sconcat :: NonEmpty (Set a) -> Set a # stimes :: Integral b => b -> Set a -> Set a #
Semigroup (Doc a)
Instance details Methods (<>) :: Doc a -> Doc a -> Doc a # sconcat :: NonEmpty (Doc a) -> Doc a # stimes :: Integral b => b -> Doc a -> Doc a #
Semigroup (Leftmost a)
Instance details Methods (<>) :: Leftmost a -> Leftmost a -> Leftmost a # sconcat :: NonEmpty (Leftmost a) -> Leftmost a # stimes :: Integral b => b -> Leftmost a -> Leftmost a #
Semigroup (Rightmost a)
Instance details Methods (<>) :: Rightmost a -> Rightmost a -> Rightmost a # sconcat :: NonEmpty (Rightmost a) -> Rightmost a # stimes :: Integral b => b -> Rightmost a -> Rightmost a #
Semigroup (DList a)
Instance details Methods (<>) :: DList a -> DList a -> DList a # sconcat :: NonEmpty (DList a) -> DList a # stimes :: Integral b => b -> DList a -> DList a #
Semigroup (MergeSet a)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
Semigroup (Vector a)
Instance details Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
Semigroup (Comparison a)
Instance details Methods (<>) :: Comparison a -> Comparison a -> Comparison a # sconcat :: NonEmpty (Comparison a) -> Comparison a # stimes :: Integral b => b -> Comparison a -> Comparison a #
Semigroup (Equivalence a)
Instance details Methods (<>) :: Equivalence a -> Equivalence a -> Equivalence a # sconcat :: NonEmpty (Equivalence a) -> Equivalence a # stimes :: Integral b => b -> Equivalence a -> Equivalence a #
Semigroup (Predicate a)
Instance details Methods (<>) :: Predicate a -> Predicate a -> Predicate a # sconcat :: NonEmpty (Predicate a) -> Predicate a # stimes :: Integral b => b -> Predicate a -> Predicate a #
Semigroup (Array a)
Instance details Methods (<>) :: Array a -> Array a -> Array a # sconcat :: NonEmpty (Array a) -> Array a # stimes :: Integral b => b -> Array a -> Array a #
Semigroup (Dict a)
Instance details 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)
Instance details 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)
Instance details Methods (<>) :: Min a -> Min a -> Min a # sconcat :: NonEmpty (Min a) -> Min a # stimes :: Integral b => b -> Min a -> Min a #
Semigroup (NonEmptyDList a)
Instance details 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))
Instance details Methods ins :: Semigroup a :- Semigroup (Maybe a)
(Semigroup a) :=> (Semigroup (Const a b))
Instance details Methods ins :: Semigroup a :- Semigroup (Const a b)
(Semigroup a) :=> (Semigroup (Identity a))
Instance details Methods ins :: Semigroup a :- Semigroup (Identity a)
(Semigroup a) :=> (Semigroup (IO a))
Instance details Methods ins :: Semigroup a :- Semigroup (IO a)
Class (Semigroup a) (Monoid a)
Instance details Methods cls :: Monoid a :- Semigroup a
Semigroup b => Semigroup (a -> b)	Since: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 4.11.0.0
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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))
Instance details Methods ins :: (Semigroup a, Semigroup b) :- Semigroup (a, b)
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)	Since: 4.9.0.0
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid ()	Since: 2.1
Instance details Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid All	Since: 2.1
Instance details Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any	Since: 2.1
Instance details Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid ByteString
Instance details Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ByteString
Instance details Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid IntSet
Instance details Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid Doc
Instance details Methods mempty :: Doc # mappend :: Doc -> Doc -> Doc # mconcat :: [Doc] -> Doc #
Monoid ULetDecEnv
Instance details Methods mempty :: ULetDecEnv # mappend :: ULetDecEnv -> ULetDecEnv -> ULetDecEnv # mconcat :: [ULetDecEnv] -> ULetDecEnv #
a :=> (Monoid (Dict a))
Instance details Methods ins :: a :- Monoid (Dict a)
() :=> (Monoid [a])
Instance details Methods ins :: () :- Monoid [a]
() :=> (Monoid Ordering)
Instance details Methods ins :: () :- Monoid Ordering
() :=> (Monoid ())
Instance details Methods ins :: () :- Monoid ()
Monoid [a]	Since: 2.1
Instance details 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 `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: 2.1*
Instance details Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (IO a)	Since: 4.9.0.0
Instance details Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
(Ord a, Bounded a) => Monoid (Min a)	Since: 4.9.0.0
Instance details Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
(Ord a, Bounded a) => Monoid (Max a)	Since: 4.9.0.0
Instance details Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
Monoid m => Monoid (WrappedMonoid m)	Since: 4.9.0.0
Instance details Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Semigroup a => Monoid (Option a)	Since: 4.9.0.0
Instance details Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid a => Monoid (Identity a)
Instance details Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Monoid (First a)	Since: 2.1
Instance details Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a)	Since: 2.1
Instance details Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid a => Monoid (Dual a)	Since: 2.1
Instance details Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Monoid (Endo a)	Since: 2.1
Instance details Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Sum a)	Since: 2.1
Instance details Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Monoid (Product a)	Since: 2.1
Instance details Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Monoid a => Monoid (Down a)	Since: 4.11.0.0
Instance details Methods mempty :: Down a # mappend :: Down a -> Down a -> Down a # mconcat :: [Down a] -> Down a #
Monoid (IntMap a)
Instance details Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Monoid (Seq a)
Instance details Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Ord a => Monoid (Set a)
Instance details Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Monoid (Doc a)
Instance details Methods mempty :: Doc a # mappend :: Doc a -> Doc a -> Doc a # mconcat :: [Doc a] -> Doc a #
Monoid (Leftmost a)
Instance details Methods mempty :: Leftmost a # mappend :: Leftmost a -> Leftmost a -> Leftmost a # mconcat :: [Leftmost a] -> Leftmost a #
Monoid (Rightmost a)
Instance details Methods mempty :: Rightmost a # mappend :: Rightmost a -> Rightmost a -> Rightmost a # mconcat :: [Rightmost a] -> Rightmost a #
Monoid (DList a)
Instance details Methods mempty :: DList a # mappend :: DList a -> DList a -> DList a # mconcat :: [DList a] -> DList a #
Monoid (MergeSet a)
Instance details Methods mempty :: MergeSet a # mappend :: MergeSet a -> MergeSet a -> MergeSet a # mconcat :: [MergeSet a] -> MergeSet a #
(Hashable a, Eq a) => Monoid (HashSet a)
Instance details Methods mempty :: HashSet a # mappend :: HashSet a -> HashSet a -> HashSet a # mconcat :: [HashSet a] -> HashSet a #
Storable a => Monoid (Vector a)
Instance details Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Prim a => Monoid (Vector a)
Instance details Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Monoid (Vector a)
Instance details Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Monoid (Comparison a)
Instance details Methods mempty :: Comparison a # mappend :: Comparison a -> Comparison a -> Comparison a # mconcat :: [Comparison a] -> Comparison a #
Monoid (Equivalence a)
Instance details Methods mempty :: Equivalence a # mappend :: Equivalence a -> Equivalence a -> Equivalence a # mconcat :: [Equivalence a] -> Equivalence a #
Monoid (Predicate a)
Instance details Methods mempty :: Predicate a # mappend :: Predicate a -> Predicate a -> Predicate a # mconcat :: [Predicate a] -> Predicate a #
Monoid (Array a)
Instance details Methods mempty :: Array a # mappend :: Array a -> Array a -> Array a # mconcat :: [Array a] -> Array a #
a => Monoid (Dict a)
Instance details Methods mempty :: Dict a # mappend :: Dict a -> Dict a -> Dict a # mconcat :: [Dict a] -> Dict a #
Ord a => Monoid (Max a)
Instance details Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
Ord a => Monoid (Min a)
Instance details Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
(Monoid a) :=> (Monoid (Maybe a))
Instance details Methods ins :: Monoid a :- Monoid (Maybe a)
(Monoid a) :=> (Monoid (Const a b))
Instance details Methods ins :: Monoid a :- Monoid (Const a b)
(Monoid a) :=> (Monoid (Identity a))
Instance details Methods ins :: Monoid a :- Monoid (Identity a)
(Monoid a) :=> (Monoid (IO a))
Instance details Methods ins :: Monoid a :- Monoid (IO a)
(Monoid a) :=> (Applicative ((,) a))
Instance details Methods ins :: Monoid a :- Applicative ((,) a)
(Monoid a) :=> (Applicative (Const a :: * -> *))
Instance details Methods ins :: Monoid a :- Applicative (Const a)
Class (Semigroup a) (Monoid a)
Instance details Methods cls :: Monoid a :- Semigroup a
Monoid b => Monoid (a -> b)	Since: 2.1
Instance details Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b)	Since: 2.1
Instance details Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid a => Monoid (ST s a)	Since: 4.11.0.0
Instance details 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: 4.7.0.0
Instance details Methods mempty :: Proxy s # mappend :: Proxy s -> Proxy s -> Proxy s # mconcat :: [Proxy s] -> Proxy s #
Ord k => Monoid (Map k v)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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))
Instance details Methods ins :: (Monoid a, Monoid b) :- Monoid (a, b)
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)	Since: 2.1
Instance details 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)
Instance details 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: 4.8.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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)
Instance details 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: 2.1
Instance details Methods minBound :: Bool # maxBound :: Bool #
Enum Bool	Since: 2.1
Instance details 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
Instance details Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Data Bool	Since: 4.0.0.0
Instance details 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
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Show Bool
Instance details Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Ix Bool	Since: 2.1
Instance details 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
Instance details Associated Types type Rep Bool :: * -> * # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Lift Bool
Instance details Methods lift :: Bool -> Q Exp #
SingKind Bool	Since: 4.9.0.0
Instance details Associated Types type DemoteRep Bool :: * Methods fromSing :: Sing a -> DemoteRep Bool
Storable Bool	Since: 2.1
Instance details 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: 4.7.0.0
Instance details 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: 4.7.0.0
Instance details Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int #
NFData Bool
Instance details Methods rnf :: Bool -> () #
ShowX Bool Source #
Instance details Methods showsPrecX :: Int -> Bool -> ShowS Source # showX :: Bool -> String Source # showListX :: [Bool] -> ShowS Source #
Arbitrary Bool
Instance details Methods arbitrary :: Gen Bool shrink :: Bool -> [Bool]
CoArbitrary Bool
Instance details Methods coarbitrary :: Bool -> Gen b -> Gen b
Unbox Bool
Instance details
BitPack Bool Source #
Instance details Associated Types type BitSize Bool :: Nat Source # Methods pack :: Bool -> BitVector (BitSize Bool) Source # unpack :: BitVector (BitSize Bool) -> Bool Source #
Testable Bool
Instance details Methods property :: Bool -> Property
PBounded Bool
Instance details Associated Types type MinBound :: a type MaxBound :: a
PEnum Bool
Instance details 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
Instance details Methods sMinBound :: Sing MinBoundSym0 sMaxBound :: Sing MaxBoundSym0
SEnum Bool
Instance details 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
Instance details Associated Types type x == y :: Bool type x /= y :: Bool
SEq Bool
Instance details Methods (%==) :: Sing a -> Sing b -> Sing (a == b) (%/=) :: Sing a -> Sing b -> Sing (a /= b)
POrd Bool
Instance details 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
Instance details 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
Instance details Associated Types type ShowsPrec arg arg1 arg2 :: Symbol type Show_ arg :: Symbol type ShowList arg arg1 :: Symbol
SShow Bool
Instance details 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
Instance details Methods showsSingPrec :: Int -> Sing a -> ShowS
Bundle Bool Source #
Instance details Associated Types type Unbundled domain Bool = (res :: *) Source # Methods bundle :: Unbundled domain Bool -> Signal domain Bool Source # unbundle :: Signal domain Bool -> Unbundled domain Bool Source #
SingI False	Since: 4.9.0.0
Instance details Methods sing :: Sing False
SingI True	Since: 4.9.0.0
Instance details Methods sing :: Sing True
Vector Vector Bool
Instance details 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
Instance details 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 Source #
Instance details Methods lockStep :: DataFlow dom Bool Bool c c Source # stepLock :: DataFlow dom Bool Bool c c Source #
() :=> (Bounded Bool)
Instance details Methods ins :: () :- Bounded Bool
() :=> (Enum Bool)
Instance details Methods ins :: () :- Enum Bool
() :=> (Eq Bool)
Instance details Methods ins :: () :- Eq Bool
() :=> (Ord Bool)
Instance details Methods ins :: () :- Ord Bool
() :=> (Read Bool)
Instance details Methods ins :: () :- Read Bool
() :=> (Show Bool)
Instance details Methods ins :: () :- Show Bool
() :=> (Bits Bool)
Instance details Methods ins :: () :- Bits Bool
SuppressUnusedWarnings ShowParenSym2
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (&&@#@$$)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (\|\|@#@$$)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551605Sym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ShowParenSym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ShowsPrec_6989586621679888031Sym2
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ShowsPrec_6989586621679888031Sym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings NotSym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (&&@#@$)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (\|\|@#@$)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551605Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ShowParenSym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings FromEnum_6989586621680021011Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings AndSym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings OrSym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ToEnum_6989586621680021001Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ShowsPrec_6989586621679888031Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (UnionBySym2 :: (TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) -> [a6989586621679681237] -> TyFun [a6989586621679681237] [a6989586621679681237] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (UnionBySym1 :: (TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) -> TyFun [a6989586621679681237] (TyFun [a6989586621679681237] [a6989586621679681237] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TakeWhileSym1 :: (TyFun a6989586621679681264 Bool -> Type) -> TyFun [a6989586621679681264] [a6989586621679681264] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (SpanSym1 :: (TyFun a6989586621679681261 Bool -> Type) -> TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (SelectSym2 :: (TyFun a6989586621679681247 Bool -> Type) -> a6989586621679681247 -> TyFun ([a6989586621679681247], [a6989586621679681247]) ([a6989586621679681247], [a6989586621679681247]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (SelectSym1 :: (TyFun a6989586621679681247 Bool -> Type) -> TyFun a6989586621679681247 (TyFun ([a6989586621679681247], [a6989586621679681247]) ([a6989586621679681247], [a6989586621679681247]) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (PartitionSym1 :: (TyFun a6989586621679681248 Bool -> Type) -> TyFun [a6989586621679681248] ([a6989586621679681248], [a6989586621679681248]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (NubBySym1 :: (TyFun a6989586621679681239 (TyFun a6989586621679681239 Bool -> Type) -> Type) -> TyFun [a6989586621679681239] [a6989586621679681239] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979ZsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979ZsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979YsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979YsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979X_6989586621679690980Sym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] ([k], [k]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979X_6989586621679690980Sym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] ([k], [k]) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886ZsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886ZsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886YsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886YsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886X_6989586621679690887Sym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] ([k], [k]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886X_6989586621679690887Sym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] ([k], [k]) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IntersectBySym2 :: (TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) -> [a6989586621679681265] -> TyFun [a6989586621679681265] [a6989586621679681265] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IntersectBySym1 :: (TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) -> TyFun [a6989586621679681265] (TyFun [a6989586621679681265] [a6989586621679681265] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (GroupBySym1 :: (TyFun a6989586621679681251 (TyFun a6989586621679681251 Bool -> Type) -> Type) -> TyFun [a6989586621679681251] [[a6989586621679681251]] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindSym1 :: (TyFun a6989586621679681271 Bool -> Type) -> TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindIndicesSym1 :: (TyFun a6989586621679681267 Bool -> Type) -> TyFun [a6989586621679681267] [Nat] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindIndexSym1 :: (TyFun a6989586621679681268 Bool -> Type) -> TyFun [a6989586621679681268] (Maybe Nat) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FilterSym1 :: (TyFun a6989586621679681272 Bool -> Type) -> TyFun [a6989586621679681272] [a6989586621679681272] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Elem_bySym2 :: (TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) -> a6989586621679681238 -> TyFun [a6989586621679681238] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Elem_bySym1 :: (TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) -> TyFun a6989586621679681238 (TyFun [a6989586621679681238] Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DropWhileSym1 :: (TyFun a6989586621679681263 Bool -> Type) -> TyFun [a6989586621679681263] [a6989586621679681263] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DropWhileEndSym1 :: (TyFun a6989586621679681262 Bool -> Type) -> TyFun [a6989586621679681262] [a6989586621679681262] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DeleteFirstsBySym2 :: (TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) -> [a6989586621679681277] -> TyFun [a6989586621679681277] [a6989586621679681277] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DeleteFirstsBySym1 :: (TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) -> TyFun [a6989586621679681277] (TyFun [a6989586621679681277] [a6989586621679681277] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DeleteBySym2 :: (TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) -> a6989586621679681278 -> TyFun [a6989586621679681278] [a6989586621679681278] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DeleteBySym1 :: (TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) -> TyFun a6989586621679681278 (TyFun [a6989586621679681278] [a6989586621679681278] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (BreakSym1 :: (TyFun a6989586621679681260 Bool -> Type) -> TyFun [a6989586621679681260] ([a6989586621679681260], [a6989586621679681260]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (AnySym1 :: (TyFun a6989586621679681341 Bool -> Type) -> TyFun [a6989586621679681341] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (AllSym1 :: (TyFun a6989586621679681342 Bool -> Type) -> TyFun [a6989586621679681342] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsSuffixOfSym1 :: [a6989586621679681323] -> TyFun [a6989586621679681323] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsPrefixOfSym1 :: [a6989586621679681324] -> TyFun [a6989586621679681324] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsInfixOfSym1 :: [a6989586621679681322] -> TyFun [a6989586621679681322] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TFHelper_6989586621679544141Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TFHelper_6989586621679544108Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TFHelper_6989586621679544075Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TFHelper_6989586621679544042Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544194Scrutinee_6989586621679542855Sym1 :: k1 -> TyFun k1 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544161Scrutinee_6989586621679542853Sym1 :: k1 -> TyFun k1 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679543995Scrutinee_6989586621679542843Sym1 :: k1 -> TyFun k1 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679543985Scrutinee_6989586621679542841Sym1 :: k1 -> TyFun k1 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((>@#@$$) :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((>=@#@$$) :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((<@#@$$) :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((<=@#@$$) :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (NotElemSym1 :: a6989586621679681320 -> TyFun [a6989586621679681320] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ElemSym1 :: a6989586621679681321 -> TyFun [a6989586621679681321] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((==@#@$$) :: a6989586621679532030 -> TyFun a6989586621679532030 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((/=@#@$$) :: a6989586621679532030 -> TyFun a6989586621679532030 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Bool_Sym2 :: a6989586621679529656 -> a6989586621679529656 -> TyFun Bool a6989586621679529656 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Bool_Sym1 :: a6989586621679529656 -> TyFun a6989586621679529656 (TyFun Bool a6989586621679529656 -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (UnionBySym0 :: TyFun (TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) (TyFun [a6989586621679681237] (TyFun [a6989586621679681237] [a6989586621679681237] -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TakeWhileSym0 :: TyFun (TyFun a6989586621679681264 Bool -> Type) (TyFun [a6989586621679681264] [a6989586621679681264] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (SpanSym0 :: TyFun (TyFun a6989586621679681261 Bool -> Type) (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (SelectSym0 :: TyFun (TyFun a6989586621679681247 Bool -> Type) (TyFun a6989586621679681247 (TyFun ([a6989586621679681247], [a6989586621679681247]) ([a6989586621679681247], [a6989586621679681247]) -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (PartitionSym0 :: TyFun (TyFun a6989586621679681248 Bool -> Type) (TyFun [a6989586621679681248] ([a6989586621679681248], [a6989586621679681248]) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (NubBySym0 :: TyFun (TyFun a6989586621679681239 (TyFun a6989586621679681239 Bool -> Type) -> Type) (TyFun [a6989586621679681239] [a6989586621679681239] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690979X_6989586621679690980Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690886X_6989586621679690887Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IntersectBySym0 :: TyFun (TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) (TyFun [a6989586621679681265] (TyFun [a6989586621679681265] [a6989586621679681265] -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (GroupBySym0 :: TyFun (TyFun a6989586621679681251 (TyFun a6989586621679681251 Bool -> Type) -> Type) (TyFun [a6989586621679681251] [[a6989586621679681251]] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindSym0 :: TyFun (TyFun a6989586621679681271 Bool -> Type) (TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindIndicesSym0 :: TyFun (TyFun a6989586621679681267 Bool -> Type) (TyFun [a6989586621679681267] [Nat] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindIndexSym0 :: TyFun (TyFun a6989586621679681268 Bool -> Type) (TyFun [a6989586621679681268] (Maybe Nat) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FilterSym0 :: TyFun (TyFun a6989586621679681272 Bool -> Type) (TyFun [a6989586621679681272] [a6989586621679681272] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Elem_bySym0 :: TyFun (TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) (TyFun a6989586621679681238 (TyFun [a6989586621679681238] Bool -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DropWhileSym0 :: TyFun (TyFun a6989586621679681263 Bool -> Type) (TyFun [a6989586621679681263] [a6989586621679681263] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DropWhileEndSym0 :: TyFun (TyFun a6989586621679681262 Bool -> Type) (TyFun [a6989586621679681262] [a6989586621679681262] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DeleteFirstsBySym0 :: TyFun (TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) (TyFun [a6989586621679681277] (TyFun [a6989586621679681277] [a6989586621679681277] -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (DeleteBySym0 :: TyFun (TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) (TyFun a6989586621679681278 (TyFun [a6989586621679681278] [a6989586621679681278] -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (BreakSym0 :: TyFun (TyFun a6989586621679681260 Bool -> Type) (TyFun [a6989586621679681260] ([a6989586621679681260], [a6989586621679681260]) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (AnySym0 :: TyFun (TyFun a6989586621679681341 Bool -> Type) (TyFun [a6989586621679681341] Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (AllSym0 :: TyFun (TyFun a6989586621679681342 Bool -> Type) (TyFun [a6989586621679681342] Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (NullSym0 :: TyFun [a6989586621679681358] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsSuffixOfSym0 :: TyFun [a6989586621679681323] (TyFun [a6989586621679681323] Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsPrefixOfSym0 :: TyFun [a6989586621679681324] (TyFun [a6989586621679681324] Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsInfixOfSym0 :: TyFun [a6989586621679681322] (TyFun [a6989586621679681322] Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsNothingSym0 :: TyFun (Maybe a6989586621679647548) Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsJustSym0 :: TyFun (Maybe a6989586621679647549) Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TFHelper_6989586621679544141Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TFHelper_6989586621679544108Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TFHelper_6989586621679544075Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (TFHelper_6989586621679544042Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544194Scrutinee_6989586621679542855Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544161Scrutinee_6989586621679542853Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679543995Scrutinee_6989586621679542843Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679543985Scrutinee_6989586621679542841Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((>@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((>=@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((<@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((<=@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (NotElemSym0 :: TyFun a6989586621679681320 (TyFun [a6989586621679681320] Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ElemSym0 :: TyFun a6989586621679681321 (TyFun [a6989586621679681321] Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((==@#@$) :: TyFun a6989586621679532030 (TyFun a6989586621679532030 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ((/=@#@$) :: TyFun a6989586621679532030 (TyFun a6989586621679532030 Bool -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Bool_Sym0 :: TyFun a6989586621679529656 (TyFun a6989586621679529656 (TyFun Bool a6989586621679529656 -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690534NubBy'Sym3 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> k -> [k1] -> TyFun [k1] [k1] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690534NubBy'Sym2 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> k -> TyFun [k1] ([k1] ~> [k1]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690534NubBy'Sym1 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> TyFun k (TyFun [k1] ([k1] ~> [k1]) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690626Scrutinee_6989586621679681939Sym1 :: k1 -> TyFun k Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690534NubBy'Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsRightSym0 :: TyFun (Either a6989586621680060960 b6989586621680060961) Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsLeftSym0 :: TyFun (Either a6989586621680060962 b6989586621680060963) Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690626Scrutinee_6989586621679681939Sym0 :: TyFun k1 (TyFun k Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043ZsSym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043YsSym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043X_6989586621679691044Sym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679693422Sym0 :: TyFun (a6989586621679681358 ~> Bool) (TyFun k (TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043ZsSym2 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> k1 -> TyFun [a6989586621679681261] [a6989586621679681261] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043ZsSym1 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043YsSym2 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> k1 -> TyFun [a6989586621679681261] [a6989586621679681261] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043YsSym1 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043X_6989586621679691044Sym2 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> k1 -> TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691043X_6989586621679691044Sym1 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679693422Sym3 :: (a6989586621679681358 ~> Bool) -> k -> a6989586621679681358 -> TyFun [a6989586621679681358] [a6989586621679681358] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679693422Sym2 :: (a6989586621679681358 ~> Bool) -> k -> TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679693422Sym1 :: (a6989586621679681358 ~> Bool) -> TyFun k (TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym4 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> k3 -> k2 -> TyFun [k3] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym3 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> k3 -> TyFun k2 (TyFun [k3] Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym2 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> TyFun k3 (TyFun k2 (TyFun [k3] Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym1 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691889Scrutinee_6989586621679681943Sym3 :: k1 -> k3 -> k2 -> TyFun [k3] Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691889Scrutinee_6989586621679681943Sym2 :: k1 -> k3 -> TyFun k2 (TyFun [k3] Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691889Scrutinee_6989586621679681943Sym1 :: k1 -> TyFun k3 (TyFun k2 (TyFun [k3] Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690818Scrutinee_6989586621679681923Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690818Scrutinee_6989586621679681923Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690790Scrutinee_6989586621679681925Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690790Scrutinee_6989586621679681925Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690756Scrutinee_6989586621679681935Sym3 :: k1 -> k1 -> k2 -> TyFun k3 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690756Scrutinee_6989586621679681935Sym2 :: k1 -> k1 -> TyFun k2 (TyFun k3 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690756Scrutinee_6989586621679681935Sym1 :: k1 -> TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690599Scrutinee_6989586621679681941Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690599Scrutinee_6989586621679681941Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym0 :: TyFun (TyFun k3 (TyFun k3 Bool -> Type) -> Type) (TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> ) -> ) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679691889Scrutinee_6989586621679681943Sym0 :: TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690818Scrutinee_6989586621679681923Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690790Scrutinee_6989586621679681925Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690756Scrutinee_6989586621679681935Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679690599Scrutinee_6989586621679681941Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679693426Scrutinee_6989586621679681917Sym0 :: TyFun (k1 ~> Bool) (TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679693426Scrutinee_6989586621679681917Sym3 :: (k1 ~> Bool) -> k1 -> [a6989586621679681358] -> TyFun k Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679693426Scrutinee_6989586621679681917Sym2 :: (k1 ~> Bool) -> k1 -> TyFun [a6989586621679681358] (TyFun k Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679693426Scrutinee_6989586621679681917Sym1 :: (k1 ~> Bool) -> TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym4 :: k1 -> k2 -> k2 -> k3 -> TyFun k4 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym3 :: k1 -> k2 -> k2 -> TyFun k3 (TyFun k4 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym2 :: k1 -> k2 -> TyFun k2 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym1 :: k1 -> TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym0 :: TyFun k1 (TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679692511Sym0 :: TyFun (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) (TyFun k1 (TyFun k2 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k3 Bool -> ) -> ) -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679692511Sym5 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> k1 -> k2 -> a6989586621679681341 -> [a6989586621679681341] -> TyFun k3 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679692511Sym4 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> k1 -> k2 -> a6989586621679681341 -> TyFun [a6989586621679681341] (TyFun k3 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679692511Sym3 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> k1 -> k2 -> TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k3 Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679692511Sym2 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> k1 -> TyFun k2 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k3 Bool -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Lambda_6989586621679692511Sym1 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> TyFun k1 (TyFun k2 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k3 Bool -> ) -> ) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym5 :: k2 -> k1 -> k2 -> k3 -> k4 -> TyFun k5 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym4 :: k2 -> k1 -> k2 -> k3 -> TyFun k4 (TyFun k5 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym3 :: k2 -> k1 -> k2 -> TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym2 :: k2 -> k1 -> TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym1 :: k2 -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym5 :: k2 -> k1 -> k2 -> k3 -> k4 -> TyFun k5 Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym4 :: k2 -> k1 -> k2 -> k3 -> TyFun k4 (TyFun k5 Bool -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym3 :: k2 -> k1 -> k2 -> TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym2 :: k2 -> k1 -> TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym1 :: k2 -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym0 :: TyFun k2 (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym0 :: TyFun k2 (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
type Rep Bool
Instance details 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)
Instance details data Sing (a :: Bool) where STrue :: Sing True SFalse :: Sing False
type DemoteRep Bool
Instance details type DemoteRep Bool = Bool
data Vector Bool
Instance details data Vector Bool = V_Bool (Vector Word8)
type BitSize Bool Source #
Instance details type BitSize Bool = 1
data Sing (z :: Bool)
Instance details data Sing (z :: Bool) where SFalse :: Sing False STrue :: Sing True
type Demote Bool
Instance details type Demote Bool = Bool
type MaxBound
Instance details type MaxBound = MaxBound_6989586621679997941Sym0
type MinBound
Instance details type MinBound = MinBound_6989586621679997939Sym0
data MVector s Bool
Instance details data MVector s Bool = MV_Bool (MVector s Word8)
type FromEnum (a :: Bool)
Instance details type FromEnum (a :: Bool) = Apply FromEnum_6989586621680021011Sym0 a
type ToEnum a
Instance details type ToEnum a = Apply ToEnum_6989586621680021001Sym0 a
type Show_ (arg :: Bool)
Instance details type Show_ (arg :: Bool) = Apply (Show__6989586621679871872Sym0 :: TyFun Bool Symbol -> *) arg
type Pred (arg :: Bool)
Instance details type Pred (arg :: Bool) = Apply (Pred_6989586621680002470Sym0 :: TyFun Bool Bool -> *) arg
type Succ (arg :: Bool)
Instance details type Succ (arg :: Bool) = Apply (Succ_6989586621680002457Sym0 :: TyFun Bool Bool -> *) arg
type Unbundled domain Bool Source #
Instance details type Unbundled domain Bool = Signal domain Bool
type EnumFromTo (arg1 :: Bool) (arg2 :: Bool)
Instance details type EnumFromTo (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (EnumFromTo_6989586621680002488Sym0 :: TyFun Bool (TyFun Bool [Bool] -> Type) -> *) arg1) arg2
type (x :: Bool) /= (y :: Bool)
Instance details type (x :: Bool) /= (y :: Bool) = Not (x == y)
type (a :: Bool) == (b :: Bool)
Instance details type (a :: Bool) == (b :: Bool) = Equals_6989586621679532926 a b
type (arg1 :: Bool) < (arg2 :: Bool)
Instance details type (arg1 :: Bool) < (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679544042Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2
type (arg1 :: Bool) <= (arg2 :: Bool)
Instance details type (arg1 :: Bool) <= (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679544075Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2
type (arg1 :: Bool) > (arg2 :: Bool)
Instance details type (arg1 :: Bool) > (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679544108Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2
type (arg1 :: Bool) >= (arg2 :: Bool)
Instance details type (arg1 :: Bool) >= (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679544141Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2
type Compare (a1 :: Bool) (a2 :: Bool)
Instance details type Compare (a1 :: Bool) (a2 :: Bool) = Apply (Apply Compare_6989586621679551605Sym0 a1) a2
type Max (arg1 :: Bool) (arg2 :: Bool)
Instance details type Max (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (Max_6989586621679544174Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2
type Min (arg1 :: Bool) (arg2 :: Bool)
Instance details type Min (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (Min_6989586621679544207Sym0 :: TyFun Bool (TyFun Bool Bool -> Type) -> *) arg1) arg2
type ShowList (arg1 :: [Bool]) arg2
Instance details type ShowList (arg1 :: [Bool]) arg2 = Apply (Apply (ShowList_6989586621679871890Sym0 :: TyFun [Bool] (TyFun Symbol Symbol -> Type) -> *) arg1) arg2
type Apply NotSym0 (l :: Bool)
Instance details type Apply NotSym0 (l :: Bool) = Not l
type Apply FromEnum_6989586621680021011Sym0 (l :: Bool)
Instance details type Apply FromEnum_6989586621680021011Sym0 (l :: Bool) = FromEnum_6989586621680021011 l
type Apply ToEnum_6989586621680021001Sym0 (l :: Nat)
Instance details type Apply ToEnum_6989586621680021001Sym0 (l :: Nat) = ToEnum_6989586621680021001 l
type EnumFromThenTo (arg1 :: Bool) (arg2 :: Bool) (arg3 :: Bool)
Instance details type EnumFromThenTo (arg1 :: Bool) (arg2 :: Bool) (arg3 :: Bool) = Apply (Apply (Apply (EnumFromThenTo_6989586621680002518Sym0 :: TyFun Bool (TyFun Bool (TyFun Bool [Bool] -> Type) -> Type) -> *) arg1) arg2) arg3
type ShowsPrec a1 (a2 :: Bool) a3
Instance details type ShowsPrec a1 (a2 :: Bool) a3 = Apply (Apply (Apply ShowsPrec_6989586621679888031Sym0 a1) a2) a3
type Apply ((&&@#@$$) l1 :: TyFun Bool Bool -> *) (l2 :: Bool)
Instance details type Apply ((&&@#@$$) l1 :: TyFun Bool Bool -> *) (l2 :: Bool) = l1 && l2
type Apply ((\|\|@#@$$) l1 :: TyFun Bool Bool -> *) (l2 :: Bool)
Instance details type Apply ((\|\|@#@$$) l1 :: TyFun Bool Bool -> *) (l2 :: Bool) = l1 \|\| l2
type Apply (Compare_6989586621679551605Sym1 l1 :: TyFun Bool Ordering -> *) (l2 :: Bool)
Instance details type Apply (Compare_6989586621679551605Sym1 l1 :: TyFun Bool Ordering -> *) (l2 :: Bool) = Compare_6989586621679551605 l1 l2
type Apply (Let6989586621679543985Scrutinee_6989586621679542841Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679543985Scrutinee_6989586621679542841Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1) = Let6989586621679543985Scrutinee_6989586621679542841 l1 l2
type Apply (TFHelper_6989586621679544141Sym1 l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply (TFHelper_6989586621679544141Sym1 l1 :: TyFun a Bool -> *) (l2 :: a) = TFHelper_6989586621679544141 l1 l2
type Apply (TFHelper_6989586621679544108Sym1 l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply (TFHelper_6989586621679544108Sym1 l1 :: TyFun a Bool -> *) (l2 :: a) = TFHelper_6989586621679544108 l1 l2
type Apply (TFHelper_6989586621679544075Sym1 l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply (TFHelper_6989586621679544075Sym1 l1 :: TyFun a Bool -> *) (l2 :: a) = TFHelper_6989586621679544075 l1 l2
type Apply (TFHelper_6989586621679544042Sym1 l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply (TFHelper_6989586621679544042Sym1 l1 :: TyFun a Bool -> *) (l2 :: a) = TFHelper_6989586621679544042 l1 l2
type Apply ((<=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply ((<=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 <= l2
type Apply ((>=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply ((>=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 >= l2
type Apply ((>@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply ((>@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 > l2
type Apply (Let6989586621679544194Scrutinee_6989586621679542855Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679544194Scrutinee_6989586621679542855Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1) = Let6989586621679544194Scrutinee_6989586621679542855 l1 l2
type Apply (Let6989586621679544161Scrutinee_6989586621679542853Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679544161Scrutinee_6989586621679542853Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1) = Let6989586621679544161Scrutinee_6989586621679542853 l1 l2
type Apply (Let6989586621679543995Scrutinee_6989586621679542843Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679543995Scrutinee_6989586621679542843Sym1 l1 :: TyFun k1 Bool -> *) (l2 :: k1) = Let6989586621679543995Scrutinee_6989586621679542843 l1 l2
type Apply ((<@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply ((<@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 < l2
type Apply ((==@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply ((==@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 == l2
type Apply ((/=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a)
Instance details type Apply ((/=@#@$$) l1 :: TyFun a Bool -> *) (l2 :: a) = l1 /= l2
type Apply (Bool_Sym2 l1 l2 :: TyFun Bool a -> *) (l3 :: Bool)
Instance details type Apply (Bool_Sym2 l1 l2 :: TyFun Bool a -> *) (l3 :: Bool) = Bool_ l1 l2 l3
type Apply (Let6989586621679690626Scrutinee_6989586621679681939Sym1 l1 :: TyFun k Bool -> *) (l2 :: k)
Instance details type Apply (Let6989586621679690626Scrutinee_6989586621679681939Sym1 l1 :: TyFun k Bool -> *) (l2 :: k) = Let6989586621679690626Scrutinee_6989586621679681939 l1 l2
type Apply (Let6989586621679690599Scrutinee_6989586621679681941Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3)
Instance details type Apply (Let6989586621679690599Scrutinee_6989586621679681941Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3) = Let6989586621679690599Scrutinee_6989586621679681941 l1 l2 l3
type Apply (Let6989586621679690790Scrutinee_6989586621679681925Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3)
Instance details type Apply (Let6989586621679690790Scrutinee_6989586621679681925Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3) = Let6989586621679690790Scrutinee_6989586621679681925 l1 l2 l3
type Apply (Let6989586621679690818Scrutinee_6989586621679681923Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3)
Instance details type Apply (Let6989586621679690818Scrutinee_6989586621679681923Sym2 l1 l2 :: TyFun k3 Bool -> *) (l3 :: k3) = Let6989586621679690818Scrutinee_6989586621679681923 l1 l2 l3
type Apply (Let6989586621679690756Scrutinee_6989586621679681935Sym3 l1 l2 l3 :: TyFun k3 Bool -> *) (l4 :: k3)
Instance details type Apply (Let6989586621679690756Scrutinee_6989586621679681935Sym3 l1 l2 l3 :: TyFun k3 Bool -> *) (l4 :: k3) = Let6989586621679690756Scrutinee_6989586621679681935 l1 l2 l3 l4
type Apply (Let6989586621679693426Scrutinee_6989586621679681917Sym3 l1 l2 l3 :: TyFun k Bool -> *) (l4 :: k)
Instance details type Apply (Let6989586621679693426Scrutinee_6989586621679681917Sym3 l1 l2 l3 :: TyFun k Bool -> *) (l4 :: k) = Let6989586621679693426Scrutinee_6989586621679681917 l1 l2 l3 l4
type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym4 l1 l2 l3 l4 :: TyFun k4 Bool -> *) (l5 :: k4)
Instance details type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym4 l1 l2 l3 l4 :: TyFun k4 Bool -> *) (l5 :: k4) = Let6989586621680002365Scrutinee_6989586621680001847 l1 l2 l3 l4 l5
type Apply (Lambda_6989586621679692511Sym5 l1 l2 l3 l4 l5 :: TyFun k1 Bool -> *) (l6 :: k1)
Instance details type Apply (Lambda_6989586621679692511Sym5 l1 l2 l3 l4 l5 :: TyFun k1 Bool -> *) (l6 :: k1) = Lambda_6989586621679692511 l1 l2 l3 l4 l5 l6
type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *) (l6 :: k5)
Instance details type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *) (l6 :: k5) = Let6989586621680001956Scrutinee_6989586621680001871 l1 l2 l3 l4 l5 l6
type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *) (l6 :: k5)
Instance details type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *) (l6 :: k5) = Let6989586621680002138Scrutinee_6989586621680001861 l1 l2 l3 l4 l5 l6
type Apply (&&@#@$) (l :: Bool)
Instance details type Apply (&&@#@$) (l :: Bool) = (&&@#@$$) l
type Apply (\|\|@#@$) (l :: Bool)
Instance details type Apply (\|\|@#@$) (l :: Bool) = (\|\|@#@$$) l
type Apply Compare_6989586621679551605Sym0 (l :: Bool)
Instance details type Apply Compare_6989586621679551605Sym0 (l :: Bool) = Compare_6989586621679551605Sym1 l
type Apply ShowParenSym0 (l :: Bool)
Instance details type Apply ShowParenSym0 (l :: Bool) = ShowParenSym1 l
type Apply ShowsPrec_6989586621679888031Sym0 (l :: Nat)
Instance details type Apply ShowsPrec_6989586621679888031Sym0 (l :: Nat) = ShowsPrec_6989586621679888031Sym1 l
type Apply (ShowsPrec_6989586621679888031Sym1 l1 :: TyFun Bool (TyFun Symbol Symbol -> Type) -> *) (l2 :: Bool)
Instance details type Apply (ShowsPrec_6989586621679888031Sym1 l1 :: TyFun Bool (TyFun Symbol Symbol -> Type) -> *) (l2 :: Bool) = ShowsPrec_6989586621679888031Sym2 l1 l2
type Apply (Let6989586621679543985Scrutinee_6989586621679542841Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679543985Scrutinee_6989586621679542841Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> ) (l :: k1) = Let6989586621679543985Scrutinee_6989586621679542841Sym1 l
type Apply (TFHelper_6989586621679544141Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply (TFHelper_6989586621679544141Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823) = TFHelper_6989586621679544141Sym1 l
type Apply (TFHelper_6989586621679544108Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply (TFHelper_6989586621679544108Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823) = TFHelper_6989586621679544108Sym1 l
type Apply (TFHelper_6989586621679544075Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply (TFHelper_6989586621679544075Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823) = TFHelper_6989586621679544075Sym1 l
type Apply (TFHelper_6989586621679544042Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply (TFHelper_6989586621679544042Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823) = TFHelper_6989586621679544042Sym1 l
type Apply ((<=@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply ((<=@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823) = (<=@#@$$) l
type Apply ((>=@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply ((>=@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823) = (>=@#@$$) l
type Apply ((>@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply ((>@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823) = (>@#@$$) l
type Apply (Let6989586621679544194Scrutinee_6989586621679542855Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679544194Scrutinee_6989586621679542855Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> ) (l :: k1) = Let6989586621679544194Scrutinee_6989586621679542855Sym1 l
type Apply (Let6989586621679544161Scrutinee_6989586621679542853Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679544161Scrutinee_6989586621679542853Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> ) (l :: k1) = Let6989586621679544161Scrutinee_6989586621679542853Sym1 l
type Apply (Let6989586621679543995Scrutinee_6989586621679542843Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679543995Scrutinee_6989586621679542843Sym0 :: TyFun k1 (TyFun k1 Bool -> ) -> ) (l :: k1) = Let6989586621679543995Scrutinee_6989586621679542843Sym1 l
type Apply ((<@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply ((<@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) (l :: a6989586621679542823) = (<@#@$$) l
type Apply (NotElemSym0 :: TyFun a6989586621679681320 (TyFun [a6989586621679681320] Bool -> Type) -> *) (l :: a6989586621679681320)
Instance details type Apply (NotElemSym0 :: TyFun a6989586621679681320 (TyFun [a6989586621679681320] Bool -> Type) -> *) (l :: a6989586621679681320) = NotElemSym1 l
type Apply (ElemSym0 :: TyFun a6989586621679681321 (TyFun [a6989586621679681321] Bool -> Type) -> *) (l :: a6989586621679681321)
Instance details type Apply (ElemSym0 :: TyFun a6989586621679681321 (TyFun [a6989586621679681321] Bool -> Type) -> *) (l :: a6989586621679681321) = ElemSym1 l
type Apply ((==@#@$) :: TyFun a6989586621679532030 (TyFun a6989586621679532030 Bool -> Type) -> *) (l :: a6989586621679532030)
Instance details type Apply ((==@#@$) :: TyFun a6989586621679532030 (TyFun a6989586621679532030 Bool -> Type) -> *) (l :: a6989586621679532030) = (==@#@$$) l
type Apply ((/=@#@$) :: TyFun a6989586621679532030 (TyFun a6989586621679532030 Bool -> Type) -> *) (l :: a6989586621679532030)
Instance details type Apply ((/=@#@$) :: TyFun a6989586621679532030 (TyFun a6989586621679532030 Bool -> Type) -> *) (l :: a6989586621679532030) = (/=@#@$$) l
type Apply (Bool_Sym0 :: TyFun a6989586621679529656 (TyFun a6989586621679529656 (TyFun Bool a6989586621679529656 -> Type) -> Type) -> *) (l :: a6989586621679529656)
Instance details type Apply (Bool_Sym0 :: TyFun a6989586621679529656 (TyFun a6989586621679529656 (TyFun Bool a6989586621679529656 -> Type) -> Type) -> *) (l :: a6989586621679529656) = Bool_Sym1 l
type Apply (Let6989586621679690626Scrutinee_6989586621679681939Sym0 :: TyFun k1 (TyFun k Bool -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679690626Scrutinee_6989586621679681939Sym0 :: TyFun k1 (TyFun k Bool -> ) -> ) (l :: k1) = (Let6989586621679690626Scrutinee_6989586621679681939Sym1 l :: TyFun k Bool -> *)
type Apply (Elem_bySym1 l1 :: TyFun a6989586621679681238 (TyFun [a6989586621679681238] Bool -> Type) -> *) (l2 :: a6989586621679681238)
Instance details type Apply (Elem_bySym1 l1 :: TyFun a6989586621679681238 (TyFun [a6989586621679681238] Bool -> Type) -> *) (l2 :: a6989586621679681238) = Elem_bySym2 l1 l2
type Apply (Bool_Sym1 l1 :: TyFun a6989586621679529656 (TyFun Bool a6989586621679529656 -> Type) -> *) (l2 :: a6989586621679529656)
Instance details type Apply (Bool_Sym1 l1 :: TyFun a6989586621679529656 (TyFun Bool a6989586621679529656 -> Type) -> *) (l2 :: a6989586621679529656) = Bool_Sym2 l1 l2
type Apply (Let6989586621679690599Scrutinee_6989586621679681941Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *) (l :: k1)
Instance details type Apply (Let6989586621679690599Scrutinee_6989586621679681941Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> ) (l :: k1) = (Let6989586621679690599Scrutinee_6989586621679681941Sym1 l :: TyFun k2 (TyFun k3 Bool -> ) -> *)
type Apply (Let6989586621679690756Scrutinee_6989586621679681935Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679690756Scrutinee_6989586621679681935Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> ) -> ) (l :: k1) = (Let6989586621679690756Scrutinee_6989586621679681935Sym1 l :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *)
type Apply (Let6989586621679690790Scrutinee_6989586621679681925Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *) (l :: k1)
Instance details type Apply (Let6989586621679690790Scrutinee_6989586621679681925Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> ) (l :: k1) = (Let6989586621679690790Scrutinee_6989586621679681925Sym1 l :: TyFun k2 (TyFun k3 Bool -> ) -> *)
type Apply (Let6989586621679690818Scrutinee_6989586621679681923Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *) (l :: k1)
Instance details type Apply (Let6989586621679690818Scrutinee_6989586621679681923Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> ) (l :: k1) = (Let6989586621679690818Scrutinee_6989586621679681923Sym1 l :: TyFun k2 (TyFun k3 Bool -> ) -> *)
type Apply (Let6989586621679691889Scrutinee_6989586621679681943Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun [k2] Bool -> ) -> ) -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679691889Scrutinee_6989586621679681943Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun [k2] Bool -> ) -> ) -> ) -> ) (l :: k1) = (Let6989586621679691889Scrutinee_6989586621679681943Sym1 l :: TyFun k2 (TyFun k3 (TyFun [k2] Bool -> ) -> ) -> *)
type Apply (Let6989586621679690599Scrutinee_6989586621679681941Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> ) -> ) (l2 :: k1)
Instance details type Apply (Let6989586621679690599Scrutinee_6989586621679681941Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> ) -> ) (l2 :: k1) = (Let6989586621679690599Scrutinee_6989586621679681941Sym2 l1 l2 :: TyFun k3 Bool -> *)
type Apply (Let6989586621679690756Scrutinee_6989586621679681935Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679690756Scrutinee_6989586621679681935Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> ) -> ) -> ) (l2 :: k1) = (Let6989586621679690756Scrutinee_6989586621679681935Sym2 l1 l2 :: TyFun k2 (TyFun k3 Bool -> ) -> *)
type Apply (Let6989586621679690790Scrutinee_6989586621679681925Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> ) -> ) (l2 :: k1)
Instance details type Apply (Let6989586621679690790Scrutinee_6989586621679681925Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> ) -> ) (l2 :: k1) = (Let6989586621679690790Scrutinee_6989586621679681925Sym2 l1 l2 :: TyFun k3 Bool -> *)
type Apply (Let6989586621679690818Scrutinee_6989586621679681923Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> ) -> ) (l2 :: k1)
Instance details type Apply (Let6989586621679690818Scrutinee_6989586621679681923Sym1 l1 :: TyFun k1 (TyFun k3 Bool -> ) -> ) (l2 :: k1) = (Let6989586621679690818Scrutinee_6989586621679681923Sym2 l1 l2 :: TyFun k3 Bool -> *)
type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun [k2] Bool -> ) -> ) -> ) -> ) (l2 :: k1)
Instance details type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun [k2] Bool -> ) -> ) -> ) -> ) (l2 :: k1) = (Let6989586621679690558Scrutinee_6989586621679681945Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun [k2] Bool -> ) -> ) -> *)
type Apply (Let6989586621679691889Scrutinee_6989586621679681943Sym1 l1 :: TyFun k1 (TyFun k3 (TyFun [k1] Bool -> ) -> ) -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679691889Scrutinee_6989586621679681943Sym1 l1 :: TyFun k1 (TyFun k3 (TyFun [k1] Bool -> ) -> ) -> ) (l2 :: k1) = (Let6989586621679691889Scrutinee_6989586621679681943Sym2 l1 l2 :: TyFun k3 (TyFun [k1] Bool -> ) -> *)
type Apply (Let6989586621679693426Scrutinee_6989586621679681917Sym1 l1 :: TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679693426Scrutinee_6989586621679681917Sym1 l1 :: TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) -> ) (l2 :: k1) = (Let6989586621679693426Scrutinee_6989586621679681917Sym2 l1 l2 :: TyFun [a6989586621679681358] (TyFun k Bool -> ) -> *)
type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym0 :: TyFun k1 (TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> ) -> ) -> *) (l :: k1)
Instance details type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym0 :: TyFun k1 (TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> ) -> ) -> ) (l :: k1) = (Let6989586621680002365Scrutinee_6989586621680001847Sym1 l :: TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> ) -> *)
type Apply (Let6989586621679690756Scrutinee_6989586621679681935Sym2 l1 l2 :: TyFun k2 (TyFun k3 Bool -> ) -> ) (l3 :: k2)
Instance details type Apply (Let6989586621679690756Scrutinee_6989586621679681935Sym2 l1 l2 :: TyFun k2 (TyFun k3 Bool -> ) -> ) (l3 :: k2) = (Let6989586621679690756Scrutinee_6989586621679681935Sym3 l1 l2 l3 :: TyFun k3 Bool -> *)
type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun [k2] Bool -> ) -> ) -> *) (l3 :: k2)
Instance details type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun [k2] Bool -> ) -> ) -> ) (l3 :: k2) = (Let6989586621679690558Scrutinee_6989586621679681945Sym3 l1 l2 l3 :: TyFun k3 (TyFun [k2] Bool -> ) -> *)
type Apply (Let6989586621679691889Scrutinee_6989586621679681943Sym2 l1 l2 :: TyFun k3 (TyFun [k1] Bool -> ) -> ) (l3 :: k3)
Instance details type Apply (Let6989586621679691889Scrutinee_6989586621679681943Sym2 l1 l2 :: TyFun k3 (TyFun [k1] Bool -> ) -> ) (l3 :: k3) = Let6989586621679691889Scrutinee_6989586621679681943Sym3 l1 l2 l3
type Apply (Lambda_6989586621679692511Sym1 l1 :: TyFun k2 (TyFun k3 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> ) -> ) -> *) (l2 :: k2)
Instance details type Apply (Lambda_6989586621679692511Sym1 l1 :: TyFun k2 (TyFun k3 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> ) -> ) -> ) (l2 :: k2) = (Lambda_6989586621679692511Sym2 l1 l2 :: TyFun k3 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> ) -> *)
type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> ) -> ) (l :: k1) = (Let6989586621680001956Scrutinee_6989586621680001871Sym1 l :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> *)
type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> ) -> ) (l :: k1) = (Let6989586621680002138Scrutinee_6989586621680001861Sym1 l :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> *)
type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym1 l1 :: TyFun k1 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> ) -> ) (l2 :: k1)
Instance details type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym1 l1 :: TyFun k1 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> ) -> ) (l2 :: k1) = (Let6989586621680002365Scrutinee_6989586621680001847Sym2 l1 l2 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> *)
type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym3 l1 l2 l3 :: TyFun k3 (TyFun [k2] Bool -> ) -> ) (l4 :: k3)
Instance details type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym3 l1 l2 l3 :: TyFun k3 (TyFun [k2] Bool -> ) -> ) (l4 :: k3) = Let6989586621679690558Scrutinee_6989586621679681945Sym4 l1 l2 l3 l4
type Apply (Lambda_6989586621679692511Sym2 l1 l2 :: TyFun k3 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> ) -> ) (l3 :: k3)
Instance details type Apply (Lambda_6989586621679692511Sym2 l1 l2 :: TyFun k3 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> ) -> ) (l3 :: k3) = Lambda_6989586621679692511Sym3 l1 l2 l3
type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> *) (l2 :: k1)
Instance details type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> ) (l2 :: k1) = (Let6989586621680001956Scrutinee_6989586621680001871Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> *)
type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> *) (l2 :: k1)
Instance details type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym1 l1 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) -> ) (l2 :: k1) = (Let6989586621680002138Scrutinee_6989586621680001861Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> *)
type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym2 l1 l2 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> *) (l3 :: k1)
Instance details type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym2 l1 l2 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> ) -> ) -> ) (l3 :: k1) = (Let6989586621680002365Scrutinee_6989586621680001847Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 Bool -> ) -> *)
type Apply (Lambda_6989586621679692511Sym3 l1 l2 l3 :: TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> *) (l4 :: a6989586621679681341)
Instance details type Apply (Lambda_6989586621679692511Sym3 l1 l2 l3 :: TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> *) (l4 :: a6989586621679681341) = Lambda_6989586621679692511Sym4 l1 l2 l3 l4
type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) (l3 :: k2)
Instance details type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) (l3 :: k2) = (Let6989586621680001956Scrutinee_6989586621680001871Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> *)
type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) (l3 :: k2)
Instance details type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym2 l1 l2 :: TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) -> ) (l3 :: k2) = (Let6989586621680002138Scrutinee_6989586621680001861Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> *)
type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 Bool -> ) -> ) (l4 :: k3)
Instance details type Apply (Let6989586621680002365Scrutinee_6989586621680001847Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 Bool -> ) -> ) (l4 :: k3) = (Let6989586621680002365Scrutinee_6989586621680001847Sym4 l1 l2 l3 l4 :: TyFun k4 Bool -> *)
type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> *) (l4 :: k3)
Instance details type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) (l4 :: k3) = (Let6989586621680001956Scrutinee_6989586621680001871Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> ) -> *)
type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> *) (l4 :: k3)
Instance details type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym3 l1 l2 l3 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> ) -> ) -> ) (l4 :: k3) = (Let6989586621680002138Scrutinee_6989586621680001861Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> ) -> *)
type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> ) -> ) (l5 :: k4)
Instance details type Apply (Let6989586621680001956Scrutinee_6989586621680001871Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> ) -> ) (l5 :: k4) = (Let6989586621680001956Scrutinee_6989586621680001871Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *)
type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> ) -> ) (l5 :: k4)
Instance details type Apply (Let6989586621680002138Scrutinee_6989586621680001861Sym4 l1 l2 l3 l4 :: TyFun k4 (TyFun k5 Bool -> ) -> ) (l5 :: k4) = (Let6989586621680002138Scrutinee_6989586621680001861Sym5 l1 l2 l3 l4 l5 :: TyFun k5 Bool -> *)
type Apply AndSym0 (l :: [Bool])
Instance details type Apply AndSym0 (l :: [Bool]) = And l
type Apply OrSym0 (l :: [Bool])
Instance details type Apply OrSym0 (l :: [Bool]) = Or l
type Apply (NullSym0 :: TyFun [a] Bool -> *) (l :: [a])
Instance details type Apply (NullSym0 :: TyFun [a] Bool -> *) (l :: [a]) = Null l
type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a)
Instance details type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a) = IsNothing l
type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a)
Instance details type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a) = IsJust l
type Apply (NotElemSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])
Instance details type Apply (NotElemSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = NotElem l1 l2
type Apply (ElemSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])
Instance details type Apply (ElemSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = Elem l1 l2
type Apply (IsPrefixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])
Instance details type Apply (IsPrefixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = IsPrefixOf l1 l2
type Apply (AnySym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])
Instance details type Apply (AnySym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = Any l1 l2
type Apply (IsInfixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])
Instance details type Apply (IsInfixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = IsInfixOf l1 l2
type Apply (AllSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])
Instance details type Apply (AllSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = All l1 l2
type Apply (IsSuffixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a])
Instance details type Apply (IsSuffixOfSym1 l1 :: TyFun [a] Bool -> *) (l2 :: [a]) = IsSuffixOf l1 l2
type Apply (Elem_bySym2 l1 l2 :: TyFun [a] Bool -> *) (l3 :: [a])
Instance details type Apply (Elem_bySym2 l1 l2 :: TyFun [a] Bool -> *) (l3 :: [a]) = Elem_by l1 l2 l3
type Apply (Let6989586621679691889Scrutinee_6989586621679681943Sym3 l1 l2 l3 :: TyFun [k1] Bool -> *) (l4 :: [k1])
Instance details type Apply (Let6989586621679691889Scrutinee_6989586621679681943Sym3 l1 l2 l3 :: TyFun [k1] Bool -> *) (l4 :: [k1]) = Let6989586621679691889Scrutinee_6989586621679681943 l1 l2 l3 l4
type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym4 l1 l2 l3 l4 :: TyFun [k2] Bool -> *) (l5 :: [k2])
Instance details type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym4 l1 l2 l3 l4 :: TyFun [k2] Bool -> *) (l5 :: [k2]) = Let6989586621679690558Scrutinee_6989586621679681945 l1 l2 l3 l4 l5
type Apply (IsPrefixOfSym0 :: TyFun [a6989586621679681324] (TyFun [a6989586621679681324] Bool -> Type) -> *) (l :: [a6989586621679681324])
Instance details type Apply (IsPrefixOfSym0 :: TyFun [a6989586621679681324] (TyFun [a6989586621679681324] Bool -> Type) -> *) (l :: [a6989586621679681324]) = IsPrefixOfSym1 l
type Apply (IsInfixOfSym0 :: TyFun [a6989586621679681322] (TyFun [a6989586621679681322] Bool -> Type) -> *) (l :: [a6989586621679681322])
Instance details type Apply (IsInfixOfSym0 :: TyFun [a6989586621679681322] (TyFun [a6989586621679681322] Bool -> Type) -> *) (l :: [a6989586621679681322]) = IsInfixOfSym1 l
type Apply (IsSuffixOfSym0 :: TyFun [a6989586621679681323] (TyFun [a6989586621679681323] Bool -> Type) -> *) (l :: [a6989586621679681323])
Instance details type Apply (IsSuffixOfSym0 :: TyFun [a6989586621679681323] (TyFun [a6989586621679681323] Bool -> Type) -> *) (l :: [a6989586621679681323]) = IsSuffixOfSym1 l
type Apply (Let6989586621679693426Scrutinee_6989586621679681917Sym2 l1 l2 :: TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) (l3 :: [a6989586621679681358])
Instance details type Apply (Let6989586621679693426Scrutinee_6989586621679681917Sym2 l1 l2 :: TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) (l3 :: [a6989586621679681358]) = (Let6989586621679693426Scrutinee_6989586621679681917Sym3 l1 l2 l3 :: TyFun k Bool -> *)
type Apply (Lambda_6989586621679692511Sym4 l1 l2 l3 l4 :: TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) (l5 :: [a6989586621679681341])
Instance details type Apply (Lambda_6989586621679692511Sym4 l1 l2 l3 l4 :: TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) (l5 :: [a6989586621679681341]) = Lambda_6989586621679692511Sym5 l1 l2 l3 l4 l5
type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b)
Instance details 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)
Instance details type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b) = IsLeft l
type Apply (Elem_bySym0 :: TyFun (TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) (TyFun a6989586621679681238 (TyFun [a6989586621679681238] Bool -> Type) -> Type) -> *) (l :: TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type)
Instance details type Apply (Elem_bySym0 :: TyFun (TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) (TyFun a6989586621679681238 (TyFun [a6989586621679681238] Bool -> Type) -> Type) -> *) (l :: TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) = Elem_bySym1 l
type Apply (NubBySym0 :: TyFun (TyFun a6989586621679681239 (TyFun a6989586621679681239 Bool -> Type) -> Type) (TyFun [a6989586621679681239] [a6989586621679681239] -> Type) -> *) (l :: TyFun a6989586621679681239 (TyFun a6989586621679681239 Bool -> Type) -> Type)
Instance details type Apply (NubBySym0 :: TyFun (TyFun a6989586621679681239 (TyFun a6989586621679681239 Bool -> Type) -> Type) (TyFun [a6989586621679681239] [a6989586621679681239] -> Type) -> *) (l :: TyFun a6989586621679681239 (TyFun a6989586621679681239 Bool -> Type) -> Type) = NubBySym1 l
type Apply (SelectSym0 :: TyFun (TyFun a6989586621679681247 Bool -> Type) (TyFun a6989586621679681247 (TyFun ([a6989586621679681247], [a6989586621679681247]) ([a6989586621679681247], [a6989586621679681247]) -> Type) -> Type) -> *) (l :: TyFun a6989586621679681247 Bool -> Type)
Instance details type Apply (SelectSym0 :: TyFun (TyFun a6989586621679681247 Bool -> Type) (TyFun a6989586621679681247 (TyFun ([a6989586621679681247], [a6989586621679681247]) ([a6989586621679681247], [a6989586621679681247]) -> Type) -> Type) -> *) (l :: TyFun a6989586621679681247 Bool -> Type) = SelectSym1 l
type Apply (PartitionSym0 :: TyFun (TyFun a6989586621679681248 Bool -> Type) (TyFun [a6989586621679681248] ([a6989586621679681248], [a6989586621679681248]) -> Type) -> *) (l :: TyFun a6989586621679681248 Bool -> Type)
Instance details type Apply (PartitionSym0 :: TyFun (TyFun a6989586621679681248 Bool -> Type) (TyFun [a6989586621679681248] ([a6989586621679681248], [a6989586621679681248]) -> Type) -> *) (l :: TyFun a6989586621679681248 Bool -> Type) = PartitionSym1 l
type Apply (BreakSym0 :: TyFun (TyFun a6989586621679681260 Bool -> Type) (TyFun [a6989586621679681260] ([a6989586621679681260], [a6989586621679681260]) -> Type) -> *) (l :: TyFun a6989586621679681260 Bool -> Type)
Instance details type Apply (BreakSym0 :: TyFun (TyFun a6989586621679681260 Bool -> Type) (TyFun [a6989586621679681260] ([a6989586621679681260], [a6989586621679681260]) -> Type) -> *) (l :: TyFun a6989586621679681260 Bool -> Type) = BreakSym1 l
type Apply (Let6989586621679690886ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *) (l :: TyFun k Bool -> Type)
Instance details type Apply (Let6989586621679690886ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679690886ZsSym1 l
type Apply (Let6989586621679690886YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *) (l :: TyFun k Bool -> Type)
Instance details type Apply (Let6989586621679690886YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679690886YsSym1 l
type Apply (Let6989586621679690886X_6989586621679690887Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> ) -> ) -> *) (l :: TyFun k Bool -> Type)
Instance details type Apply (Let6989586621679690886X_6989586621679690887Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> ) -> ) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679690886X_6989586621679690887Sym1 l
type Apply (SpanSym0 :: TyFun (TyFun a6989586621679681261 Bool -> Type) (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> Type) -> *) (l :: TyFun a6989586621679681261 Bool -> Type)
Instance details type Apply (SpanSym0 :: TyFun (TyFun a6989586621679681261 Bool -> Type) (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> Type) -> *) (l :: TyFun a6989586621679681261 Bool -> Type) = SpanSym1 l
type Apply (Let6989586621679690979ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *) (l :: TyFun k Bool -> Type)
Instance details type Apply (Let6989586621679690979ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679690979ZsSym1 l
type Apply (Let6989586621679690979YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *) (l :: TyFun k Bool -> Type)
Instance details type Apply (Let6989586621679690979YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> ) -> ) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679690979YsSym1 l
type Apply (Let6989586621679690979X_6989586621679690980Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> ) -> ) -> *) (l :: TyFun k Bool -> Type)
Instance details type Apply (Let6989586621679690979X_6989586621679690980Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> ) -> ) -> *) (l :: TyFun k Bool -> Type) = Let6989586621679690979X_6989586621679690980Sym1 l
type Apply (GroupBySym0 :: TyFun (TyFun a6989586621679681251 (TyFun a6989586621679681251 Bool -> Type) -> Type) (TyFun [a6989586621679681251] [[a6989586621679681251]] -> Type) -> *) (l :: TyFun a6989586621679681251 (TyFun a6989586621679681251 Bool -> Type) -> Type)
Instance details type Apply (GroupBySym0 :: TyFun (TyFun a6989586621679681251 (TyFun a6989586621679681251 Bool -> Type) -> Type) (TyFun [a6989586621679681251] [[a6989586621679681251]] -> Type) -> *) (l :: TyFun a6989586621679681251 (TyFun a6989586621679681251 Bool -> Type) -> Type) = GroupBySym1 l
type Apply (DropWhileSym0 :: TyFun (TyFun a6989586621679681263 Bool -> Type) (TyFun [a6989586621679681263] [a6989586621679681263] -> Type) -> *) (l :: TyFun a6989586621679681263 Bool -> Type)
Instance details type Apply (DropWhileSym0 :: TyFun (TyFun a6989586621679681263 Bool -> Type) (TyFun [a6989586621679681263] [a6989586621679681263] -> Type) -> *) (l :: TyFun a6989586621679681263 Bool -> Type) = DropWhileSym1 l
type Apply (TakeWhileSym0 :: TyFun (TyFun a6989586621679681264 Bool -> Type) (TyFun [a6989586621679681264] [a6989586621679681264] -> Type) -> *) (l :: TyFun a6989586621679681264 Bool -> Type)
Instance details type Apply (TakeWhileSym0 :: TyFun (TyFun a6989586621679681264 Bool -> Type) (TyFun [a6989586621679681264] [a6989586621679681264] -> Type) -> *) (l :: TyFun a6989586621679681264 Bool -> Type) = TakeWhileSym1 l
type Apply (FilterSym0 :: TyFun (TyFun a6989586621679681272 Bool -> Type) (TyFun [a6989586621679681272] [a6989586621679681272] -> Type) -> *) (l :: TyFun a6989586621679681272 Bool -> Type)
Instance details type Apply (FilterSym0 :: TyFun (TyFun a6989586621679681272 Bool -> Type) (TyFun [a6989586621679681272] [a6989586621679681272] -> Type) -> *) (l :: TyFun a6989586621679681272 Bool -> Type) = FilterSym1 l
type Apply (FindSym0 :: TyFun (TyFun a6989586621679681271 Bool -> Type) (TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> Type) -> *) (l :: TyFun a6989586621679681271 Bool -> Type)
Instance details type Apply (FindSym0 :: TyFun (TyFun a6989586621679681271 Bool -> Type) (TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> Type) -> *) (l :: TyFun a6989586621679681271 Bool -> Type) = FindSym1 l
type Apply (DeleteBySym0 :: TyFun (TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) (TyFun a6989586621679681278 (TyFun [a6989586621679681278] [a6989586621679681278] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type)
Instance details type Apply (DeleteBySym0 :: TyFun (TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) (TyFun a6989586621679681278 (TyFun [a6989586621679681278] [a6989586621679681278] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) = DeleteBySym1 l
type Apply (DeleteFirstsBySym0 :: TyFun (TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) (TyFun [a6989586621679681277] (TyFun [a6989586621679681277] [a6989586621679681277] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type)
Instance details type Apply (DeleteFirstsBySym0 :: TyFun (TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) (TyFun [a6989586621679681277] (TyFun [a6989586621679681277] [a6989586621679681277] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) = DeleteFirstsBySym1 l
type Apply (UnionBySym0 :: TyFun (TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) (TyFun [a6989586621679681237] (TyFun [a6989586621679681237] [a6989586621679681237] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type)
Instance details type Apply (UnionBySym0 :: TyFun (TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) (TyFun [a6989586621679681237] (TyFun [a6989586621679681237] [a6989586621679681237] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) = UnionBySym1 l
type Apply (FindIndicesSym0 :: TyFun (TyFun a6989586621679681267 Bool -> Type) (TyFun [a6989586621679681267] [Nat] -> Type) -> *) (l :: TyFun a6989586621679681267 Bool -> Type)
Instance details type Apply (FindIndicesSym0 :: TyFun (TyFun a6989586621679681267 Bool -> Type) (TyFun [a6989586621679681267] [Nat] -> Type) -> *) (l :: TyFun a6989586621679681267 Bool -> Type) = FindIndicesSym1 l
type Apply (FindIndexSym0 :: TyFun (TyFun a6989586621679681268 Bool -> Type) (TyFun [a6989586621679681268] (Maybe Nat) -> Type) -> *) (l :: TyFun a6989586621679681268 Bool -> Type)
Instance details type Apply (FindIndexSym0 :: TyFun (TyFun a6989586621679681268 Bool -> Type) (TyFun [a6989586621679681268] (Maybe Nat) -> Type) -> *) (l :: TyFun a6989586621679681268 Bool -> Type) = FindIndexSym1 l
type Apply (AnySym0 :: TyFun (TyFun a6989586621679681341 Bool -> Type) (TyFun [a6989586621679681341] Bool -> Type) -> *) (l :: TyFun a6989586621679681341 Bool -> Type)
Instance details type Apply (AnySym0 :: TyFun (TyFun a6989586621679681341 Bool -> Type) (TyFun [a6989586621679681341] Bool -> Type) -> *) (l :: TyFun a6989586621679681341 Bool -> Type) = AnySym1 l
type Apply (IntersectBySym0 :: TyFun (TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) (TyFun [a6989586621679681265] (TyFun [a6989586621679681265] [a6989586621679681265] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type)
Instance details type Apply (IntersectBySym0 :: TyFun (TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) (TyFun [a6989586621679681265] (TyFun [a6989586621679681265] [a6989586621679681265] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) = IntersectBySym1 l
type Apply (AllSym0 :: TyFun (TyFun a6989586621679681342 Bool -> Type) (TyFun [a6989586621679681342] Bool -> Type) -> *) (l :: TyFun a6989586621679681342 Bool -> Type)
Instance details type Apply (AllSym0 :: TyFun (TyFun a6989586621679681342 Bool -> Type) (TyFun [a6989586621679681342] Bool -> Type) -> *) (l :: TyFun a6989586621679681342 Bool -> Type) = AllSym1 l
type Apply (DropWhileEndSym0 :: TyFun (TyFun a6989586621679681262 Bool -> Type) (TyFun [a6989586621679681262] [a6989586621679681262] -> Type) -> *) (l :: TyFun a6989586621679681262 Bool -> Type)
Instance details type Apply (DropWhileEndSym0 :: TyFun (TyFun a6989586621679681262 Bool -> Type) (TyFun [a6989586621679681262] [a6989586621679681262] -> Type) -> *) (l :: TyFun a6989586621679681262 Bool -> Type) = DropWhileEndSym1 l
type Apply (Let6989586621679690534NubBy'Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> ) -> ) -> *) (l :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)
Instance details type Apply (Let6989586621679690534NubBy'Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> ) -> ) -> ) (l :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) = (Let6989586621679690534NubBy'Sym1 l :: TyFun k (TyFun [k1] ([k1] ~> [k1]) -> ) -> *)
type Apply (Let6989586621679691043ZsSym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> ) -> ) -> *) (l :: k1 ~> (TyFun a6989586621679681261 Bool -> Type))
Instance details type Apply (Let6989586621679691043ZsSym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> ) -> ) -> *) (l :: k1 ~> (TyFun a6989586621679681261 Bool -> Type)) = Let6989586621679691043ZsSym1 l
type Apply (Let6989586621679691043YsSym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> ) -> ) -> *) (l :: k1 ~> (TyFun a6989586621679681261 Bool -> Type))
Instance details type Apply (Let6989586621679691043YsSym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> ) -> ) -> *) (l :: k1 ~> (TyFun a6989586621679681261 Bool -> Type)) = Let6989586621679691043YsSym1 l
type Apply (Let6989586621679691043X_6989586621679691044Sym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> ) -> ) -> *) (l :: k1 ~> (TyFun a6989586621679681261 Bool -> Type))
Instance details type Apply (Let6989586621679691043X_6989586621679691044Sym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> ) -> ) -> *) (l :: k1 ~> (TyFun a6989586621679681261 Bool -> Type)) = Let6989586621679691043X_6989586621679691044Sym1 l
type Apply (Lambda_6989586621679693422Sym0 :: TyFun (a6989586621679681358 ~> Bool) (TyFun k (TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> ) -> ) -> ) -> ) (l :: a6989586621679681358 ~> Bool)
Instance details type Apply (Lambda_6989586621679693422Sym0 :: TyFun (a6989586621679681358 ~> Bool) (TyFun k (TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> ) -> ) -> ) -> ) (l :: a6989586621679681358 ~> Bool) = (Lambda_6989586621679693422Sym1 l :: TyFun k (TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> ) -> ) -> *)
type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym0 :: 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)
Instance details type Apply (Let6989586621679690558Scrutinee_6989586621679681945Sym0 :: 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) = (Let6989586621679690558Scrutinee_6989586621679681945Sym1 l :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun [k1] Bool -> ) -> ) -> ) -> *)
type Apply (Let6989586621679693426Scrutinee_6989586621679681917Sym0 :: TyFun (k1 ~> Bool) (TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) -> ) -> ) (l :: k1 ~> Bool)
Instance details type Apply (Let6989586621679693426Scrutinee_6989586621679681917Sym0 :: TyFun (k1 ~> Bool) (TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) -> ) -> ) (l :: k1 ~> Bool) = (Let6989586621679693426Scrutinee_6989586621679681917Sym1 l :: TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> ) -> ) -> *)
type Apply (Lambda_6989586621679692511Sym0 :: TyFun (k1 ~> (TyFun a6989586621679681341 Bool -> Type)) (TyFun k2 (TyFun k3 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> ) -> ) -> ) -> ) (l :: k1 ~> (TyFun a6989586621679681341 Bool -> Type))
Instance details type Apply (Lambda_6989586621679692511Sym0 :: TyFun (k1 ~> (TyFun a6989586621679681341 Bool -> Type)) (TyFun k2 (TyFun k3 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k1 Bool -> ) -> ) -> ) -> ) -> ) -> ) (l :: k1 ~> (TyFun a6989586621679681341 Bool -> Type)) = (Lambda_6989586621679692511Sym1 l :: TyFun k2 (TyFun k3 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (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: 2.1
Instance details Methods minBound :: Char # maxBound :: Char #
Enum Char	Since: 2.1
Instance details 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
Instance details Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Data Char	Since: 4.0.0.0
Instance details 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
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Show Char	Since: 2.1
Instance details Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Ix Char	Since: 2.1
Instance details 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
Instance details Methods lift :: Char -> Q Exp #
Storable Char	Since: 2.1
Instance details 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
Instance details Methods rnf :: Char -> () #
ErrorList Char
Instance details Methods listMsg :: String -> [Char] #
ShowX Char Source #
Instance details Methods showsPrecX :: Int -> Char -> ShowS Source # showX :: Char -> String Source # showListX :: [Char] -> ShowS Source #
ShowX String Source #
Instance details Methods showsPrecX :: Int -> String -> ShowS Source # showX :: String -> String Source # showListX :: [String] -> ShowS Source #
Arbitrary Char
Instance details Methods arbitrary :: Gen Char shrink :: Char -> [Char]
CoArbitrary Char
Instance details Methods coarbitrary :: Char -> Gen b -> Gen b
Unbox Char
Instance details
Prim Char
Instance details 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
Instance details 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
Instance details 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
Instance details Methods reflect :: proxy n -> String
Cons Text Text Char Char
Instance details Methods _Cons :: Prism Text Text (Char, Text) (Char, Text)
Cons Text Text Char Char
Instance details Methods _Cons :: Prism Text Text (Char, Text) (Char, Text)
Snoc Text Text Char Char
Instance details Methods _Snoc :: Prism Text Text (Text, Char) (Text, Char)
Snoc Text Text Char Char
Instance details Methods _Snoc :: Prism Text Text (Text, Char) (Text, Char)
() :=> (Bounded Char)
Instance details Methods ins :: () :- Bounded Char
() :=> (Enum Char)
Instance details Methods ins :: () :- Enum Char
() :=> (Ord Char)
Instance details Methods ins :: () :- Ord Char
() :=> (Read Char)
Instance details Methods ins :: () :- Read Char
() :=> (Show Char)
Instance details Methods ins :: () :- Show Char
Generic1 (URec Char :: k -> *)
Instance details 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 :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Foldable (URec Char :: * -> *)
Instance details 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 :: * -> *)
Instance details 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)
Instance details Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Ord (URec Char p)
Instance details 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)
Instance details Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Generic (URec Char p)
Instance details 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
Instance details data Vector Char = V_Char (Vector Char)
data URec Char (p :: k)	Used for marking occurrences of `Char#` Since: 4.9.0.0
Instance details data URec Char (p :: k) = UChar { uChar# :: Char# }
data MVector s Char
Instance details data MVector s Char = MV_Char (MVector s Char)
type Rep1 (URec Char :: k -> *)
Instance details 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)
Instance details 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
Instance details Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Floating Double	Since: 2.1
Instance details 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: 4.0.0.0
Instance details 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
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
RealFloat Double	Since: 2.1
Instance details 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
Instance details Methods lift :: Double -> Q Exp #
Storable Double	Since: 2.1
Instance details 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
Instance details Methods rnf :: Double -> () #
ShowX Double Source #
Instance details Methods showsPrecX :: Int -> Double -> ShowS Source # showX :: Double -> String Source # showListX :: [Double] -> ShowS Source #
Default Double
Instance details Methods def :: Double
Arbitrary Double
Instance details Methods arbitrary :: Gen Double shrink :: Double -> [Double]
CoArbitrary Double
Instance details Methods coarbitrary :: Double -> Gen b -> Gen b
Unbox Double
Instance details
Prim Double
Instance details 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 Source #
Instance details Associated Types type BitSize Double :: Nat Source # Methods pack :: Double -> BitVector (BitSize Double) Source # unpack :: BitVector (BitSize Double) -> Double Source #
Bundle Double Source #
Instance details Associated Types type Unbundled domain Double = (res :: *) Source # Methods bundle :: Unbundled domain Double -> Signal domain Double Source # unbundle :: Signal domain Double -> Unbundled domain Double Source #
Vector Vector Double
Instance details 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
Instance details 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)
Instance details Methods ins :: () :- Enum Double
() :=> (Eq Double)
Instance details Methods ins :: () :- Eq Double
() :=> (Floating Double)
Instance details Methods ins :: () :- Floating Double
() :=> (Fractional Double)
Instance details Methods ins :: () :- Fractional Double
() :=> (Num Double)
Instance details Methods ins :: () :- Num Double
() :=> (Ord Double)
Instance details Methods ins :: () :- Ord Double
() :=> (Real Double)
Instance details Methods ins :: () :- Real Double
() :=> (RealFloat Double)
Instance details Methods ins :: () :- RealFloat Double
() :=> (RealFrac Double)
Instance details Methods ins :: () :- RealFrac Double
Generic1 (URec Double :: k -> *)
Instance details 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 :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Foldable (URec Double :: * -> *)
Instance details 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 :: * -> *)
Instance details 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)
Instance details Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Ord (URec Double p)
Instance details 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)
Instance details Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Generic (URec Double p)
Instance details 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
Instance details data Vector Double = V_Double (Vector Double)
type BitSize Double Source #
Instance details type BitSize Double = 64
data URec Double (p :: k)	Used for marking occurrences of `Double#` Since: 4.9.0.0
Instance details data URec Double (p :: k) = UDouble { uDouble# :: Double# }
data MVector s Double
Instance details data MVector s Double = MV_Double (MVector s Double)
type Unbundled domain Double Source #
Instance details type Unbundled domain Double = Signal domain Double
type Rep1 (URec Double :: k -> *)
Instance details 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)
Instance details 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
Instance details Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Floating Float	Since: 2.1
Instance details 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: 4.0.0.0
Instance details 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
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
RealFloat Float	Since: 2.1
Instance details 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
Instance details Methods lift :: Float -> Q Exp #
Storable Float	Since: 2.1
Instance details 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
Instance details Methods rnf :: Float -> () #
ShowX Float Source #
Instance details Methods showsPrecX :: Int -> Float -> ShowS Source # showX :: Float -> String Source # showListX :: [Float] -> ShowS Source #
Default Float
Instance details Methods def :: Float
Arbitrary Float
Instance details Methods arbitrary :: Gen Float shrink :: Float -> [Float]
CoArbitrary Float
Instance details Methods coarbitrary :: Float -> Gen b -> Gen b
Unbox Float
Instance details
Prim Float
Instance details 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 Source #
Instance details Associated Types type BitSize Float :: Nat Source # Methods pack :: Float -> BitVector (BitSize Float) Source # unpack :: BitVector (BitSize Float) -> Float Source #
Bundle Float Source #
Instance details Associated Types type Unbundled domain Float = (res :: *) Source # Methods bundle :: Unbundled domain Float -> Signal domain Float Source # unbundle :: Signal domain Float -> Unbundled domain Float Source #
Vector Vector Float
Instance details 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
Instance details 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)
Instance details Methods ins :: () :- Enum Float
() :=> (Eq Float)
Instance details Methods ins :: () :- Eq Float
() :=> (Floating Float)
Instance details Methods ins :: () :- Floating Float
() :=> (Fractional Float)
Instance details Methods ins :: () :- Fractional Float
() :=> (Num Float)
Instance details Methods ins :: () :- Num Float
() :=> (Ord Float)
Instance details Methods ins :: () :- Ord Float
() :=> (Real Float)
Instance details Methods ins :: () :- Real Float
() :=> (RealFloat Float)
Instance details Methods ins :: () :- RealFloat Float
() :=> (RealFrac Float)
Instance details Methods ins :: () :- RealFrac Float
Generic1 (URec Float :: k -> *)
Instance details 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 :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Foldable (URec Float :: * -> *)
Instance details 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 :: * -> *)
Instance details 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)
Instance details Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Ord (URec Float p)
Instance details 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)
Instance details Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Generic (URec Float p)
Instance details 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
Instance details data Vector Float = V_Float (Vector Float)
type BitSize Float Source #
Instance details type BitSize Float = 32
data URec Float (p :: k)	Used for marking occurrences of `Float#` Since: 4.9.0.0
Instance details data URec Float (p :: k) = UFloat { uFloat# :: Float# }
data MVector s Float
Instance details data MVector s Float = MV_Float (MVector s Float)
type Unbundled domain Float Source #
Instance details type Unbundled domain Float = Signal domain Float
type Rep1 (URec Float :: k -> *)
Instance details 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)
Instance details 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: 2.1
Instance details Methods minBound :: Int # maxBound :: Int #
Enum Int	Since: 2.1
Instance details 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
Instance details Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Integral Int	Since: 2.0.1
Instance details 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: 4.0.0.0
Instance details 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: 2.1
Instance details Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Ord Int
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Real Int	Since: 2.0.1
Instance details Methods toRational :: Int -> Rational #
Show Int	Since: 2.1
Instance details Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Ix Int	Since: 2.1
Instance details 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
Instance details Methods lift :: Int -> Q Exp #
Storable Int	Since: 2.1
Instance details 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: 2.1
Instance details 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: 4.6.0.0
Instance details Methods finiteBitSize :: Int -> Int # countLeadingZeros :: Int -> Int # countTrailingZeros :: Int -> Int #
NFData Int
Instance details Methods rnf :: Int -> () #
ShowX Int Source #
Instance details Methods showsPrecX :: Int -> Int -> ShowS Source # showX :: Int -> String Source # showListX :: [Int] -> ShowS Source #
Default Int
Instance details Methods def :: Int
Arbitrary Int
Instance details Methods arbitrary :: Gen Int shrink :: Int -> [Int]
CoArbitrary Int
Instance details Methods coarbitrary :: Int -> Gen b -> Gen b
Unbox Int
Instance details
Prim Int
Instance details 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 Source #
Instance details Associated Types type BitSize Int :: Nat Source # Methods pack :: Int -> BitVector (BitSize Int) Source # unpack :: BitVector (BitSize Int) -> Int Source #
Bundle Int Source #
Instance details Associated Types type Unbundled domain Int = (res :: *) Source # Methods bundle :: Unbundled domain Int -> Signal domain Int Source # unbundle :: Signal domain Int -> Unbundled domain Int Source #
FoldableWithIndex Int []
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 []
Instance details Methods imap :: (Int -> a -> b) -> [a] -> [b] imapped :: (Indexable Int p, Settable f) => p a (f b) -> [a] -> f [b]
FunctorWithIndex Int ZipList
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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 []
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details Methods traverseMax :: (Indexable Int p, Applicative f) => p v (f v) -> IntMap v -> f (IntMap v)
TraverseMin Int IntMap
Instance details Methods traverseMin :: (Indexable Int p, Applicative f) => p v (f v) -> IntMap v -> f (IntMap v)
Vector Vector Int
Instance details 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
Instance details 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)
Instance details Methods ins :: () :- Bounded Int
() :=> (Enum Int)
Instance details Methods ins :: () :- Enum Int
() :=> (Eq Int)
Instance details Methods ins :: () :- Eq Int
() :=> (Integral Int)
Instance details Methods ins :: () :- Integral Int
() :=> (Num Int)
Instance details Methods ins :: () :- Num Int
() :=> (Ord Int)
Instance details Methods ins :: () :- Ord Int
() :=> (Read Int)
Instance details Methods ins :: () :- Read Int
() :=> (Real Int)
Instance details Methods ins :: () :- Real Int
() :=> (Show Int)
Instance details Methods ins :: () :- Show Int
() :=> (Bits Int)
Instance details Methods ins :: () :- Bits Int
Generic1 (URec Int :: k -> *)
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details Methods bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t
Reifies Z Int
Instance details Methods reflect :: proxy Z -> Int
Reifies n Int => Reifies (D n :: *) Int
Instance details Methods reflect :: proxy (D n) -> Int
Reifies n Int => Reifies (PD n :: *) Int
Instance details Methods reflect :: proxy (PD n) -> Int
Reifies n Int => Reifies (SD n :: *) Int
Instance details Methods reflect :: proxy (SD n) -> Int
Functor (URec Int :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Foldable (URec Int :: * -> *)
Instance details 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 :: * -> *)
Instance details 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)
Instance details Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Ord (URec Int p)
Instance details 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)
Instance details Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Generic (URec Int p)
Instance details 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
Instance details data Vector Int = V_Int (Vector Int)
type BitSize Int Source #
Instance details type BitSize Int = 64
data URec Int (p :: k)	Used for marking occurrences of `Int#` Since: 4.9.0.0
Instance details data URec Int (p :: k) = UInt { uInt# :: Int# }
data MVector s Int
Instance details data MVector s Int = MV_Int (MVector s Int)
type Unbundled domain Int Source #
Instance details type Unbundled domain Int = Signal domain Int
type Rep1 (URec Int :: k -> *)
Instance details 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)
Instance details 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: 2.1
Instance details 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
Instance details Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Integral Integer	Since: 2.0.1
Instance details 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: 4.0.0.0
Instance details 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: 2.1
Instance details Methods (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # (*) :: Integer -> Integer -> Integer # negate :: Integer -> Integer # abs :: Integer -> Integer # signum :: Integer -> Integer # fromInteger :: Integer -> Integer #
Ord Integer
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] # readPrec :: ReadPrec Integer # readListPrec :: ReadPrec [Integer] #
Real Integer	Since: 2.0.1
Instance details Methods toRational :: Integer -> Rational #
Show Integer	Since: 2.1
Instance details Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Ix Integer	Since: 2.1
Instance details 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
Instance details Methods lift :: Integer -> Q Exp #
Bits Integer	Since: 2.1
Instance details 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
Instance details Methods rnf :: Integer -> () #
ShowX Integer Source #
Instance details Methods showsPrecX :: Int -> Integer -> ShowS Source # showX :: Integer -> String Source # showListX :: [Integer] -> ShowS Source #
Default Integer
Instance details Methods def :: Integer
Arbitrary Integer
Instance details Methods arbitrary :: Gen Integer shrink :: Integer -> [Integer]
CoArbitrary Integer
Instance details Methods coarbitrary :: Integer -> Gen b -> Gen b
Bundle Integer Source #
Instance details Associated Types type Unbundled domain Integer = (res :: *) Source # Methods bundle :: Unbundled domain Integer -> Signal domain Integer Source # unbundle :: Signal domain Integer -> Unbundled domain Integer Source #
KnownNat n => Reifies (n :: Nat) Integer
Instance details Methods reflect :: proxy n -> Integer
() :=> (Enum Integer)
Instance details Methods ins :: () :- Enum Integer
() :=> (Eq Integer)
Instance details Methods ins :: () :- Eq Integer
() :=> (Integral Integer)
Instance details Methods ins :: () :- Integral Integer
() :=> (Num Integer)
Instance details Methods ins :: () :- Num Integer
() :=> (Ord Integer)
Instance details Methods ins :: () :- Ord Integer
() :=> (Real Integer)
Instance details Methods ins :: () :- Real Integer
() :=> (Bits Integer)
Instance details Methods ins :: () :- Bits Integer
type Unbundled domain Integer Source #
Instance details 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: 2.1
Instance details 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: 2.1
Instance details Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Applicative Maybe	Since: 2.1
Instance details 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: 2.1
Instance details 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: 2.1
Instance details 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: 4.9.0.0
Instance details Methods liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool #
Ord1 Maybe	Since: 4.9.0.0
Instance details Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering #
Read1 Maybe	Since: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS #
Alternative Maybe	Since: 2.1
Instance details Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
MonadPlus Maybe	Since: 2.1
Instance details Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
NFData1 Maybe	Since: 1.4.3.0
Instance details Methods liftRnf :: (a -> ()) -> Maybe a -> () #
Arbitrary1 Maybe
Instance details Methods liftArbitrary :: Gen a -> Gen (Maybe a) liftShrink :: (a -> [a]) -> Maybe a -> [Maybe a]
FoldableWithIndex () Maybe
Instance details 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
Instance details Methods imap :: (() -> a -> b) -> Maybe a -> Maybe b imapped :: (Indexable () p, Settable f) => p a (f b) -> Maybe a -> f (Maybe b)
TraversableWithIndex () Maybe
Instance details 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)
Instance details Methods ins :: () :- Functor Maybe
() :=> (Applicative Maybe)
Instance details Methods ins :: () :- Applicative Maybe
() :=> (Alternative Maybe)
Instance details Methods ins :: () :- Alternative Maybe
() :=> (MonadPlus Maybe)
Instance details Methods ins :: () :- MonadPlus Maybe
Eq a => Eq (Maybe a)
Instance details Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Data a => Data (Maybe a)	Since: 4.0.0.0
Instance details 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)
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
Show a => Show (Maybe a)
Instance details Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Generic (Maybe a)
Instance details 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: 4.9.0.0
Instance details 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 `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: 2.1*
Instance details Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Lift a => Lift (Maybe a)
Instance details Methods lift :: Maybe a -> Q Exp #
SingKind a => SingKind (Maybe a)	Since: 4.9.0.0
Instance details Associated Types type DemoteRep (Maybe a) :: * Methods fromSing :: Sing a0 -> DemoteRep (Maybe a)
NFData a => NFData (Maybe a)
Instance details Methods rnf :: Maybe a -> () #
ShowX a => ShowX (Maybe a) Source #
Instance details Methods showsPrecX :: Int -> Maybe a -> ShowS Source # showX :: Maybe a -> String Source # showListX :: [Maybe a] -> ShowS Source #
At (Maybe a)
Instance details Methods at :: Index (Maybe a) -> Lens' (Maybe a) (Maybe (IxValue (Maybe a)))
Ixed (Maybe a)
Instance details Methods ix :: Index (Maybe a) -> Traversal' (Maybe a) (IxValue (Maybe a))
AsEmpty (Maybe a)
Instance details Methods _Empty :: Prism' (Maybe a) ()
Default (Maybe a)
Instance details Methods def :: Maybe a
Arbitrary a => Arbitrary (Maybe a)
Instance details Methods arbitrary :: Gen (Maybe a) shrink :: Maybe a -> [Maybe a]
CoArbitrary a => CoArbitrary (Maybe a)
Instance details Methods coarbitrary :: Maybe a -> Gen b -> Gen b
(BitPack a, KnownNat (BitSize a)) => BitPack (Maybe a) Source #
Instance details Associated Types type BitSize (Maybe a) :: Nat Source # Methods pack :: Maybe a -> BitVector (BitSize (Maybe a)) Source # unpack :: BitVector (BitSize (Maybe a)) -> Maybe a Source #
PEq (Maybe a)
Instance details Associated Types type x == y :: Bool type x /= y :: Bool
SEq a => SEq (Maybe a)
Instance details Methods (%==) :: Sing a0 -> Sing b -> Sing (a0 == b) (%/=) :: Sing a0 -> Sing b -> Sing (a0 /= b)
POrd (Maybe a)
Instance details 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)
Instance details 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)
Instance details Associated Types type ShowsPrec arg arg1 arg2 :: Symbol type Show_ arg :: Symbol type ShowList arg arg1 :: Symbol
SShow a => SShow (Maybe a)
Instance details 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)
Instance details Methods showsSingPrec :: Int -> Sing a0 -> ShowS
Bundle (Maybe a) Source #
Instance details Associated Types type Unbundled domain (Maybe a) = (res :: *) Source # Methods bundle :: Unbundled domain (Maybe a) -> Signal domain (Maybe a) Source # unbundle :: Signal domain (Maybe a) -> Unbundled domain (Maybe a) Source #
Generic1 Maybe
Instance details Associated Types type Rep1 Maybe :: k -> * # Methods from1 :: Maybe a -> Rep1 Maybe a # to1 :: Rep1 Maybe a -> Maybe a #
SingI (Nothing :: Maybe a)	Since: 4.9.0.0
Instance details Methods sing :: Sing Nothing
(Eq a) :=> (Eq (Maybe a))
Instance details Methods ins :: Eq a :- Eq (Maybe a)
(Ord a) :=> (Ord (Maybe a))
Instance details Methods ins :: Ord a :- Ord (Maybe a)
(Read a) :=> (Read (Maybe a))
Instance details Methods ins :: Read a :- Read (Maybe a)
(Show a) :=> (Show (Maybe a))
Instance details Methods ins :: Show a :- Show (Maybe a)
(Semigroup a) :=> (Semigroup (Maybe a))
Instance details Methods ins :: Semigroup a :- Semigroup (Maybe a)
(Monoid a) :=> (Monoid (Maybe a))
Instance details Methods ins :: Monoid a :- Monoid (Maybe a)
Each (Maybe a) (Maybe b) a b
Instance details Methods each :: Traversal (Maybe a) (Maybe b) a b
SingI a2 => SingI (Just a2 :: Maybe a1)	Since: 4.9.0.0
Instance details Methods sing :: Sing (Just a2)
SuppressUnusedWarnings (FindSym1 :: (TyFun a6989586621679681271 Bool -> Type) -> TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindIndexSym1 :: (TyFun a6989586621679681268 Bool -> Type) -> TyFun [a6989586621679681268] (Maybe Nat) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551085Sym1 :: Maybe a3530822107858468865 -> TyFun (Maybe a3530822107858468865) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ShowsPrec_6989586621679887881Sym2 :: Nat -> Maybe a3530822107858468865 -> TyFun Symbol Symbol -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ShowsPrec_6989586621679887881Sym1 :: Nat -> TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FromMaybeSym1 :: a6989586621679647546 -> TyFun (Maybe a6989586621679647546) a6989586621679647546 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ElemIndexSym1 :: a6989586621679681270 -> TyFun [a6989586621679681270] (Maybe Nat) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindSym0 :: TyFun (TyFun a6989586621679681271 Bool -> Type) (TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FindIndexSym0 :: TyFun (TyFun a6989586621679681268 Bool -> Type) (TyFun [a6989586621679681268] (Maybe Nat) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (CatMaybesSym0 :: TyFun [Maybe a6989586621679647543] [a6989586621679647543] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ListToMaybeSym0 :: TyFun [a6989586621679647544] (Maybe a6989586621679647544) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551085Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (MaybeToListSym0 :: TyFun (Maybe a6989586621679647545) [a6989586621679647545] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsNothingSym0 :: TyFun (Maybe a6989586621679647548) Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsJustSym0 :: TyFun (Maybe a6989586621679647549) Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FromJustSym0 :: TyFun (Maybe a6989586621679647547) a6989586621679647547 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ShowsPrec_6989586621679887881Sym0 :: TyFun Nat (TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (FromMaybeSym0 :: TyFun a6989586621679647546 (TyFun (Maybe a6989586621679647546) a6989586621679647546 -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ElemIndexSym0 :: TyFun a6989586621679681270 (TyFun [a6989586621679681270] (Maybe Nat) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (JustSym0 :: TyFun a3530822107858468865 (Maybe a3530822107858468865) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (MapMaybeSym1 :: (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) -> TyFun [a6989586621679647541] [b6989586621679647542] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679647720RsSym2 :: (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) -> a6989586621679647541 -> TyFun [a6989586621679647541] [b6989586621679647542] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679647720RsSym1 :: (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) -> TyFun a6989586621679647541 (TyFun [a6989586621679647541] [b6989586621679647542] -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (UnfoldrSym1 :: (TyFun b6989586621679681327 (Maybe (a6989586621679681328, b6989586621679681327)) -> Type) -> TyFun b6989586621679681327 [a6989586621679681328] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Maybe_Sym2 :: b6989586621679646418 -> (TyFun a6989586621679646419 b6989586621679646418 -> Type) -> TyFun (Maybe a6989586621679646419) b6989586621679646418 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Maybe_Sym1 :: b6989586621679646418 -> TyFun (TyFun a6989586621679646419 b6989586621679646418 -> Type) (TyFun (Maybe a6989586621679646419) b6989586621679646418 -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (LookupSym1 :: a6989586621679681249 -> TyFun [(a6989586621679681249, b6989586621679681250)] (Maybe b6989586621679681250) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (MapMaybeSym0 :: TyFun (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) (TyFun [a6989586621679647541] [b6989586621679647542] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679647720RsSym0 :: TyFun (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) (TyFun a6989586621679647541 (TyFun [a6989586621679647541] [b6989586621679647542] -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (UnfoldrSym0 :: TyFun (TyFun b6989586621679681327 (Maybe (a6989586621679681328, b6989586621679681327)) -> Type) (TyFun b6989586621679681327 [a6989586621679681328] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Maybe_Sym0 :: TyFun b6989586621679646418 (TyFun (TyFun a6989586621679646419 b6989586621679646418 -> Type) (TyFun (Maybe a6989586621679646419) b6989586621679646418 -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (LookupSym0 :: TyFun a6989586621679681249 (TyFun [(a6989586621679681249, b6989586621679681250)] (Maybe b6989586621679681250) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
type Unbundled domain (Maybe a) Source #
Instance details type Unbundled domain (Maybe a) = Signal domain (Maybe a)
type Apply (JustSym0 :: TyFun a (Maybe a) -> *) (l :: a)
Instance details type Apply (JustSym0 :: TyFun a (Maybe a) -> *) (l :: a) = Just l
type Apply (ShowsPrec_6989586621679887881Sym0 :: TyFun Nat (TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> Type) -> *) (l :: Nat)
Instance details type Apply (ShowsPrec_6989586621679887881Sym0 :: TyFun Nat (TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> Type) -> ) (l :: Nat) = (ShowsPrec_6989586621679887881Sym1 l :: TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> )
type Apply (FromMaybeSym0 :: TyFun a6989586621679647546 (TyFun (Maybe a6989586621679647546) a6989586621679647546 -> Type) -> *) (l :: a6989586621679647546)
Instance details type Apply (FromMaybeSym0 :: TyFun a6989586621679647546 (TyFun (Maybe a6989586621679647546) a6989586621679647546 -> Type) -> *) (l :: a6989586621679647546) = FromMaybeSym1 l
type Apply (ElemIndexSym0 :: TyFun a6989586621679681270 (TyFun [a6989586621679681270] (Maybe Nat) -> Type) -> *) (l :: a6989586621679681270)
Instance details type Apply (ElemIndexSym0 :: TyFun a6989586621679681270 (TyFun [a6989586621679681270] (Maybe Nat) -> Type) -> *) (l :: a6989586621679681270) = ElemIndexSym1 l
type Apply (Maybe_Sym0 :: TyFun b6989586621679646418 (TyFun (TyFun a6989586621679646419 b6989586621679646418 -> Type) (TyFun (Maybe a6989586621679646419) b6989586621679646418 -> Type) -> Type) -> *) (l :: b6989586621679646418)
Instance details type Apply (Maybe_Sym0 :: TyFun b6989586621679646418 (TyFun (TyFun a6989586621679646419 b6989586621679646418 -> Type) (TyFun (Maybe a6989586621679646419) b6989586621679646418 -> Type) -> Type) -> ) (l :: b6989586621679646418) = (Maybe_Sym1 l :: TyFun (TyFun a6989586621679646419 b6989586621679646418 -> Type) (TyFun (Maybe a6989586621679646419) b6989586621679646418 -> Type) -> )
type Apply (LookupSym0 :: TyFun a6989586621679681249 (TyFun [(a6989586621679681249, b6989586621679681250)] (Maybe b6989586621679681250) -> Type) -> *) (l :: a6989586621679681249)
Instance details type Apply (LookupSym0 :: TyFun a6989586621679681249 (TyFun [(a6989586621679681249, b6989586621679681250)] (Maybe b6989586621679681250) -> Type) -> ) (l :: a6989586621679681249) = (LookupSym1 l :: TyFun [(a6989586621679681249, b6989586621679681250)] (Maybe b6989586621679681250) -> )
type Rep (Maybe a)
Instance details 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)
Instance details data Sing (b :: Maybe a) where SNothing :: Sing (Nothing :: Maybe a) SJust :: Sing (Just a1)
type DemoteRep (Maybe a)
Instance details type DemoteRep (Maybe a) = Maybe (DemoteRep a)
type Index (Maybe a)
Instance details type Index (Maybe a) = ()
type IxValue (Maybe a)
Instance details type IxValue (Maybe a) = a
type BitSize (Maybe a) Source #
Instance details type BitSize (Maybe a) = 1 + BitSize a
data Sing (z :: Maybe a)
Instance details data Sing (z :: Maybe a) where SNothing :: Sing (Nothing :: Maybe a) SJust :: Sing (Just n)
type Demote (Maybe a)
Instance details type Demote (Maybe a) = Maybe (Demote a)
type Rep1 Maybe
Instance details 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)
Instance details type Show_ (arg :: Maybe a) = Apply (Show__6989586621679871872Sym0 :: TyFun (Maybe a) Symbol -> *) arg
type (x :: Maybe a) /= (y :: Maybe a)
Instance details type (x :: Maybe a) /= (y :: Maybe a) = Not (x == y)
type (a2 :: Maybe a1) == (b :: Maybe a1)
Instance details type (a2 :: Maybe a1) == (b :: Maybe a1) = Equals_6989586621679532642 a2 b
type (arg1 :: Maybe a) < (arg2 :: Maybe a)
Instance details type (arg1 :: Maybe a) < (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679544042Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) Bool -> Type) -> *) arg1) arg2
type (arg1 :: Maybe a) <= (arg2 :: Maybe a)
Instance details type (arg1 :: Maybe a) <= (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679544075Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) Bool -> Type) -> *) arg1) arg2
type (arg1 :: Maybe a) > (arg2 :: Maybe a)
Instance details type (arg1 :: Maybe a) > (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679544108Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) Bool -> Type) -> *) arg1) arg2
type (arg1 :: Maybe a) >= (arg2 :: Maybe a)
Instance details type (arg1 :: Maybe a) >= (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679544141Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) Bool -> Type) -> *) arg1) arg2
type Compare (a2 :: Maybe a1) (a3 :: Maybe a1)
Instance details type Compare (a2 :: Maybe a1) (a3 :: Maybe a1) = Apply (Apply (Compare_6989586621679551085Sym0 :: TyFun (Maybe a1) (TyFun (Maybe a1) Ordering -> Type) -> *) a2) a3
type Max (arg1 :: Maybe a) (arg2 :: Maybe a)
Instance details type Max (arg1 :: Maybe a) (arg2 :: Maybe a) = Apply (Apply (Max_6989586621679544174Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) (Maybe a) -> Type) -> *) arg1) arg2
type Min (arg1 :: Maybe a) (arg2 :: Maybe a)
Instance details type Min (arg1 :: Maybe a) (arg2 :: Maybe a) = Apply (Apply (Min_6989586621679544207Sym0 :: TyFun (Maybe a) (TyFun (Maybe a) (Maybe a) -> Type) -> *) arg1) arg2
type ShowList (arg1 :: [Maybe a]) arg2
Instance details type ShowList (arg1 :: [Maybe a]) arg2 = Apply (Apply (ShowList_6989586621679871890Sym0 :: TyFun [Maybe a] (TyFun Symbol Symbol -> Type) -> *) arg1) arg2
type ShowsPrec a2 (a3 :: Maybe a1) a4
Instance details type ShowsPrec a2 (a3 :: Maybe a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621679887881Sym0 :: TyFun Nat (TyFun (Maybe a1) (TyFun Symbol Symbol -> Type) -> Type) -> *) a2) a3) a4
type Apply (FromJustSym0 :: TyFun (Maybe a) a -> *) (l :: Maybe a)
Instance details type Apply (FromJustSym0 :: TyFun (Maybe a) a -> *) (l :: Maybe a) = FromJust l
type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a)
Instance details type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a) = IsNothing l
type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a)
Instance details type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> *) (l :: Maybe a) = IsJust l
type Apply (Compare_6989586621679551085Sym1 l1 :: TyFun (Maybe a) Ordering -> *) (l2 :: Maybe a)
Instance details type Apply (Compare_6989586621679551085Sym1 l1 :: TyFun (Maybe a) Ordering -> *) (l2 :: Maybe a) = Compare_6989586621679551085 l1 l2
type Apply (FromMaybeSym1 l1 :: TyFun (Maybe a) a -> *) (l2 :: Maybe a)
Instance details 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)
Instance details 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])
Instance details type Apply (CatMaybesSym0 :: TyFun [Maybe a] [a] -> *) (l :: [Maybe a]) = CatMaybes l
type Apply (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> *) (l :: [a])
Instance details type Apply (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> *) (l :: [a]) = ListToMaybe l
type Apply (MaybeToListSym0 :: TyFun (Maybe a) [a] -> *) (l :: Maybe a)
Instance details type Apply (MaybeToListSym0 :: TyFun (Maybe a) [a] -> *) (l :: Maybe a) = MaybeToList l
type Apply (FindSym1 l1 :: TyFun [a] (Maybe a) -> *) (l2 :: [a])
Instance details type Apply (FindSym1 l1 :: TyFun [a] (Maybe a) -> *) (l2 :: [a]) = Find l1 l2
type Apply (FindIndexSym1 l1 :: TyFun [a] (Maybe Nat) -> *) (l2 :: [a])
Instance details type Apply (FindIndexSym1 l1 :: TyFun [a] (Maybe Nat) -> *) (l2 :: [a]) = FindIndex l1 l2
type Apply (ElemIndexSym1 l1 :: TyFun [a] (Maybe Nat) -> *) (l2 :: [a])
Instance details 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)])
Instance details type Apply (LookupSym1 l1 :: TyFun [(a, b)] (Maybe b) -> *) (l2 :: [(a, b)]) = Lookup l1 l2
type Apply (Compare_6989586621679551085Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *) (l :: Maybe a3530822107858468865)
Instance details type Apply (Compare_6989586621679551085Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *) (l :: Maybe a3530822107858468865) = Compare_6989586621679551085Sym1 l
type Apply (ShowsPrec_6989586621679887881Sym1 l1 :: TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> *) (l2 :: Maybe a3530822107858468865)
Instance details type Apply (ShowsPrec_6989586621679887881Sym1 l1 :: TyFun (Maybe a3530822107858468865) (TyFun Symbol Symbol -> Type) -> *) (l2 :: Maybe a3530822107858468865) = ShowsPrec_6989586621679887881Sym2 l1 l2
type Apply (FindSym0 :: TyFun (TyFun a6989586621679681271 Bool -> Type) (TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> Type) -> *) (l :: TyFun a6989586621679681271 Bool -> Type)
Instance details type Apply (FindSym0 :: TyFun (TyFun a6989586621679681271 Bool -> Type) (TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> Type) -> *) (l :: TyFun a6989586621679681271 Bool -> Type) = FindSym1 l
type Apply (FindIndexSym0 :: TyFun (TyFun a6989586621679681268 Bool -> Type) (TyFun [a6989586621679681268] (Maybe Nat) -> Type) -> *) (l :: TyFun a6989586621679681268 Bool -> Type)
Instance details type Apply (FindIndexSym0 :: TyFun (TyFun a6989586621679681268 Bool -> Type) (TyFun [a6989586621679681268] (Maybe Nat) -> Type) -> *) (l :: TyFun a6989586621679681268 Bool -> Type) = FindIndexSym1 l
type Apply (MapMaybeSym0 :: TyFun (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) (TyFun [a6989586621679647541] [b6989586621679647542] -> Type) -> *) (l :: TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type)
Instance details type Apply (MapMaybeSym0 :: TyFun (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) (TyFun [a6989586621679647541] [b6989586621679647542] -> Type) -> *) (l :: TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) = MapMaybeSym1 l
type Apply (Let6989586621679647720RsSym0 :: TyFun (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) (TyFun a6989586621679647541 (TyFun [a6989586621679647541] [b6989586621679647542] -> ) -> ) -> *) (l :: TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type)
Instance details type Apply (Let6989586621679647720RsSym0 :: TyFun (TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) (TyFun a6989586621679647541 (TyFun [a6989586621679647541] [b6989586621679647542] -> ) -> ) -> *) (l :: TyFun a6989586621679647541 (Maybe b6989586621679647542) -> Type) = Let6989586621679647720RsSym1 l
type Apply (UnfoldrSym0 :: TyFun (TyFun b6989586621679681327 (Maybe (a6989586621679681328, b6989586621679681327)) -> Type) (TyFun b6989586621679681327 [a6989586621679681328] -> Type) -> *) (l :: TyFun b6989586621679681327 (Maybe (a6989586621679681328, b6989586621679681327)) -> Type)
Instance details type Apply (UnfoldrSym0 :: TyFun (TyFun b6989586621679681327 (Maybe (a6989586621679681328, b6989586621679681327)) -> Type) (TyFun b6989586621679681327 [a6989586621679681328] -> Type) -> *) (l :: TyFun b6989586621679681327 (Maybe (a6989586621679681328, b6989586621679681327)) -> Type) = UnfoldrSym1 l
type Apply (Maybe_Sym1 l1 :: TyFun (TyFun a6989586621679646419 b6989586621679646418 -> Type) (TyFun (Maybe a6989586621679646419) b6989586621679646418 -> Type) -> *) (l2 :: TyFun a6989586621679646419 b6989586621679646418 -> Type)
Instance details type Apply (Maybe_Sym1 l1 :: TyFun (TyFun a6989586621679646419 b6989586621679646418 -> Type) (TyFun (Maybe a6989586621679646419) b6989586621679646418 -> Type) -> *) (l2 :: TyFun a6989586621679646419 b6989586621679646418 -> Type) = Maybe_Sym2 l1 l2

data Ordering #

Constructors

LT
EQ
GT

Instances

Bounded Ordering	Since: 2.1
Instance details Methods minBound :: Ordering # maxBound :: Ordering #
Enum Ordering	Since: 2.1
Instance details 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
Instance details Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Data Ordering	Since: 4.0.0.0
Instance details 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
Instance details 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: 2.1
Instance details Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] # readPrec :: ReadPrec Ordering # readListPrec :: ReadPrec [Ordering] #
Show Ordering
Instance details Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Ix Ordering	Since: 2.1
Instance details 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
Instance details Associated Types type Rep Ordering :: * -> * # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Semigroup Ordering	Since: 4.9.0.0
Instance details Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Monoid Ordering	Since: 2.1
Instance details Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
NFData Ordering
Instance details Methods rnf :: Ordering -> () #
AsEmpty Ordering
Instance details Methods _Empty :: Prism' Ordering ()
Default Ordering
Instance details Methods def :: Ordering
Arbitrary Ordering
Instance details Methods arbitrary :: Gen Ordering shrink :: Ordering -> [Ordering]
CoArbitrary Ordering
Instance details Methods coarbitrary :: Ordering -> Gen b -> Gen b
PBounded Ordering
Instance details Associated Types type MinBound :: a type MaxBound :: a
PEnum Ordering
Instance details 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
Instance details Methods sMinBound :: Sing MinBoundSym0 sMaxBound :: Sing MaxBoundSym0
SEnum Ordering
Instance details 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
Instance details Associated Types type x == y :: Bool type x /= y :: Bool
SEq Ordering
Instance details Methods (%==) :: Sing a -> Sing b -> Sing (a == b) (%/=) :: Sing a -> Sing b -> Sing (a /= b)
POrd Ordering
Instance details 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
Instance details 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
Instance details Associated Types type ShowsPrec arg arg1 arg2 :: Symbol type Show_ arg :: Symbol type ShowList arg arg1 :: Symbol
SShow Ordering
Instance details 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
Instance details Methods showsSingPrec :: Int -> Sing a -> ShowS
() :=> (Bounded Ordering)
Instance details Methods ins :: () :- Bounded Ordering
() :=> (Enum Ordering)
Instance details Methods ins :: () :- Enum Ordering
() :=> (Read Ordering)
Instance details Methods ins :: () :- Read Ordering
() :=> (Show Ordering)
Instance details Methods ins :: () :- Show Ordering
() :=> (Semigroup Ordering)
Instance details Methods ins :: () :- Semigroup Ordering
() :=> (Monoid Ordering)
Instance details Methods ins :: () :- Monoid Ordering
SuppressUnusedWarnings Compare_6989586621679551605Sym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ThenCmpSym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551625Sym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ShowsPrec_6989586621679888076Sym2
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ShowsPrec_6989586621679888076Sym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551645Sym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551222Sym1
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551605Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ThenCmpSym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551625Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings FromEnum_6989586621680021043Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ShowsPrec_6989586621679888076Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings ToEnum_6989586621680021033Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551645Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings Compare_6989586621679551222Sym0
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (SortBySym1 :: (TyFun a6989586621679681276 (TyFun a6989586621679681276 Ordering -> Type) -> Type) -> TyFun [a6989586621679681276] [a6989586621679681276] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (MinimumBySym1 :: (TyFun a6989586621679681273 (TyFun a6989586621679681273 Ordering -> Type) -> Type) -> TyFun [a6989586621679681273] a6989586621679681273 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (MaximumBySym1 :: (TyFun a6989586621679681274 (TyFun a6989586621679681274 Ordering -> Type) -> Type) -> TyFun [a6989586621679681274] a6989586621679681274 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (InsertBySym2 :: (TyFun a6989586621679681275 (TyFun a6989586621679681275 Ordering -> Type) -> Type) -> a6989586621679681275 -> TyFun [a6989586621679681275] [a6989586621679681275] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (InsertBySym1 :: (TyFun a6989586621679681275 (TyFun a6989586621679681275 Ordering -> Type) -> Type) -> TyFun a6989586621679681275 (TyFun [a6989586621679681275] [a6989586621679681275] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551121Sym1 :: [a3530822107858468865] -> TyFun [a3530822107858468865] Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551085Sym1 :: Maybe a3530822107858468865 -> TyFun (Maybe a3530822107858468865) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544128Scrutinee_6989586621679542851Sym1 :: k1 -> TyFun k1 Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544095Scrutinee_6989586621679542849Sym1 :: k1 -> TyFun k1 Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544062Scrutinee_6989586621679542847Sym1 :: k1 -> TyFun k1 Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544029Scrutinee_6989586621679542845Sym1 :: k1 -> TyFun k1 Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679544009Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (CompareSym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551198Sym1 :: NonEmpty a6989586621679060067 -> TyFun (NonEmpty a6989586621679060067) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (SortBySym0 :: TyFun (TyFun a6989586621679681276 (TyFun a6989586621679681276 Ordering -> Type) -> Type) (TyFun [a6989586621679681276] [a6989586621679681276] -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (MinimumBySym0 :: TyFun (TyFun a6989586621679681273 (TyFun a6989586621679681273 Ordering -> Type) -> Type) (TyFun [a6989586621679681273] a6989586621679681273 -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (MaximumBySym0 :: TyFun (TyFun a6989586621679681274 (TyFun a6989586621679681274 Ordering -> Type) -> Type) (TyFun [a6989586621679681274] a6989586621679681274 -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (InsertBySym0 :: TyFun (TyFun a6989586621679681275 (TyFun a6989586621679681275 Ordering -> Type) -> Type) (TyFun a6989586621679681275 (TyFun [a6989586621679681275] [a6989586621679681275] -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551121Sym0 :: TyFun [a3530822107858468865] (TyFun [a3530822107858468865] Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551085Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544128Scrutinee_6989586621679542851Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544095Scrutinee_6989586621679542849Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544062Scrutinee_6989586621679542847Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679544029Scrutinee_6989586621679542845Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679544009Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (CompareSym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551198Sym0 :: TyFun (NonEmpty a6989586621679060067) (TyFun (NonEmpty a6989586621679060067) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ComparingSym2 :: (TyFun b6989586621679542813 a6989586621679542812 -> Type) -> b6989586621679542813 -> TyFun b6989586621679542813 Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ComparingSym1 :: (TyFun b6989586621679542813 a6989586621679542812 -> Type) -> TyFun b6989586621679542813 (TyFun b6989586621679542813 Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551161Sym1 :: Either a6989586621679081252 b6989586621679081253 -> TyFun (Either a6989586621679081252 b6989586621679081253) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551256Sym1 :: (a3530822107858468865, b3530822107858468866) -> TyFun (a3530822107858468865, b3530822107858468866) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ComparingSym0 :: TyFun (TyFun b6989586621679542813 a6989586621679542812 -> Type) (TyFun b6989586621679542813 (TyFun b6989586621679542813 Ordering -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551161Sym0 :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun (Either a6989586621679081252 b6989586621679081253) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551256Sym0 :: TyFun (a3530822107858468865, b3530822107858468866) (TyFun (a3530822107858468865, b3530822107858468866) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551301Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551301Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692761MinBySym0 :: TyFun (k3 ~> (k3 ~> Ordering)) (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k3 k3 -> ) -> ) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692677MaxBySym0 :: TyFun (k3 ~> (k3 ~> Ordering)) (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k3 k3 -> ) -> ) -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692761MinBySym4 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> k2 -> k3 -> TyFun k3 k3 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692761MinBySym3 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> k2 -> TyFun k3 (TyFun k3 k3 -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692761MinBySym2 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> TyFun k2 (TyFun k3 (TyFun k3 k3 -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692761MinBySym1 :: (k3 ~> (k3 ~> Ordering)) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k3 k3 -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692677MaxBySym4 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> k2 -> k3 -> TyFun k3 k3 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692677MaxBySym3 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> k2 -> TyFun k3 (TyFun k3 k3 -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692677MaxBySym2 :: (k3 ~> (k3 ~> Ordering)) -> k1 -> TyFun k2 (TyFun k3 (TyFun k3 k3 -> ) -> ) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Let6989586621679692677MaxBySym1 :: (k3 ~> (k3 ~> Ordering)) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k3 k3 -> ) -> ) -> ) -> )
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551355Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551355Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551418Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551418Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551490Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551490Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551571Sym1 :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) -> TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551571Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870, g3530822107858468871) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
type Rep Ordering
Instance details 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)
Instance details data Sing (z :: Ordering) where SLT :: Sing LT SEQ :: Sing EQ SGT :: Sing GT
type Demote Ordering
Instance details type Demote Ordering = Ordering
type MaxBound
Instance details type MaxBound = MaxBound_6989586621679997945Sym0
type MinBound
Instance details type MinBound = MinBound_6989586621679997943Sym0
type FromEnum (a :: Ordering)
Instance details type FromEnum (a :: Ordering) = Apply FromEnum_6989586621680021043Sym0 a
type ToEnum a
Instance details type ToEnum a = Apply ToEnum_6989586621680021033Sym0 a
type Show_ (arg :: Ordering)
Instance details type Show_ (arg :: Ordering) = Apply (Show__6989586621679871872Sym0 :: TyFun Ordering Symbol -> *) arg
type Pred (arg :: Ordering)
Instance details type Pred (arg :: Ordering) = Apply (Pred_6989586621680002470Sym0 :: TyFun Ordering Ordering -> *) arg
type Succ (arg :: Ordering)
Instance details type Succ (arg :: Ordering) = Apply (Succ_6989586621680002457Sym0 :: TyFun Ordering Ordering -> *) arg
type EnumFromTo (arg1 :: Ordering) (arg2 :: Ordering)
Instance details type EnumFromTo (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (EnumFromTo_6989586621680002488Sym0 :: TyFun Ordering (TyFun Ordering [Ordering] -> Type) -> *) arg1) arg2
type (x :: Ordering) /= (y :: Ordering)
Instance details type (x :: Ordering) /= (y :: Ordering) = Not (x == y)
type (a :: Ordering) == (b :: Ordering)
Instance details type (a :: Ordering) == (b :: Ordering) = Equals_6989586621679532930 a b
type (arg1 :: Ordering) < (arg2 :: Ordering)
Instance details type (arg1 :: Ordering) < (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679544042Sym0 :: TyFun Ordering (TyFun Ordering Bool -> Type) -> *) arg1) arg2
type (arg1 :: Ordering) <= (arg2 :: Ordering)
Instance details type (arg1 :: Ordering) <= (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679544075Sym0 :: TyFun Ordering (TyFun Ordering Bool -> Type) -> *) arg1) arg2
type (arg1 :: Ordering) > (arg2 :: Ordering)
Instance details type (arg1 :: Ordering) > (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679544108Sym0 :: TyFun Ordering (TyFun Ordering Bool -> Type) -> *) arg1) arg2
type (arg1 :: Ordering) >= (arg2 :: Ordering)
Instance details type (arg1 :: Ordering) >= (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679544141Sym0 :: TyFun Ordering (TyFun Ordering Bool -> Type) -> *) arg1) arg2
type Compare (a1 :: Ordering) (a2 :: Ordering)
Instance details type Compare (a1 :: Ordering) (a2 :: Ordering) = Apply (Apply Compare_6989586621679551625Sym0 a1) a2
type Max (arg1 :: Ordering) (arg2 :: Ordering)
Instance details type Max (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (Max_6989586621679544174Sym0 :: TyFun Ordering (TyFun Ordering Ordering -> Type) -> *) arg1) arg2
type Min (arg1 :: Ordering) (arg2 :: Ordering)
Instance details type Min (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (Min_6989586621679544207Sym0 :: TyFun Ordering (TyFun Ordering Ordering -> Type) -> *) arg1) arg2
type ShowList (arg1 :: [Ordering]) arg2
Instance details type ShowList (arg1 :: [Ordering]) arg2 = Apply (Apply (ShowList_6989586621679871890Sym0 :: TyFun [Ordering] (TyFun Symbol Symbol -> Type) -> *) arg1) arg2
type Apply FromEnum_6989586621680021043Sym0 (l :: Ordering)
Instance details type Apply FromEnum_6989586621680021043Sym0 (l :: Ordering) = FromEnum_6989586621680021043 l
type Apply ToEnum_6989586621680021033Sym0 (l :: Nat)
Instance details type Apply ToEnum_6989586621680021033Sym0 (l :: Nat) = ToEnum_6989586621680021033 l
type EnumFromThenTo (arg1 :: Ordering) (arg2 :: Ordering) (arg3 :: Ordering)
Instance details type EnumFromThenTo (arg1 :: Ordering) (arg2 :: Ordering) (arg3 :: Ordering) = Apply (Apply (Apply (EnumFromThenTo_6989586621680002518Sym0 :: TyFun Ordering (TyFun Ordering (TyFun Ordering [Ordering] -> Type) -> Type) -> *) arg1) arg2) arg3
type ShowsPrec a1 (a2 :: Ordering) a3
Instance details type ShowsPrec a1 (a2 :: Ordering) a3 = Apply (Apply (Apply ShowsPrec_6989586621679888076Sym0 a1) a2) a3
type Apply (Compare_6989586621679551605Sym1 l1 :: TyFun Bool Ordering -> *) (l2 :: Bool)
Instance details type Apply (Compare_6989586621679551605Sym1 l1 :: TyFun Bool Ordering -> *) (l2 :: Bool) = Compare_6989586621679551605 l1 l2
type Apply (ThenCmpSym1 l1 :: TyFun Ordering Ordering -> *) (l2 :: Ordering)
Instance details type Apply (ThenCmpSym1 l1 :: TyFun Ordering Ordering -> *) (l2 :: Ordering) = ThenCmp l1 l2
type Apply (Compare_6989586621679551625Sym1 l1 :: TyFun Ordering Ordering -> *) (l2 :: Ordering)
Instance details type Apply (Compare_6989586621679551625Sym1 l1 :: TyFun Ordering Ordering -> *) (l2 :: Ordering) = Compare_6989586621679551625 l1 l2
type Apply (Compare_6989586621679551645Sym1 l1 :: TyFun () Ordering -> *) (l2 :: ())
Instance details type Apply (Compare_6989586621679551645Sym1 l1 :: TyFun () Ordering -> *) (l2 :: ()) = Compare_6989586621679551645 l1 l2
type Apply (Compare_6989586621679551222Sym1 l1 :: TyFun Void Ordering -> *) (l2 :: Void)
Instance details type Apply (Compare_6989586621679551222Sym1 l1 :: TyFun Void Ordering -> *) (l2 :: Void) = Compare_6989586621679551222 l1 l2
type Apply (Compare_6989586621679544009Sym1 l1 :: TyFun a Ordering -> *) (l2 :: a)
Instance details type Apply (Compare_6989586621679544009Sym1 l1 :: TyFun a Ordering -> *) (l2 :: a) = Compare_6989586621679544009 l1 l2
type Apply (CompareSym1 l1 :: TyFun a Ordering -> *) (l2 :: a)
Instance details type Apply (CompareSym1 l1 :: TyFun a Ordering -> *) (l2 :: a) = Compare l1 l2
type Apply (Let6989586621679544128Scrutinee_6989586621679542851Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679544128Scrutinee_6989586621679542851Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1) = Let6989586621679544128Scrutinee_6989586621679542851 l1 l2
type Apply (Let6989586621679544095Scrutinee_6989586621679542849Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679544095Scrutinee_6989586621679542849Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1) = Let6989586621679544095Scrutinee_6989586621679542849 l1 l2
type Apply (Let6989586621679544062Scrutinee_6989586621679542847Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679544062Scrutinee_6989586621679542847Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1) = Let6989586621679544062Scrutinee_6989586621679542847 l1 l2
type Apply (Let6989586621679544029Scrutinee_6989586621679542845Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1)
Instance details type Apply (Let6989586621679544029Scrutinee_6989586621679542845Sym1 l1 :: TyFun k1 Ordering -> *) (l2 :: k1) = Let6989586621679544029Scrutinee_6989586621679542845 l1 l2
type Apply (ComparingSym2 l1 l2 :: TyFun b Ordering -> *) (l3 :: b)
Instance details type Apply (ComparingSym2 l1 l2 :: TyFun b Ordering -> *) (l3 :: b) = Comparing l1 l2 l3
type Apply Compare_6989586621679551605Sym0 (l :: Bool)
Instance details type Apply Compare_6989586621679551605Sym0 (l :: Bool) = Compare_6989586621679551605Sym1 l
type Apply ThenCmpSym0 (l :: Ordering)
Instance details type Apply ThenCmpSym0 (l :: Ordering) = ThenCmpSym1 l
type Apply Compare_6989586621679551625Sym0 (l :: Ordering)
Instance details type Apply Compare_6989586621679551625Sym0 (l :: Ordering) = Compare_6989586621679551625Sym1 l
type Apply ShowsPrec_6989586621679888076Sym0 (l :: Nat)
Instance details type Apply ShowsPrec_6989586621679888076Sym0 (l :: Nat) = ShowsPrec_6989586621679888076Sym1 l
type Apply Compare_6989586621679551645Sym0 (l :: ())
Instance details type Apply Compare_6989586621679551645Sym0 (l :: ()) = Compare_6989586621679551645Sym1 l
type Apply Compare_6989586621679551222Sym0 (l :: Void)
Instance details type Apply Compare_6989586621679551222Sym0 (l :: Void) = Compare_6989586621679551222Sym1 l
type Apply (ShowsPrec_6989586621679888076Sym1 l1 :: TyFun Ordering (TyFun Symbol Symbol -> Type) -> *) (l2 :: Ordering)
Instance details type Apply (ShowsPrec_6989586621679888076Sym1 l1 :: TyFun Ordering (TyFun Symbol Symbol -> Type) -> *) (l2 :: Ordering) = ShowsPrec_6989586621679888076Sym2 l1 l2
type Apply (Compare_6989586621679544009Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Ordering -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply (Compare_6989586621679544009Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Ordering -> Type) -> *) (l :: a6989586621679542823) = Compare_6989586621679544009Sym1 l
type Apply (CompareSym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Ordering -> Type) -> *) (l :: a6989586621679542823)
Instance details type Apply (CompareSym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Ordering -> Type) -> *) (l :: a6989586621679542823) = CompareSym1 l
type Apply (Let6989586621679544128Scrutinee_6989586621679542851Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679544128Scrutinee_6989586621679542851Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> ) (l :: k1) = Let6989586621679544128Scrutinee_6989586621679542851Sym1 l
type Apply (Let6989586621679544095Scrutinee_6989586621679542849Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679544095Scrutinee_6989586621679542849Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> ) (l :: k1) = Let6989586621679544095Scrutinee_6989586621679542849Sym1 l
type Apply (Let6989586621679544062Scrutinee_6989586621679542847Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679544062Scrutinee_6989586621679542847Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> ) (l :: k1) = Let6989586621679544062Scrutinee_6989586621679542847Sym1 l
type Apply (Let6989586621679544029Scrutinee_6989586621679542845Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> ) (l :: k1)
Instance details type Apply (Let6989586621679544029Scrutinee_6989586621679542845Sym0 :: TyFun k1 (TyFun k1 Ordering -> ) -> ) (l :: k1) = Let6989586621679544029Scrutinee_6989586621679542845Sym1 l
type Apply (ComparingSym1 l1 :: TyFun b6989586621679542813 (TyFun b6989586621679542813 Ordering -> Type) -> *) (l2 :: b6989586621679542813)
Instance details type Apply (ComparingSym1 l1 :: TyFun b6989586621679542813 (TyFun b6989586621679542813 Ordering -> Type) -> *) (l2 :: b6989586621679542813) = ComparingSym2 l1 l2
type Apply (Compare_6989586621679551121Sym1 l1 :: TyFun [a] Ordering -> *) (l2 :: [a])
Instance details type Apply (Compare_6989586621679551121Sym1 l1 :: TyFun [a] Ordering -> *) (l2 :: [a]) = Compare_6989586621679551121 l1 l2
type Apply (Compare_6989586621679551085Sym1 l1 :: TyFun (Maybe a) Ordering -> *) (l2 :: Maybe a)
Instance details type Apply (Compare_6989586621679551085Sym1 l1 :: TyFun (Maybe a) Ordering -> *) (l2 :: Maybe a) = Compare_6989586621679551085 l1 l2
type Apply (Compare_6989586621679551198Sym1 l1 :: TyFun (NonEmpty a) Ordering -> *) (l2 :: NonEmpty a)
Instance details type Apply (Compare_6989586621679551198Sym1 l1 :: TyFun (NonEmpty a) Ordering -> *) (l2 :: NonEmpty a) = Compare_6989586621679551198 l1 l2
type Apply (Compare_6989586621679551121Sym0 :: TyFun [a3530822107858468865] (TyFun [a3530822107858468865] Ordering -> Type) -> *) (l :: [a3530822107858468865])
Instance details type Apply (Compare_6989586621679551121Sym0 :: TyFun [a3530822107858468865] (TyFun [a3530822107858468865] Ordering -> Type) -> *) (l :: [a3530822107858468865]) = Compare_6989586621679551121Sym1 l
type Apply (Compare_6989586621679551085Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *) (l :: Maybe a3530822107858468865)
Instance details type Apply (Compare_6989586621679551085Sym0 :: TyFun (Maybe a3530822107858468865) (TyFun (Maybe a3530822107858468865) Ordering -> Type) -> *) (l :: Maybe a3530822107858468865) = Compare_6989586621679551085Sym1 l
type Apply (Compare_6989586621679551198Sym0 :: TyFun (NonEmpty a6989586621679060067) (TyFun (NonEmpty a6989586621679060067) Ordering -> Type) -> *) (l :: NonEmpty a6989586621679060067)
Instance details type Apply (Compare_6989586621679551198Sym0 :: TyFun (NonEmpty a6989586621679060067) (TyFun (NonEmpty a6989586621679060067) Ordering -> Type) -> *) (l :: NonEmpty a6989586621679060067) = Compare_6989586621679551198Sym1 l
type Apply (Compare_6989586621679551161Sym1 l1 :: TyFun (Either a b) Ordering -> *) (l2 :: Either a b)
Instance details type Apply (Compare_6989586621679551161Sym1 l1 :: TyFun (Either a b) Ordering -> *) (l2 :: Either a b) = Compare_6989586621679551161 l1 l2
type Apply (Compare_6989586621679551256Sym1 l1 :: TyFun (a, b) Ordering -> *) (l2 :: (a, b))
Instance details type Apply (Compare_6989586621679551256Sym1 l1 :: TyFun (a, b) Ordering -> *) (l2 :: (a, b)) = Compare_6989586621679551256 l1 l2
type Apply (InsertBySym0 :: TyFun (TyFun a6989586621679681275 (TyFun a6989586621679681275 Ordering -> Type) -> Type) (TyFun a6989586621679681275 (TyFun [a6989586621679681275] [a6989586621679681275] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681275 (TyFun a6989586621679681275 Ordering -> Type) -> Type)
Instance details type Apply (InsertBySym0 :: TyFun (TyFun a6989586621679681275 (TyFun a6989586621679681275 Ordering -> Type) -> Type) (TyFun a6989586621679681275 (TyFun [a6989586621679681275] [a6989586621679681275] -> Type) -> Type) -> *) (l :: TyFun a6989586621679681275 (TyFun a6989586621679681275 Ordering -> Type) -> Type) = InsertBySym1 l
type Apply (SortBySym0 :: TyFun (TyFun a6989586621679681276 (TyFun a6989586621679681276 Ordering -> Type) -> Type) (TyFun [a6989586621679681276] [a6989586621679681276] -> Type) -> *) (l :: TyFun a6989586621679681276 (TyFun a6989586621679681276 Ordering -> Type) -> Type)
Instance details type Apply (SortBySym0 :: TyFun (TyFun a6989586621679681276 (TyFun a6989586621679681276 Ordering -> Type) -> Type) (TyFun [a6989586621679681276] [a6989586621679681276] -> Type) -> *) (l :: TyFun a6989586621679681276 (TyFun a6989586621679681276 Ordering -> Type) -> Type) = SortBySym1 l
type Apply (MaximumBySym0 :: TyFun (TyFun a6989586621679681274 (TyFun a6989586621679681274 Ordering -> Type) -> Type) (TyFun [a6989586621679681274] a6989586621679681274 -> Type) -> *) (l :: TyFun a6989586621679681274 (TyFun a6989586621679681274 Ordering -> Type) -> Type)
Instance details type Apply (MaximumBySym0 :: TyFun (TyFun a6989586621679681274 (TyFun a6989586621679681274 Ordering -> Type) -> Type) (TyFun [a6989586621679681274] a6989586621679681274 -> Type) -> *) (l :: TyFun a6989586621679681274 (TyFun a6989586621679681274 Ordering -> Type) -> Type) = MaximumBySym1 l
type Apply (MinimumBySym0 :: TyFun (TyFun a6989586621679681273 (TyFun a6989586621679681273 Ordering -> Type) -> Type) (TyFun [a6989586621679681273] a6989586621679681273 -> Type) -> *) (l :: TyFun a6989586621679681273 (TyFun a6989586621679681273 Ordering -> Type) -> Type)
Instance details type Apply (MinimumBySym0 :: TyFun (TyFun a6989586621679681273 (TyFun a6989586621679681273 Ordering -> Type) -> Type) (TyFun [a6989586621679681273] a6989586621679681273 -> Type) -> *) (l :: TyFun a6989586621679681273 (TyFun a6989586621679681273 Ordering -> Type) -> Type) = MinimumBySym1 l
type Apply (ComparingSym0 :: TyFun (TyFun b6989586621679542813 a6989586621679542812 -> Type) (TyFun b6989586621679542813 (TyFun b6989586621679542813 Ordering -> Type) -> Type) -> *) (l :: TyFun b6989586621679542813 a6989586621679542812 -> Type)
Instance details type Apply (ComparingSym0 :: TyFun (TyFun b6989586621679542813 a6989586621679542812 -> Type) (TyFun b6989586621679542813 (TyFun b6989586621679542813 Ordering -> Type) -> Type) -> *) (l :: TyFun b6989586621679542813 a6989586621679542812 -> Type) = ComparingSym1 l
type Apply (Compare_6989586621679551161Sym0 :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun (Either a6989586621679081252 b6989586621679081253) Ordering -> Type) -> *) (l :: Either a6989586621679081252 b6989586621679081253)
Instance details type Apply (Compare_6989586621679551161Sym0 :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun (Either a6989586621679081252 b6989586621679081253) Ordering -> Type) -> *) (l :: Either a6989586621679081252 b6989586621679081253) = Compare_6989586621679551161Sym1 l
type Apply (Compare_6989586621679551256Sym0 :: TyFun (a3530822107858468865, b3530822107858468866) (TyFun (a3530822107858468865, b3530822107858468866) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866))
Instance details type Apply (Compare_6989586621679551256Sym0 :: TyFun (a3530822107858468865, b3530822107858468866) (TyFun (a3530822107858468865, b3530822107858468866) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866)) = Compare_6989586621679551256Sym1 l
type Apply (Let6989586621679692677MaxBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> ) -> ) -> ) -> ) -> *) (l :: k1 ~> (k1 ~> Ordering))
Instance details type Apply (Let6989586621679692677MaxBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> ) -> ) -> ) -> ) -> ) (l :: k1 ~> (k1 ~> Ordering)) = (Let6989586621679692677MaxBySym1 l :: TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> ) -> ) -> ) -> *)
type Apply (Let6989586621679692761MinBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> ) -> ) -> ) -> ) -> *) (l :: k1 ~> (k1 ~> Ordering))
Instance details type Apply (Let6989586621679692761MinBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> ) -> ) -> ) -> ) -> ) (l :: k1 ~> (k1 ~> Ordering)) = (Let6989586621679692761MinBySym1 l :: TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> ) -> ) -> ) -> *)
type Apply (Compare_6989586621679551301Sym1 l1 :: TyFun (a, b, c) Ordering -> *) (l2 :: (a, b, c))
Instance details type Apply (Compare_6989586621679551301Sym1 l1 :: TyFun (a, b, c) Ordering -> *) (l2 :: (a, b, c)) = Compare_6989586621679551301 l1 l2
type Apply (Compare_6989586621679551301Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867))
Instance details type Apply (Compare_6989586621679551301Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867)) = Compare_6989586621679551301Sym1 l
type Apply (Compare_6989586621679551355Sym1 l1 :: TyFun (a, b, c, d) Ordering -> *) (l2 :: (a, b, c, d))
Instance details type Apply (Compare_6989586621679551355Sym1 l1 :: TyFun (a, b, c, d) Ordering -> *) (l2 :: (a, b, c, d)) = Compare_6989586621679551355 l1 l2
type Apply (Compare_6989586621679551355Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868))
Instance details type Apply (Compare_6989586621679551355Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868)) = Compare_6989586621679551355Sym1 l
type Apply (Compare_6989586621679551418Sym1 l1 :: TyFun (a, b, c, d, e) Ordering -> *) (l2 :: (a, b, c, d, e))
Instance details type Apply (Compare_6989586621679551418Sym1 l1 :: TyFun (a, b, c, d, e) Ordering -> *) (l2 :: (a, b, c, d, e)) = Compare_6989586621679551418 l1 l2
type Apply (Compare_6989586621679551418Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869))
Instance details type Apply (Compare_6989586621679551418Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869)) = Compare_6989586621679551418Sym1 l
type Apply (Compare_6989586621679551490Sym1 l1 :: TyFun (a, b, c, d, e, f) Ordering -> *) (l2 :: (a, b, c, d, e, f))
Instance details type Apply (Compare_6989586621679551490Sym1 l1 :: TyFun (a, b, c, d, e, f) Ordering -> *) (l2 :: (a, b, c, d, e, f)) = Compare_6989586621679551490 l1 l2
type Apply (Compare_6989586621679551490Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870))
Instance details type Apply (Compare_6989586621679551490Sym0 :: TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) (TyFun (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870) Ordering -> Type) -> *) (l :: (a3530822107858468865, b3530822107858468866, c3530822107858468867, d3530822107858468868, e3530822107858468869, f3530822107858468870)) = Compare_6989586621679551490Sym1 l
type Apply (Compare_6989586621679551571Sym1 l1 :: TyFun (a, b, c, d, e, f, g) Ordering -> *) (l2 :: (a, b, c, d, e, f, g))
Instance details type Apply (Compare_6989586621679551571Sym1 l1 :: TyFun (a, b, c, d, e, f, g) Ordering -> *) (l2 :: (a, b, c, d, e, f, g)) = Compare_6989586621679551571 l1 l2
type Apply (Compare_6989586621679551571Sym0 :: 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))
Instance details type Apply (Compare_6989586621679551571Sym0 :: 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_6989586621679551571Sym1 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: 2.1
Instance details 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: 2.1
Instance details Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Applicative IO	Since: 2.1
Instance details 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: 4.9.0.0
Instance details Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
MonadPlus IO	Since: 4.9.0.0
Instance details Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
Quasi IO
Instance details 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
Instance details Associated Types type PrimState IO :: * Methods primitive :: (State# (PrimState IO) -> (#State# (PrimState IO), a#)) -> IO a
PrimBase IO
Instance details Methods internal :: IO a -> State# (PrimState IO) -> (#State# (PrimState IO), a#)
() :=> (Monad IO)
Instance details Methods ins :: () :- Monad IO
() :=> (Functor IO)
Instance details Methods ins :: () :- Functor IO
() :=> (Applicative IO)
Instance details Methods ins :: () :- Applicative IO
Semigroup a => Semigroup (IO a)	Since: 4.10.0.0
Instance details 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: 4.9.0.0
Instance details Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Default a => Default (IO a)
Instance details Methods def :: IO a
(Semigroup a) :=> (Semigroup (IO a))
Instance details Methods ins :: Semigroup a :- Semigroup (IO a)
(Monoid a) :=> (Monoid (IO a))
Instance details Methods ins :: Monoid a :- Monoid (IO a)
type PrimState IO
Instance details type PrimState IO = RealWorld

data Word #

A Word is an unsigned integral type, with the same size as Int.

Instances

Bounded Word	Since: 2.1
Instance details Methods minBound :: Word # maxBound :: Word #
Enum Word	Since: 2.1
Instance details 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
Instance details Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Integral Word	Since: 2.1
Instance details 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: 4.0.0.0
Instance details 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: 2.1
Instance details Methods (+) :: Word -> Word -> Word # (-) :: Word -> Word -> Word # (*) :: Word -> Word -> Word # negate :: Word -> Word # abs :: Word -> Word # signum :: Word -> Word # fromInteger :: Integer -> Word #
Ord Word
Instance details 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: 4.5.0.0
Instance details Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] # readPrec :: ReadPrec Word # readListPrec :: ReadPrec [Word] #
Real Word	Since: 2.1
Instance details Methods toRational :: Word -> Rational #
Show Word	Since: 2.1
Instance details Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Ix Word	Since: 4.6.0.0
Instance details 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
Instance details Methods lift :: Word -> Q Exp #
Storable Word	Since: 2.1
Instance details 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: 2.1
Instance details 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: 4.6.0.0
Instance details Methods finiteBitSize :: Word -> Int # countLeadingZeros :: Word -> Int # countTrailingZeros :: Word -> Int #
NFData Word
Instance details Methods rnf :: Word -> () #
ShowX Word Source #
Instance details Methods showsPrecX :: Int -> Word -> ShowS Source # showX :: Word -> String Source # showListX :: [Word] -> ShowS Source #
Default Word
Instance details Methods def :: Word
Arbitrary Word
Instance details Methods arbitrary :: Gen Word shrink :: Word -> [Word]
CoArbitrary Word
Instance details Methods coarbitrary :: Word -> Gen b -> Gen b
Unbox Word
Instance details
Prim Word
Instance details 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 Source #
Instance details Associated Types type BitSize Word :: Nat Source # Methods pack :: Word -> BitVector (BitSize Word) Source # unpack :: BitVector (BitSize Word) -> Word Source #
Vector Vector Word
Instance details 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
Instance details 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)
Instance details Methods ins :: () :- Bounded Word
() :=> (Enum Word)
Instance details Methods ins :: () :- Enum Word
() :=> (Eq Word)
Instance details Methods ins :: () :- Eq Word
() :=> (Integral Word)
Instance details Methods ins :: () :- Integral Word
() :=> (Num Word)
Instance details Methods ins :: () :- Num Word
() :=> (Ord Word)
Instance details Methods ins :: () :- Ord Word
() :=> (Read Word)
Instance details Methods ins :: () :- Read Word
() :=> (Real Word)
Instance details Methods ins :: () :- Real Word
() :=> (Show Word)
Instance details Methods ins :: () :- Show Word
() :=> (Bits Word)
Instance details Methods ins :: () :- Bits Word
Generic1 (URec Word :: k -> *)
Instance details 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 :: * -> *)
Instance details Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Foldable (URec Word :: * -> *)
Instance details 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 :: * -> *)
Instance details 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)
Instance details Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Ord (URec Word p)
Instance details 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)
Instance details Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
Generic (URec Word p)
Instance details 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
Instance details data Vector Word = V_Word (Vector Word)
type BitSize Word Source #
Instance details type BitSize Word = 64
data URec Word (p :: k)	Used for marking occurrences of `Word#` Since: 4.9.0.0
Instance details data URec Word (p :: k) = UWord { uWord# :: Word# }
data MVector s Word
Instance details data MVector s Word = MV_Word (MVector s Word)
type Rep1 (URec Word :: k -> *)
Instance details 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)
Instance details 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

Expand

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: 4.10.0.0
Instance details 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: 4.8.0.0
Instance details 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: 4.9.0.0
Instance details Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Either a c -> Either b d -> Bool #
Ord2 Either	Since: 4.9.0.0
Instance details Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Either a c -> Either b d -> Ordering #
Read2 Either	Since: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 1.4.3.0
Instance details Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> Either a b -> () #
Swapped Either
Instance details Methods swapped :: (Profunctor p, Functor f) => p (Either b a) (f (Either d c)) -> p (Either a b) (f (Either c d))
Arbitrary2 Either
Instance details Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (Either a b) liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Either a b -> [Either a b]
Bitraversable1 Either
Instance details 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))
Instance details Methods ins :: () :- Monad (Either a)
() :=> (Functor (Either a))
Instance details Methods ins :: () :- Functor (Either a)
() :=> (Applicative (Either a))
Instance details Methods ins :: () :- Applicative (Either a)
Monad (Either e)	Since: 4.4.0.0
Instance details 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: 3.0
Instance details Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Applicative (Either e)	Since: 3.0
Instance details 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: 4.7.0.0
Instance details 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: 4.7.0.0
Instance details 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: 4.9.0.0
Instance details Methods liftEq :: (a0 -> b -> Bool) -> Either a a0 -> Either a b -> Bool #
Ord a => Ord1 (Either a)	Since: 4.9.0.0
Instance details Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering #
Read a => Read1 (Either a)	Since: 4.9.0.0
Instance details 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: 4.9.0.0
Instance details 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: 1.4.3.0
Instance details Methods liftRnf :: (a0 -> ()) -> Either a a0 -> () #
Arbitrary a => Arbitrary1 (Either a)
Instance details Methods liftArbitrary :: Gen a0 -> Gen (Either a a0) liftShrink :: (a0 -> [a0]) -> Either a a0 -> [Either a a0]
Generic1 (Either a :: * -> *)
Instance details 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)
Instance details Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
(Data a, Data b) => Data (Either a b)	Since: 4.0.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
Generic (Either a b)
Instance details 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: 4.9.0.0
Instance details 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)
Instance details Methods lift :: Either a b -> Q Exp #
(NFData a, NFData b) => NFData (Either a b)
Instance details Methods rnf :: Either a b -> () #
(ShowX a, ShowX b) => ShowX (Either a b) Source #
Instance details Methods showsPrecX :: Int -> Either a b -> ShowS Source # showX :: Either a b -> String Source # showListX :: [Either a b] -> ShowS Source #
(Arbitrary a, Arbitrary b) => Arbitrary (Either a b)
Instance details Methods arbitrary :: Gen (Either a b) shrink :: Either a b -> [Either a b]
(CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b)
Instance details Methods coarbitrary :: Either a b -> Gen b0 -> Gen b0
PEq (Either a b)
Instance details Associated Types type x == y :: Bool type x /= y :: Bool
(SEq a, SEq b) => SEq (Either a b)
Instance details Methods (%==) :: Sing a0 -> Sing b0 -> Sing (a0 == b0) (%/=) :: Sing a0 -> Sing b0 -> Sing (a0 /= b0)
POrd (Either a b)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Methods showsSingPrec :: Int -> Sing a0 -> ShowS
Bundle (Either a b) Source #
Instance details Associated Types type Unbundled domain (Either a b) = (res :: *) Source # Methods bundle :: Unbundled domain (Either a b) -> Signal domain (Either a b) Source # unbundle :: Signal domain (Either a b) -> Unbundled domain (Either a b) Source #
(Eq a, Eq b) :=> (Eq (Either a b))
Instance details Methods ins :: (Eq a, Eq b) :- Eq (Either a b)
(Ord a, Ord b) :=> (Ord (Either a b))
Instance details Methods ins :: (Ord a, Ord b) :- Ord (Either a b)
(Read a, Read b) :=> (Read (Either a b))
Instance details Methods ins :: (Read a, Read b) :- Read (Either a b)
(Show a, Show b) :=> (Show (Either a b))
Instance details Methods ins :: (Show a, Show b) :- Show (Either a b)
SuppressUnusedWarnings (Compare_6989586621679551161Sym1 :: Either a6989586621679081252 b6989586621679081253 -> TyFun (Either a6989586621679081252 b6989586621679081253) Ordering -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ShowsPrec_6989586621679887937Sym2 :: Nat -> Either a6989586621679081252 b6989586621679081253 -> TyFun Symbol Symbol -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ShowsPrec_6989586621679887937Sym1 :: Nat -> TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun Symbol Symbol -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (RightsSym0 :: TyFun [Either a6989586621680060966 b6989586621680060967] [b6989586621680060967] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (PartitionEithersSym0 :: TyFun [Either a6989586621680060964 b6989586621680060965] ([a6989586621680060964], [b6989586621680060965]) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (LeftsSym0 :: TyFun [Either a6989586621680060968 b6989586621680060969] [a6989586621680060968] -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Compare_6989586621679551161Sym0 :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun (Either a6989586621679081252 b6989586621679081253) Ordering -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsRightSym0 :: TyFun (Either a6989586621680060960 b6989586621680060961) Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (IsLeftSym0 :: TyFun (Either a6989586621680060962 b6989586621680060963) Bool -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (ShowsPrec_6989586621679887937Sym0 :: TyFun Nat (TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun Symbol Symbol -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (RightSym0 :: TyFun b6989586621679081253 (Either a6989586621679081252 b6989586621679081253) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (LeftSym0 :: TyFun a6989586621679081252 (Either a6989586621679081252 b6989586621679081253) -> *)
Instance details Methods suppressUnusedWarnings :: ()
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Sum f g)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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 a6989586621680059832 c6989586621680059833 -> Type) -> (TyFun b6989586621680059834 c6989586621680059833 -> Type) -> TyFun (Either a6989586621680059832 b6989586621680059834) c6989586621680059833 -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Either_Sym1 :: (TyFun a6989586621680059832 c6989586621680059833 -> Type) -> TyFun (TyFun b6989586621680059834 c6989586621680059833 -> Type) (TyFun (Either a6989586621680059832 b6989586621680059834) c6989586621680059833 -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
SuppressUnusedWarnings (Either_Sym0 :: TyFun (TyFun a6989586621680059832 c6989586621680059833 -> Type) (TyFun (TyFun b6989586621680059834 c6989586621680059833 -> Type) (TyFun (Either a6989586621680059832 b6989586621680059834) c6989586621680059833 -> Type) -> Type) -> *)
Instance details Methods suppressUnusedWarnings :: ()
type Unbundled domain (Either a b) Source #
Instance details type Unbundled domain (Either a b) = Signal domain (Either a b)
type Apply (ShowsPrec_6989586621679887937Sym0 :: TyFun Nat (TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun Symbol Symbol -> Type) -> Type) -> *) (l :: Nat)
Instance details type Apply (ShowsPrec_6989586621679887937Sym0 :: TyFun Nat (TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun Symbol Symbol -> Type) -> Type) -> ) (l :: Nat) = (ShowsPrec_6989586621679887937Sym1 l :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun Symbol Symbol -> Type) -> )
type Apply (LeftSym0 :: TyFun a (Either a b6989586621679081253) -> *) (l :: a)
Instance details type Apply (LeftSym0 :: TyFun a (Either a b6989586621679081253) -> *) (l :: a) = (Left l :: Either a b6989586621679081253)
type Apply (RightSym0 :: TyFun b (Either a6989586621679081252 b) -> *) (l :: b)
Instance details type Apply (RightSym0 :: TyFun b (Either a6989586621679081252 b) -> *) (l :: b) = (Right l :: Either a6989586621679081252 b)
type Rep1 (Either a :: * -> *)
Instance details 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])
Instance details 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])
Instance details 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])
Instance details type Apply (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> *) (l :: [Either a b]) = PartitionEithers l
type Rep (Either a b)
Instance details 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)
Instance details 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)
Instance details type Demote (Either a b) = Either (Demote a) (Demote b)
type Show_ (arg :: Either a b)
Instance details type Show_ (arg :: Either a b) = Apply (Show__6989586621679871872Sym0 :: TyFun (Either a b) Symbol -> *) arg
type (x :: Either a b) /= (y :: Either a b)
Instance details type (x :: Either a b) /= (y :: Either a b) = Not (x == y)
type (a2 :: Either a1 b1) == (b2 :: Either a1 b1)
Instance details type (a2 :: Either a1 b1) == (b2 :: Either a1 b1) = Equals_6989586621679532675 a2 b2
type (arg1 :: Either a b) < (arg2 :: Either a b)
Instance details type (arg1 :: Either a b) < (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679544042Sym0 :: TyFun (Either a b) (TyFun (Either a b) Bool -> Type) -> *) arg1) arg2
type (arg1 :: Either a b) <= (arg2 :: Either a b)
Instance details type (arg1 :: Either a b) <= (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679544075Sym0 :: TyFun (Either a b) (TyFun (Either a b) Bool -> Type) -> *) arg1) arg2
type (arg1 :: Either a b) > (arg2 :: Either a b)
Instance details type (arg1 :: Either a b) > (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679544108Sym0 :: TyFun (Either a b) (TyFun (Either a b) Bool -> Type) -> *) arg1) arg2
type (arg1 :: Either a b) >= (arg2 :: Either a b)
Instance details type (arg1 :: Either a b) >= (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679544141Sym0 :: TyFun (Either a b) (TyFun (Either a b) Bool -> Type) -> *) arg1) arg2
type Compare (a2 :: Either a1 b) (a3 :: Either a1 b)
Instance details type Compare (a2 :: Either a1 b) (a3 :: Either a1 b) = Apply (Apply (Compare_6989586621679551161Sym0 :: TyFun (Either a1 b) (TyFun (Either a1 b) Ordering -> Type) -> *) a2) a3
type Max (arg1 :: Either a b) (arg2 :: Either a b)
Instance details type Max (arg1 :: Either a b) (arg2 :: Either a b) = Apply (Apply (Max_6989586621679544174Sym0 :: TyFun (Either a b) (TyFun (Either a b) (Either a b) -> Type) -> *) arg1) arg2
type Min (arg1 :: Either a b) (arg2 :: Either a b)
Instance details type Min (arg1 :: Either a b) (arg2 :: Either a b) = Apply (Apply (Min_6989586621679544207Sym0 :: TyFun (Either a b) (TyFun (Either a b) (Either a b) -> Type) -> *) arg1) arg2
type ShowList (arg1 :: [Either a b]) arg2
Instance details type ShowList (arg1 :: [Either a b]) arg2 = Apply (Apply (ShowList_6989586621679871890Sym0 :: TyFun [Either a b] (TyFun Symbol Symbol -> Type) -> *) arg1) arg2
type ShowsPrec a2 (a3 :: Either a1 b) a4
Instance details type ShowsPrec a2 (a3 :: Either a1 b) a4 = Apply (Apply (Apply (ShowsPrec_6989586621679887937Sym0 :: 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)
Instance details 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)
Instance details type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> *) (l :: Either a b) = IsLeft l
type Apply (Compare_6989586621679551161Sym1 l1 :: TyFun (Either a b) Ordering -> *) (l2 :: Either a b)
Instance details type Apply (Compare_6989586621679551161Sym1 l1 :: TyFun (Either a b) Ordering -> *) (l2 :: Either a b) = Compare_6989586621679551161 l1 l2
type Apply (Either_Sym2 l1 l2 :: TyFun (Either a b) c -> *) (l3 :: Either a b)
Instance details type Apply (Either_Sym2 l1 l2 :: TyFun (Either a b) c -> *) (l3 :: Either a b) = Either_ l1 l2 l3
type Apply (Compare_6989586621679551161Sym0 :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun (Either a6989586621679081252 b6989586621679081253) Ordering -> Type) -> *) (l :: Either a6989586621679081252 b6989586621679081253)
Instance details type Apply (Compare_6989586621679551161Sym0 :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun (Either a6989586621679081252 b6989586621679081253) Ordering -> Type) -> *) (l :: Either a6989586621679081252 b6989586621679081253) = Compare_6989586621679551161Sym1 l
type Apply (Either_Sym0 :: TyFun (TyFun a6989586621680059832 c6989586621680059833 -> Type) (TyFun (TyFun b6989586621680059834 c6989586621680059833 -> Type) (TyFun (Either a6989586621680059832 b6989586621680059834) c6989586621680059833 -> Type) -> Type) -> *) (l :: TyFun a6989586621680059832 c6989586621680059833 -> Type)
Instance details type Apply (Either_Sym0 :: TyFun (TyFun a6989586621680059832 c6989586621680059833 -> Type) (TyFun (TyFun b6989586621680059834 c6989586621680059833 -> Type) (TyFun (Either a6989586621680059832 b6989586621680059834) c6989586621680059833 -> Type) -> Type) -> ) (l :: TyFun a6989586621680059832 c6989586621680059833 -> Type) = (Either_Sym1 l :: TyFun (TyFun b6989586621680059834 c6989586621680059833 -> Type) (TyFun (Either a6989586621680059832 b6989586621680059834) c6989586621680059833 -> Type) -> )
type Apply (ShowsPrec_6989586621679887937Sym1 l1 :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun Symbol Symbol -> Type) -> *) (l2 :: Either a6989586621679081252 b6989586621679081253)
Instance details type Apply (ShowsPrec_6989586621679887937Sym1 l1 :: TyFun (Either a6989586621679081252 b6989586621679081253) (TyFun Symbol Symbol -> Type) -> *) (l2 :: Either a6989586621679081252 b6989586621679081253) = ShowsPrec_6989586621679887937Sym2 l1 l2
type Apply (Either_Sym1 l1 :: TyFun (TyFun b6989586621680059834 c6989586621680059833 -> Type) (TyFun (Either a6989586621680059832 b6989586621680059834) c6989586621680059833 -> Type) -> *) (l2 :: TyFun b6989586621680059834 c6989586621680059833 -> Type)
Instance details type Apply (Either_Sym1 l1 :: TyFun (TyFun b6989586621680059834 c6989586621680059833 -> Type) (TyFun (Either a6989586621680059832 b6989586621680059834) c6989586621680059833 -> Type) -> *) (l2 :: TyFun b6989586621680059834 c6989586621680059833 -> 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

Expand

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

Expand

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

Expand

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

Expand

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

Expand

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

Creating synchronous sequential circuits

ROMs

ROMs initialised with a data file

RAM primitives with a combinational read port

BlockRAM primitives

BlockRAM primitives initialised with a data file

BlockRAM read/write conflict resolution

Utility functions

Exported modules

Synchronous signals

DataFlow interface

Datatypes

Bit vectors

Arbitrary-width numbers

Fixed point numbers

Fixed size vectors

Perfect depth trees

Annotations

Type-level natural numbers

Type-level strings

Template Haskell

Type classes

Clash

Other

Exceptions

Named types

Hidden arguments

Haskell Prelude

Examples

Examples

Examples

Examples

Examples

Examples