Conjure

A library for Conjuring function implementations from tests or partial definitions. (a.k.a.: functional inductive programming)

This is currently an experimental tool in its early stages, don't expect much from its current version. It is just a piece of curiosity in its current state.

Step 1: declare your partial function

square :: Int -> Int
square 0  =  0
square 1  =  1
square 2  =  4

Step 2: declare a list with the potential building blocks:

primitives :: [Prim]
primitives =
  [ pr (0::Int)
  , pr (1::Int)
  , prim "+" ((+) :: Int -> Int -> Int)
  , prim "*" ((*) :: Int -> Int -> Int)
]

Step 3: call conjure and see your generated function:

> conjure "square" square primitives
square :: Int -> Int
-- testing 3 combinations of argument values
-- pruning with 14/25 rules
-- looking through 3 candidates of size 1
-- looking through 4 candidates of size 2
-- looking through 9 candidates of size 3
square x  =  x * x

Basic use

conjure :: Conjurable f => String -> f -> [Prim] -> IO ()

Conjures an implementation of a partially defined function.

Takes a String with the name of a function, a partially-defined function from a conjurable type, and a list of building blocks encoded as Exprs.

For example, given:

square :: Int -> Int
square 0  =  0
square 1  =  1
square 2  =  4

primitives :: [Prim]
primitives =
  [ pr (0::Int)
  , pr (1::Int)
  , prim "+" ((+) :: Int -> Int -> Int)
  , prim "*" ((*) :: Int -> Int -> Int)
]

The conjure function does the following:

> conjure "square" square primitives
square :: Int -> Int
-- testing 3 combinations of argument values
-- looking through 3 candidates of size 1
-- looking through 3 candidates of size 2
-- looking through 5 candidates of size 3
square x  =  x * x

The primitives list is defined with pr and prim.

type Prim = (Expr, Reification)

A primtive expression (paired with instance reification).

pr :: (Conjurable a, Show a) => a -> Prim

Provides a primitive value to Conjure. To be used on Show instances. (cf. prim)

prim :: Conjurable a => String -> a -> Prim

Provides a primitive value to Conjure. To be used on values that are not Show instances such as functions. (cf. pr)

prif :: Conjurable a => a -> Prim

Provides an if condition bound to the given return type.

Advanced use

conjureWithMaxSize :: Conjurable f => Int -> String -> f -> [Prim] -> IO ()

Like conjure but allows setting the maximum size of considered expressions instead of the default value of 12.

conjureWithMaxSize 10 "function" function [...]

conjureWith :: Conjurable f => Args -> String -> f -> [Prim] -> IO ()

Like conjure but allows setting options through Args/args.

conjureWith args{maxSize = 11} "function" function [...]

data Args

Arguments to be passed to conjureWith or conjpureWith. See args for the defaults.

Constructors

Args

Fields

• maxTests :: Int

  maximum number of tests to each candidate

• maxSize :: Int

  maximum size of candidate bodies

• maxEvalRecursions :: Int

  maximum number of recursive evaluations when testing candidates

• maxEquationSize :: Int

  maximum size of equation operands

• maxSearchTests :: Int

  maximum number of tests to search for defined values

• requireDescent :: Bool

  require recursive calls to deconstruct arguments

• usePatterns :: Bool

  use pattern matching to create (recursive) candidates

• showTheory :: Bool

  show theory discovered by Speculate used in pruning

• forceTests :: [[Expr]]

  force tests

args :: Args

Default arguments to conjure.

• 60 tests
• functions of up to 12 symbols
• maximum of one recursive call allowed in candidate bodies
• maximum evaluation of up to 60 recursions
• pruning with equations up to size 5
• search for defined applications for up to 100000 combinations
• require recursive calls to deconstruct arguments
• don't show the theory used in pruning

data Expr

Values of type Expr represent objects or applications between objects. Each object is encapsulated together with its type and string representation. Values encoded in Exprs are always monomorphic.

An Expr can be constructed using:

• val, for values that are Show instances;
• value, for values that are not Show instances, like functions;
• :$, for applications between Exprs.

> val False
False :: Bool

> value "not" not :$ val False
not False :: Bool

An Expr can be evaluated using evaluate, eval or evl.

> evl $ val (1 :: Int) :: Int
1

> evaluate $ val (1 :: Int) :: Maybe Bool
Nothing

> eval 'a' (val 'b')
'b'

Showing a value of type Expr will return a pretty-printed representation of the expression together with its type.

> show (value "not" not :$ val False)
"not False :: Bool"

Expr is like Dynamic but has support for applications and variables (:$, var).

The var underscore convention: Functions that manipulate Exprs usually follow the convention where a value whose String representation starts with '_' represents a variable.

Instances

Eq Expr

O(n). Does not evaluate values when comparing, but rather uses their representation as strings and their types.

This instance works for ill-typed expressions.

Defined in Data.Express.Core

Methods

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

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

Ord Expr

O(n). Does not evaluate values when comparing, but rather uses their representation as strings and their types.

This instance works for ill-typed expressions.

Expressions come first when they have smaller complexity (compareComplexity) or when they come first lexicographically (compareLexicographically).

Defined in Data.Express.Core

Methods

compare :: Expr -> Expr -> Ordering

(<) :: Expr -> Expr -> Bool

(<=) :: Expr -> Expr -> Bool

(>) :: Expr -> Expr -> Bool

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

max :: Expr -> Expr -> Expr

min :: Expr -> Expr -> Expr

Show Expr

Shows Exprs with their types.

> show (value "not" not :$ val False)
"not False :: Bool"

Defined in Data.Express.Core

Methods

showsPrec :: Int -> Expr -> ShowS

show :: Expr -> String

showList :: [Expr] -> ShowS

val :: (Typeable a, Show a) => a -> Expr

O(1). A shorthand for value for values that are Show instances.

> val (0 :: Int)
0 :: Int

> val 'a'
'a' :: Char

> val True
True :: Bool

Example equivalences to value:

val 0     =  value "0" 0
val 'a'   =  value "'a'" 'a'
val True  =  value "True" True

value :: Typeable a => String -> a -> Expr

O(1). It takes a string representation of a value and a value, returning an Expr with that terminal value. For instances of Show, it is preferable to use val.

> value "0" (0 :: Integer)
0 :: Integer

> value "'a'" 'a'
'a' :: Char

> value "True" True
True :: Bool

> value "id" (id :: Int -> Int)
id :: Int -> Int

> value "(+)" ((+) :: Int -> Int -> Int)
(+) :: Int -> Int -> Int

> value "sort" (sort :: [Bool] -> [Bool])
sort :: [Bool] -> [Bool]

Conjuring from a specification

type Spec1 a b = [(a, b)]

A partial specification of a function with one argument:

sumSpec :: Spec1 [Int] Int
sumSpec  =
  [ []      -= 0
  , [1,2]   -= 3
  , [3,4,5] -= 12
  ]

To be passed as one of the arguments to conjure1.

type Spec2 a b c = [((a, b), c)]

A partial specification of a function with two arguments:

appSpec :: Spec2 [Int] [Int] [Int]
appSpec  =
  [ (,) []      [0,1]   -= [0,1]
  , (,) [2,3]   []      -= [2,3]
  , (,) [4,5,6] [7,8,9] -= [4,5,6,7,8,9]
  ]

To be passed as one of the arguments to conjure2.

type Spec3 a b c d = [((a, b, c), d)]

A partial specification of a function with three arguments.

To be passed as one of the arguments to conjure3

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

To be used when constructing specifications: Spec1, Spec2 and Spec3.

conjure1 :: (Eq a, Eq b, Show a, Express a, Conjurable a, Conjurable b) => String -> Spec1 a b -> [Prim] -> IO ()

Conjures a one argument function from a specification.

Given:

sumSpec :: Spec1 [Int] Int
sumSpec  =
  [ []      -= 0
  , [1,2]   -= 3
  , [3,4,5] -= 12
  ]

sumPrimitives :: [Prim]
sumPrimitives  =
  [ prim "null" (null :: [Int] -> Bool)
  , pr (0::Int)
  , prim "+"    ((+) :: Int -> Int -> Int)
  , prim "head" (head :: [Int] -> Int)
  , prim "tail" (tail :: [Int] -> [Int])
  ]

Then:

> conjure1 "sum" sumSpec sumPrimitives
sum :: [Int] -> Int
-- testing 3 combinations of argument values
-- ...
-- looking through 189/465 candidates of size 10
xs ++ ys  =  if null xs then ys else head xs:(tail xs ++ ys)

(cf. Spec1, conjure1With)

conjure2 :: (Conjurable a, Eq a, Show a, Express a, Conjurable b, Eq b, Show b, Express b, Conjurable c, Eq c) => String -> Spec2 a b c -> [Prim] -> IO ()

Conjures a two argument function from a specification.

Given:

appSpec :: Spec2 [Int] [Int] [Int]
appSpec  =
  [ (,) []      [0,1]   -= [0,1]
  , (,) [2,3]   []      -= [2,3]
  , (,) [4,5,6] [7,8,9] -= [4,5,6,7,8,9]
  ]

appPrimitives :: [Expr]
appPrimitives =
  [ prim "null" (null :: [Int] -> Bool)
  , prim ":"    ((:) :: Int -> [Int] -> [Int])
  , prim "head" (head :: [Int] -> Int)
  , prim "tail" (tail :: [Int] -> [Int])
  ]

Then:

> conjure2 "++" appSpec appPrimitives
(++) :: [Int] -> [Int] -> [Int]
-- testing 3 combinations of argument values
-- ...
-- looking through 26166/57090 candidates of size 11
xs ++ ys  =  if null xs then ys else head xs:(tail xs ++ ys)

(cf. Spec2, conjure2With)

conjure3 :: (Conjurable a, Eq a, Show a, Express a, Conjurable b, Eq b, Show b, Express b, Conjurable c, Eq c, Show c, Express c, Conjurable d, Eq d) => String -> Spec3 a b c d -> [Prim] -> IO ()

Conjures a three argument function from a specification.

(cf. Spec3, conjure3With)

conjure1With :: (Eq a, Eq b, Show a, Express a, Conjurable a, Conjurable b) => Args -> String -> Spec1 a b -> [Prim] -> IO ()

Like conjure1 but allows setting options through Args/args.

conjure2With :: (Conjurable a, Eq a, Show a, Express a, Conjurable b, Eq b, Show b, Express b, Conjurable c, Eq c) => Args -> String -> Spec2 a b c -> [Prim] -> IO ()

Like conjure2 but allows setting options through Args/args.

conjure3With :: (Conjurable a, Eq a, Show a, Express a, Conjurable b, Eq b, Show b, Express b, Conjurable c, Eq c, Show c, Express c, Conjurable d, Eq d) => Args -> String -> Spec3 a b c d -> [Prim] -> IO ()

Like conjure3 but allows setting options through Args/args.

When using custom types

class (Typeable a, Name a) => Conjurable a where

Class of Conjurable types. Functions are Conjurable if all their arguments are Conjurable, Listable and Showable.

For atomic types that are Listable, instances are defined as:

instance Conjurable Atomic where
  conjureTiers  =  reifyTiers

For atomic types that are both Listable and Eq, instances are defined as:

instance Conjurable Atomic where
  conjureTiers     =  reifyTiers
  conjureEquality  =  reifyEquality

For types with subtypes, instances are defined as:

instance Conjurable Composite where
  conjureTiers     =  reifyTiers
  conjureEquality  =  reifyEquality
  conjureSubTypes x  =  conjureType y
                     .  conjureType z
                     .  conjureType w
    where
    (Composite ... y ... z ... w ...)  =  x

Above x, y, z and w are just proxies. The Proxy type was avoided for backwards compatibility.

Please see the source code of Conjure.Conjurable for more examples.

(cf. reifyTiers, reifyEquality, conjureType)

Minimal complete definition

conjureExpress

Methods

conjureEquality :: a -> Maybe Expr

Returns Just the == function encoded as an Expr when available or Nothing otherwise.

conjureTiers :: a -> Maybe [[Expr]]

Returns Just tiers of values encoded as Exprs when possible or Nothing otherwise.

conjureSubTypes :: a -> Reification

conjureCases :: a -> [Expr]

conjureExpress :: a -> Expr -> Expr

Instances

Conjurable Bool

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Bool -> [Expr]

conjureEquality :: Bool -> Maybe Expr

conjureTiers :: Bool -> Maybe [[Expr]]

conjureSubTypes :: Bool -> Reification

conjureIf :: Bool -> Expr

conjureCases :: Bool -> [Expr]

conjureArgumentCases :: Bool -> [[Expr]]

conjureSize :: Bool -> Int

conjureExpress :: Bool -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Bool

Conjurable Char

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Char -> [Expr]

conjureEquality :: Char -> Maybe Expr

conjureTiers :: Char -> Maybe [[Expr]]

conjureSubTypes :: Char -> Reification

conjureIf :: Char -> Expr

conjureCases :: Char -> [Expr]

conjureArgumentCases :: Char -> [[Expr]]

conjureSize :: Char -> Int

conjureExpress :: Char -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Char

Conjurable Double

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Double -> [Expr]

conjureEquality :: Double -> Maybe Expr

conjureTiers :: Double -> Maybe [[Expr]]

conjureSubTypes :: Double -> Reification

conjureIf :: Double -> Expr

conjureCases :: Double -> [Expr]

conjureArgumentCases :: Double -> [[Expr]]

conjureSize :: Double -> Int

conjureExpress :: Double -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Double

Conjurable Float

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Float -> [Expr]

conjureEquality :: Float -> Maybe Expr

conjureTiers :: Float -> Maybe [[Expr]]

conjureSubTypes :: Float -> Reification

conjureIf :: Float -> Expr

conjureCases :: Float -> [Expr]

conjureArgumentCases :: Float -> [[Expr]]

conjureSize :: Float -> Int

conjureExpress :: Float -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Float

Conjurable Int

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Int -> [Expr]

conjureEquality :: Int -> Maybe Expr

conjureTiers :: Int -> Maybe [[Expr]]

conjureSubTypes :: Int -> Reification

conjureIf :: Int -> Expr

conjureCases :: Int -> [Expr]

conjureArgumentCases :: Int -> [[Expr]]

conjureSize :: Int -> Int

conjureExpress :: Int -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Int

Conjurable Int8

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Int8 -> [Expr]

conjureEquality :: Int8 -> Maybe Expr

conjureTiers :: Int8 -> Maybe [[Expr]]

conjureSubTypes :: Int8 -> Reification

conjureIf :: Int8 -> Expr

conjureCases :: Int8 -> [Expr]

conjureArgumentCases :: Int8 -> [[Expr]]

conjureSize :: Int8 -> Int

conjureExpress :: Int8 -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Int8

Conjurable Int16

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Int16 -> [Expr]

conjureEquality :: Int16 -> Maybe Expr

conjureTiers :: Int16 -> Maybe [[Expr]]

conjureSubTypes :: Int16 -> Reification

conjureIf :: Int16 -> Expr

conjureCases :: Int16 -> [Expr]

conjureArgumentCases :: Int16 -> [[Expr]]

conjureSize :: Int16 -> Int

conjureExpress :: Int16 -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Int16

Conjurable Int32

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Int32 -> [Expr]

conjureEquality :: Int32 -> Maybe Expr

conjureTiers :: Int32 -> Maybe [[Expr]]

conjureSubTypes :: Int32 -> Reification

conjureIf :: Int32 -> Expr

conjureCases :: Int32 -> [Expr]

conjureArgumentCases :: Int32 -> [[Expr]]

conjureSize :: Int32 -> Int

conjureExpress :: Int32 -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Int32

Conjurable Int64

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Int64 -> [Expr]

conjureEquality :: Int64 -> Maybe Expr

conjureTiers :: Int64 -> Maybe [[Expr]]

conjureSubTypes :: Int64 -> Reification

conjureIf :: Int64 -> Expr

conjureCases :: Int64 -> [Expr]

conjureArgumentCases :: Int64 -> [[Expr]]

conjureSize :: Int64 -> Int

conjureExpress :: Int64 -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Int64

Conjurable Integer

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Integer -> [Expr]

conjureEquality :: Integer -> Maybe Expr

conjureTiers :: Integer -> Maybe [[Expr]]

conjureSubTypes :: Integer -> Reification

conjureIf :: Integer -> Expr

conjureCases :: Integer -> [Expr]

conjureArgumentCases :: Integer -> [[Expr]]

conjureSize :: Integer -> Int

conjureExpress :: Integer -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Integer

Conjurable Ordering

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Ordering -> [Expr]

conjureEquality :: Ordering -> Maybe Expr

conjureTiers :: Ordering -> Maybe [[Expr]]

conjureSubTypes :: Ordering -> Reification

conjureIf :: Ordering -> Expr

conjureCases :: Ordering -> [Expr]

conjureArgumentCases :: Ordering -> [[Expr]]

conjureSize :: Ordering -> Int

conjureExpress :: Ordering -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Ordering

Conjurable Word

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Word -> [Expr]

conjureEquality :: Word -> Maybe Expr

conjureTiers :: Word -> Maybe [[Expr]]

conjureSubTypes :: Word -> Reification

conjureIf :: Word -> Expr

conjureCases :: Word -> [Expr]

conjureArgumentCases :: Word -> [[Expr]]

conjureSize :: Word -> Int

conjureExpress :: Word -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Word

Conjurable Word8

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Word8 -> [Expr]

conjureEquality :: Word8 -> Maybe Expr

conjureTiers :: Word8 -> Maybe [[Expr]]

conjureSubTypes :: Word8 -> Reification

conjureIf :: Word8 -> Expr

conjureCases :: Word8 -> [Expr]

conjureArgumentCases :: Word8 -> [[Expr]]

conjureSize :: Word8 -> Int

conjureExpress :: Word8 -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Word8

Conjurable Word16

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Word16 -> [Expr]

conjureEquality :: Word16 -> Maybe Expr

conjureTiers :: Word16 -> Maybe [[Expr]]

conjureSubTypes :: Word16 -> Reification

conjureIf :: Word16 -> Expr

conjureCases :: Word16 -> [Expr]

conjureArgumentCases :: Word16 -> [[Expr]]

conjureSize :: Word16 -> Int

conjureExpress :: Word16 -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Word16

Conjurable Word32

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Word32 -> [Expr]

conjureEquality :: Word32 -> Maybe Expr

conjureTiers :: Word32 -> Maybe [[Expr]]

conjureSubTypes :: Word32 -> Reification

conjureIf :: Word32 -> Expr

conjureCases :: Word32 -> [Expr]

conjureArgumentCases :: Word32 -> [[Expr]]

conjureSize :: Word32 -> Int

conjureExpress :: Word32 -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Word32

Conjurable Word64

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Word64 -> [Expr]

conjureEquality :: Word64 -> Maybe Expr

conjureTiers :: Word64 -> Maybe [[Expr]]

conjureSubTypes :: Word64 -> Reification

conjureIf :: Word64 -> Expr

conjureCases :: Word64 -> [Expr]

conjureArgumentCases :: Word64 -> [[Expr]]

conjureSize :: Word64 -> Int

conjureExpress :: Word64 -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe Word64

Conjurable ()

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: () -> [Expr]

conjureEquality :: () -> Maybe Expr

conjureTiers :: () -> Maybe [[Expr]]

conjureSubTypes :: () -> Reification

conjureIf :: () -> Expr

conjureCases :: () -> [Expr]

conjureArgumentCases :: () -> [[Expr]]

conjureSize :: () -> Int

conjureExpress :: () -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe ()

Conjurable A

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: A -> [Expr]

conjureEquality :: A -> Maybe Expr

conjureTiers :: A -> Maybe [[Expr]]

conjureSubTypes :: A -> Reification

conjureIf :: A -> Expr

conjureCases :: A -> [Expr]

conjureArgumentCases :: A -> [[Expr]]

conjureSize :: A -> Int

conjureExpress :: A -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe A

Conjurable B

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: B -> [Expr]

conjureEquality :: B -> Maybe Expr

conjureTiers :: B -> Maybe [[Expr]]

conjureSubTypes :: B -> Reification

conjureIf :: B -> Expr

conjureCases :: B -> [Expr]

conjureArgumentCases :: B -> [[Expr]]

conjureSize :: B -> Int

conjureExpress :: B -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe B

Conjurable C

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: C -> [Expr]

conjureEquality :: C -> Maybe Expr

conjureTiers :: C -> Maybe [[Expr]]

conjureSubTypes :: C -> Reification

conjureIf :: C -> Expr

conjureCases :: C -> [Expr]

conjureArgumentCases :: C -> [[Expr]]

conjureSize :: C -> Int

conjureExpress :: C -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe C

Conjurable D

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: D -> [Expr]

conjureEquality :: D -> Maybe Expr

conjureTiers :: D -> Maybe [[Expr]]

conjureSubTypes :: D -> Reification

conjureIf :: D -> Expr

conjureCases :: D -> [Expr]

conjureArgumentCases :: D -> [[Expr]]

conjureSize :: D -> Int

conjureExpress :: D -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe D

Conjurable E

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: E -> [Expr]

conjureEquality :: E -> Maybe Expr

conjureTiers :: E -> Maybe [[Expr]]

conjureSubTypes :: E -> Reification

conjureIf :: E -> Expr

conjureCases :: E -> [Expr]

conjureArgumentCases :: E -> [[Expr]]

conjureSize :: E -> Int

conjureExpress :: E -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe E

Conjurable F

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: F -> [Expr]

conjureEquality :: F -> Maybe Expr

conjureTiers :: F -> Maybe [[Expr]]

conjureSubTypes :: F -> Reification

conjureIf :: F -> Expr

conjureCases :: F -> [Expr]

conjureArgumentCases :: F -> [[Expr]]

conjureSize :: F -> Int

conjureExpress :: F -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe F

(Conjurable a, Listable a, Express a, Show a) => Conjurable [a]

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: [a] -> [Expr]

conjureEquality :: [a] -> Maybe Expr

conjureTiers :: [a] -> Maybe [[Expr]]

conjureSubTypes :: [a] -> Reification

conjureIf :: [a] -> Expr

conjureCases :: [a] -> [Expr]

conjureArgumentCases :: [a] -> [[Expr]]

conjureSize :: [a] -> Int

conjureExpress :: [a] -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe [a]

(Conjurable a, Listable a, Show a, Express a) => Conjurable (Maybe a)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Maybe a -> [Expr]

conjureEquality :: Maybe a -> Maybe Expr

conjureTiers :: Maybe a -> Maybe [[Expr]]

conjureSubTypes :: Maybe a -> Reification

conjureIf :: Maybe a -> Expr

conjureCases :: Maybe a -> [Expr]

conjureArgumentCases :: Maybe a -> [[Expr]]

conjureSize :: Maybe a -> Int

conjureExpress :: Maybe a -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (Maybe a)

(Integral a, Conjurable a, Listable a, Show a, Eq a, Express a) => Conjurable (Ratio a)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Ratio a -> [Expr]

conjureEquality :: Ratio a -> Maybe Expr

conjureTiers :: Ratio a -> Maybe [[Expr]]

conjureSubTypes :: Ratio a -> Reification

conjureIf :: Ratio a -> Expr

conjureCases :: Ratio a -> [Expr]

conjureArgumentCases :: Ratio a -> [[Expr]]

conjureSize :: Ratio a -> Int

conjureExpress :: Ratio a -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (Ratio a)

(RealFloat a, Conjurable a, Listable a, Show a, Eq a, Express a) => Conjurable (Complex a)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Complex a -> [Expr]

conjureEquality :: Complex a -> Maybe Expr

conjureTiers :: Complex a -> Maybe [[Expr]]

conjureSubTypes :: Complex a -> Reification

conjureIf :: Complex a -> Expr

conjureCases :: Complex a -> [Expr]

conjureArgumentCases :: Complex a -> [[Expr]]

conjureSize :: Complex a -> Int

conjureExpress :: Complex a -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (Complex a)

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

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: (a -> b) -> [Expr]

conjureEquality :: (a -> b) -> Maybe Expr

conjureTiers :: (a -> b) -> Maybe [[Expr]]

conjureSubTypes :: (a -> b) -> Reification

conjureIf :: (a -> b) -> Expr

conjureCases :: (a -> b) -> [Expr]

conjureArgumentCases :: (a -> b) -> [[Expr]]

conjureSize :: (a -> b) -> Int

conjureExpress :: (a -> b) -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (a -> b)

(Conjurable a, Listable a, Show a, Express a, Conjurable b, Listable b, Show b, Express b) => Conjurable (Either a b)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: Either a b -> [Expr]

conjureEquality :: Either a b -> Maybe Expr

conjureTiers :: Either a b -> Maybe [[Expr]]

conjureSubTypes :: Either a b -> Reification

conjureIf :: Either a b -> Expr

conjureCases :: Either a b -> [Expr]

conjureArgumentCases :: Either a b -> [[Expr]]

conjureSize :: Either a b -> Int

conjureExpress :: Either a b -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (Either a b)

(Conjurable a, Listable a, Show a, Express a, Conjurable b, Listable b, Show b, Express b) => Conjurable (a, b)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: (a, b) -> [Expr]

conjureEquality :: (a, b) -> Maybe Expr

conjureTiers :: (a, b) -> Maybe [[Expr]]

conjureSubTypes :: (a, b) -> Reification

conjureIf :: (a, b) -> Expr

conjureCases :: (a, b) -> [Expr]

conjureArgumentCases :: (a, b) -> [[Expr]]

conjureSize :: (a, b) -> Int

conjureExpress :: (a, b) -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (a, b)

(Conjurable a, Listable a, Show a, Express a, Conjurable b, Listable b, Show b, Express b, Conjurable c, Listable c, Show c, Express c) => Conjurable (a, b, c)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: (a, b, c) -> [Expr]

conjureEquality :: (a, b, c) -> Maybe Expr

conjureTiers :: (a, b, c) -> Maybe [[Expr]]

conjureSubTypes :: (a, b, c) -> Reification

conjureIf :: (a, b, c) -> Expr

conjureCases :: (a, b, c) -> [Expr]

conjureArgumentCases :: (a, b, c) -> [[Expr]]

conjureSize :: (a, b, c) -> Int

conjureExpress :: (a, b, c) -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (a, b, c)

(Conjurable a, Listable a, Show a, Express a, Conjurable b, Listable b, Show b, Express b, Conjurable c, Listable c, Show c, Express c, Conjurable d, Listable d, Show d, Express d) => Conjurable (a, b, c, d)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: (a, b, c, d) -> [Expr]

conjureEquality :: (a, b, c, d) -> Maybe Expr

conjureTiers :: (a, b, c, d) -> Maybe [[Expr]]

conjureSubTypes :: (a, b, c, d) -> Reification

conjureIf :: (a, b, c, d) -> Expr

conjureCases :: (a, b, c, d) -> [Expr]

conjureArgumentCases :: (a, b, c, d) -> [[Expr]]

conjureSize :: (a, b, c, d) -> Int

conjureExpress :: (a, b, c, d) -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (a, b, c, d)

(Conjurable a, Listable a, Show a, Express a, Conjurable b, Listable b, Show b, Express b, Conjurable c, Listable c, Show c, Express c, Conjurable d, Listable d, Show d, Express d, Conjurable e, Listable e, Show e, Express e) => Conjurable (a, b, c, d, e)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: (a, b, c, d, e) -> [Expr]

conjureEquality :: (a, b, c, d, e) -> Maybe Expr

conjureTiers :: (a, b, c, d, e) -> Maybe [[Expr]]

conjureSubTypes :: (a, b, c, d, e) -> Reification

conjureIf :: (a, b, c, d, e) -> Expr

conjureCases :: (a, b, c, d, e) -> [Expr]

conjureArgumentCases :: (a, b, c, d, e) -> [[Expr]]

conjureSize :: (a, b, c, d, e) -> Int

conjureExpress :: (a, b, c, d, e) -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (a, b, c, d, e)

(Conjurable a, Listable a, Show a, Express a, Conjurable b, Listable b, Show b, Express b, Conjurable c, Listable c, Show c, Express c, Conjurable d, Listable d, Show d, Express d, Conjurable e, Listable e, Show e, Express e, Conjurable f, Listable f, Show f, Express f) => Conjurable (a, b, c, d, e, f)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: (a, b, c, d, e, f) -> [Expr]

conjureEquality :: (a, b, c, d, e, f) -> Maybe Expr

conjureTiers :: (a, b, c, d, e, f) -> Maybe [[Expr]]

conjureSubTypes :: (a, b, c, d, e, f) -> Reification

conjureIf :: (a, b, c, d, e, f) -> Expr

conjureCases :: (a, b, c, d, e, f) -> [Expr]

conjureArgumentCases :: (a, b, c, d, e, f) -> [[Expr]]

conjureSize :: (a, b, c, d, e, f) -> Int

conjureExpress :: (a, b, c, d, e, f) -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (a, b, c, d, e, f)

(Conjurable a, Listable a, Show a, Express a, Conjurable b, Listable b, Show b, Express b, Conjurable c, Listable c, Show c, Express c, Conjurable d, Listable d, Show d, Express d, Conjurable e, Listable e, Show e, Express e, Conjurable f, Listable f, Show f, Express f, Conjurable g, Listable g, Show g, Express g) => Conjurable (a, b, c, d, e, f, g)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: (a, b, c, d, e, f, g) -> [Expr]

conjureEquality :: (a, b, c, d, e, f, g) -> Maybe Expr

conjureTiers :: (a, b, c, d, e, f, g) -> Maybe [[Expr]]

conjureSubTypes :: (a, b, c, d, e, f, g) -> Reification

conjureIf :: (a, b, c, d, e, f, g) -> Expr

conjureCases :: (a, b, c, d, e, f, g) -> [Expr]

conjureArgumentCases :: (a, b, c, d, e, f, g) -> [[Expr]]

conjureSize :: (a, b, c, d, e, f, g) -> Int

conjureExpress :: (a, b, c, d, e, f, g) -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (a, b, c, d, e, f, g)

reifyExpress :: (Express a, Show a) => a -> Expr -> Expr

reifyEquality :: (Eq a, Typeable a) => a -> Maybe Expr

Reifies equality to be used in a conjurable type.

This is to be used in the definition of conjureEquality of Conjurable typeclass instances:

instance ... => Conjurable <Type> where
  ...
  conjureEquality  =  reifyEquality
  ...

reifyTiers :: (Listable a, Show a, Typeable a) => a -> Maybe [[Expr]]

Reifies equality to be used in a conjurable type.

This is to be used in the definition of conjureTiers of Conjurable typeclass instances:

instance ... => Conjurable <Type> where
  ...
  conjureTiers  =  reifyTiers
  ...

conjureType :: Conjurable a => a -> Reification

Pure interfaces

conjpure :: Conjurable f => String -> f -> [Prim] -> ([[Defn]], [[Defn]], [Expr], Thy)

Like conjure but in the pure world.

Returns a triple with:

1. tiers of implementations
2. tiers of candidate bodies (right type)
3. tiers of candidate expressions (any type)
4. a list of tests

conjpureWith :: Conjurable f => Args -> String -> f -> [Prim] -> ([[Defn]], [[Defn]], [Expr], Thy)

Like conjpure but allows setting options through Args and args.

Helper test types

data A

Generic type A.

Can be used to test polymorphic functions with a type variable such as take or sort:

take :: Int -> [a] -> [a]
sort :: Ord a => [a] -> [a]

by binding them to the following types:

take :: Int -> [A] -> [A]
sort :: [A] -> [A]

This type is homomorphic to Nat6, B, C, D, E and F.

It is instance to several typeclasses so that it can be used to test functions with type contexts.

Instances

Bounded A

Defined in Test.LeanCheck.Utils.Types

Methods

minBound :: A

maxBound :: A

Enum A

Defined in Test.LeanCheck.Utils.Types

Methods

succ :: A -> A

pred :: A -> A

toEnum :: Int -> A

fromEnum :: A -> Int

enumFrom :: A -> [A]

enumFromThen :: A -> A -> [A]

enumFromTo :: A -> A -> [A]

enumFromThenTo :: A -> A -> A -> [A]

Eq A

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

Integral A

Defined in Test.LeanCheck.Utils.Types

Methods

quot :: A -> A -> A

rem :: A -> A -> A

div :: A -> A -> A

mod :: A -> A -> A

quotRem :: A -> A -> (A, A)

divMod :: A -> A -> (A, A)

toInteger :: A -> Integer

Num A

Defined in Test.LeanCheck.Utils.Types

Methods

(+) :: A -> A -> A

(-) :: A -> A -> A

(*) :: A -> A -> A

negate :: A -> A

abs :: A -> A

signum :: A -> A

fromInteger :: Integer -> A

Ord A

Defined in Test.LeanCheck.Utils.Types

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

Read A

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS A

readList :: ReadS [A]

readPrec :: ReadPrec A

readListPrec :: ReadPrec [A]

Real A

Defined in Test.LeanCheck.Utils.Types

Methods

toRational :: A -> Rational

Show A

Defined in Test.LeanCheck.Utils.Types

Methods

showsPrec :: Int -> A -> ShowS

show :: A -> String

showList :: [A] -> ShowS

Ix A

Defined in Test.LeanCheck.Utils.Types

Methods

range :: (A, A) -> [A]

index :: (A, A) -> A -> Int

unsafeIndex :: (A, A) -> A -> Int

inRange :: (A, A) -> A -> Bool

rangeSize :: (A, A) -> Int

unsafeRangeSize :: (A, A) -> Int

Express A

Defined in Conjure.Expr

Methods

expr :: A -> Expr

Name A

Defined in Conjure.Conjurable

Methods

name :: A -> String

Listable A

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[A]]

list :: [A]

Conjurable A

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: A -> [Expr]

conjureEquality :: A -> Maybe Expr

conjureTiers :: A -> Maybe [[Expr]]

conjureSubTypes :: A -> Reification

conjureIf :: A -> Expr

conjureCases :: A -> [Expr]

conjureArgumentCases :: A -> [[Expr]]

conjureSize :: A -> Int

conjureExpress :: A -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe A

data B

Generic type B.

Can be used to test polymorphic functions with two type variables such as map or foldr:

map :: (a -> b) -> [a] -> [b]
foldr :: (a -> b -> b) -> b -> [a] -> b

by binding them to the following types:

map :: (A -> B) -> [A] -> [B]
foldr :: (A -> B -> B) -> B -> [A] -> B

This type is homomorphic to A, Nat6, C, D, E and F.

Instances

Bounded B

Defined in Test.LeanCheck.Utils.Types

Methods

minBound :: B

maxBound :: B

Enum B

Defined in Test.LeanCheck.Utils.Types

Methods

succ :: B -> B

pred :: B -> B

toEnum :: Int -> B

fromEnum :: B -> Int

enumFrom :: B -> [B]

enumFromThen :: B -> B -> [B]

enumFromTo :: B -> B -> [B]

enumFromThenTo :: B -> B -> B -> [B]

Eq B

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

Integral B

Defined in Test.LeanCheck.Utils.Types

Methods

quot :: B -> B -> B

rem :: B -> B -> B

div :: B -> B -> B

mod :: B -> B -> B

quotRem :: B -> B -> (B, B)

divMod :: B -> B -> (B, B)

toInteger :: B -> Integer

Num B

Defined in Test.LeanCheck.Utils.Types

Methods

(+) :: B -> B -> B

(-) :: B -> B -> B

(*) :: B -> B -> B

negate :: B -> B

abs :: B -> B

signum :: B -> B

fromInteger :: Integer -> B

Ord B

Defined in Test.LeanCheck.Utils.Types

Methods

compare :: B -> B -> Ordering

(<) :: B -> B -> Bool

(<=) :: B -> B -> Bool

(>) :: B -> B -> Bool

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

max :: B -> B -> B

min :: B -> B -> B

Read B

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS B

readList :: ReadS [B]

readPrec :: ReadPrec B

readListPrec :: ReadPrec [B]

Real B

Defined in Test.LeanCheck.Utils.Types

Methods

toRational :: B -> Rational

Show B

Defined in Test.LeanCheck.Utils.Types

Methods

showsPrec :: Int -> B -> ShowS

show :: B -> String

showList :: [B] -> ShowS

Ix B

Defined in Test.LeanCheck.Utils.Types

Methods

range :: (B, B) -> [B]

index :: (B, B) -> B -> Int

unsafeIndex :: (B, B) -> B -> Int

inRange :: (B, B) -> B -> Bool

rangeSize :: (B, B) -> Int

unsafeRangeSize :: (B, B) -> Int

Express B

Defined in Conjure.Expr

Methods

expr :: B -> Expr

Name B

Defined in Conjure.Conjurable

Methods

name :: B -> String

Listable B

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[B]]

list :: [B]

Conjurable B

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: B -> [Expr]

conjureEquality :: B -> Maybe Expr

conjureTiers :: B -> Maybe [[Expr]]

conjureSubTypes :: B -> Reification

conjureIf :: B -> Expr

conjureCases :: B -> [Expr]

conjureArgumentCases :: B -> [[Expr]]

conjureSize :: B -> Int

conjureExpress :: B -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe B

data C

Generic type C.

Can be used to test polymorphic functions with three type variables such as uncurry or zipWith:

uncurry :: (a -> b -> c) -> (a, b) -> c
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

by binding them to the following types:

uncurry :: (A -> B -> C) -> (A, B) -> C
zipWith :: (A -> B -> C) -> [A] -> [B] -> [C]

This type is homomorphic to A, B, Nat6, D, E and F.

Instances

Bounded C

Defined in Test.LeanCheck.Utils.Types

Methods

minBound :: C

maxBound :: C

Enum C

Defined in Test.LeanCheck.Utils.Types

Methods

succ :: C -> C

pred :: C -> C

toEnum :: Int -> C

fromEnum :: C -> Int

enumFrom :: C -> [C]

enumFromThen :: C -> C -> [C]

enumFromTo :: C -> C -> [C]

enumFromThenTo :: C -> C -> C -> [C]

Eq C

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

Integral C

Defined in Test.LeanCheck.Utils.Types

Methods

quot :: C -> C -> C

rem :: C -> C -> C

div :: C -> C -> C

mod :: C -> C -> C

quotRem :: C -> C -> (C, C)

divMod :: C -> C -> (C, C)

toInteger :: C -> Integer

Num C

Defined in Test.LeanCheck.Utils.Types

Methods

(+) :: C -> C -> C

(-) :: C -> C -> C

(*) :: C -> C -> C

negate :: C -> C

abs :: C -> C

signum :: C -> C

fromInteger :: Integer -> C

Ord C

Defined in Test.LeanCheck.Utils.Types

Methods

compare :: C -> C -> Ordering

(<) :: C -> C -> Bool

(<=) :: C -> C -> Bool

(>) :: C -> C -> Bool

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

max :: C -> C -> C

min :: C -> C -> C

Read C

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS C

readList :: ReadS [C]

readPrec :: ReadPrec C

readListPrec :: ReadPrec [C]

Real C

Defined in Test.LeanCheck.Utils.Types

Methods

toRational :: C -> Rational

Show C

Defined in Test.LeanCheck.Utils.Types

Methods

showsPrec :: Int -> C -> ShowS

show :: C -> String

showList :: [C] -> ShowS

Ix C

Defined in Test.LeanCheck.Utils.Types

Methods

range :: (C, C) -> [C]

index :: (C, C) -> C -> Int

unsafeIndex :: (C, C) -> C -> Int

inRange :: (C, C) -> C -> Bool

rangeSize :: (C, C) -> Int

unsafeRangeSize :: (C, C) -> Int

Express C

Defined in Conjure.Expr

Methods

expr :: C -> Expr

Name C

Defined in Conjure.Conjurable

Methods

name :: C -> String

Listable C

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[C]]

list :: [C]

Conjurable C

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: C -> [Expr]

conjureEquality :: C -> Maybe Expr

conjureTiers :: C -> Maybe [[Expr]]

conjureSubTypes :: C -> Reification

conjureIf :: C -> Expr

conjureCases :: C -> [Expr]

conjureArgumentCases :: C -> [[Expr]]

conjureSize :: C -> Int

conjureExpress :: C -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe C

data D

Generic type D.

Can be used to test polymorphic functions with four type variables.

This type is homomorphic to A, B, C, Nat6, E and F.

Instances

Bounded D

Defined in Test.LeanCheck.Utils.Types

Methods

minBound :: D

maxBound :: D

Enum D

Defined in Test.LeanCheck.Utils.Types

Methods

succ :: D -> D

pred :: D -> D

toEnum :: Int -> D

fromEnum :: D -> Int

enumFrom :: D -> [D]

enumFromThen :: D -> D -> [D]

enumFromTo :: D -> D -> [D]

enumFromThenTo :: D -> D -> D -> [D]

Eq D

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

Integral D

Defined in Test.LeanCheck.Utils.Types

Methods

quot :: D -> D -> D

rem :: D -> D -> D

div :: D -> D -> D

mod :: D -> D -> D

quotRem :: D -> D -> (D, D)

divMod :: D -> D -> (D, D)

toInteger :: D -> Integer

Num D

Defined in Test.LeanCheck.Utils.Types

Methods

(+) :: D -> D -> D

(-) :: D -> D -> D

(*) :: D -> D -> D

negate :: D -> D

abs :: D -> D

signum :: D -> D

fromInteger :: Integer -> D

Ord D

Defined in Test.LeanCheck.Utils.Types

Methods

compare :: D -> D -> Ordering

(<) :: D -> D -> Bool

(<=) :: D -> D -> Bool

(>) :: D -> D -> Bool

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

max :: D -> D -> D

min :: D -> D -> D

Read D

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS D

readList :: ReadS [D]

readPrec :: ReadPrec D

readListPrec :: ReadPrec [D]

Real D

Defined in Test.LeanCheck.Utils.Types

Methods

toRational :: D -> Rational

Show D

Defined in Test.LeanCheck.Utils.Types

Methods

showsPrec :: Int -> D -> ShowS

show :: D -> String

showList :: [D] -> ShowS

Ix D

Defined in Test.LeanCheck.Utils.Types

Methods

range :: (D, D) -> [D]

index :: (D, D) -> D -> Int

unsafeIndex :: (D, D) -> D -> Int

inRange :: (D, D) -> D -> Bool

rangeSize :: (D, D) -> Int

unsafeRangeSize :: (D, D) -> Int

Express D

Defined in Conjure.Expr

Methods

expr :: D -> Expr

Name D

Defined in Conjure.Conjurable

Methods

name :: D -> String

Listable D

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[D]]

list :: [D]

Conjurable D

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: D -> [Expr]

conjureEquality :: D -> Maybe Expr

conjureTiers :: D -> Maybe [[Expr]]

conjureSubTypes :: D -> Reification

conjureIf :: D -> Expr

conjureCases :: D -> [Expr]

conjureArgumentCases :: D -> [[Expr]]

conjureSize :: D -> Int

conjureExpress :: D -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe D

data E

Generic type E.

Can be used to test polymorphic functions with five type variables.

This type is homomorphic to A, B, C, D, Nat6 and F.

Instances

Bounded E

Defined in Test.LeanCheck.Utils.Types

Methods

minBound :: E

maxBound :: E

Enum E

Defined in Test.LeanCheck.Utils.Types

Methods

succ :: E -> E

pred :: E -> E

toEnum :: Int -> E

fromEnum :: E -> Int

enumFrom :: E -> [E]

enumFromThen :: E -> E -> [E]

enumFromTo :: E -> E -> [E]

enumFromThenTo :: E -> E -> E -> [E]

Eq E

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

Integral E

Defined in Test.LeanCheck.Utils.Types

Methods

quot :: E -> E -> E

rem :: E -> E -> E

div :: E -> E -> E

mod :: E -> E -> E

quotRem :: E -> E -> (E, E)

divMod :: E -> E -> (E, E)

toInteger :: E -> Integer

Num E

Defined in Test.LeanCheck.Utils.Types

Methods

(+) :: E -> E -> E

(-) :: E -> E -> E

(*) :: E -> E -> E

negate :: E -> E

abs :: E -> E

signum :: E -> E

fromInteger :: Integer -> E

Ord E

Defined in Test.LeanCheck.Utils.Types

Methods

compare :: E -> E -> Ordering

(<) :: E -> E -> Bool

(<=) :: E -> E -> Bool

(>) :: E -> E -> Bool

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

max :: E -> E -> E

min :: E -> E -> E

Read E

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS E

readList :: ReadS [E]

readPrec :: ReadPrec E

readListPrec :: ReadPrec [E]

Real E

Defined in Test.LeanCheck.Utils.Types

Methods

toRational :: E -> Rational

Show E

Defined in Test.LeanCheck.Utils.Types

Methods

showsPrec :: Int -> E -> ShowS

show :: E -> String

showList :: [E] -> ShowS

Ix E

Defined in Test.LeanCheck.Utils.Types

Methods

range :: (E, E) -> [E]

index :: (E, E) -> E -> Int

unsafeIndex :: (E, E) -> E -> Int

inRange :: (E, E) -> E -> Bool

rangeSize :: (E, E) -> Int

unsafeRangeSize :: (E, E) -> Int

Express E

Defined in Conjure.Expr

Methods

expr :: E -> Expr

Name E

Defined in Conjure.Conjurable

Methods

name :: E -> String

Listable E

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[E]]

list :: [E]

Conjurable E

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: E -> [Expr]

conjureEquality :: E -> Maybe Expr

conjureTiers :: E -> Maybe [[Expr]]

conjureSubTypes :: E -> Reification

conjureIf :: E -> Expr

conjureCases :: E -> [Expr]

conjureArgumentCases :: E -> [[Expr]]

conjureSize :: E -> Int

conjureExpress :: E -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe E

data F

Generic type F.

Can be used to test polymorphic functions with five type variables.

This type is homomorphic to A, B, C, D, E and Nat6.

Instances

Bounded F

Defined in Test.LeanCheck.Utils.Types

Methods

minBound :: F

maxBound :: F

Enum F

Defined in Test.LeanCheck.Utils.Types

Methods

succ :: F -> F

pred :: F -> F

toEnum :: Int -> F

fromEnum :: F -> Int

enumFrom :: F -> [F]

enumFromThen :: F -> F -> [F]

enumFromTo :: F -> F -> [F]

enumFromThenTo :: F -> F -> F -> [F]

Eq F

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

Integral F

Defined in Test.LeanCheck.Utils.Types

Methods

quot :: F -> F -> F

rem :: F -> F -> F

div :: F -> F -> F

mod :: F -> F -> F

quotRem :: F -> F -> (F, F)

divMod :: F -> F -> (F, F)

toInteger :: F -> Integer

Num F

Defined in Test.LeanCheck.Utils.Types

Methods

(+) :: F -> F -> F

(-) :: F -> F -> F

(*) :: F -> F -> F

negate :: F -> F

abs :: F -> F

signum :: F -> F

fromInteger :: Integer -> F

Ord F

Defined in Test.LeanCheck.Utils.Types

Methods

compare :: F -> F -> Ordering

(<) :: F -> F -> Bool

(<=) :: F -> F -> Bool

(>) :: F -> F -> Bool

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

max :: F -> F -> F

min :: F -> F -> F

Read F

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS F

readList :: ReadS [F]

readPrec :: ReadPrec F

readListPrec :: ReadPrec [F]

Real F

Defined in Test.LeanCheck.Utils.Types

Methods

toRational :: F -> Rational

Show F

Defined in Test.LeanCheck.Utils.Types

Methods

showsPrec :: Int -> F -> ShowS

show :: F -> String

showList :: [F] -> ShowS

Ix F

Defined in Test.LeanCheck.Utils.Types

Methods

range :: (F, F) -> [F]

index :: (F, F) -> F -> Int

unsafeIndex :: (F, F) -> F -> Int

inRange :: (F, F) -> F -> Bool

rangeSize :: (F, F) -> Int

unsafeRangeSize :: (F, F) -> Int

Express F

Defined in Conjure.Expr

Methods

expr :: F -> Expr

Name F

Defined in Conjure.Conjurable

Methods

name :: F -> String

Listable F

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[F]]

list :: [F]

Conjurable F

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: F -> [Expr]

conjureEquality :: F -> Maybe Expr

conjureTiers :: F -> Maybe [[Expr]]

conjureSubTypes :: F -> Reification

conjureIf :: F -> Expr

conjureCases :: F -> [Expr]

conjureArgumentCases :: F -> [[Expr]]

conjureSize :: F -> Int

conjureExpress :: F -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe F