| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Data.Universe.Helpers
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.
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
newtype Tagged (s :: k) b Source #
A
value is a value
Tagged
s b
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
can't try to use the argument
Tagged
s b
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.
Instances
Type representing arbitrary-precision non-negative integers.
>>>2^100 :: Natural1267650600228229401496703205376
Operations whose result would be negative
,
throw
(
Underflow
::
ArithException
)
>>>-1 :: Natural*** Exception: arithmetic underflow
Since: base-4.8.0.0
Instances
Debugging
These functions exist primarily as a specification to test against.
unfairCartesianProduct :: (a -> b -> c) -> [a] -> [b] -> [c] Source #
Very unfair 2-way Cartesian product: same guarantee as the slightly unfair
one, except that lower indices may occur as the
fst
part of the tuple
exponentially more frequently.
unfairChoices :: [[a]] -> [[a]] Source #
Very unfair n-way Cartesian product: same guarantee as the slightly unfair one, but not as good in the same sense that the very unfair 2-way product is worse than the slightly unfair 2-way product.