Safe Haskell	Safe
Language	Haskell2010

Data.Universe.Helpers

Contents

Building lists
Building cardinalities
Debugging

Synopsis

universeDef :: (Bounded a, Enum a) => [a]
interleave :: [[a]] -> [a]
diagonal :: [[a]] -> [a]
diagonals :: [[a]] -> [[a]]
(+++) :: [a] -> [a] -> [a]
cartesianProduct :: (a -> b -> c) -> [a] -> [b] -> [c]
(+*+) :: [a] -> [b] -> [(a, b)]
(<+*+>) :: [a -> b] -> [a] -> [b]
choices :: [[a]] -> [[a]]
retagWith :: (a -> b) -> Tagged a x -> Tagged b x
retag :: forall {k1} {k2} (s :: k1) b (t :: k2). Tagged s b -> Tagged t b
newtype Tagged (s :: k) b = Tagged {
- unTagged :: b
}
data Natural
unfairCartesianProduct :: (a -> b -> c) -> [a] -> [b] -> [c]
unfairChoices :: [[a]] -> [[a]]

Documentation

This module is for functions that are useful for writing instances, but not necessarily for using them (and hence are not exported by the main module to avoid cluttering up the namespace).

Building lists

universeDef :: (Bounded a, Enum a) => [a] Source #

For many types, the universe should be [minBound .. maxBound]; universeDef makes it easy to make such types an instance of Universe via the snippet

instance Universe Foo where universe = universeDef

interleave :: [[a]] -> [a] Source #

Fair n-way interleaving: given a finite number of (possibly infinite) lists, produce a single list such that whenever v has finite index in one of the input lists, v also has finite index in the output list. No list's elements occur more frequently (on average) than another's.

diagonal :: [[a]] -> [a] Source #

Unfair n-way interleaving: given a possibly infinite number of (possibly infinite) lists, produce a single list such that whenever v has finite index in an input list at finite index, v also has finite index in the output list. Elements from lists at lower index occur more frequently, but not exponentially so.

diagonals :: [[a]] -> [[a]] Source #

Like diagonal, but expose a tiny bit more (non-semantic) information: if you lay out the input list in two dimensions, each list in the result will be one of the diagonals of the input. In particular, each element of the output will be a list whose elements are each from a distinct input list.

(+++) :: [a] -> [a] -> [a] Source #

Fair 2-way interleaving.

cartesianProduct :: (a -> b -> c) -> [a] -> [b] -> [c] Source #

Slightly unfair 2-way Cartesian product: given two (possibly infinite) lists, produce a single list such that whenever v and w have finite indices in the input lists, (v,w) has finite index in the output list. Lower indices occur as the fst part of the tuple more frequently, but not exponentially so.

(+*+) :: [a] -> [b] -> [(a, b)] Source #

cartesianProduct (,)

(<+*+>) :: [a -> b] -> [a] -> [b] Source #

A +*+ with application.

cartesianProduct ($)

choices :: [[a]] -> [[a]] Source #

Slightly unfair n-way Cartesian product: given a finite number of (possibly infinite) lists, produce a single list such that whenever vi has finite index in list i for each i, [v1, ..., vn] has finite index in the output list.

Building cardinalities

These functions are handy for inheriting the definition of cardinality in a newtype instance. For example, one might write

newtype Foo = Foo Bar
instance Finite Foo where cardinality = retagWith Foo cardinality

retagWith :: (a -> b) -> Tagged a x -> Tagged b x Source #

retag :: forall {k1} {k2} (s :: k1) b (t :: k2). Tagged s b -> Tagged t b Source #

Some times you need to change the tag you have lying around. Idiomatic usage is to make a new combinator for the relationship between the tags that you want to enforce, and define that combinator using retag.

data Succ n
retagSucc :: Tagged n a -> Tagged (Succ n) a
retagSucc = retag

newtype Tagged (s :: k) b Source #

A Tagged s b value is a value b with an attached phantom type s. This can be used in place of the more traditional but less safe idiom of passing in an undefined value with the type, because unlike an (s -> b), a Tagged s b can't try to use the argument s as a real value.

Moreover, you don't have to rely on the compiler to inline away the extra argument, because the newtype is "free"

Tagged has kind k -> * -> * if the compiler supports PolyKinds, therefore there is an extra k showing in the instance haddocks that may cause confusion.

Constructors

Tagged
Fields unTagged :: b

Instances

Instances details

Generic1 (Tagged s :: Type -> Type)

Instance details

PrintfArg Natural
Instance details Defined in Text.Printf Methods formatArg :: Natural -> FieldFormatter parseFormat :: Natural -> ModifierParser
NFData Natural
Instance details Defined in Control.DeepSeq Methods rnf :: Natural -> ()
Enum Natural
Instance details Defined in GHC.Internal.Enum Methods succ :: Natural -> Natural pred :: Natural -> Natural toEnum :: Int -> Natural fromEnum :: Natural -> Int enumFrom :: Natural -> [Natural] enumFromThen :: Natural -> Natural -> [Natural] enumFromTo :: Natural -> Natural -> [Natural] enumFromThenTo :: Natural -> Natural -> Natural -> [Natural]
Num Natural
Instance details Defined in GHC.Internal.Num Methods (+) :: Natural -> Natural -> Natural (-) :: Natural -> Natural -> Natural (*) :: Natural -> Natural -> Natural negate :: Natural -> Natural abs :: Natural -> Natural signum :: Natural -> Natural fromInteger :: Integer -> Natural
Integral Natural
Instance details Defined in GHC.Internal.Real Methods quot :: Natural -> Natural -> Natural rem :: Natural -> Natural -> Natural div :: Natural -> Natural -> Natural mod :: Natural -> Natural -> Natural quotRem :: Natural -> Natural -> (Natural, Natural) divMod :: Natural -> Natural -> (Natural, Natural) toInteger :: Natural -> Integer
Real Natural
Instance details Defined in GHC.Internal.Real Methods toRational :: Natural -> Rational
Eq Natural
Instance details Defined in GHC.Num.Natural Methods (==) :: Natural -> Natural -> Bool (/=) :: Natural -> Natural -> Bool
Ord Natural
Instance details Defined in GHC.Num.Natural Methods compare :: Natural -> Natural -> Ordering (<) :: Natural -> Natural -> Bool (<=) :: Natural -> Natural -> Bool (>) :: Natural -> Natural -> Bool (>=) :: Natural -> Natural -> Bool max :: Natural -> Natural -> Natural min :: Natural -> Natural -> Natural
Universe Natural Source #
Instance details Defined in Data.Universe.Class Methods universe :: [Natural] Source #
KnownNat n => HasResolution (n :: Nat)
Instance details Defined in Data.Fixed Methods resolution :: p n -> Integer
Lift Natural
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Natural -> m Exp liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural

Documentation

Building lists

Building cardinalities

Instances

Instances

Debugging