Safe Haskell  SafeInferred 

Language  Haskell2010 
Types are great. Lifting them into some sort of applicative functor makes them even better. This module is an homage to our favorite applicatives, and to the semigroups with which they are instrinsically connected.
Synopsis
 data LiftedButWhy a = LiftedButWhy a
 data OrNot a
 = ActuallyYes a
  Nope
 data Two a = Two {
 firstOfTwo :: a
 secondOfTwo :: a
 data AnyNumberOf a
 = OneAndMaybeMore a (AnyNumberOf a)
  ActuallyNone
 (~~) :: a > AnyNumberOf a > AnyNumberOf a
 data OneOrMore a = OneOrMore {
 theFirstOfMany :: a
 possiblyMore :: AnyNumberOf a
 data Also extraThing a = Also {
 withoutExtraThing :: a
 theExtraThing :: extraThing
 data OrInstead otherThing a
 = NotInstead a
  Instead otherThing
 data OrInsteadFirst otherThing a
 = NotInsteadFirst a
  InsteadFirst otherThing
 data DeterminedBy parameter a = Determination ((>) parameter a)
Liftedbutwhy
data LiftedButWhy a Source #
LiftedButWhy
is a boring functor that just has one value and no other
structure or interesting properties.
LiftedButWhy a  A value that has been lifted for some damned reason. ... Okay, to be honest, this one is nobody's favorite, but it is included here for completeness. 
Instances
Ornot
OrNot
is somehow slightly more interesting than LiftedButWhy
, even
though it may actually contain less. Instead of a value, there might not
be a value.
When you combine stuff with (<*>)
or (<>)
, all of the values need to
be present. If any of them are absent, the whole expression evaluates to
Nope
.
ActuallyYes a  Some normal value. 
Nope  Chuck Testa. 
Instances
Monad OrNot Source #  
Functor OrNot Source #  
Applicative OrNot Source #  If you have a function pure = ActuallyYes ActuallyYes f <*> ActuallyYes a = ActuallyYes (f a) _ <*> _ = Nope 
Eq a => Eq (OrNot a) Source #  
Show a => Show (OrNot a) Source #  
Semigroup a => Semigroup (OrNot a) Source #  If you have value ActuallyYes a <> ActuallyYes a' = ActuallyYes (a <> a') _ <> _ = Nope 
Monoid a => Monoid (OrNot a) Source #  mempty = ActuallyYes mempty 
Defined in Acme.Functors 
Two
Two
is two values. Yep. Just two values.
Two  

Instances
Functor Two Source #  
Applicative Two Source #  If you have two functions pure a = Two a a Two f g <*> Two a a' = Two (f a) (g a') 
Eq a => Eq (Two a) Source #  
Show a => Show (Two a) Source #  
Semigroup a => Semigroup (Two a) Source #  Two x y <> Two x' y' = Two (x <> x') (y <> y') 
Monoid a => Monoid (Two a) Source #  mempty = Two mempty mempty 
Defined in Acme.Functors 
Anynumberof
data AnyNumberOf a Source #
AnyNumberOf
starts to get exciting. Any number of values you want.
Zero ... one ... two ... three ... four ... five ... The possibilities are
truly endless.
OneAndMaybeMore a (AnyNumberOf a)  One value, and maybe even more after that! 
ActuallyNone  Oh. Well this is less fun. 
Instances
Functor AnyNumberOf Source #  
Defined in Acme.Functors fmap :: (a > b) > AnyNumberOf a > AnyNumberOf b # (<$) :: a > AnyNumberOf b > AnyNumberOf a #  
Applicative AnyNumberOf Source #  You can use this to apply any number of functions to any number of arguments. pure a = OneAndMaybeMore a ActuallyNone OneAndMaybeMore f fs <*> OneAndMaybeMore x xs = OneAndMaybeMore (f x) (fs <*> xs) _ <*> _ = ActuallyNone Example: ( (+ 1) ~~ (* 2) ~~ (+ 5) ~~ ActuallyNone ) <*> ( 1 ~~ 6 ~~ 4 ~~ 37 ~~ ActuallyNone ) = ( 2 ~~ 12 ~~ 9 ~~ ActuallyNone ) This example demonstrates how when there are more arguments than functions,
any excess arguments (in this case, the 
Defined in Acme.Functors pure :: a > AnyNumberOf a # (<*>) :: AnyNumberOf (a > b) > AnyNumberOf a > AnyNumberOf b # liftA2 :: (a > b > c) > AnyNumberOf a > AnyNumberOf b > AnyNumberOf c # (*>) :: AnyNumberOf a > AnyNumberOf b > AnyNumberOf b # (<*) :: AnyNumberOf a > AnyNumberOf b > AnyNumberOf a #  
Eq a => Eq (AnyNumberOf a) Source #  
Defined in Acme.Functors (==) :: AnyNumberOf a > AnyNumberOf a > Bool # (/=) :: AnyNumberOf a > AnyNumberOf a > Bool #  
Show a => Show (AnyNumberOf a) Source #  
Defined in Acme.Functors showsPrec :: Int > AnyNumberOf a > ShowS # show :: AnyNumberOf a > String # showList :: [AnyNumberOf a] > ShowS #  
Semigroup a => Semigroup (AnyNumberOf a) Source #  The operation of combining some number of OneAndMaybeMore x xs <> OneAndMaybeMore y ys = OneAndMaybeMore (x <> y) (xs <> ys) _ <> _ = ActuallyNone 
Defined in Acme.Functors (<>) :: AnyNumberOf a > AnyNumberOf a > AnyNumberOf a # sconcat :: NonEmpty (AnyNumberOf a) > AnyNumberOf a # stimes :: Integral b => b > AnyNumberOf a > AnyNumberOf a #  
Monoid a => Monoid (AnyNumberOf a) Source #  mempty = mempty ~~ mempty 
Defined in Acme.Functors mempty :: AnyNumberOf a Source # 
(~~) :: a > AnyNumberOf a > AnyNumberOf a infixr 5 Source #
Alias for OneAndMaybeMore
which provides some brevity.
Oneormore
OneOrMore
is more restrictive than AnyNumberOf
, yet somehow
actually more interesting, because it excludes that dull situation where
there aren't any values at all.
OneOrMore  

Instances
Functor OneOrMore Source #  
Applicative OneOrMore Source #  pure a = OneOrMore a ActuallyNone OneOrMore f fs <*> OneOrMore x xs = OneOrMore (f x) (fs <*> xs) 
Eq a => Eq (OneOrMore a) Source #  
Show a => Show (OneOrMore a) Source #  
Semigroup a => Semigroup (OneOrMore a) Source #  OneOrMore a more <> OneOrMore a' more' = OneOrMore a (more <> OneAndMaybeMore a' more') 
Monoid a => Monoid (OneOrMore a) Source #  mempty = OneOrMore mempty ActuallyNone 
Defined in Acme.Functors 
Alsoextrathing
data Also extraThing a Source #
Also extraThing
is a functor in which each value has an extraThing
of some other type that tags along with it.
Also  

Instances
Functor (Also extraThing) Source #  
Monoid extraThing => Applicative (Also extraThing) Source #  Dragging the pure = (`Also` mempty) (f `Also` extra1) <*> (a `Also` extra2) = f a `Also` (extra1 <> extra2) 
Defined in Acme.Functors pure :: a > Also extraThing a # (<*>) :: Also extraThing (a > b) > Also extraThing a > Also extraThing b # liftA2 :: (a > b > c) > Also extraThing a > Also extraThing b > Also extraThing c # (*>) :: Also extraThing a > Also extraThing b > Also extraThing b # (<*) :: Also extraThing a > Also extraThing b > Also extraThing a #  
(Eq a, Eq extraThing) => Eq (Also extraThing a) Source #  
(Show a, Show extraThing) => Show (Also extraThing a) Source #  
(Semigroup extraThing, Semigroup a) => Semigroup (Also extraThing a) Source #  (a `Also` extra1) <> (a' `Also` extra2) = (a <> a') `Also` (extra1 <> extra2) 
(Monoid extraThing, Monoid a) => Monoid (Also extraThing a) Source #  mempty = Also mempty mempty 
Defined in Acme.Functors 
Orinsteadotherthing
data OrInstead otherThing a Source #
OrInstead otherThing
is a functor in which, instead of having a
value, can actually just have some totally unrelated otherThing
instead.
When you combine stuff with (<*>)
or (<>)
, all of the values need to
be present. If any of them are the otherThing
instead, then the whole
expression evaluates to the combination of the otherThing
s.
NotInstead a  A normal value. 
Instead otherThing  Some totally unrelated other thing. 
Instances
Functor (OrInstead otherThing) Source #  
Semigroup otherThing => Applicative (OrInstead otherThing) Source #  The possibility of having an pure = NotInstead NotInstead f <*> NotInstead a = NotInstead (f a) Instead other1 <*> Instead other2 = Instead (other1 <> other2) Instead other <*> _ = Instead other _ <*> Instead other = Instead other 
Defined in Acme.Functors pure :: a > OrInstead otherThing a # (<*>) :: OrInstead otherThing (a > b) > OrInstead otherThing a > OrInstead otherThing b # liftA2 :: (a > b > c) > OrInstead otherThing a > OrInstead otherThing b > OrInstead otherThing c # (*>) :: OrInstead otherThing a > OrInstead otherThing b > OrInstead otherThing b # (<*) :: OrInstead otherThing a > OrInstead otherThing b > OrInstead otherThing a #  
(Eq a, Eq otherThing) => Eq (OrInstead otherThing a) Source #  
(Show a, Show otherThing) => Show (OrInstead otherThing a) Source #  
(Semigroup otherThing, Semigroup a) => Semigroup (OrInstead otherThing a) Source #  NotInstead a <> NotInstead a' = NotInstead (a <> a') Instead other1 <> Instead other2 = Instead (other1 <> other2) Instead other <> _ = Instead other _ <> Instead other = Instead other 
(Semigroup otherThing, Monoid a) => Monoid (OrInstead otherThing a) Source #  
Defined in Acme.Functors 
Orinsteadotherthing ("first" variant)
data OrInsteadFirst otherThing a Source #
OrInsteadFirst otherThing
looks a lot like OrInstead otherThing
,
but it manages to always be an applicative functor — and even a monad too —
by handling the otherThing
s a bit more hamfistedly.
When you combine stuff with (<*>)
or (<>)
, all of the values need to
be present. If any of them are the otherThing
instead, then the whole
expression evaluates to the first otherThing
encountered, ignoring any
additional otherThing
s that may subsequently pop up.
NotInsteadFirst a  A normal value. 
InsteadFirst otherThing  Some totally unrelated other thing. 
Instances
Monad (OrInsteadFirst otherThing) Source #  InsteadFirst other >>= _ = InsteadFirst other NotInsteadFirst a >>= f = f a 
Defined in Acme.Functors (>>=) :: OrInsteadFirst otherThing a > (a > OrInsteadFirst otherThing b) > OrInsteadFirst otherThing b # (>>) :: OrInsteadFirst otherThing a > OrInsteadFirst otherThing b > OrInsteadFirst otherThing b # return :: a > OrInsteadFirst otherThing a #  
Functor (OrInsteadFirst otherThing) Source #  
Defined in Acme.Functors fmap :: (a > b) > OrInsteadFirst otherThing a > OrInsteadFirst otherThing b # (<$) :: a > OrInsteadFirst otherThing b > OrInsteadFirst otherThing a #  
Applicative (OrInsteadFirst otherThing) Source #  pure = NotInsteadFirst NotInsteadFirst f <*> NotInsteadFirst a = NotInsteadFirst (f a) InsteadFirst other <*> _ = InsteadFirst other _ <*> InsteadFirst other = InsteadFirst other 
Defined in Acme.Functors pure :: a > OrInsteadFirst otherThing a # (<*>) :: OrInsteadFirst otherThing (a > b) > OrInsteadFirst otherThing a > OrInsteadFirst otherThing b # liftA2 :: (a > b > c) > OrInsteadFirst otherThing a > OrInsteadFirst otherThing b > OrInsteadFirst otherThing c # (*>) :: OrInsteadFirst otherThing a > OrInsteadFirst otherThing b > OrInsteadFirst otherThing b # (<*) :: OrInsteadFirst otherThing a > OrInsteadFirst otherThing b > OrInsteadFirst otherThing a #  
(Eq a, Eq otherThing) => Eq (OrInsteadFirst otherThing a) Source #  
Defined in Acme.Functors (==) :: OrInsteadFirst otherThing a > OrInsteadFirst otherThing a > Bool # (/=) :: OrInsteadFirst otherThing a > OrInsteadFirst otherThing a > Bool #  
(Show a, Show otherThing) => Show (OrInsteadFirst otherThing a) Source #  
Defined in Acme.Functors showsPrec :: Int > OrInsteadFirst otherThing a > ShowS # show :: OrInsteadFirst otherThing a > String # showList :: [OrInsteadFirst otherThing a] > ShowS #  
(Semigroup otherThing, Semigroup a) => Semigroup (OrInsteadFirst otherThing a) Source #  NotInsteadFirst a <> NotInsteadFirst a' = NotInsteadFirst (a <> a') InsteadFirst other <> _ = InsteadFirst other _ <> InsteadFirst other = InsteadFirst other 
Defined in Acme.Functors (<>) :: OrInsteadFirst otherThing a > OrInsteadFirst otherThing a > OrInsteadFirst otherThing a # sconcat :: NonEmpty (OrInsteadFirst otherThing a) > OrInsteadFirst otherThing a # stimes :: Integral b => b > OrInsteadFirst otherThing a > OrInsteadFirst otherThing a #  
(Semigroup otherThing, Monoid a) => Monoid (OrInsteadFirst otherThing a) Source #  mempty = NotInsteadFirst mempty 
Defined in Acme.Functors mempty :: OrInsteadFirst otherThing a Source # 
Determinedbyparameter
data DeterminedBy parameter a Source #
DeterminedBy parameter
is a value that... well, we're not really sure
what it is. We'll find out once a parameter
is provided.
The mechanism for deciding how the value is determined from the
parameter
is opaque; all you can do is test it with different parameters
and see what results. There aren't even Eq
or Show
instances, which is
annoying.
Determination ((>) parameter a) 
Instances
Monad (DeterminedBy parameter) Source #  Determination fa >>= ff = Determination (\x > let Determination f = ff (fa x) in f x) 
Defined in Acme.Functors (>>=) :: DeterminedBy parameter a > (a > DeterminedBy parameter b) > DeterminedBy parameter b # (>>) :: DeterminedBy parameter a > DeterminedBy parameter b > DeterminedBy parameter b # return :: a > DeterminedBy parameter a #  
Functor (DeterminedBy parameter) Source #  
Defined in Acme.Functors fmap :: (a > b) > DeterminedBy parameter a > DeterminedBy parameter b # (<$) :: a > DeterminedBy parameter b > DeterminedBy parameter a #  
Applicative (DeterminedBy parameter) Source #  pure a = Determination (\_ > a) Determination f <*> Determination a = Determination (\x > f x (a x)) 
Defined in Acme.Functors pure :: a > DeterminedBy parameter a # (<*>) :: DeterminedBy parameter (a > b) > DeterminedBy parameter a > DeterminedBy parameter b # liftA2 :: (a > b > c) > DeterminedBy parameter a > DeterminedBy parameter b > DeterminedBy parameter c # (*>) :: DeterminedBy parameter a > DeterminedBy parameter b > DeterminedBy parameter b # (<*) :: DeterminedBy parameter a > DeterminedBy parameter b > DeterminedBy parameter a #  
Semigroup a => Semigroup (DeterminedBy parameter a) Source #  Determination f <> Determination g = Determination (\x > f x <> g x) 
Defined in Acme.Functors (<>) :: DeterminedBy parameter a > DeterminedBy parameter a > DeterminedBy parameter a # sconcat :: NonEmpty (DeterminedBy parameter a) > DeterminedBy parameter a # stimes :: Integral b => b > DeterminedBy parameter a > DeterminedBy parameter a #  
Monoid a => Monoid (DeterminedBy parameter a) Source #  mempty = Determination (\_ > mempty) 
Defined in Acme.Functors mempty :: DeterminedBy parameter a Source # 