Safe Haskell  None 

Language  Haskell2010 
Synopsis
 (&) :: a > (a > b) > b
 (&&&) :: Arrow a => a b c > a b c' > a b (c, c')
 (<&>) :: Functor f => f a > (a > b) > f b
 toList :: Foldable t => t a > [a]
 bool :: a > a > Bool > a
 first :: Bifunctor p => (a > b) > p a c > p b c
 second :: Bifunctor p => (b > c) > p a b > p a c
 on :: (b > b > c) > (a > b) > a > a > c
 isNothing :: Maybe a > Bool
 isJust :: Maybe a > Bool
 fromMaybe :: a > Maybe a > a
 guard :: Alternative f => Bool > f ()
 foldl' :: Foldable t => (b > a > b) > b > t a > b
 fold :: ( Foldable t, Monoid m) => t m > m
 for :: ( Traversable t, Applicative f) => t a > (a > f b) > f (t b)
 throw :: forall (r :: RuntimeRep ) (a :: TYPE r) e. Exception e => e > a
 join :: Monad m => m (m a) > m a
 (<=<) :: Monad m => (b > m c) > (a > m b) > a > m c
 (>=>) :: Monad m => (a > m b) > (b > m c) > a > m c
 ($>) :: Functor f => f a > b > f b
 fromRight :: b > Either a b > b
 isRight :: Either a b > Bool
 void :: Functor f => f a > f ()
 through :: Functor f => (a > f b) > a > f a
 coerce :: forall (k :: RuntimeRep ) (a :: TYPE k) (b :: TYPE k). Coercible a b => a > b
 class Generic a
 class NFData a
 data Natural
 data NonEmpty a = a : [a]
 data Word8
 class Applicative f => Alternative (f :: Type > Type ) where
 class ( Typeable e, Show e) => Exception e

newtype
PairT
b f a =
PairT
{
 unPairT :: f (b, a)
 class a ~R# b => Coercible (a :: k) (b :: k)
 class Typeable (a :: k)
 type Lens' s a = Lens s s a a
 lens :: (s > a) > (s > b > t) > Lens s t a b
 (^.) :: s > Getting a s a > a
 view :: MonadReader s m => Getting a s a > m a
 (.~) :: ASetter s t a b > b > s > t
 set :: ASetter s t a b > b > s > t
 (%~) :: ASetter s t a b > (a > b) > s > t
 over :: ASetter s t a b > (a > b) > s > t
 traceShowId :: Show a => a > a
 trace :: String > a > a
 (.*) :: (c > d) > (a > b > c) > a > b > d
 (<<$>>) :: ( Functor f1, Functor f2) => (a > b) > f1 (f2 a) > f1 (f2 b)
 (<<*>>) :: ( Applicative f1, Applicative f2) => f1 (f2 (a > b)) > f1 (f2 a) > f1 (f2 b)
 mtraverse :: ( Monad m, Traversable m, Applicative f) => (a > f (m b)) > m a > f (m b)
 foldMapM :: ( Foldable f, Monad m, Monoid b) => (a > m b) > f a > m b
 reoption :: ( Foldable f, Alternative g) => f a > g a
 enumeration :: ( Bounded a, Enum a) => [a]
 tabulateArray :: ( Bounded i, Enum i, Ix i) => (i > a) > Array i a
 (?) :: Alternative f => Bool > a > f a
 ensure :: Alternative f => (a > Bool ) > a > f a
 asksM :: MonadReader r m => (r > m a) > m a
 data Doc ann

newtype
ShowPretty
a =
ShowPretty
{
 unShowPretty :: a

class
Pretty
a
where
 pretty :: a > Doc ann
 prettyList :: [a] > Doc ann

class
PrettyBy
config a
where
 prettyBy :: config > a > Doc ann
 prettyListBy :: config > [a] > Doc ann
 type family HasPrettyDefaults config :: Bool
 type PrettyDefaultBy config = DispatchPrettyDefaultBy ( NonStuckHasPrettyDefaults config) config

newtype
PrettyAny
a =
PrettyAny
{
 unPrettyAny :: a
 class Render str where
 display :: forall str a. ( Pretty a, Render str) => a > str
 printPretty :: Pretty a => a > IO ()
 showText :: Show a => a > Text
Reexports from base
(&&&) :: Arrow a => a b c > a b c' > a b (c, c') infixr 3 Source #
Fanout: send the input to both argument arrows and combine their output.
The default definition may be overridden with a more efficient version if desired.
toList :: Foldable t => t a > [a] Source #
List of elements of a structure, from left to right.
Since: base4.8.0.0
bool :: a > a > Bool > a Source #
Case analysis for the
Bool
type.
evaluates to
bool
x y p
x
when
p
is
False
, and evaluates to
y
when
p
is
True
.
This is equivalent to
if p then y else x
; that is, one can
think of it as an ifthenelse construct with its arguments
reordered.
Examples
Basic usage:
>>>
bool "foo" "bar" True
"bar">>>
bool "foo" "bar" False
"foo"
Confirm that
and
bool
x y p
if p then y else x
are
equivalent:
>>>
let p = True; x = "bar"; y = "foo"
>>>
bool x y p == if p then y else x
True>>>
let p = False
>>>
bool x y p == if p then y else x
True
Since: base4.7.0.0
on :: (b > b > c) > (a > b) > a > a > c infixl 0 Source #
fromMaybe :: a > Maybe a > a Source #
The
fromMaybe
function takes a default value and and
Maybe
value. If the
Maybe
is
Nothing
, it returns the default values;
otherwise, it returns the value contained in the
Maybe
.
Examples
Basic usage:
>>>
fromMaybe "" (Just "Hello, World!")
"Hello, World!"
>>>
fromMaybe "" Nothing
""
Read an integer from a string using
readMaybe
. If we fail to
parse an integer, we want to return
0
by default:
>>>
import Text.Read ( readMaybe )
>>>
fromMaybe 0 (readMaybe "5")
5>>>
fromMaybe 0 (readMaybe "")
0
guard :: Alternative f => Bool > f () Source #
Conditional failure of
Alternative
computations. Defined by
guard True =pure
() guard False =empty
Examples
Common uses of
guard
include conditionally signaling an error in
an error monad and conditionally rejecting the current choice in an
Alternative
based parser.
As an example of signaling an error in the error monad
Maybe
,
consider a safe division function
safeDiv x y
that returns
Nothing
when the denominator
y
is zero and
otherwise. For example:
Just
(x `div`
y)
>>> safeDiv 4 0 Nothing >>> safeDiv 4 2 Just 2
A definition of
safeDiv
using guards, but not
guard
:
safeDiv :: Int > Int > Maybe Int safeDiv x y  y /= 0 = Just (x `div` y)  otherwise = Nothing
A definition of
safeDiv
using
guard
and
Monad
do
notation:
safeDiv :: Int > Int > Maybe Int safeDiv x y = do guard (y /= 0) return (x `div` y)
foldl' :: Foldable t => (b > a > b) > b > t a > b Source #
Leftassociative fold of a structure but with strict application of the operator.
This ensures that each step of the fold is forced to weak head normal
form before being applied, avoiding the collection of thunks that would
otherwise occur. This is often what you want to strictly reduce a finite
list to a single, monolithic result (e.g.
length
).
For a general
Foldable
structure this should be semantically identical
to,
foldl' f z =foldl'
f z .toList
Since: base4.6.0.0
fold :: ( Foldable t, Monoid m) => t m > m Source #
Combine the elements of a structure using a monoid.
for :: ( Traversable t, Applicative f) => t a > (a > f b) > f (t b) Source #
throw :: forall (r :: RuntimeRep ) (a :: TYPE r) e. Exception e => e > a Source #
Throw an exception. Exceptions may be thrown from purely
functional code, but may only be caught within the
IO
monad.
join :: Monad m => m (m a) > m a Source #
The
join
function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
'
' can be understood as the
join
bss
do
expression
do bs < bss bs
Examples
A common use of
join
is to run an
IO
computation returned from
an
STM
transaction, since
STM
transactions
can't perform
IO
directly. Recall that
atomically
:: STM a > IO a
is used to run
STM
transactions atomically. So, by
specializing the types of
atomically
and
join
to
atomically
:: STM (IO b) > IO (IO b)join
:: IO (IO b) > IO b
we can compose them as
join
.atomically
:: STM (IO b) > IO b
(>=>) :: Monad m => (a > m b) > (b > m c) > a > m c infixr 1 Source #
Lefttoright composition of Kleisli arrows.
'
(bs
' can be understood as the
>=>
cs) a
do
expression
do b < bs a cs b
($>) :: Functor f => f a > b > f b infixl 4 Source #
Flipped version of
<$
.
Using
ApplicativeDo
: '
as
' can be understood as the
$>
b
do
expression
do as pure b
with an inferred
Functor
constraint.
Examples
Replace the contents of a
with a constant
Maybe
Int
String
:
>>>
Nothing $> "foo"
Nothing>>>
Just 90210 $> "foo"
Just "foo"
Replace the contents of an
with a constant
Either
Int
Int
String
, resulting in an
:
Either
Int
String
>>>
Left 8675309 $> "foo"
Left 8675309>>>
Right 8675309 $> "foo"
Right "foo"
Replace each element of a list with a constant
String
:
>>>
[1,2,3] $> "foo"
["foo","foo","foo"]
Replace the second element of a pair with a constant
String
:
>>>
(1,2) $> "foo"
(1,"foo")
Since: base4.7.0.0
fromRight :: b > Either a b > b Source #
Return the contents of a
Right
value or a default value otherwise.
Examples
Basic usage:
>>>
fromRight 1 (Right 3)
3>>>
fromRight 1 (Left "foo")
1
Since: base4.10.0.0
isRight :: Either a b > Bool Source #
Return
True
if the given value is a
Right
value,
False
otherwise.
Examples
Basic usage:
>>>
isRight (Left "foo")
False>>>
isRight (Right 3)
True
Assuming a
Left
value signifies some sort of error, we can use
isRight
to write a very simple reporting function that only
outputs "SUCCESS" when a computation has succeeded.
This example shows how
isRight
might be used to avoid pattern
matching when one does not care about the value contained in the
constructor:
>>>
import Control.Monad ( when )
>>>
let report e = when (isRight e) $ putStrLn "SUCCESS"
>>>
report (Left "parse error")
>>>
report (Right 1)
SUCCESS
Since: base4.7.0.0
void :: Functor f => f a > f () Source #
discards or ignores the result of evaluation, such
as the return value of an
void
value
IO
action.
Using
ApplicativeDo
: '
' can be understood as the
void
as
do
expression
do as pure ()
with an inferred
Functor
constraint.
Examples
Replace the contents of a
with unit:
Maybe
Int
>>>
void Nothing
Nothing>>>
void (Just 3)
Just ()
Replace the contents of an
with unit, resulting in an
Either
Int
Int
:
Either
Int
()
>>>
void (Left 8675309)
Left 8675309>>>
void (Right 8675309)
Right ()
Replace every element of a list with unit:
>>>
void [1,2,3]
[(),(),()]
Replace the second element of a pair with unit:
>>>
void (1,2)
(1,())
Discard the result of an
IO
action:
>>>
mapM print [1,2]
1 2 [(),()]>>>
void $ mapM print [1,2]
1 2
through :: Functor f => (a > f b) > a > f a Source #
Makes an effectful function ignore its result value and return its input value.
coerce :: forall (k :: RuntimeRep ) (a :: TYPE k) (b :: TYPE k). Coercible a b => a > b Source #
The function
coerce
allows you to safely convert between values of
types that have the same representation with no runtime overhead. In the
simplest case you can use it instead of a newtype constructor, to go from
the newtype's concrete type to the abstract type. But it also works in
more complicated settings, e.g. converting a list of newtypes to a list of
concrete types.
This function is runtimerepresentation polymorphic, but the
RuntimeRep
type argument is marked as
Inferred
, meaning
that it is not available for visible type application. This means
the typechecker will accept
coerce @Int @Age 42
.
Representable types of kind
*
.
This class is derivable in GHC with the
DeriveGeneric
flag on.
A
Generic
instance must satisfy the following laws:
from
.to
≡id
to
.from
≡id