Conjure.Conjurable

This module is part of Conjure.

This defines the Conjurable typeclass and utilities involving it.

You are probably better off importing Conjure.

Documentation

type Reification1 = (Expr, Maybe Expr, Maybe [[Expr]], [String], Bool, Expr)

Single reification of some functions over a type as Exprs.

This is a sixtuple, in order:

1. a hole encoded as an Expr;
2. the == function encoded as an Expr when available;
3. tiers of enumerated test values encoded as Exprs when available;
4. infinite list of potential variable names;
5. boolean indicating whether the type is atomic;
6. the conjureSize function encoded as an Expr.

type Reification = [Reification1] -> [Reification1]

A reification over a collection of types.

Represented as a transformation of a list to a list.

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

conjureArgumentHoles :: a -> [Expr]

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

conjureIf :: a -> Expr

Returns an if-function encoded as an Expr.

conjureCases :: a -> [Expr]

Returns a top-level case breakdown.

conjureArgumentCases :: a -> [[Expr]]

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.

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

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)

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

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

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

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

conjureApplication :: Conjurable f => String -> f -> Expr

Computes a complete application for the given function.

> conjureApplication "not" not
not p :: Bool

> conjureApplication "+" ((+) :: Int -> Int -> Int)
x + y :: Int

(cf. conjureVarApplication)

conjureVarApplication :: Conjurable f => String -> f -> Expr

Computes a complete application for a variable of the same type of the given function.

> conjureVarApplication "not" not
not p :: Bool

> conjureVarApplication "+" ((+) :: Int -> Int -> Int)
x + y :: Int

(cf. conjureApplication)

conjurePats :: Conjurable f => [Expr] -> String -> f -> [[[Expr]]]

Computes tiers of sets of patterns for the given function.

> conjurePats [zero] "f" (undefined :: Int -> Int)
[[[f x :: Int]],[[f 0 :: Int,f x :: Int]]]

conjureHoles :: Conjurable f => f -> [Expr]

Computes a list of holes encoded as Exprs from a Conjurable functional value.

(cf. cjHoles)

conjureTiersFor :: Conjurable f => f -> Expr -> [[Expr]]

Compute tiers of values encoded as Exprs of the type of the given Expr.

conjureListFor :: Conjurable f => f -> Expr -> [Expr]

Compure a list of values encoded as Exprs of the type of the given Expr.

conjureSizeFor :: Conjurable f => f -> Expr -> Expr

Conjures an Expr-encoded size function for the given expression type.

> conjureSizeFor (undefined :: [Int] -> [Bool]) i_
conjureSize :: Int -> Int

> conjureSizeFor (undefined :: [Int] -> [Bool]) is_
conjureSize :: [Int] -> Int

> conjureSizeFor (undefined :: [Int] -> [Bool]) bs_
conjureSize :: [Bool] -> Int

conjureGrounds :: Conjurable f => f -> Expr -> [Expr]

conjureAreEqual :: Conjurable f => f -> Int -> Expr -> Expr -> Bool

Given a Conjurable functional value, computes a function that checks whether two Exprs are equal up to a given number of tests.

conjureMkEquation :: Conjurable f => f -> Expr -> Expr -> Expr

Computes a function that makes an equation between two expressions.

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]

conjureIsUnbreakable :: Conjurable f => f -> Expr -> Bool

Checks if an Expr is of an unbreakable type.

conjureReification :: Conjurable a => a -> [Reification1]

Conjures a list of Reification1 for a Conjurable type, its subtypes and Bool.

This is used in the implementation of conjureHoles, conjureMkEquation, conjureAreEqual, conjureTiersFor, conjureNamesFor, conjureIsUnbreakable, etc.

conjureReification1 :: Conjurable a => a -> Reification1

Conjures a Reification1 for a Conjurable type.

This is used in the implementation of conjureReification.

conjureDynamicEq :: Conjurable f => f -> Dynamic

conjureIsNumeric :: Conjurable f => f -> Expr -> Bool

cevaluate :: Conjurable f => Int -> Defn -> Maybe f

Evaluates a Defn into a regular Haskell value returning Nothing when there's a type mismatch.

The integer argument indicates the limit of recursive evaluations.

ceval :: Conjurable f => Int -> f -> Defn -> f

Evaluates a Defn into a regular Haskell value returning the given default value when there's a type mismatch.

The integer argument indicates the limit of recursive evaluations.

cevl :: Conjurable f => Int -> Defn -> f

Evaluates a Defn into a regular Haskell value raising an error there's a type mismatch.

The integer argument indicates the limit of recursive evaluations.

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

conjureArgumentPats :: Conjurable f => [Expr] -> f -> [[[[Expr]]]]

Returns a list of tiers of possible patterns for each argument.

The outer list has the same number of elements as the number of arguments of the given function.

This function is internal and only used in the implementation of conjurePats. It may be removed from the API without further notice. It has been temporarily promoted to public to help refactor conjurePats.

conjureMostGeneralCanonicalVariation :: Conjurable f => f -> Expr -> Expr

Orphan instances

Name A

Methods

name :: A -> String

Name B

Methods

name :: B -> String

Name C

Methods

name :: C -> String

Name D

Methods

name :: D -> String

Name E

Methods

name :: E -> String

Name F

Methods

name :: F -> String