clash-prelude-0.99.1: CAES Language for Synchronous Hardware - Prelude library

Copyright(C) 2013-2016 University of Twente
2017 Myrtle Software Ltd Google Inc.
LicenseBSD2 (see the file LICENSE)
MaintainerChristiaan Baaij <christiaan.baaij@gmail.com>
Safe HaskellSafe
LanguageHaskell2010
Extensions
  • DataKinds
  • FlexibleContexts
  • TypeOperators
  • ExplicitNamespaces

Clash.Prelude.Safe

Contents

Description

This is the Safe API only of Clash.Prelude

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:

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

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:

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:

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:

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:

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.

Additional helpful information:

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

Additional helpful information:

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

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

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

Type classes

Clash

Other

module Data.Bits

Exceptions

Named types

Hidden arguments

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

Since: 2.1

Instance details
Bounded Int

Since: 2.1

Instance details

Methods

minBound :: Int #

maxBound :: Int #

Bounded Int8

Since: 2.1

Instance details
Bounded Int16

Since: 2.1

Instance details
Bounded Int32

Since: 2.1

Instance details
Bounded Int64

Since: 2.1

Instance details
Bounded Ordering

Since: 2.1

Instance details
Bounded Word

Since: 2.1

Instance details
Bounded Word8

Since: 2.1

Instance details
Bounded Word16

Since: 2.1

Instance details
Bounded Word32

Since: 2.1

Instance details
Bounded Word64

Since: 2.1

Instance details
Bounded VecCount

Since: 4.10.0.0

Instance details
Bounded VecElem

Since: 4.10.0.0

Instance details
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
Bounded SourceUnpackedness 
Instance details
Bounded SourceStrictness 
Instance details
Bounded DecidedStrictness 
Instance details
Bounded CChar 
Instance details
Bounded CSChar 
Instance details
Bounded CUChar 
Instance details
Bounded CShort 
Instance details
Bounded CUShort 
Instance details
Bounded CInt 
Instance details
Bounded CUInt 
Instance details
Bounded CLong 
Instance details
Bounded CULong 
Instance details
Bounded CLLong 
Instance details
Bounded CULLong 
Instance details
Bounded CBool 
Instance details
Bounded CPtrdiff 
Instance details
Bounded CSize 
Instance details
Bounded CWchar 
Instance details
Bounded CSigAtomic 
Instance details
Bounded CIntPtr 
Instance details
Bounded CUIntPtr 
Instance details
Bounded CIntMax 
Instance details
Bounded CUIntMax 
Instance details
Bounded GeneralCategory 
Instance details
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
Bounded a => Bounded (Identity a) 
Instance details
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
KnownNat n => Bounded (BitVector n) # 
Instance details
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
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:

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

Since: 2.1

Instance details
Enum Int64

Since: 2.1

Instance details
Enum Integer

Since: 2.1

Instance details
Enum Natural

Since: 4.8.0.0

Instance details
Enum Ordering

Since: 2.1

Instance details
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
Enum Word16

Since: 2.1

Instance details
Enum Word32

Since: 2.1

Instance details
Enum Word64

Since: 2.1

Instance details
Enum VecCount

Since: 4.10.0.0

Instance details
Enum VecElem

Since: 4.10.0.0

Instance details
Enum ()

Since: 2.1

Instance details

Methods

succ :: () -> () #

pred :: () -> () #

toEnum :: Int -> () #

fromEnum :: () -> Int #

enumFrom :: () -> [()] #

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

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

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

Enum Associativity 
Instance details
Enum SourceUnpackedness 
Instance details
Enum SourceStrictness 
Instance details
Enum DecidedStrictness 
Instance details
Enum CChar 
Instance details
Enum CSChar 
Instance details
Enum CUChar 
Instance details
Enum CShort 
Instance details
Enum CUShort 
Instance details
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
Enum CLong 
Instance details
Enum CULong 
Instance details
Enum CLLong 
Instance details
Enum CULLong 
Instance details
Enum CBool 
Instance details
Enum CFloat 
Instance details
Enum CDouble 
Instance details
Enum CPtrdiff 
Instance details
Enum CSize 
Instance details
Enum CWchar 
Instance details
Enum CSigAtomic 
Instance details
Enum CClock 
Instance details
Enum CTime 
Instance details
Enum CUSeconds 
Instance details
Enum CSUSeconds 
Instance details
Enum CIntPtr 
Instance details
Enum CUIntPtr 
Instance details
Enum CIntMax 
Instance details
Enum CUIntMax 
Instance details
Enum GeneralCategory 
Instance details
Enum Extension 
Instance details
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
Enum a => Enum (Identity a) 
Instance details
KnownNat n => Enum (BitVector n) #

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

Instance details
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
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
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
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
Eq Overlap 
Instance details

Methods

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

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

Eq DerivStrategy 
Instance details
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
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
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
Eq BlockReason 
Instance details
Eq ThreadStatus 
Instance details
Eq AsyncException 
Instance details
Eq ArrayException 
Instance details
Eq ExitCode 
Instance details
Eq IOErrorType

Since: 4.1.0.0

Instance details
Eq MaskingState 
Instance details
Eq IOException

Since: 4.1.0.0

Instance details
Eq ErrorCall 
Instance details
Eq ArithException 
Instance details
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
Eq SourceUnpackedness 
Instance details
Eq SourceStrictness 
Instance details
Eq DecidedStrictness 
Instance details
Eq SomeSymbol

Since: 4.7.0.0

Instance details
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
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
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
Eq CSUSeconds 
Instance details
Eq CIntPtr 
Instance details

Methods

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

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

Eq CUIntPtr 
Instance details
Eq CIntMax 
Instance details

Methods

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

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

Eq CUIntMax 
Instance details
Eq Fingerprint 
Instance details
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
Eq SrcLoc 
Instance details

Methods

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

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

Eq ByteString 
Instance details
Eq ByteString 
Instance details
Eq IntSet 
Instance details

Methods

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

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

Eq TyVarBndr 
Instance details
Eq Extension 
Instance details
Eq ForeignSrcLang 
Instance details
Eq Doc 
Instance details

Methods

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

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

Eq TextDetails 
Instance details
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
Eq NameSpace 
Instance details
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
Eq Fixity 
Instance details

Methods

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

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

Eq FixityDirection 
Instance details
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
Eq TypeFamilyHead 
Instance details
Eq TySynEqn 
Instance details
Eq Foreign 
Instance details

Methods

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

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

Eq Callconv 
Instance details
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
Eq Phases 
Instance details

Methods

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

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

Eq RuleBndr 
Instance details
Eq AnnTarget 
Instance details
Eq SourceUnpackedness 
Instance details
Eq SourceStrictness 
Instance details
Eq DecidedStrictness 
Instance details
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
Eq PatSynArgs 
Instance details
Eq FamilyResultSig 
Instance details
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
Eq LocalTime 
Instance details
Eq UniversalTime 
Instance details
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
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
Eq ClockKind # 
Instance details
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
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
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
Floating Float

Since: 2.1

Instance details
Floating CFloat 
Instance details
Floating CDouble 
Instance details
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
(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
Fractional CDouble 
Instance details
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
(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:

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

Since: 2.1

Instance details
Integral Int64

Since: 2.1

Instance details
Integral Integer

Since: 2.0.1

Instance details
Integral Natural

Since: 4.8.0.0

Instance details
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
Integral Word16

Since: 2.1

Instance details
Integral Word32

Since: 2.1

Instance details
Integral Word64

Since: 2.1

Instance details
Integral CChar 
Instance details
Integral CSChar 
Instance details
Integral CUChar 
Instance details
Integral CShort 
Instance details
Integral CUShort 
Instance details
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
Integral CLong 
Instance details
Integral CULong 
Instance details
Integral CLLong 
Instance details
Integral CULLong 
Instance details
Integral CBool 
Instance details
Integral CPtrdiff 
Instance details
Integral CSize 
Instance details
Integral CWchar 
Instance details
Integral CSigAtomic 
Instance details
Integral CIntPtr 
Instance details
Integral CUIntPtr 
Instance details
Integral CIntMax 
Instance details
Integral CUIntMax 
Instance details
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
KnownNat n => Integral (BitVector n) # 
Instance details
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
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:

Furthermore, the Monad and Applicative operations should relate as follows:

The above laws imply:

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

Since: 2.1

Instance details
Num Int64

Since: 2.1

Instance details
Num Integer

Since: 2.1

Instance details
Num Natural

Since: 4.8.0.0

Instance details
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
Num Word16

Since: 2.1

Instance details
Num Word32

Since: 2.1

Instance details
Num Word64

Since: 2.1

Instance details
Num CChar 
Instance details
Num CSChar 
Instance details
Num CUChar 
Instance details
Num CShort 
Instance details
Num CUShort 
Instance details
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
Num CLong 
Instance details
Num CULong 
Instance details
Num CLLong 
Instance details
Num CULLong 
Instance details
Num CBool 
Instance details
Num CFloat 
Instance details
Num CDouble 
Instance details
Num CPtrdiff 
Instance details
Num CSize 
Instance details
Num CWchar 
Instance details
Num CSigAtomic 
Instance details
Num CClock 
Instance details
Num CTime 
Instance details
Num CUSeconds 
Instance details
Num CSUSeconds 
Instance details
Num CIntPtr 
Instance details
Num CUIntPtr 
Instance details
Num CIntMax 
Instance details
Num CUIntMax 
Instance details
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
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
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
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:

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
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
Ord Natural 
Instance details
Ord Ordering 
Instance details
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
Ord Word32

Since: 2.1

Instance details
Ord Word64

Since: 2.1

Instance details
Ord SomeTypeRep 
Instance details
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
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
Ord InjectivityAnn 
Instance details
Ord Overlap 
Instance details
Ord DerivStrategy 
Instance details
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
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
Ord Version

Since: 2.1

Instance details
Ord ThreadId

Since: 4.2.0.0

Instance details
Ord BlockReason 
Instance details
Ord ThreadStatus 
Instance details
Ord AsyncException 
Instance details
Ord ArrayException 
Instance details
Ord ExitCode 
Instance details
Ord ErrorCall 
Instance details
Ord ArithException 
Instance details
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
Ord Associativity 
Instance details
Ord SourceUnpackedness 
Instance details
Ord SourceStrictness 
Instance details
Ord DecidedStrictness 
Instance details
Ord SomeSymbol

Since: 4.7.0.0

Instance details
Ord SomeNat

Since: 4.7.0.0

Instance details
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
Ord CUChar 
Instance details
Ord CShort 
Instance details
Ord CUShort 
Instance details
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
Ord CLLong 
Instance details
Ord CULLong 
Instance details
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
Ord CDouble 
Instance details
Ord CPtrdiff 
Instance details
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
Ord CSigAtomic 
Instance details
Ord CClock 
Instance details
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
Ord CSUSeconds 
Instance details
Ord CIntPtr 
Instance details
Ord CUIntPtr 
Instance details
Ord CIntMax 
Instance details
Ord CUIntMax 
Instance details
Ord Fingerprint 
Instance details
Ord GeneralCategory 
Instance details
Ord ByteString 
Instance details
Ord ByteString 
Instance details
Ord IntSet 
Instance details
Ord TyVarBndr 
Instance details
Ord ModName 
Instance details
Ord PkgName 
Instance details
Ord Module 
Instance details
Ord OccName 
Instance details
Ord NameFlavour 
Instance details
Ord NameSpace 
Instance details
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
Ord Fixity 
Instance details
Ord FixityDirection 
Instance details
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
Ord TypeFamilyHead 
Instance details
Ord TySynEqn 
Instance details
Ord Foreign 
Instance details
Ord Callconv 
Instance details
Ord Safety 
Instance details
Ord Pragma 
Instance details
Ord Inline 
Instance details
Ord RuleMatch 
Instance details
Ord Phases 
Instance details
Ord RuleBndr 
Instance details
Ord AnnTarget 
Instance details
Ord SourceUnpackedness 
Instance details
Ord SourceStrictness 
Instance details
Ord DecidedStrictness 
Instance details
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
Ord PatSynArgs 
Instance details
Ord FamilyResultSig 
Instance details
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
Ord LocalTime 
Instance details
Ord UniversalTime 
Instance details
Ord UTCTime 
Instance details
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
Ord ClockKind # 
Instance details
() :=> (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
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
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:

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

Since: 2.1

Instance details
Read Double

Since: 2.1

Instance details
Read Float

Since: 2.1

Instance details
Read Int

Since: 2.1

Instance details
Read Int8

Since: 2.1

Instance details
Read Int16

Since: 2.1

Instance details
Read Int32

Since: 2.1

Instance details
Read Int64

Since: 2.1

Instance details
Read Integer

Since: 2.1

Instance details
Read Natural

Since: 4.8.0.0

Instance details
Read Ordering

Since: 2.1

Instance details
Read Word

Since: 4.5.0.0

Instance details
Read Word8

Since: 2.1

Instance details
Read Word16

Since: 2.1

Instance details
Read Word32

Since: 2.1

Instance details
Read Word64

Since: 2.1

Instance details
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
Read Version 
Instance details
Read ExitCode 
Instance details
Read All 
Instance details
Read Any 
Instance details
Read Fixity 
Instance details
Read Associativity 
Instance details
Read SourceUnpackedness 
Instance details
Read SourceStrictness 
Instance details
Read DecidedStrictness 
Instance details
Read SomeSymbol

Since: 4.7.0.0

Instance details
Read SomeNat

Since: 4.7.0.0

Instance details
Read CChar 
Instance details
Read CSChar 
Instance details
Read CUChar 
Instance details
Read CShort 
Instance details
Read CUShort 
Instance details
Read CInt 
Instance details
Read CUInt 
Instance details
Read CLong 
Instance details
Read CULong 
Instance details
Read CLLong 
Instance details
Read CULLong 
Instance details
Read CBool 
Instance details
Read CFloat 
Instance details
Read CDouble 
Instance details
Read CPtrdiff 
Instance details
Read CSize 
Instance details
Read CWchar 
Instance details
Read CSigAtomic 
Instance details
Read CClock 
Instance details
Read CTime 
Instance details
Read CUSeconds 
Instance details
Read CSUSeconds 
Instance details
Read CIntPtr 
Instance details
Read CUIntPtr 
Instance details
Read CIntMax 
Instance details
Read CUIntMax 
Instance details
Read Lexeme

Since: 2.1

Instance details
Read GeneralCategory 
Instance details
Read ByteString 
Instance details
Read ByteString 
Instance details
Read IntSet 
Instance details
Read Primitive # 
Instance details
Read HDL # 
Instance details
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
(Integral a, Read a) => Read (Ratio a)

Since: 2.1

Instance details
Read p => Read (Par1 p) 
Instance details
Read a => Read (Complex a) 
Instance details
HasResolution a => Read (Fixed a)

Since: 4.3.0.0

Instance details
Read a => Read (Min a) 
Instance details
Read a => Read (Max a) 
Instance details
Read a => Read (First a) 
Instance details
Read a => Read (Last a) 
Instance details
Read m => Read (WrappedMonoid m) 
Instance details
Read a => Read (Option a) 
Instance details
Read a => Read (ZipList a) 
Instance details
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
Read a => Read (First a) 
Instance details
Read a => Read (Last a) 
Instance details
Read a => Read (Dual a) 
Instance details
Read a => Read (Sum a) 
Instance details
Read a => Read (Product a) 
Instance details
Read a => Read (Down a)

Since: 4.7.0.0

Instance details
Read a => Read (NonEmpty a) 
Instance details
Read e => Read (IntMap e) 
Instance details
Read a => Read (Tree a) 
Instance details
Read a => Read (Seq a) 
Instance details
Read a => Read (ViewL a) 
Instance details
Read a => Read (ViewR a) 
Instance details
(Read a, Ord a) => Read (Set a) 
Instance details
KnownNat n => Read (Index n) #

None of the Read class' methods are synthesisable.

Instance details
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
KnownNat n => Read (Signed n) #

None of the Read class' methods are synthesisable.

Instance details
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
Read (V1 p)

Since: 4.9.0.0

Instance details
Read (U1 p)

Since: 4.9.0.0

Instance details
(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
(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
(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
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
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
Real Natural

Since: 4.8.0.0

Instance details
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
Real Word32

Since: 2.1

Instance details
Real Word64

Since: 2.1

Instance details
Real CChar 
Instance details

Methods

toRational :: CChar -> Rational #

Real CSChar 
Instance details
Real CUChar 
Instance details
Real CShort 
Instance details
Real CUShort 
Instance details
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
Real CLLong 
Instance details
Real CULLong 
Instance details
Real CBool 
Instance details

Methods

toRational :: CBool -> Rational #

Real CFloat 
Instance details
Real CDouble 
Instance details
Real CPtrdiff 
Instance details
Real CSize 
Instance details

Methods

toRational :: CSize -> Rational #

Real CWchar 
Instance details
Real CSigAtomic 
Instance details
Real CClock 
Instance details
Real CTime 
Instance details

Methods

toRational :: CTime -> Rational #

Real CUSeconds 
Instance details
Real CSUSeconds 
Instance details
Real CIntPtr 
Instance details
Real CUIntPtr 
Instance details
Real CIntMax 
Instance details
Real CUIntMax 
Instance details
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
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.

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

Since: 2.1

Instance details
RealFloat CFloat 
Instance details
RealFloat CDouble 
Instance details
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
(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:

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

Since: 4.8.0.0

Instance details
Show Ordering 
Instance details
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
Show Word32

Since: 2.1

Instance details
Show Word64

Since: 2.1

Instance details
Show RuntimeRep 
Instance details
Show VecCount 
Instance details
Show VecElem 
Instance details
Show CallStack

Since: 4.9.0.0

Instance details
Show SomeTypeRep

Since: 4.10.0.0

Instance details
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
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
Show InjectivityAnn 
Instance details
Show Overlap 
Instance details
Show DerivStrategy 
Instance details
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
Show TrName

Since: 4.9.0.0

Instance details
Show KindRep 
Instance details
Show TypeLitSort 
Instance details
Show Void

Since: 4.8.0.0

Instance details

Methods

showsPrec :: Int -> Void -> ShowS #

show :: Void -> String #

showList :: [Void] -> ShowS #

Show DataType 
Instance details
Show Constr

Since: 4.0.0.0

Instance details
Show DataRep 
Instance details
Show ConstrRep 
Instance details
Show Fixity 
Instance details
Show Version 
Instance details
Show ThreadId

Since: 4.2.0.0

Instance details
Show BlockReason 
Instance details
Show ThreadStatus 
Instance details
Show BlockedIndefinitelyOnMVar

Since: 4.1.0.0

Instance details
Show BlockedIndefinitelyOnSTM

Since: 4.1.0.0

Instance details
Show Deadlock

Since: 4.1.0.0

Instance details
Show AllocationLimitExceeded

Since: 4.7.1.0

Instance details
Show CompactionFailed

Since: 4.10.0.0

Instance details
Show AssertionFailed

Since: 4.1.0.0

Instance details
Show SomeAsyncException

Since: 4.7.0.0

Instance details
Show AsyncException

Since: 4.1.0.0

Instance details
Show ArrayException

Since: 4.1.0.0

Instance details
Show FixIOException 
Instance details
Show ExitCode 
Instance details
Show IOErrorType

Since: 4.1.0.0

Instance details
Show MaskingState 
Instance details
Show IOException

Since: 4.1.0.0

Instance details
Show ErrorCall

Since: 4.0.0.0

Instance details
Show ArithException

Since: 4.0.0.0

Instance details
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
Show Associativity 
Instance details
Show SourceUnpackedness 
Instance details
Show SourceStrictness 
Instance details
Show DecidedStrictness 
Instance details
Show SomeSymbol

Since: 4.7.0.0

Instance details
Show SomeNat

Since: 4.7.0.0

Instance details
Show CChar 
Instance details

Methods

showsPrec :: Int -> CChar -> ShowS #

show :: CChar -> String #

showList :: [CChar] -> ShowS #

Show CSChar 
Instance details
Show CUChar 
Instance details
Show CShort 
Instance details
Show CUShort 
Instance details
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
Show CLLong 
Instance details
Show CULLong 
Instance details
Show CBool 
Instance details

Methods

showsPrec :: Int -> CBool -> ShowS #

show :: CBool -> String #

showList :: [CBool] -> ShowS #

Show CFloat 
Instance details
Show CDouble 
Instance details
Show CPtrdiff 
Instance details
Show CSize 
Instance details

Methods

showsPrec :: Int -> CSize -> ShowS #

show :: CSize -> String #

showList :: [CSize] -> ShowS #

Show CWchar 
Instance details
Show CSigAtomic 
Instance details
Show CClock 
Instance details
Show CTime 
Instance details

Methods

showsPrec :: Int -> CTime -> ShowS #

show :: CTime -> String #

showList :: [CTime] -> ShowS #

Show CUSeconds 
Instance details
Show CSUSeconds 
Instance details
Show CIntPtr 
Instance details
Show CUIntPtr 
Instance details
Show CIntMax 
Instance details
Show CUIntMax 
Instance details
Show Fingerprint

Since: 4.7.0.0

Instance details
Show Lexeme 
Instance details
Show Number 
Instance details
Show GeneralCategory 
Instance details
Show SomeException

Since: 3.0

Instance details
Show SrcLoc 
Instance details
Show ByteString 
Instance details
Show ByteString 
Instance details
Show IntSet 
Instance details
Show TyVarBndr 
Instance details
Show Extension 
Instance details
Show ForeignSrcLang 
Instance details
Show Doc 
Instance details

Methods

showsPrec :: Int -> Doc -> ShowS #

show :: Doc -> String #

showList :: [Doc] -> ShowS #

Show TextDetails 
Instance details
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
Show PkgName 
Instance details
Show Module 
Instance details
Show OccName 
Instance details
Show NameFlavour 
Instance details
Show NameSpace 
Instance details
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
Show Fixity 
Instance details
Show FixityDirection 
Instance details
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
Show TypeFamilyHead 
Instance details
Show TySynEqn 
Instance details
Show Foreign 
Instance details
Show Callconv 
Instance details
Show Safety 
Instance details
Show Pragma 
Instance details
Show Inline 
Instance details
Show RuleMatch 
Instance details
Show Phases 
Instance details
Show RuleBndr 
Instance details
Show AnnTarget 
Instance details
Show SourceUnpackedness 
Instance details
Show SourceStrictness 
Instance details
Show DecidedStrictness 
Instance details
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
Show PatSynArgs 
Instance details
Show FamilyResultSig 
Instance details
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
Show ZonedTime 
Instance details
Show LocalTime 
Instance details
Show Primitive # 
Instance details
Show HDL # 
Instance details

Methods

showsPrec :: Int -> HDL -> ShowS #

show :: HDL -> String #

showList :: [HDL] -> ShowS #

Show PortName # 
Instance details
Show TopEntity # 
Instance details
Show Bit # 
Instance details

Methods

showsPrec :: Int -> Bit -> ShowS #

show :: Bit -> String #

showList :: [Bit] -> ShowS #

Show XException # 
Instance details
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
Show ClockKind # 
Instance details
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
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
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
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:

As a consequence of these laws, the Functor instance for f will satisfy

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

(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, Strings 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.

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:

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:

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
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
Semigroup ByteString 
Instance details
Semigroup IntSet

Since: 0.5.7

Instance details
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
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:

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
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
Monoid ByteString 
Instance details
Monoid IntSet 
Instance details
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 e*e = e and e*s = s = s*e for all s ∈ S."

Since 4.11.0: constraint on inner a value generalised from Monoid to Semigroup.

Since: 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
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
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
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
FiniteBits Bool

Since: 4.7.0.0

Instance details
NFData Bool 
Instance details

Methods

rnf :: Bool -> () #

ShowX Bool Source # 
Instance details
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 #

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
() :=> (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
SuppressUnusedWarnings (&&@#@$$) 
Instance details
SuppressUnusedWarnings (||@#@$$) 
Instance details
SuppressUnusedWarnings Compare_6989586621679551605Sym1 
Instance details
SuppressUnusedWarnings ShowParenSym1 
Instance details
SuppressUnusedWarnings ShowsPrec_6989586621679888031Sym2 
Instance details
SuppressUnusedWarnings ShowsPrec_6989586621679888031Sym1 
Instance details
SuppressUnusedWarnings NotSym0 
Instance details
SuppressUnusedWarnings (&&@#@$) 
Instance details
SuppressUnusedWarnings (||@#@$) 
Instance details
SuppressUnusedWarnings Compare_6989586621679551605Sym0 
Instance details
SuppressUnusedWarnings ShowParenSym0 
Instance details
SuppressUnusedWarnings FromEnum_6989586621680021011Sym0 
Instance details
SuppressUnusedWarnings AndSym0 
Instance details
SuppressUnusedWarnings OrSym0 
Instance details
SuppressUnusedWarnings ToEnum_6989586621680021001Sym0 
Instance details
SuppressUnusedWarnings ShowsPrec_6989586621679888031Sym0 
Instance details
SuppressUnusedWarnings (UnionBySym2 :: (TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) -> [a6989586621679681237] -> TyFun [a6989586621679681237] [a6989586621679681237] -> *) 
Instance details
SuppressUnusedWarnings (UnionBySym1 :: (TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) -> TyFun [a6989586621679681237] (TyFun [a6989586621679681237] [a6989586621679681237] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (TakeWhileSym1 :: (TyFun a6989586621679681264 Bool -> Type) -> TyFun [a6989586621679681264] [a6989586621679681264] -> *) 
Instance details
SuppressUnusedWarnings (SpanSym1 :: (TyFun a6989586621679681261 Bool -> Type) -> TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> *) 
Instance details
SuppressUnusedWarnings (SelectSym2 :: (TyFun a6989586621679681247 Bool -> Type) -> a6989586621679681247 -> TyFun ([a6989586621679681247], [a6989586621679681247]) ([a6989586621679681247], [a6989586621679681247]) -> *) 
Instance details
SuppressUnusedWarnings (SelectSym1 :: (TyFun a6989586621679681247 Bool -> Type) -> TyFun a6989586621679681247 (TyFun ([a6989586621679681247], [a6989586621679681247]) ([a6989586621679681247], [a6989586621679681247]) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (PartitionSym1 :: (TyFun a6989586621679681248 Bool -> Type) -> TyFun [a6989586621679681248] ([a6989586621679681248], [a6989586621679681248]) -> *) 
Instance details
SuppressUnusedWarnings (NubBySym1 :: (TyFun a6989586621679681239 (TyFun a6989586621679681239 Bool -> Type) -> Type) -> TyFun [a6989586621679681239] [a6989586621679681239] -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979ZsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979ZsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979YsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979YsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979X_6989586621679690980Sym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] ([k], [k]) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979X_6989586621679690980Sym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] ([k], [k]) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886ZsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886ZsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886YsSym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] [k] -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886YsSym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] [k] -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886X_6989586621679690887Sym2 :: (TyFun k Bool -> Type) -> k -> TyFun [k] ([k], [k]) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886X_6989586621679690887Sym1 :: (TyFun k Bool -> Type) -> TyFun k (TyFun [k] ([k], [k]) -> *) -> *) 
Instance details
SuppressUnusedWarnings (IntersectBySym2 :: (TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) -> [a6989586621679681265] -> TyFun [a6989586621679681265] [a6989586621679681265] -> *) 
Instance details
SuppressUnusedWarnings (IntersectBySym1 :: (TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) -> TyFun [a6989586621679681265] (TyFun [a6989586621679681265] [a6989586621679681265] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (GroupBySym1 :: (TyFun a6989586621679681251 (TyFun a6989586621679681251 Bool -> Type) -> Type) -> TyFun [a6989586621679681251] [[a6989586621679681251]] -> *) 
Instance details
SuppressUnusedWarnings (FindSym1 :: (TyFun a6989586621679681271 Bool -> Type) -> TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> *) 
Instance details
SuppressUnusedWarnings (FindIndicesSym1 :: (TyFun a6989586621679681267 Bool -> Type) -> TyFun [a6989586621679681267] [Nat] -> *) 
Instance details
SuppressUnusedWarnings (FindIndexSym1 :: (TyFun a6989586621679681268 Bool -> Type) -> TyFun [a6989586621679681268] (Maybe Nat) -> *) 
Instance details
SuppressUnusedWarnings (FilterSym1 :: (TyFun a6989586621679681272 Bool -> Type) -> TyFun [a6989586621679681272] [a6989586621679681272] -> *) 
Instance details
SuppressUnusedWarnings (Elem_bySym2 :: (TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) -> a6989586621679681238 -> TyFun [a6989586621679681238] Bool -> *) 
Instance details
SuppressUnusedWarnings (Elem_bySym1 :: (TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) -> TyFun a6989586621679681238 (TyFun [a6989586621679681238] Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (DropWhileSym1 :: (TyFun a6989586621679681263 Bool -> Type) -> TyFun [a6989586621679681263] [a6989586621679681263] -> *) 
Instance details
SuppressUnusedWarnings (DropWhileEndSym1 :: (TyFun a6989586621679681262 Bool -> Type) -> TyFun [a6989586621679681262] [a6989586621679681262] -> *) 
Instance details
SuppressUnusedWarnings (DeleteFirstsBySym2 :: (TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) -> [a6989586621679681277] -> TyFun [a6989586621679681277] [a6989586621679681277] -> *) 
Instance details
SuppressUnusedWarnings (DeleteFirstsBySym1 :: (TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) -> TyFun [a6989586621679681277] (TyFun [a6989586621679681277] [a6989586621679681277] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (DeleteBySym2 :: (TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) -> a6989586621679681278 -> TyFun [a6989586621679681278] [a6989586621679681278] -> *) 
Instance details
SuppressUnusedWarnings (DeleteBySym1 :: (TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) -> TyFun a6989586621679681278 (TyFun [a6989586621679681278] [a6989586621679681278] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (BreakSym1 :: (TyFun a6989586621679681260 Bool -> Type) -> TyFun [a6989586621679681260] ([a6989586621679681260], [a6989586621679681260]) -> *) 
Instance details
SuppressUnusedWarnings (AnySym1 :: (TyFun a6989586621679681341 Bool -> Type) -> TyFun [a6989586621679681341] Bool -> *) 
Instance details
SuppressUnusedWarnings (AllSym1 :: (TyFun a6989586621679681342 Bool -> Type) -> TyFun [a6989586621679681342] Bool -> *) 
Instance details
SuppressUnusedWarnings (IsSuffixOfSym1 :: [a6989586621679681323] -> TyFun [a6989586621679681323] Bool -> *) 
Instance details
SuppressUnusedWarnings (IsPrefixOfSym1 :: [a6989586621679681324] -> TyFun [a6989586621679681324] Bool -> *) 
Instance details
SuppressUnusedWarnings (IsInfixOfSym1 :: [a6989586621679681322] -> TyFun [a6989586621679681322] Bool -> *) 
Instance details
SuppressUnusedWarnings (TFHelper_6989586621679544141Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *) 
Instance details
SuppressUnusedWarnings (TFHelper_6989586621679544108Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *) 
Instance details
SuppressUnusedWarnings (TFHelper_6989586621679544075Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *) 
Instance details
SuppressUnusedWarnings (TFHelper_6989586621679544042Sym1 :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679544194Scrutinee_6989586621679542855Sym1 :: k1 -> TyFun k1 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679544161Scrutinee_6989586621679542853Sym1 :: k1 -> TyFun k1 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679543995Scrutinee_6989586621679542843Sym1 :: k1 -> TyFun k1 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679543985Scrutinee_6989586621679542841Sym1 :: k1 -> TyFun k1 Bool -> *) 
Instance details
SuppressUnusedWarnings ((>@#@$$) :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *) 
Instance details
SuppressUnusedWarnings ((>=@#@$$) :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *) 
Instance details
SuppressUnusedWarnings ((<@#@$$) :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *) 
Instance details
SuppressUnusedWarnings ((<=@#@$$) :: a6989586621679542823 -> TyFun a6989586621679542823 Bool -> *) 
Instance details
SuppressUnusedWarnings (NotElemSym1 :: a6989586621679681320 -> TyFun [a6989586621679681320] Bool -> *) 
Instance details
SuppressUnusedWarnings (ElemSym1 :: a6989586621679681321 -> TyFun [a6989586621679681321] Bool -> *) 
Instance details
SuppressUnusedWarnings ((==@#@$$) :: a6989586621679532030 -> TyFun a6989586621679532030 Bool -> *) 
Instance details
SuppressUnusedWarnings ((/=@#@$$) :: a6989586621679532030 -> TyFun a6989586621679532030 Bool -> *) 
Instance details
SuppressUnusedWarnings (Bool_Sym2 :: a6989586621679529656 -> a6989586621679529656 -> TyFun Bool a6989586621679529656 -> *) 
Instance details
SuppressUnusedWarnings (Bool_Sym1 :: a6989586621679529656 -> TyFun a6989586621679529656 (TyFun Bool a6989586621679529656 -> Type) -> *) 
Instance details
SuppressUnusedWarnings (UnionBySym0 :: TyFun (TyFun a6989586621679681237 (TyFun a6989586621679681237 Bool -> Type) -> Type) (TyFun [a6989586621679681237] (TyFun [a6989586621679681237] [a6989586621679681237] -> Type) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (TakeWhileSym0 :: TyFun (TyFun a6989586621679681264 Bool -> Type) (TyFun [a6989586621679681264] [a6989586621679681264] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (SpanSym0 :: TyFun (TyFun a6989586621679681261 Bool -> Type) (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (SelectSym0 :: TyFun (TyFun a6989586621679681247 Bool -> Type) (TyFun a6989586621679681247 (TyFun ([a6989586621679681247], [a6989586621679681247]) ([a6989586621679681247], [a6989586621679681247]) -> Type) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (PartitionSym0 :: TyFun (TyFun a6989586621679681248 Bool -> Type) (TyFun [a6989586621679681248] ([a6989586621679681248], [a6989586621679681248]) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (NubBySym0 :: TyFun (TyFun a6989586621679681239 (TyFun a6989586621679681239 Bool -> Type) -> Type) (TyFun [a6989586621679681239] [a6989586621679681239] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690979X_6989586621679690980Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886ZsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886YsSym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] [k] -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690886X_6989586621679690887Sym0 :: TyFun (TyFun k Bool -> Type) (TyFun k (TyFun [k] ([k], [k]) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (IntersectBySym0 :: TyFun (TyFun a6989586621679681265 (TyFun a6989586621679681265 Bool -> Type) -> Type) (TyFun [a6989586621679681265] (TyFun [a6989586621679681265] [a6989586621679681265] -> Type) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (GroupBySym0 :: TyFun (TyFun a6989586621679681251 (TyFun a6989586621679681251 Bool -> Type) -> Type) (TyFun [a6989586621679681251] [[a6989586621679681251]] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (FindSym0 :: TyFun (TyFun a6989586621679681271 Bool -> Type) (TyFun [a6989586621679681271] (Maybe a6989586621679681271) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (FindIndicesSym0 :: TyFun (TyFun a6989586621679681267 Bool -> Type) (TyFun [a6989586621679681267] [Nat] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (FindIndexSym0 :: TyFun (TyFun a6989586621679681268 Bool -> Type) (TyFun [a6989586621679681268] (Maybe Nat) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (FilterSym0 :: TyFun (TyFun a6989586621679681272 Bool -> Type) (TyFun [a6989586621679681272] [a6989586621679681272] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (Elem_bySym0 :: TyFun (TyFun a6989586621679681238 (TyFun a6989586621679681238 Bool -> Type) -> Type) (TyFun a6989586621679681238 (TyFun [a6989586621679681238] Bool -> Type) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (DropWhileSym0 :: TyFun (TyFun a6989586621679681263 Bool -> Type) (TyFun [a6989586621679681263] [a6989586621679681263] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (DropWhileEndSym0 :: TyFun (TyFun a6989586621679681262 Bool -> Type) (TyFun [a6989586621679681262] [a6989586621679681262] -> Type) -> *) 
Instance details
SuppressUnusedWarnings (DeleteFirstsBySym0 :: TyFun (TyFun a6989586621679681277 (TyFun a6989586621679681277 Bool -> Type) -> Type) (TyFun [a6989586621679681277] (TyFun [a6989586621679681277] [a6989586621679681277] -> Type) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (DeleteBySym0 :: TyFun (TyFun a6989586621679681278 (TyFun a6989586621679681278 Bool -> Type) -> Type) (TyFun a6989586621679681278 (TyFun [a6989586621679681278] [a6989586621679681278] -> Type) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (BreakSym0 :: TyFun (TyFun a6989586621679681260 Bool -> Type) (TyFun [a6989586621679681260] ([a6989586621679681260], [a6989586621679681260]) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (AnySym0 :: TyFun (TyFun a6989586621679681341 Bool -> Type) (TyFun [a6989586621679681341] Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (AllSym0 :: TyFun (TyFun a6989586621679681342 Bool -> Type) (TyFun [a6989586621679681342] Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (NullSym0 :: TyFun [a6989586621679681358] Bool -> *) 
Instance details
SuppressUnusedWarnings (IsSuffixOfSym0 :: TyFun [a6989586621679681323] (TyFun [a6989586621679681323] Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (IsPrefixOfSym0 :: TyFun [a6989586621679681324] (TyFun [a6989586621679681324] Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (IsInfixOfSym0 :: TyFun [a6989586621679681322] (TyFun [a6989586621679681322] Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (IsNothingSym0 :: TyFun (Maybe a6989586621679647548) Bool -> *) 
Instance details
SuppressUnusedWarnings (IsJustSym0 :: TyFun (Maybe a6989586621679647549) Bool -> *) 
Instance details
SuppressUnusedWarnings (TFHelper_6989586621679544141Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (TFHelper_6989586621679544108Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (TFHelper_6989586621679544075Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (TFHelper_6989586621679544042Sym0 :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679544194Scrutinee_6989586621679542855Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679544161Scrutinee_6989586621679542853Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679543995Scrutinee_6989586621679542843Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679543985Scrutinee_6989586621679542841Sym0 :: TyFun k1 (TyFun k1 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings ((>@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings ((>=@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings ((<@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings ((<=@#@$) :: TyFun a6989586621679542823 (TyFun a6989586621679542823 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (NotElemSym0 :: TyFun a6989586621679681320 (TyFun [a6989586621679681320] Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (ElemSym0 :: TyFun a6989586621679681321 (TyFun [a6989586621679681321] Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings ((==@#@$) :: TyFun a6989586621679532030 (TyFun a6989586621679532030 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings ((/=@#@$) :: TyFun a6989586621679532030 (TyFun a6989586621679532030 Bool -> Type) -> *) 
Instance details
SuppressUnusedWarnings (Bool_Sym0 :: TyFun a6989586621679529656 (TyFun a6989586621679529656 (TyFun Bool a6989586621679529656 -> Type) -> Type) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690534NubBy'Sym3 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> k -> [k1] -> TyFun [k1] [k1] -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690534NubBy'Sym2 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> k -> TyFun [k1] ([k1] ~> [k1]) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690534NubBy'Sym1 :: (TyFun k1 (TyFun k1 Bool -> Type) -> Type) -> TyFun k (TyFun [k1] ([k1] ~> [k1]) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690626Scrutinee_6989586621679681939Sym1 :: k1 -> TyFun k Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690534NubBy'Sym0 :: TyFun (TyFun k1 (TyFun k1 Bool -> Type) -> Type) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (IsRightSym0 :: TyFun (Either a6989586621680060960 b6989586621680060961) Bool -> *) 
Instance details
SuppressUnusedWarnings (IsLeftSym0 :: TyFun (Either a6989586621680060962 b6989586621680060963) Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690626Scrutinee_6989586621679681939Sym0 :: TyFun k1 (TyFun k Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043ZsSym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043YsSym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043X_6989586621679691044Sym0 :: TyFun (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) (TyFun k1 (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679693422Sym0 :: TyFun (a6989586621679681358 ~> Bool) (TyFun k (TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043ZsSym2 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> k1 -> TyFun [a6989586621679681261] [a6989586621679681261] -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043ZsSym1 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043YsSym2 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> k1 -> TyFun [a6989586621679681261] [a6989586621679681261] -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043YsSym1 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679681261] [a6989586621679681261] -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043X_6989586621679691044Sym2 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> k1 -> TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691043X_6989586621679691044Sym1 :: (k1 ~> (TyFun a6989586621679681261 Bool -> Type)) -> TyFun k1 (TyFun [a6989586621679681261] ([a6989586621679681261], [a6989586621679681261]) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679693422Sym3 :: (a6989586621679681358 ~> Bool) -> k -> a6989586621679681358 -> TyFun [a6989586621679681358] [a6989586621679681358] -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679693422Sym2 :: (a6989586621679681358 ~> Bool) -> k -> TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> *) -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679693422Sym1 :: (a6989586621679681358 ~> Bool) -> TyFun k (TyFun a6989586621679681358 (TyFun [a6989586621679681358] [a6989586621679681358] -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym4 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> k3 -> k2 -> TyFun [k3] Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym3 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> k3 -> TyFun k2 (TyFun [k3] Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym2 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> k1 -> TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym1 :: (TyFun k3 (TyFun k3 Bool -> Type) -> Type) -> TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691889Scrutinee_6989586621679681943Sym3 :: k1 -> k3 -> k2 -> TyFun [k3] Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691889Scrutinee_6989586621679681943Sym2 :: k1 -> k3 -> TyFun k2 (TyFun [k3] Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691889Scrutinee_6989586621679681943Sym1 :: k1 -> TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690818Scrutinee_6989586621679681923Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690818Scrutinee_6989586621679681923Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690790Scrutinee_6989586621679681925Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690790Scrutinee_6989586621679681925Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690756Scrutinee_6989586621679681935Sym3 :: k1 -> k1 -> k2 -> TyFun k3 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690756Scrutinee_6989586621679681935Sym2 :: k1 -> k1 -> TyFun k2 (TyFun k3 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690756Scrutinee_6989586621679681935Sym1 :: k1 -> TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690599Scrutinee_6989586621679681941Sym2 :: k1 -> k2 -> TyFun k3 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690599Scrutinee_6989586621679681941Sym1 :: k1 -> TyFun k2 (TyFun k3 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690558Scrutinee_6989586621679681945Sym0 :: TyFun (TyFun k3 (TyFun k3 Bool -> Type) -> Type) (TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679691889Scrutinee_6989586621679681943Sym0 :: TyFun k1 (TyFun k3 (TyFun k2 (TyFun [k3] Bool -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690818Scrutinee_6989586621679681923Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690790Scrutinee_6989586621679681925Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690756Scrutinee_6989586621679681935Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679690599Scrutinee_6989586621679681941Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679693426Scrutinee_6989586621679681917Sym0 :: TyFun (k1 ~> Bool) (TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679693426Scrutinee_6989586621679681917Sym3 :: (k1 ~> Bool) -> k1 -> [a6989586621679681358] -> TyFun k Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679693426Scrutinee_6989586621679681917Sym2 :: (k1 ~> Bool) -> k1 -> TyFun [a6989586621679681358] (TyFun k Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621679693426Scrutinee_6989586621679681917Sym1 :: (k1 ~> Bool) -> TyFun k1 (TyFun [a6989586621679681358] (TyFun k Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym4 :: k1 -> k2 -> k2 -> k3 -> TyFun k4 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym3 :: k1 -> k2 -> k2 -> TyFun k3 (TyFun k4 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym2 :: k1 -> k2 -> TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym1 :: k1 -> TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002365Scrutinee_6989586621680001847Sym0 :: TyFun k1 (TyFun k2 (TyFun k2 (TyFun k3 (TyFun k4 Bool -> *) -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679692511Sym0 :: TyFun (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) (TyFun k1 (TyFun k2 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k3 Bool -> *) -> *) -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679692511Sym5 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> k1 -> k2 -> a6989586621679681341 -> [a6989586621679681341] -> TyFun k3 Bool -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679692511Sym4 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> k1 -> k2 -> a6989586621679681341 -> TyFun [a6989586621679681341] (TyFun k3 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679692511Sym3 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> k1 -> k2 -> TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k3 Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679692511Sym2 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> k1 -> TyFun k2 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k3 Bool -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Lambda_6989586621679692511Sym1 :: (k3 ~> (TyFun a6989586621679681341 Bool -> Type)) -> TyFun k1 (TyFun k2 (TyFun a6989586621679681341 (TyFun [a6989586621679681341] (TyFun k3 Bool -> *) -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym5 :: k2 -> k1 -> k2 -> k3 -> k4 -> TyFun k5 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym4 :: k2 -> k1 -> k2 -> k3 -> TyFun k4 (TyFun k5 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym3 :: k2 -> k1 -> k2 -> TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym2 :: k2 -> k1 -> TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym1 :: k2 -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym5 :: k2 -> k1 -> k2 -> k3 -> k4 -> TyFun k5 Bool -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym4 :: k2 -> k1 -> k2 -> k3 -> TyFun k4 (TyFun k5 Bool -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym3 :: k2 -> k1 -> k2 -> TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym2 :: k2 -> k1 -> TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym1 :: k2 -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680002138Scrutinee_6989586621680001861Sym0 :: TyFun k2 (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) -> *) 
Instance details
SuppressUnusedWarnings (Let6989586621680001956Scrutinee_6989586621680001871Sym0 :: TyFun k2 (TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> *) -> *) -> *) -> *) -> *) -> *) 
Instance details
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
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
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
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
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
ShowX String Source # 
Instance details
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
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 {}
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
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
Read Double

Since: 2.1

Instance details
RealFloat Double

Since: 2.1

Instance details
Lift Double 
Instance details

Methods

lift :: Double -> Q Exp #

Storable Double

Since: 2.1

Instance details
NFData Double 
Instance details

Methods

rnf :: Double -> () #

ShowX Double Source # 
Instance details
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
BitPack Double Source # 
Instance details

Associated Types

type BitSize Double :: Nat 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 {}
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
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
RealFloat Float

Since: 2.1

Instance details
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
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
BitPack Float Source # 
Instance details

Associated Types

type BitSize Float :: Nat 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 {}
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
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
NFData Int 
Instance details

Methods

rnf :: Int -> () #

ShowX Int Source # 
Instance details
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
BitPack Int Source # 
Instance details

Associated Types

type BitSize Int :: Nat 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