Safe Haskell | None |
---|---|

Language | Haskell2010 |

This module reexports most of the definitions from the "base" package, which are meant to be imported unqualified.

For details check out the source.

- bool :: a -> a -> Bool -> a
- (&) :: a -> (a -> b) -> b
- ($>) :: Functor f => f a -> b -> f b
- isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- uncons :: [a] -> Maybe (a, [a])
- traceShowId :: Show a => a -> a
- traceM :: Applicative f => String -> f ()
- traceShowM :: (Show a, Applicative f) => a -> f ()

# Reimplementations of functions presented in versions of "base" newer than 4.6

## Data.Bool

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 if-then-else construct with its arguments
reordered.

#### Examples

Basic usage:

`>>>`

"bar"`bool "foo" "bar" True`

`>>>`

"foo"`bool "foo" "bar" False`

Confirm that

and `bool`

x y p`if p then y else x`

are
equivalent:

`>>>`

`let p = True; x = "bar"; y = "foo"`

`>>>`

True`bool x y p == if p then y else x`

`>>>`

`let p = False`

`>>>`

True`bool x y p == if p then y else x`

*Since: 4.7.0.0*

## Data.Function

## Data.Functor

($>) :: Functor f => f a -> b -> f b infixl 4 #

Flipped version of `<$`

.

#### Examples

Replace the contents of a

with a constant `Maybe`

`Int`

`String`

:

`>>>`

Nothing`Nothing $> "foo"`

`>>>`

Just "foo"`Just 90210 $> "foo"`

Replace the contents of an

with a constant
`Either`

`Int`

`Int`

`String`

, resulting in an

:`Either`

`Int`

`String`

`>>>`

Left 8675309`Left 8675309 $> "foo"`

`>>>`

Right "foo"`Right 8675309 $> "foo"`

Replace each element of a list with a constant `String`

:

`>>>`

["foo","foo","foo"]`[1,2,3] $> "foo"`

Replace the second element of a pair with a constant `String`

:

`>>>`

(1,"foo")`(1,2) $> "foo"`

*Since: 4.7.0.0*

## Data.List

isSubsequenceOf :: Eq a => [a] -> [a] -> Bool #

The `isSubsequenceOf`

function takes two lists and returns `True`

if all
the elements of the first list occur, in order, in the second. The
elements do not have to occur consecutively.

is equivalent to `isSubsequenceOf`

x y

.`elem`

x (`subsequences`

y)

#### Examples

`>>>`

True`isSubsequenceOf "GHC" "The Glorious Haskell Compiler"`

`>>>`

True`isSubsequenceOf ['a','d'..'z'] ['a'..'z']`

`>>>`

False`isSubsequenceOf [1..10] [10,9..0]`

*Since: 4.8.0.0*

sortOn :: Ord b => (a -> b) -> [a] -> [a] #

Sort a list by comparing the results of a key function applied to each
element. `sortOn f`

is equivalent to `sortBy (comparing f)`

, but has the
performance advantage of only evaluating `f`

once for each element in the
input list. This is called the decorate-sort-undecorate paradigm, or
Schwartzian transform.

*Since: 4.8.0.0*

## Debug.Trace

traceShowId :: Show a => a -> a #

Like `traceShow`

but returns the shown value instead of a third value.

*Since: 4.7.0.0*

traceM :: Applicative f => String -> f () #

Like `trace`

but returning unit in an arbitrary `Applicative`

context. Allows
for convenient use in do-notation.

Note that the application of `traceM`

is not an action in the `Applicative`

context, as `traceIO`

is in the `IO`

type. While the fresh bindings in the
following example will force the `traceM`

expressions to be reduced every time
the `do`

-block is executed, `traceM "not crashed"`

would only be reduced once,
and the message would only be printed once. If your monad is in `MonadIO`

,
`liftIO . traceIO`

may be a better option.

... = do x <- ... traceM $ "x: " ++ show x y <- ... traceM $ "y: " ++ show y

*Since: 4.7.0.0*

traceShowM :: (Show a, Applicative f) => a -> f () #