Copyright | (c) Tristan Wibberley 2017 |
---|---|
License | GPL-2 |
Maintainer | tristan.wibberley@gmail.com |
Stability | experimental |
Safe Haskell | None |
Language | Haskell2010 |
Here is a longer description of this module, containing some
commentary with some markup
.
- data SubZero f g a
- points :: (Functor f, Alternative g) => (a -> Bool) -> f a -> SubZero f g a
- reveal :: (Functor f, Applicative g) => f a -> SubZero f g a
- flatten :: Applicative f => f a -> SubZero f Maybe a -> f a
- collapse :: (Functor f, Foldable g, Alternative h) => (a -> a -> a) -> SubZero f g a -> SubZero f h a
Documentation
Converts a functor so that each point at the source has alternatives.
It's just like Compose but the applicative instance appends new alternative values in the rightmost (inner/minor) functor instead of in the leftmost (outer/major) functor.
The result is that two
s of alternatives zip together,
providing alternatives to each point.ZipList
Given the immediate utility of this, I do wonder if the
instance of Alternative
is the wrong one.Compose
f
- The major functor, overall mapping/view
g
- This has a a few key useful interpretations depending on its instances, examples below.
a
- Transformed/contained value type.
Some example instances that you might want to rely on from g
:
Alternative
- Superposition functor.
- How do individual items have a set of possible values?
- How do those possible values collapse to form one optional value?
- etc.
- etc
- There are a lot of other utilities for this type.
(Functor g, Functor f) => Functor (SubZero f g) Source # | |
(Applicative g, Applicative f) => Applicative (SubZero f g) Source # | |
(Applicative f, Alternative g) => Alternative (SubZero f g) Source # | |
(Eq a, Eq1 g, Eq1 f) => Eq (SubZero f g a) Source # | |
(Ord a, Ord1 g, Ord1 f) => Ord (SubZero f g a) Source # | |
(Read a, Read1 g, Read1 f) => Read (SubZero f g a) Source # | |
(Show a, Show1 g, Show1 f) => Show (SubZero f g a) Source # | |
Constructors
:: (Functor f, Alternative g) | |
=> (a -> Bool) | A predicate that indicates whether a point is occupied by its original value or vacant. |
-> f a | The seed points with their values. |
-> SubZero f g a | The constructed |
Turns a container of values to a container of either retained or destroyed values based on a predicate
The type constraint allows us to model possible outcomes so destroyed values are just "no possible outcomes" while retained values represent "the only possible outcome".
To represent that "no value" is a possible outcome, a
should be some type like (
) or (Maybe
a
).Either
String
a
f
- This
Functor
defines the broad scale behaviours but itsAlternative
instance is overridden. This in particular might change during upcoming design validation. g
- This
Functor
supplies the supercedentAlternative
instance and thus the finer behaviours.
:: (Functor f, Applicative g) | |
=> f a | Initial flat structure |
-> SubZero f g a | enhanced structure, albeit with no changes |
Provides structure for values at the other end of a Functor
Destructors
:: Applicative f | |
=> f a | Default values |
-> SubZero f Maybe a | Structured container |
-> f a | Destructured container |
If the type of the possibilities concept is
then you can
use Maybe
to provide default values for impossible points.flatten
- NOTE: This uses the applicative instance of the broad scale
which means exact behaviour can vary depending on the type ofFunctor
because each has a different technique to ensure a value is found for every point:Applicative
f
list of a
- Cross-product; Providing all default values once for all points.
ZipList
a- zipWith; Providing one default value for each point until there are either no defaults remaining or no more points.
Identity
a- One default must surely be provided and it is used if a default is required.
Maybe
a- Not sure exactly what this does, TBC.
Either
a- Not sure exactly what this does, TBC.
Restructors
:: (Functor f, Foldable g, Alternative h) | |
=> (a -> a -> a) | combining function |
-> SubZero f g a | full structure |
-> SubZero f h a | collapsed structure |
Take the alternatives embedded in the
and collapse them
with a combining function to a single SubZero
value or empty which
means no possible outcomes.
This is quite free in the type of the possibilities concept of the result.
It's compatible with Alternative
for further uses with Maybe
, but you can
retain behaviours of more sophisticated types. A consequence of this
is that you will probably need to state a type.flatten