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
-- pruning with 14/25 rules
-- 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.

primOrdCaseFor :: Conjurable a => a -> Prim

Provides a case 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

• maxDeconstructionSize :: Int

  maximum size of deconstructions (e.g.: _ - 1)

• carryOn :: Bool

  whether to carry on after finding a suitable candidate

• showTheory :: Bool

  show theory discovered by Speculate used in pruning

• usePatterns :: Bool

  use pattern matching to create (recursive) candidates

• rewriting :: Bool

  unique-modulo-rewriting candidates

• requireDescent :: Bool

  require recursive calls to deconstruct arguments

• adHocRedundancy :: Bool

  ad-hoc redundancy checks

• copyBindings :: Bool

  copy partial definition bindings in candidates

• atomicNumbers :: Bool

  restrict constant/ground numeric expressions to atoms

• uniqueCandidates :: Bool

  unique-modulo-testing candidates

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
• do not make candidates unique module testing

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

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

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

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

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

Conjures an implementation from a function specification.

This function works like conjure but instead of receiving a partial definition it receives a boolean filter / property about the function.

For example, given:

squareSpec :: (Int -> Int) -> Bool
squareSpec square  =  square 0 == 0
                   && square 1 == 1
                   && square 2 == 4

Then:

> conjureFromSpec "square" squareSpec primitives
square :: Int -> Int
-- 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

This allows users to specify QuickCheck-style properties, here is an example using LeanCheck:

import Test.LeanCheck (holds, exists)

squarePropertySpec :: (Int -> Int) -> Bool
squarePropertySpec square  =  and
  [ holds n $ \x -> square x >= x
  , holds n $ \x -> square x >= 0
  , exists n $ \x -> square x > x
  ]  where  n = 60

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

Like conjureFromSpec but allows setting options through Args/args.

conjureFromSpecWith args{maxSize = 11} "function" spec [...]

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.

Use reifyEquality when defining this.

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

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

Use reifyTiers when defining this.

conjureSubTypes :: a -> Reification

conjureCases :: a -> [Expr]

Returns a top-level case breakdown.

conjureSize :: a -> Int

Returns the (recursive) size of the given value.

conjureExpress :: a -> Expr -> Expr

Returns a function that deeply reencodes an expression when possible. (id when not available.)

Use reifyExpress when defining this.

Instances

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

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

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

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

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

(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 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, 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 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)

(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 h, Listable h, Show h, Express h) => Conjurable (a, b, c, d, e, f, g, h)

Defined in Conjure.Conjurable

Methods

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

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

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

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

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

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

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

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

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

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

(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 h, Listable h, Show h, Express h, Conjurable i, Listable i, Show i, Express i) => Conjurable (a, b, c, d, e, f, g, h, i)

Defined in Conjure.Conjurable

Methods

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

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

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

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

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

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

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

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

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

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

(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 h, Listable h, Show h, Express h, Conjurable i, Listable i, Show i, Express i, Conjurable j, Listable j, Show j, Express j) => Conjurable (a, b, c, d, e, f, g, h, i, j)

Defined in Conjure.Conjurable

Methods

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

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

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

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

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

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

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

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

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

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

(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 h, Listable h, Show h, Express h, Conjurable i, Listable i, Show i, Express i, Conjurable j, Listable j, Show j, Express j, Conjurable k, Listable k, Show k, Express k) => Conjurable (a, b, c, d, e, f, g, h, i, j, k)

Defined in Conjure.Conjurable

Methods

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

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

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

conjureSubTypes :: (a, b, c, d, e, f, g, h, i, j, k) -> Reification

conjureIf :: (a, b, c, d, e, f, g, h, i, j, k) -> Expr

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

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

conjureSize :: (a, b, c, d, e, f, g, h, i, j, k) -> Int

conjureExpress :: (a, b, c, d, e, f, g, h, i, j, k) -> Expr -> Expr

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

(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 h, Listable h, Show h, Express h, Conjurable i, Listable i, Show i, Express i, Conjurable j, Listable j, Show j, Express j, Conjurable k, Listable k, Show k, Express k, Conjurable l, Listable l, Show l, Express l) => Conjurable (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Conjure.Conjurable

Methods

conjureArgumentHoles :: (a, b, c, d, e, f, g, h, i, j, k, l) -> [Expr]

conjureEquality :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Maybe Expr

conjureTiers :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Maybe [[Expr]]

conjureSubTypes :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Reification

conjureIf :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Expr

conjureCases :: (a, b, c, d, e, f, g, h, i, j, k, l) -> [Expr]

conjureArgumentCases :: (a, b, c, d, e, f, g, h, i, j, k, l) -> [[Expr]]

conjureSize :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Int

conjureExpress :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Expr -> Expr

conjureEvaluate :: (Expr -> Expr) -> Int -> Defn -> Expr -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l)

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

Reifies the expr function in a Conjurable type instance.

This is to be used in the definition of conjureExpress of Conjurable typeclass instances.

instance ... => Conjurable <Type> where
  ...
  conjureExpress  =  reifyExpress
  ...

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

Reifies equality == in a Conjurable type instance.

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

To be used in the implementation of conjureSubTypes.

instance ... => Conjurable <Type> where
  ...
  conjureSubTypes x  =  conjureType (field1 x)
                     .  conjureType (field2 x)
                     .  ...
                     .  conjureType (fieldN x)
  ...

class Name a where

If we were to come up with a variable name for the given type what name would it be?

An instance for a given type Ty is simply given by:

instance Name Ty where name _ = "x"

Examples:

> name (undefined :: Int)
"x"

> name (undefined :: Bool)
"p"

> name (undefined :: [Int])
"xs"

This is then used to generate an infinite list of variable names:

> names (undefined :: Int)
["x", "y", "z", "x'", "y'", "z'", "x''", "y''", "z''", ...]

> names (undefined :: Bool)
["p", "q", "r", "p'", "q'", "r'", "p''", "q''", "r''", ...]

> names (undefined :: [Int])
["xs", "ys", "zs", "xs'", "ys'", "zs'", "xs''", "ys''", ...]

Minimal complete definition

Nothing

Methods

name :: a -> String

O(1).

Returns a name for a variable of the given argument's type.

> name (undefined :: Int)
"x"

> name (undefined :: [Bool])
"ps"

> name (undefined :: [Maybe Integer])
"mxs"

The default definition is:

name _ = "x"

Instances

Name Int16

Defined in Data.Express.Name

Methods

name :: Int16 -> String

Name Int32

Defined in Data.Express.Name

Methods

name :: Int32 -> String

Name Int64

Defined in Data.Express.Name

Methods

name :: Int64 -> String

Name Int8

Defined in Data.Express.Name

Methods

name :: Int8 -> String

Name GeneralCategory

Defined in Data.Express.Name

Methods

name :: GeneralCategory -> String

Name Word16

Defined in Data.Express.Name

Methods

name :: Word16 -> String

Name Word32

Defined in Data.Express.Name

Methods

name :: Word32 -> String

Name Word64

Defined in Data.Express.Name

Methods

name :: Word64 -> String

Name Word8

Defined in Data.Express.Name

Methods

name :: Word8 -> String

Name Ordering

name (undefined :: Ordering) = "o"
names (undefined :: Ordering) = ["o", "p", "q", "o'", ...]

Defined in Data.Express.Name

Methods

name :: Ordering -> String

Name A

Defined in Conjure.Conjurable

Methods

name :: A -> String

Name B

Defined in Conjure.Conjurable

Methods

name :: B -> String

Name C

Defined in Conjure.Conjurable

Methods

name :: C -> String

Name D

Defined in Conjure.Conjurable

Methods

name :: D -> String

Name E

Defined in Conjure.Conjurable

Methods

name :: E -> String

Name F

Defined in Conjure.Conjurable

Methods

name :: F -> String

Name Integer

name (undefined :: Integer) = "x"
names (undefined :: Integer) = ["x", "y", "z", "x'", ...]

Defined in Data.Express.Name

Methods

name :: Integer -> String

Name ()

name (undefined :: ()) = "u"
names (undefined :: ()) = ["u", "v", "w", "u'", "v'", ...]

Defined in Data.Express.Name

Methods

name :: () -> String

Name Bool

name (undefined :: Bool) = "p"
names (undefined :: Bool) = ["p", "q", "r", "p'", "q'", ...]

Defined in Data.Express.Name

Methods

name :: Bool -> String

Name Char

name (undefined :: Char) = "c"
names (undefined :: Char) = ["c", "d", "e", "c'", "d'", ...]

Defined in Data.Express.Name

Methods

name :: Char -> String

Name Double

name (undefined :: Double) = "x"
names (undefined :: Double) = ["x", "y", "z", "x'", ...]

Defined in Data.Express.Name

Methods

name :: Double -> String

Name Float

name (undefined :: Float) = "x"
names (undefined :: Float) = ["x", "y", "z", "x'", ...]

Defined in Data.Express.Name

Methods

name :: Float -> String

Name Int

name (undefined :: Int) = "x"
names (undefined :: Int) = ["x", "y", "z", "x'", "y'", ...]

Defined in Data.Express.Name

Methods

name :: Int -> String

Name Word

Defined in Data.Express.Name

Methods

name :: Word -> String

Name (Complex a)

name (undefined :: Complex) = "x"
names (undefined :: Complex) = ["x", "y", "z", "x'", ...]

Defined in Data.Express.Name

Methods

name :: Complex a -> String

Name (Ratio a)

name (undefined :: Rational) = "q"
names (undefined :: Rational) = ["q", "r", "s", "q'", ...]

Defined in Data.Express.Name

Methods

name :: Ratio a -> String

Name a => Name (Maybe a)

names (undefined :: Maybe Int) = ["mx", "mx1", "mx2", ...]
nemes (undefined :: Maybe Bool) = ["mp", "mp1", "mp2", ...]

Defined in Data.Express.Name

Methods

name :: Maybe a -> String

Name a => Name [a]

names (undefined :: [Int]) = ["xs", "ys", "zs", "xs'", ...]
names (undefined :: [Bool]) = ["ps", "qs", "rs", "ps'", ...]

Defined in Data.Express.Name

Methods

name :: [a] -> String

(Name a, Name b) => Name (Either a b)

names (undefined :: Either Int Int) = ["exy", "exy1", ...]
names (undefined :: Either Int Bool) = ["exp", "exp1", ...]

Defined in Data.Express.Name

Methods

name :: Either a b -> String

(Name a, Name b) => Name (a, b)

names (undefined :: (Int,Int)) = ["xy", "zw", "xy'", ...]
names (undefined :: (Bool,Bool)) = ["pq", "rs", "pq'", ...]

Defined in Data.Express.Name

Methods

name :: (a, b) -> String

Name (a -> b)

names (undefined :: ()->()) = ["f", "g", "h", "f'", ...]
names (undefined :: Int->Int) = ["f", "g", "h", ...]

Defined in Data.Express.Name

Methods

name :: (a -> b) -> String

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

names (undefined :: (Int,Int,Int)) = ["xyz","uvw", ...]
names (undefined :: (Int,Bool,Char)) = ["xpc", "xpc1", ...]

Defined in Data.Express.Name

Methods

name :: (a, b, c) -> String

(Name a, Name b, Name c, Name d) => Name (a, b, c, d)

names (undefined :: ((),(),(),())) = ["uuuu", "uuuu1", ...]
names (undefined :: (Int,Int,Int,Int)) = ["xxxx", ...]

Defined in Data.Express.Name

Methods

name :: (a, b, c, d) -> String

(Name a, Name b, Name c, Name d, Name e) => Name (a, b, c, d, e)

Defined in Data.Express.Name

Methods

name :: (a, b, c, d, e) -> String

(Name a, Name b, Name c, Name d, Name e, Name f) => Name (a, b, c, d, e, f)

Defined in Data.Express.Name

Methods

name :: (a, b, c, d, e, f) -> String

(Name a, Name b, Name c, Name d, Name e, Name f, Name g) => Name (a, b, c, d, e, f, g)

Defined in Data.Express.Name

Methods

name :: (a, b, c, d, e, f, g) -> String

(Name a, Name b, Name c, Name d, Name e, Name f, Name g, Name h) => Name (a, b, c, d, e, f, g, h)

Defined in Data.Express.Name

Methods

name :: (a, b, c, d, e, f, g, h) -> String

(Name a, Name b, Name c, Name d, Name e, Name f, Name g, Name h, Name i) => Name (a, b, c, d, e, f, g, h, i)

Defined in Data.Express.Name

Methods

name :: (a, b, c, d, e, f, g, h, i) -> String

(Name a, Name b, Name c, Name d, Name e, Name f, Name g, Name h, Name i, Name j) => Name (a, b, c, d, e, f, g, h, i, j)

Defined in Data.Express.Name

Methods

name :: (a, b, c, d, e, f, g, h, i, j) -> String

(Name a, Name b, Name c, Name d, Name e, Name f, Name g, Name h, Name i, Name j, Name k) => Name (a, b, c, d, e, f, g, h, i, j, k)

Defined in Data.Express.Name

Methods

name :: (a, b, c, d, e, f, g, h, i, j, k) -> String

(Name a, Name b, Name c, Name d, Name e, Name f, Name g, Name h, Name i, Name j, Name k, Name l) => Name (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Data.Express.Name

Methods

name :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String

class (Show a, Typeable a) => Express a where

Express typeclass instances provide an expr function that allows values to be deeply encoded as applications of Exprs.

expr False  =  val False
expr (Just True)  =  value "Just" (Just :: Bool -> Maybe Bool) :$ val True

The function expr can be contrasted with the function val:

• val always encodes values as atomic Value Exprs -- shallow encoding.
• expr ideally encodes expressions as applications (:$) between Value Exprs -- deep encoding.

Depending on the situation, one or the other may be desirable.

Instances can be automatically derived using the TH function deriveExpress.

The following example shows a datatype and its instance:

data Stack a = Stack a (Stack a) | Empty

instance Express a => Express (Stack a) where
  expr s@(Stack x y) = value "Stack" (Stack ->>: s) :$ expr x :$ expr y
  expr s@Empty       = value "Empty" (Empty   -: s)

To declare expr it may be useful to use auxiliary type binding operators: -:, ->:, ->>:, ->>>:, ->>>>:, ->>>>>:, ...

For types with atomic values, just declare expr = val

Methods

expr :: a -> Expr

Instances

Express Int16

Defined in Data.Express.Express

Methods

expr :: Int16 -> Expr

Express Int32

Defined in Data.Express.Express

Methods

expr :: Int32 -> Expr

Express Int64

Defined in Data.Express.Express

Methods

expr :: Int64 -> Expr

Express Int8

Defined in Data.Express.Express

Methods

expr :: Int8 -> Expr

Express GeneralCategory

Defined in Data.Express.Express

Methods

expr :: GeneralCategory -> Expr

Express Word16

Defined in Data.Express.Express

Methods

expr :: Word16 -> Expr

Express Word32

Defined in Data.Express.Express

Methods

expr :: Word32 -> Expr

Express Word64

Defined in Data.Express.Express

Methods

expr :: Word64 -> Expr

Express Word8

Defined in Data.Express.Express

Methods

expr :: Word8 -> Expr

Express Ordering

Defined in Data.Express.Express

Methods

expr :: Ordering -> Expr

Express A

Defined in Conjure.Expr

Methods

expr :: A -> Expr

Express B

Defined in Conjure.Expr

Methods

expr :: B -> Expr

Express C

Defined in Conjure.Expr

Methods

expr :: C -> Expr

Express D

Defined in Conjure.Expr

Methods

expr :: D -> Expr

Express E

Defined in Conjure.Expr

Methods

expr :: E -> Expr

Express F

Defined in Conjure.Expr

Methods

expr :: F -> Expr

Express Integer

Defined in Data.Express.Express

Methods

expr :: Integer -> Expr

Express ()

Defined in Data.Express.Express

Methods

expr :: () -> Expr

Express Bool

Defined in Data.Express.Express

Methods

expr :: Bool -> Expr

Express Char

Defined in Data.Express.Express

Methods

expr :: Char -> Expr

Express Double

Defined in Data.Express.Express

Methods

expr :: Double -> Expr

Express Float

Defined in Data.Express.Express

Methods

expr :: Float -> Expr

Express Int

Defined in Data.Express.Express

Methods

expr :: Int -> Expr

Express Word

Defined in Data.Express.Express

Methods

expr :: Word -> Expr

(RealFloat a, Express a) => Express (Complex a)

Defined in Data.Express.Express

Methods

expr :: Complex a -> Expr

(Integral a, Express a) => Express (Ratio a)

Defined in Data.Express.Express

Methods

expr :: Ratio a -> Expr

Express a => Express (Maybe a)

Defined in Data.Express.Express

Methods

expr :: Maybe a -> Expr

Express a => Express [a]

Defined in Data.Express.Express

Methods

expr :: [a] -> Expr

(Express a, Express b) => Express (Either a b)

Defined in Data.Express.Express

Methods

expr :: Either a b -> Expr

(Express a, Express b) => Express (a, b)

Defined in Data.Express.Express

Methods

expr :: (a, b) -> Expr

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

Defined in Data.Express.Express

Methods

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

(Express a, Express b, Express c, Express d) => Express (a, b, c, d)

Defined in Data.Express.Express

Methods

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

(Express a, Express b, Express c, Express d, Express e) => Express (a, b, c, d, e)

Defined in Data.Express.Express

Methods

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

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

Defined in Data.Express.Express

Methods

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

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

Defined in Data.Express.Express

Methods

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

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h) => Express (a, b, c, d, e, f, g, h)

Defined in Data.Express.Express

Methods

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

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h, Express i) => Express (a, b, c, d, e, f, g, h, i)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h, i) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h, Express i, Express j) => Express (a, b, c, d, e, f, g, h, i, j)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h, i, j) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h, Express i, Express j, Express k) => Express (a, b, c, d, e, f, g, h, i, j, k)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h, i, j, k) -> Expr

(Express a, Express b, Express c, Express d, Express e, Express f, Express g, Express h, Express i, Express j, Express k, Express l) => Express (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Data.Express.Express

Methods

expr :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Expr

deriveConjurable :: Name -> DecsQ

Derives an Conjurable instance for the given type Name.

This function needs the TemplateHaskell extension.

If -:, ->:, ->>:, ->>>:, ... are not in scope, this will derive them as well.

For now, this function only derives conjureEquality, conjureTiers and conjureExpress and does not derive conjureSubTypes, conjureArgumentCases and conjureSize. These will be added in future versions. If you plan to use features that depend on these functionalities, please define your instances manually.

deriveConjurableIfNeeded :: Name -> DecsQ

Same as deriveConjurable but does not warn when instance already exists (deriveConjurable is preferable).

For now, this function only derives conjureEquality, conjureTiers and conjureExpress and does not derive conjureSubTypes, conjureArgumentCases and conjureSize. These will be added in future versions. If you plan to use features that depend on these functionalities, please define your instances manually.

deriveConjurableCascading :: Name -> DecsQ

Derives a Conjurable instance for a given type Name cascading derivation of type arguments as well.

For now, this function only derives conjureEquality, conjureTiers and conjureExpress and does not derive conjureSubTypes, conjureArgumentCases and conjureSize. These will be added in future versions. If you plan to use features that depend on these functionalities, please define your instances manually.

Pure interfaces

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

Like conjure but in the pure world.

Returns a quadruple with:

1. tiers of implementations
2. tiers of candidates
3. a list of tests
4. the underlying theory

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]

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

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

Read A

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS A

readList :: ReadS [A]

readPrec :: ReadPrec A

readListPrec :: ReadPrec [A]

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

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

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

Express A

Defined in Conjure.Expr

Methods

expr :: A -> Expr

Name A

Defined in Conjure.Conjurable

Methods

name :: A -> String

Eq A

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

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

Listable A

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[A]]

list :: [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]

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

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

Read B

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS B

readList :: ReadS [B]

readPrec :: ReadPrec B

readListPrec :: ReadPrec [B]

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

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

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

Express B

Defined in Conjure.Expr

Methods

expr :: B -> Expr

Name B

Defined in Conjure.Conjurable

Methods

name :: B -> String

Eq B

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

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

Listable B

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[B]]

list :: [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]

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

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

Read C

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS C

readList :: ReadS [C]

readPrec :: ReadPrec C

readListPrec :: ReadPrec [C]

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

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

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

Express C

Defined in Conjure.Expr

Methods

expr :: C -> Expr

Name C

Defined in Conjure.Conjurable

Methods

name :: C -> String

Eq C

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

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

Listable C

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[C]]

list :: [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]

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

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

Read D

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS D

readList :: ReadS [D]

readPrec :: ReadPrec D

readListPrec :: ReadPrec [D]

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

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

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

Express D

Defined in Conjure.Expr

Methods

expr :: D -> Expr

Name D

Defined in Conjure.Conjurable

Methods

name :: D -> String

Eq D

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

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

Listable D

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[D]]

list :: [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]

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

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

Read E

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS E

readList :: ReadS [E]

readPrec :: ReadPrec E

readListPrec :: ReadPrec [E]

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

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

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

Express E

Defined in Conjure.Expr

Methods

expr :: E -> Expr

Name E

Defined in Conjure.Conjurable

Methods

name :: E -> String

Eq E

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

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

Listable E

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[E]]

list :: [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]

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

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

Read F

Defined in Test.LeanCheck.Utils.Types

Methods

readsPrec :: Int -> ReadS F

readList :: ReadS [F]

readPrec :: ReadPrec F

readListPrec :: ReadPrec [F]

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

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

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

Express F

Defined in Conjure.Expr

Methods

expr :: F -> Expr

Name F

Defined in Conjure.Conjurable

Methods

name :: F -> String

Eq F

Defined in Test.LeanCheck.Utils.Types

Methods

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

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

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

Listable F

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[F]]

list :: [F]