FitSpec.Mutable

Enumeration of function mutations

Documentation

class Mutable a where

This typeclass is similar to Listable.

A type is Mutable when there exists a function that is able to list mutations of a value. Ideally: list all possible values without repetitions.

Instances are usually defined by a mutiers function that given a value, returns tiers of mutants of that value: the first tier contains the equivalent mutant, of size 0, the second tier contains mutants of size 1, the third tier contains mutants of size 2, and so on.

The equivalent mutant is the actual function without mutations.

The size of a mutant is given by the sum of: the number of mutated points (relations) and the sizes of mutated arguments and results.

To get only inequivalent mutants, just take the tail of either mutants or mutiers:

tail mutants

tail mutiers

Given that the underlying Listable enumeration has no repetitions parametric instances defined in this file will have no repeated mutants.

Minimal complete definition

mutants | mutiers

Methods

mutiers :: a -> [[a]]

mutants :: a -> [a]

Instances

Mutable Bool

mutants True = [True,False]

Methods

mutiers :: Bool -> [[Bool]]

mutants :: Bool -> [Bool]

Mutable Char

Methods

mutiers :: Char -> [[Char]]

mutants :: Char -> [Char]

Mutable Int

mutants 3 = [3,0,1,2,4,5,6,7,8,9,...

Methods

mutiers :: Int -> [[Int]]

mutants :: Int -> [Int]

Mutable ()

mutants () = [()]

Methods

mutiers :: () -> [[()]]

mutants :: () -> [()]

(Eq a, Listable a) => Mutable [a]

mutants [0] = [ [0], [], [0,0], [1], ...

Methods

mutiers :: [a] -> [[[a]]]

mutants :: [a] -> [[a]]

(Eq a, Listable a) => Mutable (Maybe a)

mutants (Just 0) = [Just 0, Nothing, ...

Methods

mutiers :: Maybe a -> [[Maybe a]]

mutants :: Maybe a -> [Maybe a]

(Eq a, Listable a, Mutable b) => Mutable (a -> b)

mutants not =
  [ not
  , \p -> case p of False -> False; _ -> not p
  , \p -> case p of True  -> True;  _ -> not p
  , \p -> case p of False -> False; True -> True
  ]

Methods

mutiers :: (a -> b) -> [[a -> b]]

mutants :: (a -> b) -> [a -> b]

(Mutable a, Mutable b) => Mutable (a, b)

mutants (0,1) = [(0,1),(0,0),(1,1),(0,-1),...]

Methods

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

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

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

Methods

mutiers :: (a, b, c) -> [[(a, b, c)]]

mutants :: (a, b, c) -> [(a, b, c)]

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

Methods

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

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

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

Methods

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

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

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

For Mutable tuple instances greater than sixtuples, see Tuples. Despite being hidden in this Haddock documentation, 7-tuples up to 12-tuples are exported by FitSpec.

Methods

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

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

mutiersEq :: (Listable a, Eq a) => a -> [[a]]

Implementation of mutiers for non-functional data types. Use this to create instances for user-defined data types, e.g.:

instance MyData
  where mutiers = mutiersEq

and for parametric datatypes:

instance (Eq a, Eq b) => MyDt a b
  where mutiers = mutiersEq

Examples:

mutiersEq True = [[True], [False]]
mutiersEq 2   = [[2], [0], [1], [], [3], [4], [5], [6], [7], [8], [9], ...]
mutiersEq [1] = [[[1]], [[]], [[0]], [[0,0]], [[0,0,0],[0,1],[1,0],[-1]], ...]