Generics.RepLib.Lib

A library of type-indexed functions

Available for all representable types

subtrees :: forall a. Rep a => a -> [a]

Produce all children of a datastructure with the same type. Note that subtrees is available for all representable types. For those that are not recursive datatypes, subtrees will always return the empty list. But, these trivial instances are convenient to have for the Shrink operation below.

deepSeq :: Rep a => a -> b -> b

Recursively force the evaluation of the first argument. For example, deepSeq ( x , y ) z where x = ... y = ... will evaluate both x and y then return z

rnf :: Rep a => a -> a

Force the evaluation of *datatypes* to their normal forms. Other types are left alone and not forced.

Specializable type-indexed functions

class Rep1 GSumD a => GSum a where

Add together all of the Ints in a datastructure For example: gsum ( 1 , True, ("a", Maybe 3, []) , Nothing) 4

Methods

gsum :: a -> Int

Instances

GSum Bool

Methods

gsum :: Bool -> Int

GSum Char

Methods

gsum :: Char -> Int

GSum Double

Methods

gsum :: Double -> Int

GSum Float

Methods

gsum :: Float -> Int

GSum Int

Methods

gsum :: Int -> Int

GSum Integer

Methods

gsum :: Integer -> Int

GSum ()

Methods

gsum :: () -> Int

GSum a => GSum [a]

Methods

gsum :: [a] -> Int

GSum a => GSum (Set a)

Methods

gsum :: Set a -> Int

(GSum a, GSum b) => GSum (a, b)

Methods

gsum :: (a, b) -> Int

(Rep k, GSum a) => GSum (Map k a)

Methods

gsum :: Map k a -> Int

class Rep1 ZeroD a => Zero a where

Create a zero element of a type ( zero :: ((Int, Maybe Int), Float)) ((0, Nothing), 0.0)

Methods

zero :: a

Instances

Zero Bool

Methods

zero :: Bool

Zero Char

Methods

zero :: Char

Zero Double

Methods

zero :: Double

Zero Float

Methods

zero :: Float

Zero Int

Methods

zero :: Int

Zero Integer

Methods

zero :: Integer

Zero ()

Methods

zero :: ()

Zero IOError

Methods

zero :: IOError

Zero a => Zero [a]

Methods

zero :: [a]

Rep a => Zero (Set a)

Methods

zero :: Set a

(Zero a, Zero b) => Zero (a -> b)

Methods

zero :: a -> b

(Zero a, Zero b) => Zero (a, b)

Methods

zero :: (a, b)

(Rep k, Rep a) => Zero (Map k a)

Methods

zero :: Map k a

class Rep1 GenerateD a => Generate a where

Generate elements of a type up to a certain depth

Methods

generate :: Int -> [a]

Instances

Generate Char

Methods

generate :: Int -> [Char]

Generate Double

Methods

generate :: Int -> [Double]

Generate Float

Methods

generate :: Int -> [Float]

Generate Int

Methods

generate :: Int -> [Int]

Generate Integer

Methods

generate :: Int -> [Integer]

Generate ()

Methods

generate :: Int -> [()]

Generate a => Generate [a]

Methods

generate :: Int -> [[a]]

(Ord a, Generate a) => Generate (Set a)

Methods

generate :: Int -> [Set a]

(Generate a, Generate b) => Generate (a, b)

Methods

generate :: Int -> [(a, b)]

(Ord k, Generate k, Generate a) => Generate (Map k a)

Methods

generate :: Int -> [Map k a]

class Rep1 EnumerateD a => Enumerate a where

enumerate the elements of a type, in DFS order.

Methods

enumerate :: [a]

Instances

Enumerate Bool

Methods

enumerate :: [Bool]

Enumerate Char

Methods

enumerate :: [Char]

Enumerate Double

Methods

enumerate :: [Double]

Enumerate Float

Methods

enumerate :: [Float]

Enumerate Int

Methods

enumerate :: [Int]

Enumerate Integer

Methods

enumerate :: [Integer]

Enumerate ()

Methods

enumerate :: [()]

Enumerate a => Enumerate [a]

Methods

enumerate :: [[a]]

(Ord a, Enumerate a) => Enumerate (Set a)

Methods

enumerate :: [Set a]

(Enumerate a, Enumerate b) => Enumerate (a, b)

Methods

enumerate :: [(a, b)]

(Ord k, Enumerate k, Enumerate a) => Enumerate (Map k a)

Methods

enumerate :: [Map k a]

class Rep1 ShrinkD a => Shrink a where

Given an element, return smaller elements of the same type for example, to automatically find small counterexamples when testing

Methods

shrink :: a -> [a]

Instances

Shrink Char

Methods

shrink :: Char -> [Char]

Shrink Int

Methods

shrink :: Int -> [Int]

Shrink ()

Methods

shrink :: () -> [()]

Shrink a => Shrink [a]

Methods

shrink :: [a] -> [[a]]

(Ord a, Shrink a) => Shrink (Set a)

Methods

shrink :: Set a -> [Set a]

(Shrink a, Shrink b) => Shrink (a, b)

Methods

shrink :: (a, b) -> [(a, b)]

(Ord k, Shrink k, Shrink a) => Shrink (Map k a)

Methods

shrink :: Map k a -> [Map k a]

class Rep1 (LreduceD b) a => Lreduce b a where

A general version of fold left, use for Fold class below

Methods

lreduce :: b -> a -> b

Instances

Lreduce b Bool

Methods

lreduce :: b -> Bool -> b

Lreduce b Char

Methods

lreduce :: b -> Char -> b

Lreduce b ()

Methods

lreduce :: b -> () -> b

Lreduce b Int

Methods

lreduce :: b -> Int -> b

(Ord a, Lreduce b a) => Lreduce b (Set a)

Methods

lreduce :: b -> Set a -> b

Lreduce c a => Lreduce c [a]

Methods

lreduce :: c -> [a] -> c

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

Methods

lreduce :: c -> (a, b) -> c

class Rep1 (RreduceD b) a => Rreduce b a where

A general version of fold right, use for Fold class below

Methods

rreduce :: a -> b -> b

Instances

Rreduce b Bool

Methods

rreduce :: Bool -> b -> b

Rreduce b Char

Methods

rreduce :: Char -> b -> b

Rreduce b ()

Methods

rreduce :: () -> b -> b

Rreduce b Int

Methods

rreduce :: Int -> b -> b

(Ord a, Rreduce b a) => Rreduce b (Set a)

Methods

rreduce :: Set a -> b -> b

Rreduce c a => Rreduce c [a]

Methods

rreduce :: [a] -> c -> c

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

Methods

rreduce :: (a, b) -> c -> c

Generic operations based on Fold

class Fold f where

All of the functions below are defined using instances of the following class

Minimal complete definition

foldRight, foldLeft

Methods

foldRight :: Rep a => (a -> b -> b) -> f a -> b -> b

foldLeft :: Rep a => (b -> a -> b) -> b -> f a -> b

Instances

Fold []

Methods

foldRight :: Rep a => (a -> b -> b) -> [a] -> b -> b

foldLeft :: Rep a => (b -> a -> b) -> b -> [a] -> b

Fold Set

Methods

foldRight :: Rep a => (a -> b -> b) -> Set a -> b -> b

foldLeft :: Rep a => (b -> a -> b) -> b -> Set a -> b

Fold (Map k)

Methods

foldRight :: Rep a => (a -> b -> b) -> Map k a -> b -> b

foldLeft :: Rep a => (b -> a -> b) -> b -> Map k a -> b

crush :: (Rep a, Fold t) => (a -> a -> a) -> a -> t a -> a

Fold a bindary operation left over a datastructure

gproduct :: (Rep a, Num a, Fold t) => t a -> a

Multiply all elements together

gand :: Fold t => t Bool -> Bool

Ensure all booleans are true

gor :: Fold t => t Bool -> Bool

Ensure at least one boolean is true

flatten :: (Rep a, Fold t) => t a -> [a]

Convert to list

count :: (Rep a, Fold t) => t a -> Int

Count number of as that appear in the argument

comp :: (Rep a, Fold t) => t (a -> a) -> a -> a

Compose all functions in the datastructure together

gconcat :: (Rep a, Fold t) => t [a] -> [a]

Concatenate all lists in the datastructure together

gall :: (Rep a, Fold t) => (a -> Bool) -> t a -> Bool

Ensure property holds of all data

gany :: (Rep a, Fold t) => (a -> Bool) -> t a -> Bool

Ensure property holds of some element

gelem :: (Rep a, Eq a, Fold t) => a -> t a -> Bool

Is an element stored in a datastructure

Auxiliary types and generators for derivable classes

data GSumD a

Constructors

GSumD

Fields

• gsumD :: a -> Int

Instances

GSum a => Sat (GSumD a)

Methods

dict :: GSumD a

data ZeroD a

Constructors

ZD

Fields

• zeroD :: a

Instances

Zero a => Sat (ZeroD a)

Methods

dict :: ZeroD a

data GenerateD a

Constructors

GenerateD

Fields

• generateD :: Int -> [a]

Instances

Generate a => Sat (GenerateD a)

Methods

dict :: GenerateD a

data EnumerateD a

Constructors

EnumerateD

Fields

• enumerateD :: [a]

Instances

Enumerate a => Sat (EnumerateD a)

Methods

dict :: EnumerateD a

data ShrinkD a

Constructors

ShrinkD

Fields

• shrinkD :: a -> [a]

Instances

Shrink a => Sat (ShrinkD a)

Methods

dict :: ShrinkD a

data LreduceD b a

Constructors

LreduceD

Fields

• lreduceD :: b -> a -> b

Instances

Lreduce b a => Sat (LreduceD b a)

Methods

dict :: LreduceD b a

data RreduceD b a

Constructors

RreduceD

Fields

• rreduceD :: a -> b -> b

Instances

Rreduce b a => Sat (RreduceD b a)

Methods

dict :: RreduceD b a

rnfR :: R a -> a -> a

deepSeqR :: R a -> a -> b -> b

gsumR1 :: R1 GSumD a -> a -> Int

zeroR1 :: R1 ZeroD a -> a

generateR1 :: R1 GenerateD a -> Int -> [a]

enumerateR1 :: R1 EnumerateD a -> [a]

lreduceR1 :: R1 (LreduceD b) a -> b -> a -> b

rreduceR1 :: R1 (RreduceD b) a -> a -> b -> b