leancheck-0.6.3: Cholesterol-free property-based testing

Copyright(c) 2015-2017 Rudy Matela
License3-Clause BSD (see the file LICENSE)
MaintainerRudy Matela <rudy@matela.com.br>
Safe HaskellNone
LanguageHaskell2010

Test.LeanCheck.Utils.Types

Contents

Description

This module is part of LeanCheck, a simple enumerative property-based testing library.

Types to aid in property-based testing.

Synopsis

Integer types

Small-width integer types to aid in property-based testing. Sometimes it is useful to limit the possibilities of enumerated values when testing polymorphic functions, these types allow that.

The signed integer types IntN are of limited bit width N bounded by -2^(N-1) to 2^(N-1)-1. The unsigned integer types WordN are of limited bit width N bounded by 0 to 2^N-1.

Operations are closed and modulo 2^N. e.g.:

maxBound + 1      = minBound
read "2"          = -2 :: Int2
abs minBound      = minBound
negate n          = 2^N - n :: WordN

newtype Int1 #

Single-bit signed integers: -1, 0

Constructors

Int1 

Fields

Instances

Bounded Int1 # 
Enum Int1 # 

Methods

succ :: Int1 -> Int1 #

pred :: Int1 -> Int1 #

toEnum :: Int -> Int1 #

fromEnum :: Int1 -> Int #

enumFrom :: Int1 -> [Int1] #

enumFromThen :: Int1 -> Int1 -> [Int1] #

enumFromTo :: Int1 -> Int1 -> [Int1] #

enumFromThenTo :: Int1 -> Int1 -> Int1 -> [Int1] #

Eq Int1 # 

Methods

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

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

Integral Int1 # 

Methods

quot :: Int1 -> Int1 -> Int1 #

rem :: Int1 -> Int1 -> Int1 #

div :: Int1 -> Int1 -> Int1 #

mod :: Int1 -> Int1 -> Int1 #

quotRem :: Int1 -> Int1 -> (Int1, Int1) #

divMod :: Int1 -> Int1 -> (Int1, Int1) #

toInteger :: Int1 -> Integer #

Num Int1 # 

Methods

(+) :: Int1 -> Int1 -> Int1 #

(-) :: Int1 -> Int1 -> Int1 #

(*) :: Int1 -> Int1 -> Int1 #

negate :: Int1 -> Int1 #

abs :: Int1 -> Int1 #

signum :: Int1 -> Int1 #

fromInteger :: Integer -> Int1 #

Ord Int1 # 

Methods

compare :: Int1 -> Int1 -> Ordering #

(<) :: Int1 -> Int1 -> Bool #

(<=) :: Int1 -> Int1 -> Bool #

(>) :: Int1 -> Int1 -> Bool #

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

max :: Int1 -> Int1 -> Int1 #

min :: Int1 -> Int1 -> Int1 #

Read Int1 # 
Real Int1 # 

Methods

toRational :: Int1 -> Rational #

Show Int1 # 

Methods

showsPrec :: Int -> Int1 -> ShowS #

show :: Int1 -> String #

showList :: [Int1] -> ShowS #

Listable Int1 # 

Methods

tiers :: [[Int1]] #

list :: [Int1] #

ShowFunction Int1 # 

Methods

tBindings :: Int1 -> [[Binding]] #

newtype Int2 #

Two-bit signed integers: -2, -1, 0, 1

Constructors

Int2 

Fields

Instances

Bounded Int2 # 
Enum Int2 # 

Methods

succ :: Int2 -> Int2 #

pred :: Int2 -> Int2 #

toEnum :: Int -> Int2 #

fromEnum :: Int2 -> Int #

enumFrom :: Int2 -> [Int2] #

enumFromThen :: Int2 -> Int2 -> [Int2] #

enumFromTo :: Int2 -> Int2 -> [Int2] #

enumFromThenTo :: Int2 -> Int2 -> Int2 -> [Int2] #

Eq Int2 # 

Methods

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

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

Integral Int2 # 

Methods

quot :: Int2 -> Int2 -> Int2 #

rem :: Int2 -> Int2 -> Int2 #

div :: Int2 -> Int2 -> Int2 #

mod :: Int2 -> Int2 -> Int2 #

quotRem :: Int2 -> Int2 -> (Int2, Int2) #

divMod :: Int2 -> Int2 -> (Int2, Int2) #

toInteger :: Int2 -> Integer #

Num Int2 # 

Methods

(+) :: Int2 -> Int2 -> Int2 #

(-) :: Int2 -> Int2 -> Int2 #

(*) :: Int2 -> Int2 -> Int2 #

negate :: Int2 -> Int2 #

abs :: Int2 -> Int2 #

signum :: Int2 -> Int2 #

fromInteger :: Integer -> Int2 #

Ord Int2 # 

Methods

compare :: Int2 -> Int2 -> Ordering #

(<) :: Int2 -> Int2 -> Bool #

(<=) :: Int2 -> Int2 -> Bool #

(>) :: Int2 -> Int2 -> Bool #

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

max :: Int2 -> Int2 -> Int2 #

min :: Int2 -> Int2 -> Int2 #

Read Int2 # 
Real Int2 # 

Methods

toRational :: Int2 -> Rational #

Show Int2 # 

Methods

showsPrec :: Int -> Int2 -> ShowS #

show :: Int2 -> String #

showList :: [Int2] -> ShowS #

Listable Int2 # 

Methods

tiers :: [[Int2]] #

list :: [Int2] #

ShowFunction Int2 # 

Methods

tBindings :: Int2 -> [[Binding]] #

newtype Int3 #

Three-bit signed integers: -4, -3, -2, -1, 0, 1, 2, 3

Constructors

Int3 

Fields

Instances

Bounded Int3 # 
Enum Int3 # 

Methods

succ :: Int3 -> Int3 #

pred :: Int3 -> Int3 #

toEnum :: Int -> Int3 #

fromEnum :: Int3 -> Int #

enumFrom :: Int3 -> [Int3] #

enumFromThen :: Int3 -> Int3 -> [Int3] #

enumFromTo :: Int3 -> Int3 -> [Int3] #

enumFromThenTo :: Int3 -> Int3 -> Int3 -> [Int3] #

Eq Int3 # 

Methods

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

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

Integral Int3 # 

Methods

quot :: Int3 -> Int3 -> Int3 #

rem :: Int3 -> Int3 -> Int3 #

div :: Int3 -> Int3 -> Int3 #

mod :: Int3 -> Int3 -> Int3 #

quotRem :: Int3 -> Int3 -> (Int3, Int3) #

divMod :: Int3 -> Int3 -> (Int3, Int3) #

toInteger :: Int3 -> Integer #

Num Int3 # 

Methods

(+) :: Int3 -> Int3 -> Int3 #

(-) :: Int3 -> Int3 -> Int3 #

(*) :: Int3 -> Int3 -> Int3 #

negate :: Int3 -> Int3 #

abs :: Int3 -> Int3 #

signum :: Int3 -> Int3 #

fromInteger :: Integer -> Int3 #

Ord Int3 # 

Methods

compare :: Int3 -> Int3 -> Ordering #

(<) :: Int3 -> Int3 -> Bool #

(<=) :: Int3 -> Int3 -> Bool #

(>) :: Int3 -> Int3 -> Bool #

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

max :: Int3 -> Int3 -> Int3 #

min :: Int3 -> Int3 -> Int3 #

Read Int3 # 
Real Int3 # 

Methods

toRational :: Int3 -> Rational #

Show Int3 # 

Methods

showsPrec :: Int -> Int3 -> ShowS #

show :: Int3 -> String #

showList :: [Int3] -> ShowS #

Listable Int3 # 

Methods

tiers :: [[Int3]] #

list :: [Int3] #

ShowFunction Int3 # 

Methods

tBindings :: Int3 -> [[Binding]] #

newtype Int4 #

Four-bit signed integers: -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7

Constructors

Int4 

Fields

Instances

Bounded Int4 # 
Enum Int4 # 

Methods

succ :: Int4 -> Int4 #

pred :: Int4 -> Int4 #

toEnum :: Int -> Int4 #

fromEnum :: Int4 -> Int #

enumFrom :: Int4 -> [Int4] #

enumFromThen :: Int4 -> Int4 -> [Int4] #

enumFromTo :: Int4 -> Int4 -> [Int4] #

enumFromThenTo :: Int4 -> Int4 -> Int4 -> [Int4] #

Eq Int4 # 

Methods

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

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

Integral Int4 # 

Methods

quot :: Int4 -> Int4 -> Int4 #

rem :: Int4 -> Int4 -> Int4 #

div :: Int4 -> Int4 -> Int4 #

mod :: Int4 -> Int4 -> Int4 #

quotRem :: Int4 -> Int4 -> (Int4, Int4) #

divMod :: Int4 -> Int4 -> (Int4, Int4) #

toInteger :: Int4 -> Integer #

Num Int4 # 

Methods

(+) :: Int4 -> Int4 -> Int4 #

(-) :: Int4 -> Int4 -> Int4 #

(*) :: Int4 -> Int4 -> Int4 #

negate :: Int4 -> Int4 #

abs :: Int4 -> Int4 #

signum :: Int4 -> Int4 #

fromInteger :: Integer -> Int4 #

Ord Int4 # 

Methods

compare :: Int4 -> Int4 -> Ordering #

(<) :: Int4 -> Int4 -> Bool #

(<=) :: Int4 -> Int4 -> Bool #

(>) :: Int4 -> Int4 -> Bool #

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

max :: Int4 -> Int4 -> Int4 #

min :: Int4 -> Int4 -> Int4 #

Read Int4 # 
Real Int4 # 

Methods

toRational :: Int4 -> Rational #

Show Int4 # 

Methods

showsPrec :: Int -> Int4 -> ShowS #

show :: Int4 -> String #

showList :: [Int4] -> ShowS #

Listable Int4 # 

Methods

tiers :: [[Int4]] #

list :: [Int4] #

ShowFunction Int4 # 

Methods

tBindings :: Int4 -> [[Binding]] #

newtype Word1 #

Single-bit unsigned integer: 0, 1

Constructors

Word1 

Fields

Instances

Bounded Word1 # 
Enum Word1 # 
Eq Word1 # 

Methods

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

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

Integral Word1 # 
Num Word1 # 
Ord Word1 # 

Methods

compare :: Word1 -> Word1 -> Ordering #

(<) :: Word1 -> Word1 -> Bool #

(<=) :: Word1 -> Word1 -> Bool #

(>) :: Word1 -> Word1 -> Bool #

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

max :: Word1 -> Word1 -> Word1 #

min :: Word1 -> Word1 -> Word1 #

Read Word1 # 
Real Word1 # 

Methods

toRational :: Word1 -> Rational #

Show Word1 # 

Methods

showsPrec :: Int -> Word1 -> ShowS #

show :: Word1 -> String #

showList :: [Word1] -> ShowS #

Listable Word1 # 

Methods

tiers :: [[Word1]] #

list :: [Word1] #

ShowFunction Word1 # 

Methods

tBindings :: Word1 -> [[Binding]] #

newtype Word2 #

Two-bit unsigned integers: 0, 1, 2, 3

Constructors

Word2 

Fields

Instances

Bounded Word2 # 
Enum Word2 # 
Eq Word2 # 

Methods

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

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

Integral Word2 # 
Num Word2 # 
Ord Word2 # 

Methods

compare :: Word2 -> Word2 -> Ordering #

(<) :: Word2 -> Word2 -> Bool #

(<=) :: Word2 -> Word2 -> Bool #

(>) :: Word2 -> Word2 -> Bool #

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

max :: Word2 -> Word2 -> Word2 #

min :: Word2 -> Word2 -> Word2 #

Read Word2 # 
Real Word2 # 

Methods

toRational :: Word2 -> Rational #

Show Word2 # 

Methods

showsPrec :: Int -> Word2 -> ShowS #

show :: Word2 -> String #

showList :: [Word2] -> ShowS #

Listable Word2 # 

Methods

tiers :: [[Word2]] #

list :: [Word2] #

ShowFunction Word2 # 

Methods

tBindings :: Word2 -> [[Binding]] #

newtype Word3 #

Three-bit unsigned integers: 0, 1, 2, 3, 4, 5, 6, 7

Constructors

Word3 

Fields

Instances

Bounded Word3 # 
Enum Word3 # 
Eq Word3 # 

Methods

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

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

Integral Word3 # 
Num Word3 # 
Ord Word3 # 

Methods

compare :: Word3 -> Word3 -> Ordering #

(<) :: Word3 -> Word3 -> Bool #

(<=) :: Word3 -> Word3 -> Bool #

(>) :: Word3 -> Word3 -> Bool #

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

max :: Word3 -> Word3 -> Word3 #

min :: Word3 -> Word3 -> Word3 #

Read Word3 # 
Real Word3 # 

Methods

toRational :: Word3 -> Rational #

Show Word3 # 

Methods

showsPrec :: Int -> Word3 -> ShowS #

show :: Word3 -> String #

showList :: [Word3] -> ShowS #

Listable Word3 # 

Methods

tiers :: [[Word3]] #

list :: [Word3] #

ShowFunction Word3 # 

Methods

tBindings :: Word3 -> [[Binding]] #

newtype Word4 #

Four-bit unsigned integers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

Constructors

Word4 

Fields

Instances

Bounded Word4 # 
Enum Word4 # 
Eq Word4 # 

Methods

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

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

Integral Word4 # 
Num Word4 # 
Ord Word4 # 

Methods

compare :: Word4 -> Word4 -> Ordering #

(<) :: Word4 -> Word4 -> Bool #

(<=) :: Word4 -> Word4 -> Bool #

(>) :: Word4 -> Word4 -> Bool #

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

max :: Word4 -> Word4 -> Word4 #

min :: Word4 -> Word4 -> Word4 #

Read Word4 # 
Real Word4 # 

Methods

toRational :: Word4 -> Rational #

Show Word4 # 

Methods

showsPrec :: Int -> Word4 -> ShowS #

show :: Word4 -> String #

showList :: [Word4] -> ShowS #

Listable Word4 # 

Methods

tiers :: [[Word4]] #

list :: [Word4] #

ShowFunction Word4 # 

Methods

tBindings :: Word4 -> [[Binding]] #

newtype Nat #

Natural numbers (including 0): 0, 1, 2, 3, 4, 5, 6, 7, ...

Internally, this type is represented as an Int. So, it is limited by the maxBound of Int.

Constructors

Nat 

Fields

Instances

Enum Nat # 

Methods

succ :: Nat -> Nat #

pred :: Nat -> Nat #

toEnum :: Int -> Nat #

fromEnum :: Nat -> Int #

enumFrom :: Nat -> [Nat] #

enumFromThen :: Nat -> Nat -> [Nat] #

enumFromTo :: Nat -> Nat -> [Nat] #

enumFromThenTo :: Nat -> Nat -> Nat -> [Nat] #

Eq Nat # 

Methods

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

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

Integral Nat # 

Methods

quot :: Nat -> Nat -> Nat #

rem :: Nat -> Nat -> Nat #

div :: Nat -> Nat -> Nat #

mod :: Nat -> Nat -> Nat #

quotRem :: Nat -> Nat -> (Nat, Nat) #

divMod :: Nat -> Nat -> (Nat, Nat) #

toInteger :: Nat -> Integer #

Num Nat # 

Methods

(+) :: Nat -> Nat -> Nat #

(-) :: Nat -> Nat -> Nat #

(*) :: Nat -> Nat -> Nat #

negate :: Nat -> Nat #

abs :: Nat -> Nat #

signum :: Nat -> Nat #

fromInteger :: Integer -> Nat #

Ord Nat # 

Methods

compare :: Nat -> Nat -> Ordering #

(<) :: Nat -> Nat -> Bool #

(<=) :: Nat -> Nat -> Bool #

(>) :: Nat -> Nat -> Bool #

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

max :: Nat -> Nat -> Nat #

min :: Nat -> Nat -> Nat #

Read Nat # 
Real Nat # 

Methods

toRational :: Nat -> Rational #

Show Nat # 

Methods

showsPrec :: Int -> Nat -> ShowS #

show :: Nat -> String #

showList :: [Nat] -> ShowS #

Listable Nat # 

Methods

tiers :: [[Nat]] #

list :: [Nat] #

ShowFunction Nat # 

Methods

tBindings :: Nat -> [[Binding]] #

CoListable Nat # 

Methods

cotiers :: [[b]] -> [[Nat -> b]] #

FunListable Nat # 

Methods

validResults :: Nat -> [b] -> Bool #

invalidResults :: Nat -> [b] -> Bool #

funtiers :: [[(Int, [b] -> Nat -> b)]] #

newtype Nat1 #

Natural numbers modulo 1: 0

Constructors

Nat1 

Fields

Instances

Bounded Nat1 # 
Enum Nat1 # 

Methods

succ :: Nat1 -> Nat1 #

pred :: Nat1 -> Nat1 #

toEnum :: Int -> Nat1 #

fromEnum :: Nat1 -> Int #

enumFrom :: Nat1 -> [Nat1] #

enumFromThen :: Nat1 -> Nat1 -> [Nat1] #

enumFromTo :: Nat1 -> Nat1 -> [Nat1] #

enumFromThenTo :: Nat1 -> Nat1 -> Nat1 -> [Nat1] #

Eq Nat1 # 

Methods

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

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

Integral Nat1 # 

Methods

quot :: Nat1 -> Nat1 -> Nat1 #

rem :: Nat1 -> Nat1 -> Nat1 #

div :: Nat1 -> Nat1 -> Nat1 #

mod :: Nat1 -> Nat1 -> Nat1 #

quotRem :: Nat1 -> Nat1 -> (Nat1, Nat1) #

divMod :: Nat1 -> Nat1 -> (Nat1, Nat1) #

toInteger :: Nat1 -> Integer #

Num Nat1 # 

Methods

(+) :: Nat1 -> Nat1 -> Nat1 #

(-) :: Nat1 -> Nat1 -> Nat1 #

(*) :: Nat1 -> Nat1 -> Nat1 #

negate :: Nat1 -> Nat1 #

abs :: Nat1 -> Nat1 #

signum :: Nat1 -> Nat1 #

fromInteger :: Integer -> Nat1 #

Ord Nat1 # 

Methods

compare :: Nat1 -> Nat1 -> Ordering #

(<) :: Nat1 -> Nat1 -> Bool #

(<=) :: Nat1 -> Nat1 -> Bool #

(>) :: Nat1 -> Nat1 -> Bool #

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

max :: Nat1 -> Nat1 -> Nat1 #

min :: Nat1 -> Nat1 -> Nat1 #

Read Nat1 # 
Real Nat1 # 

Methods

toRational :: Nat1 -> Rational #

Show Nat1 # 

Methods

showsPrec :: Int -> Nat1 -> ShowS #

show :: Nat1 -> String #

showList :: [Nat1] -> ShowS #

Listable Nat1 # 

Methods

tiers :: [[Nat1]] #

list :: [Nat1] #

ShowFunction Nat1 # 

Methods

tBindings :: Nat1 -> [[Binding]] #

newtype Nat2 #

Natural numbers modulo 2: 0, 1

Constructors

Nat2 

Fields

Instances

Bounded Nat2 # 
Enum Nat2 # 

Methods

succ :: Nat2 -> Nat2 #

pred :: Nat2 -> Nat2 #

toEnum :: Int -> Nat2 #

fromEnum :: Nat2 -> Int #

enumFrom :: Nat2 -> [Nat2] #

enumFromThen :: Nat2 -> Nat2 -> [Nat2] #

enumFromTo :: Nat2 -> Nat2 -> [Nat2] #

enumFromThenTo :: Nat2 -> Nat2 -> Nat2 -> [Nat2] #

Eq Nat2 # 

Methods

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

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

Integral Nat2 # 

Methods

quot :: Nat2 -> Nat2 -> Nat2 #

rem :: Nat2 -> Nat2 -> Nat2 #

div :: Nat2 -> Nat2 -> Nat2 #

mod :: Nat2 -> Nat2 -> Nat2 #

quotRem :: Nat2 -> Nat2 -> (Nat2, Nat2) #

divMod :: Nat2 -> Nat2 -> (Nat2, Nat2) #

toInteger :: Nat2 -> Integer #

Num Nat2 # 

Methods

(+) :: Nat2 -> Nat2 -> Nat2 #

(-) :: Nat2 -> Nat2 -> Nat2 #

(*) :: Nat2 -> Nat2 -> Nat2 #

negate :: Nat2 -> Nat2 #

abs :: Nat2 -> Nat2 #

signum :: Nat2 -> Nat2 #

fromInteger :: Integer -> Nat2 #

Ord Nat2 # 

Methods

compare :: Nat2 -> Nat2 -> Ordering #

(<) :: Nat2 -> Nat2 -> Bool #

(<=) :: Nat2 -> Nat2 -> Bool #

(>) :: Nat2 -> Nat2 -> Bool #

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

max :: Nat2 -> Nat2 -> Nat2 #

min :: Nat2 -> Nat2 -> Nat2 #

Read Nat2 # 
Real Nat2 # 

Methods

toRational :: Nat2 -> Rational #

Show Nat2 # 

Methods

showsPrec :: Int -> Nat2 -> ShowS #

show :: Nat2 -> String #

showList :: [Nat2] -> ShowS #

Listable Nat2 # 

Methods

tiers :: [[Nat2]] #

list :: [Nat2] #

ShowFunction Nat2 # 

Methods

tBindings :: Nat2 -> [[Binding]] #

CoListable Nat2 # 

Methods

cotiers :: [[b]] -> [[Nat2 -> b]] #

FunListable Nat2 # 

Methods

validResults :: Nat2 -> [b] -> Bool #

invalidResults :: Nat2 -> [b] -> Bool #

funtiers :: [[(Int, [b] -> Nat2 -> b)]] #

newtype Nat3 #

Natural numbers modulo 3: 0, 1, 2

Constructors

Nat3 

Fields

Instances

Bounded Nat3 # 
Enum Nat3 # 

Methods

succ :: Nat3 -> Nat3 #

pred :: Nat3 -> Nat3 #

toEnum :: Int -> Nat3 #

fromEnum :: Nat3 -> Int #

enumFrom :: Nat3 -> [Nat3] #

enumFromThen :: Nat3 -> Nat3 -> [Nat3] #

enumFromTo :: Nat3 -> Nat3 -> [Nat3] #

enumFromThenTo :: Nat3 -> Nat3 -> Nat3 -> [Nat3] #

Eq Nat3 # 

Methods

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

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

Integral Nat3 # 

Methods

quot :: Nat3 -> Nat3 -> Nat3 #

rem :: Nat3 -> Nat3 -> Nat3 #

div :: Nat3 -> Nat3 -> Nat3 #

mod :: Nat3 -> Nat3 -> Nat3 #

quotRem :: Nat3 -> Nat3 -> (Nat3, Nat3) #

divMod :: Nat3 -> Nat3 -> (Nat3, Nat3) #

toInteger :: Nat3 -> Integer #

Num Nat3 # 

Methods

(+) :: Nat3 -> Nat3 -> Nat3 #

(-) :: Nat3 -> Nat3 -> Nat3 #

(*) :: Nat3 -> Nat3 -> Nat3 #

negate :: Nat3 -> Nat3 #

abs :: Nat3 -> Nat3 #

signum :: Nat3 -> Nat3 #

fromInteger :: Integer -> Nat3 #

Ord Nat3 # 

Methods

compare :: Nat3 -> Nat3 -> Ordering #

(<) :: Nat3 -> Nat3 -> Bool #

(<=) :: Nat3 -> Nat3 -> Bool #

(>) :: Nat3 -> Nat3 -> Bool #

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

max :: Nat3 -> Nat3 -> Nat3 #

min :: Nat3 -> Nat3 -> Nat3 #

Read Nat3 # 
Real Nat3 # 

Methods

toRational :: Nat3 -> Rational #

Show Nat3 # 

Methods

showsPrec :: Int -> Nat3 -> ShowS #

show :: Nat3 -> String #

showList :: [Nat3] -> ShowS #

Listable Nat3 # 

Methods

tiers :: [[Nat3]] #

list :: [Nat3] #

ShowFunction Nat3 # 

Methods

tBindings :: Nat3 -> [[Binding]] #

CoListable Nat3 # 

Methods

cotiers :: [[b]] -> [[Nat3 -> b]] #

FunListable Nat3 # 

Methods

validResults :: Nat3 -> [b] -> Bool #

invalidResults :: Nat3 -> [b] -> Bool #

funtiers :: [[(Int, [b] -> Nat3 -> b)]] #

newtype Nat4 #

Natural numbers modulo 4: 0, 1, 2, 3

Constructors

Nat4 

Fields

Instances

Bounded Nat4 # 
Enum Nat4 # 

Methods

succ :: Nat4 -> Nat4 #

pred :: Nat4 -> Nat4 #

toEnum :: Int -> Nat4 #

fromEnum :: Nat4 -> Int #

enumFrom :: Nat4 -> [Nat4] #

enumFromThen :: Nat4 -> Nat4 -> [Nat4] #

enumFromTo :: Nat4 -> Nat4 -> [Nat4] #

enumFromThenTo :: Nat4 -> Nat4 -> Nat4 -> [Nat4] #

Eq Nat4 # 

Methods

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

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

Integral Nat4 # 

Methods

quot :: Nat4 -> Nat4 -> Nat4 #

rem :: Nat4 -> Nat4 -> Nat4 #

div :: Nat4 -> Nat4 -> Nat4 #

mod :: Nat4 -> Nat4 -> Nat4 #

quotRem :: Nat4 -> Nat4 -> (Nat4, Nat4) #

divMod :: Nat4 -> Nat4 -> (Nat4, Nat4) #

toInteger :: Nat4 -> Integer #

Num Nat4 # 

Methods

(+) :: Nat4 -> Nat4 -> Nat4 #

(-) :: Nat4 -> Nat4 -> Nat4 #

(*) :: Nat4 -> Nat4 -> Nat4 #

negate :: Nat4 -> Nat4 #

abs :: Nat4 -> Nat4 #

signum :: Nat4 -> Nat4 #

fromInteger :: Integer -> Nat4 #

Ord Nat4 # 

Methods

compare :: Nat4 -> Nat4 -> Ordering #

(<) :: Nat4 -> Nat4 -> Bool #

(<=) :: Nat4 -> Nat4 -> Bool #

(>) :: Nat4 -> Nat4 -> Bool #

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

max :: Nat4 -> Nat4 -> Nat4 #

min :: Nat4 -> Nat4 -> Nat4 #

Read Nat4 # 
Real Nat4 # 

Methods

toRational :: Nat4 -> Rational #

Show Nat4 # 

Methods

showsPrec :: Int -> Nat4 -> ShowS #

show :: Nat4 -> String #

showList :: [Nat4] -> ShowS #

Listable Nat4 # 

Methods

tiers :: [[Nat4]] #

list :: [Nat4] #

ShowFunction Nat4 # 

Methods

tBindings :: Nat4 -> [[Binding]] #

newtype Nat5 #

Natural numbers modulo 5: 0, 1, 2, 3, 4

Constructors

Nat5 

Fields

Instances

Bounded Nat5 # 
Enum Nat5 # 

Methods

succ :: Nat5 -> Nat5 #

pred :: Nat5 -> Nat5 #

toEnum :: Int -> Nat5 #

fromEnum :: Nat5 -> Int #

enumFrom :: Nat5 -> [Nat5] #

enumFromThen :: Nat5 -> Nat5 -> [Nat5] #

enumFromTo :: Nat5 -> Nat5 -> [Nat5] #

enumFromThenTo :: Nat5 -> Nat5 -> Nat5 -> [Nat5] #

Eq Nat5 # 

Methods

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

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

Integral Nat5 # 

Methods

quot :: Nat5 -> Nat5 -> Nat5 #

rem :: Nat5 -> Nat5 -> Nat5 #

div :: Nat5 -> Nat5 -> Nat5 #

mod :: Nat5 -> Nat5 -> Nat5 #

quotRem :: Nat5 -> Nat5 -> (Nat5, Nat5) #

divMod :: Nat5 -> Nat5 -> (Nat5, Nat5) #

toInteger :: Nat5 -> Integer #

Num Nat5 # 

Methods

(+) :: Nat5 -> Nat5 -> Nat5 #

(-) :: Nat5 -> Nat5 -> Nat5 #

(*) :: Nat5 -> Nat5 -> Nat5 #

negate :: Nat5 -> Nat5 #

abs :: Nat5 -> Nat5 #

signum :: Nat5 -> Nat5 #

fromInteger :: Integer -> Nat5 #

Ord Nat5 # 

Methods

compare :: Nat5 -> Nat5 -> Ordering #

(<) :: Nat5 -> Nat5 -> Bool #

(<=) :: Nat5 -> Nat5 -> Bool #

(>) :: Nat5 -> Nat5 -> Bool #

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

max :: Nat5 -> Nat5 -> Nat5 #

min :: Nat5 -> Nat5 -> Nat5 #

Read Nat5 # 
Real Nat5 # 

Methods

toRational :: Nat5 -> Rational #

Show Nat5 # 

Methods

showsPrec :: Int -> Nat5 -> ShowS #

show :: Nat5 -> String #

showList :: [Nat5] -> ShowS #

Listable Nat5 # 

Methods

tiers :: [[Nat5]] #

list :: [Nat5] #

ShowFunction Nat5 # 

Methods

tBindings :: Nat5 -> [[Binding]] #

newtype Nat6 #

Natural numbers modulo 6: 0, 1, 2, 3, 4, 5

Constructors

Nat6 

Fields

Instances

Bounded Nat6 # 
Enum Nat6 # 

Methods

succ :: Nat6 -> Nat6 #

pred :: Nat6 -> Nat6 #

toEnum :: Int -> Nat6 #

fromEnum :: Nat6 -> Int #

enumFrom :: Nat6 -> [Nat6] #

enumFromThen :: Nat6 -> Nat6 -> [Nat6] #

enumFromTo :: Nat6 -> Nat6 -> [Nat6] #

enumFromThenTo :: Nat6 -> Nat6 -> Nat6 -> [Nat6] #

Eq Nat6 # 

Methods

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

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

Integral Nat6 # 

Methods

quot :: Nat6 -> Nat6 -> Nat6 #

rem :: Nat6 -> Nat6 -> Nat6 #

div :: Nat6 -> Nat6 -> Nat6 #

mod :: Nat6 -> Nat6 -> Nat6 #

quotRem :: Nat6 -> Nat6 -> (Nat6, Nat6) #

divMod :: Nat6 -> Nat6 -> (Nat6, Nat6) #

toInteger :: Nat6 -> Integer #

Num Nat6 # 

Methods

(+) :: Nat6 -> Nat6 -> Nat6 #

(-) :: Nat6 -> Nat6 -> Nat6 #

(*) :: Nat6 -> Nat6 -> Nat6 #

negate :: Nat6 -> Nat6 #

abs :: Nat6 -> Nat6 #

signum :: Nat6 -> Nat6 #

fromInteger :: Integer -> Nat6 #

Ord Nat6 # 

Methods

compare :: Nat6 -> Nat6 -> Ordering #

(<) :: Nat6 -> Nat6 -> Bool #

(<=) :: Nat6 -> Nat6 -> Bool #

(>) :: Nat6 -> Nat6 -> Bool #

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

max :: Nat6 -> Nat6 -> Nat6 #

min :: Nat6 -> Nat6 -> Nat6 #

Read Nat6 # 
Real Nat6 # 

Methods

toRational :: Nat6 -> Rational #

Show Nat6 # 

Methods

showsPrec :: Int -> Nat6 -> ShowS #

show :: Nat6 -> String #

showList :: [Nat6] -> ShowS #

Listable Nat6 # 

Methods

tiers :: [[Nat6]] #

list :: [Nat6] #

ShowFunction Nat6 # 

Methods

tBindings :: Nat6 -> [[Binding]] #

newtype Nat7 #

Natural numbers modulo 7: 0, 1, 2, 3, 4, 5, 6

Constructors

Nat7 

Fields

Instances

Bounded Nat7 # 
Enum Nat7 # 

Methods

succ :: Nat7 -> Nat7 #

pred :: Nat7 -> Nat7 #

toEnum :: Int -> Nat7 #

fromEnum :: Nat7 -> Int #

enumFrom :: Nat7 -> [Nat7] #

enumFromThen :: Nat7 -> Nat7 -> [Nat7] #

enumFromTo :: Nat7 -> Nat7 -> [Nat7] #

enumFromThenTo :: Nat7 -> Nat7 -> Nat7 -> [Nat7] #

Eq Nat7 # 

Methods

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

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

Integral Nat7 # 

Methods

quot :: Nat7 -> Nat7 -> Nat7 #

rem :: Nat7 -> Nat7 -> Nat7 #

div :: Nat7 -> Nat7 -> Nat7 #

mod :: Nat7 -> Nat7 -> Nat7 #

quotRem :: Nat7 -> Nat7 -> (Nat7, Nat7) #

divMod :: Nat7 -> Nat7 -> (Nat7, Nat7) #

toInteger :: Nat7 -> Integer #

Num Nat7 # 

Methods

(+) :: Nat7 -> Nat7 -> Nat7 #

(-) :: Nat7 -> Nat7 -> Nat7 #

(*) :: Nat7 -> Nat7 -> Nat7 #

negate :: Nat7 -> Nat7 #

abs :: Nat7 -> Nat7 #

signum :: Nat7 -> Nat7 #

fromInteger :: Integer -> Nat7 #

Ord Nat7 # 

Methods

compare :: Nat7 -> Nat7 -> Ordering #

(<) :: Nat7 -> Nat7 -> Bool #

(<=) :: Nat7 -> Nat7 -> Bool #

(>) :: Nat7 -> Nat7 -> Bool #

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

max :: Nat7 -> Nat7 -> Nat7 #

min :: Nat7 -> Nat7 -> Nat7 #

Read Nat7 # 
Real Nat7 # 

Methods

toRational :: Nat7 -> Rational #

Show Nat7 # 

Methods

showsPrec :: Int -> Nat7 -> ShowS #

show :: Nat7 -> String #

showList :: [Nat7] -> ShowS #

Listable Nat7 # 

Methods

tiers :: [[Nat7]] #

list :: [Nat7] #

ShowFunction Nat7 # 

Methods

tBindings :: Nat7 -> [[Binding]] #

Aliases to word types (deprecated)

type UInt1 = Word1 #

type UInt2 = Word2 #

type UInt3 = Word3 #

type UInt4 = Word4 #

Extreme Integers

newtype X a #

Constructors

X 

Fields

Instances

Eq a => Eq (X a) # 

Methods

(==) :: X a -> X a -> Bool #

(/=) :: X a -> X a -> Bool #

Ord a => Ord (X a) # 

Methods

compare :: X a -> X a -> Ordering #

(<) :: X a -> X a -> Bool #

(<=) :: X a -> X a -> Bool #

(>) :: X a -> X a -> Bool #

(>=) :: X a -> X a -> Bool #

max :: X a -> X a -> X a #

min :: X a -> X a -> X a #

Show a => Show (X a) # 

Methods

showsPrec :: Int -> X a -> ShowS #

show :: X a -> String #

showList :: [X a] -> ShowS #

(Integral a, Bounded a) => Listable (X a) # 

Methods

tiers :: [[X a]] #

list :: [X a] #

List-wrapper types

newtype NoDup a #

Constructors

NoDup [a] 

Instances

Eq a => Eq (NoDup a) # 

Methods

(==) :: NoDup a -> NoDup a -> Bool #

(/=) :: NoDup a -> NoDup a -> Bool #

Ord a => Ord (NoDup a) # 

Methods

compare :: NoDup a -> NoDup a -> Ordering #

(<) :: NoDup a -> NoDup a -> Bool #

(<=) :: NoDup a -> NoDup a -> Bool #

(>) :: NoDup a -> NoDup a -> Bool #

(>=) :: NoDup a -> NoDup a -> Bool #

max :: NoDup a -> NoDup a -> NoDup a #

min :: NoDup a -> NoDup a -> NoDup a #

Read a => Read (NoDup a) # 
Show a => Show (NoDup a) # 

Methods

showsPrec :: Int -> NoDup a -> ShowS #

show :: NoDup a -> String #

showList :: [NoDup a] -> ShowS #

Listable a => Listable (NoDup a) # 

Methods

tiers :: [[NoDup a]] #

list :: [NoDup a] #

newtype Bag a #

Constructors

Bag [a] 

Instances

Eq a => Eq (Bag a) # 

Methods

(==) :: Bag a -> Bag a -> Bool #

(/=) :: Bag a -> Bag a -> Bool #

Ord a => Ord (Bag a) # 

Methods

compare :: Bag a -> Bag a -> Ordering #

(<) :: Bag a -> Bag a -> Bool #

(<=) :: Bag a -> Bag a -> Bool #

(>) :: Bag a -> Bag a -> Bool #

(>=) :: Bag a -> Bag a -> Bool #

max :: Bag a -> Bag a -> Bag a #

min :: Bag a -> Bag a -> Bag a #

Read a => Read (Bag a) # 
Show a => Show (Bag a) # 

Methods

showsPrec :: Int -> Bag a -> ShowS #

show :: Bag a -> String #

showList :: [Bag a] -> ShowS #

Listable a => Listable (Bag a) # 

Methods

tiers :: [[Bag a]] #

list :: [Bag a] #

newtype Set a #

Constructors

Set [a] 

Instances

Eq a => Eq (Set a) # 

Methods

(==) :: Set a -> Set a -> Bool #

(/=) :: Set a -> Set a -> Bool #

Ord a => Ord (Set a) # 

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 #

Read a => Read (Set a) # 
Show a => Show (Set a) # 

Methods

showsPrec :: Int -> Set a -> ShowS #

show :: Set a -> String #

showList :: [Set a] -> ShowS #

Listable a => Listable (Set a) # 

Methods

tiers :: [[Set a]] #

list :: [Set a] #