GHC.Prelude.Basic

A variant of foldlMap1 where the leftmost element maps to itself.

A variant of foldlMap1' where the leftmost element maps to itself.

Monadic fold over the elements of a non-empty structure, associating to the left, i.e. from left to right.

Map variant of foldlM1.

A variant of foldrMap1 where the rightmost element maps to itself.

A variant of foldrMap1' where the rightmost element maps to itself.

Monadic fold over the elements of a non-empty structure, associating to the right, i.e. from right to left.

Map variant of foldrM1.

Insert an m between each pair of t m.

>>> intercalate1 ", " $ "hello" :| ["how", "are", "you"]"hello, how, are, you"

>>> intercalate1 ", " $ "hello" :| []"hello"

>>> intercalate1 mempty $ "I" :| ["Am", "Fine", "You?"]"IAmFineYou?"

The largest element of a non-empty structure with respect to the given comparison function. Structure order is used as a tie-breaker: if there are multiple largest elements, the rightmost of them is chosen.

The least element of a non-empty structure with respect to the given comparison function. Structure order is used as a tie-breaker: if there are multiple least elements, the leftmost of them is chosen.

($) is the function application operator.

Applying ($) to a function f and an argument x gives the same result as applying f to x directly. The definition is akin to this:

($) :: (a -> b) -> a -> b
($) f x = f x

This is id specialized from a -> a to (a -> b) -> (a -> b) which by the associativity of (->) is the same as (a -> b) -> a -> b.

On the face of it, this may appear pointless! But it's actually one of the most useful and important operators in Haskell.

The order of operations is very different between ($) and normal function application. Normal function application has precedence 10 - higher than any operator - and associates to the left. So these two definitions are equivalent:

expr = min 5 1 + 5
expr = ((min 5) 1) + 5

($) has precedence 0 (the lowest) and associates to the right, so these are equivalent:

expr = min 5 $ 1 + 5
expr = (min 5) (1 + 5)

Examples

A common use cases of ($) is to avoid parentheses in complex expressions.

For example, instead of using nested parentheses in the following Haskell function:

-- | Sum numbers in a string: strSum "100  5 -7" == 98
strSum :: String -> Int
strSum s = sum (mapMaybe readMaybe (words s))

we can deploy the function application operator:

-- | Sum numbers in a string: strSum "100  5 -7" == 98
strSum :: String -> Int
strSum s = sum $ mapMaybe readMaybe $ words s

($) is also used as a section (a partially applied operator), in order to indicate that we wish to apply some yet-unspecified function to a given value. For example, to apply the argument 5 to a list of functions:

applyFive :: [Int]
applyFive = map ($ 5) [(+1), (2^)]
>>> [6, 32]

Technical Remark (Representation Polymorphism)

($) is fully representation-polymorphic. This allows it to also be used with arguments of unlifted and even unboxed kinds, such as unboxed integers:

fastMod :: Int -> Int -> Int
fastMod (I# x) (I# m) = I# $ remInt# x m

Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.

(++) appends two lists, i.e.,

[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

Performance considerations

This function takes linear time in the number of elements of the first list. Thus it is better to associate repeated applications of (++) to the right (which is the default behaviour): xs ++ (ys ++ zs) or simply xs ++ ys ++ zs, but not (xs ++ ys) ++ zs. For the same reason GHC.Internal.Data.List.concat = GHC.Internal.Data.List.foldr (++) [] has linear performance, while GHC.Internal.Data.List.foldl (++) [] is prone to quadratic slowdown

Examples

>>> [1, 2, 3] ++ [4, 5, 6][1,2,3,4,5,6]

>>> [] ++ [1, 2, 3][1,2,3]

>>> [3, 2, 1] ++ [][3,2,1]

Right to left function composition.

prop> (f . g) x = f (g x)

prop> f . id = f = id . f

Examples

>>> map ((*2) . length) [[], [0, 1, 2], [0]][0,6,2]

>>> foldr (.) id [(+1), (*3), (^3)] 225

>>> let (...) = (.).(.) in ((*2)...(+)) 5 1030

Same as >>=, but with the arguments interchanged.

as >>= f == f =<< as

asTypeOf is a type-restricted version of const. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.

const x y always evaluates to x, ignoring its second argument.

const x = \_ -> x

This function might seem useless at first glance, but it can be very useful in a higher order context.

Examples

>>> const 42 "hello"42

>>> map (const 42) [0..3][42,42,42,42]

flip f takes its (first) two arguments in the reverse order of f.

prop> flip f x y = f y x

prop> flip . flip = id

Examples

>>> flip (++) "hello" "world""worldhello"

>>> let (.>) = flip (.) in (+1) .> show $ 5"6"

Identity function.

id x = x

This function might seem useless at first glance, but it can be very useful in a higher order context.

Examples

>>> length $ filter id [True, True, False, True]3

>>> Just (Just 3) >>= idJust 3

>>> foldr id 0 [(^3), (*5), (+2)]1000

\mathcal{O}(n). map f xs is the list obtained by applying f to each element of xs, i.e.,

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
map f [x1, x2, ...] == [f x1, f x2, ...]

this means that map id == id

Examples

>>> map (+1) [1, 2, 3][2,3,4]

>>> map id [1, 2, 3][1,2,3]

>>> map (\n -> 3 * n + 1) [1, 2, 3][4,7,10]

otherwise is defined as the value True. It helps to make guards more readable. eg.

 f x | x < 0     = ...
     | otherwise = ...

until p f yields the result of applying f until p holds.

Boolean "and", lazy in the second argument

Boolean "not"

Boolean "or", lazy in the second argument

Case analysis for the Either type. If the value is Left a, apply the first function to a; if it is Right b, apply the second function to b.

Examples

We create two values of type Either String Int, one using the Left constructor and another using the Right constructor. Then we apply "either" the Prelude.length function (if we have a String) or the "times-two" function (if we have an Int):

>>> let s = Left "foo" :: Either String Int>>> let n = Right 3 :: Either String Int>>> either length (*2) s3>>> either length (*2) n6

Determines whether all elements of the structure satisfy the predicate.

Examples

Basic usage:

>>> all (> 3) []True

>>> all (> 3) [1,2]False

>>> all (> 3) [1,2,3,4,5]False

>>> all (> 3) [1..]False

>>> all (> 3) [4..]* Hangs forever *

and returns the conjunction of a container of Bools. For the result to be True, the container must be finite; False, however, results from a False value finitely far from the left end.

Examples

Basic usage:

>>> and []True

>>> and [True]True

>>> and [False]False

>>> and [True, True, False]False

>>> and (False : repeat True) -- Infinite list [False,True,True,True,...False

>>> and (repeat True)* Hangs forever *

Determines whether any element of the structure satisfies the predicate.

Examples

Basic usage:

>>> any (> 3) []False

>>> any (> 3) [1,2]False

>>> any (> 3) [1,2,3,4,5]True

>>> any (> 3) [1..]True

>>> any (> 3) [0, -1..]* Hangs forever *

The concatenation of all the elements of a container of lists.

Examples

Basic usage:

>>> concat (Just [1, 2, 3])[1,2,3]

>>> concat (Left 42)[]

>>> concat [[1, 2, 3], [4, 5], [6], []][1,2,3,4,5,6]

Map a function over all the elements of a container and concatenate the resulting lists.

Examples

Basic usage:

>>> concatMap (take 3) [[1..], [10..], [100..], [1000..]][1,2,3,10,11,12,100,101,102,1000,1001,1002]

>>> concatMap (take 3) (Just [1..])[1,2,3]

Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see Data.Traversable.mapM.

mapM_ is just like traverse_, but specialised to monadic actions.

notElem is the negation of elem.

Examples

Basic usage:

>>> 3 `notElem` []True

>>> 3 `notElem` [1,2]True

>>> 3 `notElem` [1,2,3,4,5]False

For infinite structures, notElem terminates if the value exists at a finite distance from the left side of the structure:

>>> 3 `notElem` [1..]False

>>> 3 `notElem` ([4..] ++ [3])* Hangs forever *

or returns the disjunction of a container of Bools. For the result to be False, the container must be finite; True, however, results from a True value finitely far from the left end.

Examples

Basic usage:

>>> or []False

>>> or [True]True

>>> or [False]False

>>> or [True, True, False]True

>>> or (True : repeat False) -- Infinite list [True,False,False,False,...True

>>> or (repeat False)* Hangs forever *

Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see Data.Traversable.sequence.

sequence_ is just like sequenceA_, but specialised to monadic actions.

An infix synonym for fmap.

The name of this operator is an allusion to Prelude.$. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas Prelude.$ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> NothingNothing

>>> show <$> Just 3Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17Left 17

>>> show <$> Right 17Right "17"

Double each element of a list:

>>> (*2) <$> [1,2,3][2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)(2,True)

The maybe function takes a default value, a function, and a Maybe value. If the Maybe value is Nothing, the function returns the default value. Otherwise, it applies the function to the value inside the Just and returns the result.

Examples

Basic usage:

>>> maybe False odd (Just 3)True

>>> maybe False odd NothingFalse

Read an integer from a string using readMaybe. If we succeed, return twice the integer; that is, apply (*2) to it. If instead we fail to parse an integer, return 0 by default:

>>> import GHC.Internal.Text.Read ( readMaybe )>>> maybe 0 (*2) (readMaybe "5")10>>> maybe 0 (*2) (readMaybe "")0

Apply show to a Maybe Int. If we have Just n, we want to show the underlying Int n. But if we have Nothing, we return the empty string instead of (for example) "Nothing":

>>> maybe "" show (Just 5)"5">>> maybe "" show Nothing""

Splits the argument into a list of lines stripped of their terminating \n characters. The \n terminator is optional in a final non-empty line of the argument string.

When the argument string is empty, or ends in a \n character, it can be recovered by passing the result of lines to the unlines function. Otherwise, unlines appends the missing terminating \n. This makes unlines . lines idempotent:

(unlines . lines) . (unlines . lines) = (unlines . lines)

Examples

>>> lines ""           -- empty input contains no lines[]

>>> lines "\n"         -- single empty line[""]

>>> lines "one"        -- single unterminated line["one"]

>>> lines "one\n"      -- single non-empty line["one"]

>>> lines "one\n\n"    -- second line is empty["one",""]

>>> lines "one\ntwo"   -- second line is unterminated["one","two"]

>>> lines "one\ntwo\n" -- two non-empty lines["one","two"]

Appends a \n character to each input string, then concatenates the results. Equivalent to foldMap (s -> s ++ "\n").

Examples

>>> unlines ["Hello", "World", "!"]"Hello\nWorld\n!\n"

Note that unlines . lines /= id when the input is not \n-terminated:

>>> unlines . lines $ "foo\nbar""foo\nbar\n"

unwords joins words with separating spaces (U+0020 SPACE).

unwords is neither left nor right inverse of words:

>>> words (unwords [" "])[]>>> unwords (words "foo\nbar")"foo bar"

Examples

>>> unwords ["Lorem", "ipsum", "dolor"]"Lorem ipsum dolor"

>>> unwords ["foo", "bar", "", "baz"]"foo bar  baz"

words breaks a string up into a list of words, which were delimited by white space (as defined by isSpace). This function trims any white spaces at the beginning and at the end.

Examples

>>> words "Lorem ipsum\ndolor"["Lorem","ipsum","dolor"]

>>> words " foo bar "["foo","bar"]

Convert an uncurried function to a curried function.

Examples

>>> curry fst 1 21

Extract the first component of a pair.

Extract the second component of a pair.

uncurry converts a curried function to a function on pairs.

Examples

>>> uncurry (+) (1,2)3

>>> uncurry ($) (show, 1)"1"

>>> map (uncurry max) [(1,2), (3,4), (6,8)][2,4,8]

error stops execution and displays an error message.

A variant of error that does not produce a stack trace.

A special case of error. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which undefined appears.

Raise an IOError in the IO monad.

Construct an IOError value with a string describing the error. The fail method of the IO instance of the Monad class raises a userError, thus:

instance Monad IO where
  ...
  fail s = ioError (userError s)

List index (subscript) operator, starting from 0. It is an instance of the more general genericIndex, which takes an index of any integral type.

WARNING: This function is partial, and should only be used if you are sure that the indexing will not fail. Otherwise, use Data.List.!?.

WARNING: This function takes linear time in the index.

Examples

>>> ['a', 'b', 'c'] !! 0'a'

>>> ['a', 'b', 'c'] !! 2'c'

>>> ['a', 'b', 'c'] !! 3*** Exception: Prelude.!!: index too large

>>> ['a', 'b', 'c'] !! (-1)*** Exception: Prelude.!!: negative index

break, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p and second element is the remainder of the list:

break p is equivalent to span (not . p) and consequently to (takeWhile (not . p) xs, dropWhile (not . p) xs), even if p is _|_.

Laziness

>>> break undefined []([],[])

>>> fst (break (const True) undefined)*** Exception: Prelude.undefined

>>> fst (break (const True) (undefined : undefined))[]

>>> take 1 (fst (break (const False) (1 : undefined)))[1]

break produces the first component of the tuple lazily:

>>> take 10 (fst (break (const False) [1..]))[1,2,3,4,5,6,7,8,9,10]

Examples

>>> break (> 3) [1,2,3,4,1,2,3,4]([1,2,3],[4,1,2,3,4])

>>> break (< 9) [1,2,3]([],[1,2,3])

>>> break (> 9) [1,2,3]([1,2,3],[])

cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.

Examples

>>> cycle []*** Exception: Prelude.cycle: empty list

>>> take 10 (cycle [42])[42,42,42,42,42,42,42,42,42,42]

>>> take 10 (cycle [2, 5, 7])[2,5,7,2,5,7,2,5,7,2]

>>> take 1 (cycle (42 : undefined))[42]

drop n xs returns the suffix of xs after the first n elements, or [] if n >= length xs.

It is an instance of the more general genericDrop, in which n may be of any integral type.

Examples

>>> drop 6 "Hello World!""World!"

>>> drop 3 [1,2,3,4,5][4,5]

>>> drop 3 [1,2][]

>>> drop 3 [][]

>>> drop (-1) [1,2][1,2]

>>> drop 0 [1,2][1,2]

dropWhile p xs returns the suffix remaining after takeWhile p xs.

Examples

>>> dropWhile (< 3) [1,2,3,4,5,1,2,3][3,4,5,1,2,3]

>>> dropWhile (< 9) [1,2,3][]

>>> dropWhile (< 0) [1,2,3][1,2,3]

\mathcal{O}(n). filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

filter p xs = [ x | x <- xs, p x]

Examples

>>> filter odd [1, 2, 3][1,3]

>>> filter (\l -> length l > 3) ["Hello", ", ", "World", "!"]["Hello","World"]

>>> filter (/= 3) [1, 2, 3, 4, 3, 2, 1][1,2,4,2,1]

iterate f x returns an infinite list of repeated applications of f to x:

iterate f x == [x, f x, f (f x), ...]

Laziness

Note that iterate is lazy, potentially leading to thunk build-up if the consumer doesn't force each element. See iterate' for a strict variant of this function.

>>> let xs = iterate (\x -> if x == 0 then undefined else x - 1) 2>>> xs[2,1,0,*** Exception: Prelude.undefined>>> length (take 10 xs)10

In xs every element following 0 is bottom, but the list itself is infinitely long because it is generated without forcing its elements.

Examples

>>> take 10 $ iterate not True[True,False,True,False,True,False,True,False,True,False]

>>> take 10 $ iterate (+3) 42[42,45,48,51,54,57,60,63,66,69]

iterate id == repeat:

>>> take 10 $ iterate id 1[1,1,1,1,1,1,1,1,1,1]

\mathcal{O}(n). lookup key assocs looks up a key in an association list. For the result to be Nothing, the list must be finite.

Examples

>>> lookup 2 []Nothing

>>> lookup 2 [(1, "first")]Nothing

>>> lookup 2 [(1, "first"), (2, "second"), (3, "third")]Just "second"

repeat x is an infinite list, with x the value of every element.

Examples

>>> take 10 $ repeat 17[17,17,17,17,17,17,17,17,17, 17]

>>> repeat undefined[*** Exception: Prelude.undefined

replicate n x is a list of length n with x the value of every element. It is an instance of the more general genericReplicate, in which n may be of any integral type.

Examples

>>> replicate 0 True[]

>>> replicate (-1) True[]

>>> replicate 4 True[True,True,True,True]

\mathcal{O}(n). reverse xs returns the elements of xs in reverse order. xs must be finite.

Laziness

reverse is lazy in its elements.

>>> head (reverse [undefined, 1])1

>>> reverse (1 : 2 : undefined)*** Exception: Prelude.undefined

Examples

>>> reverse [][]

>>> reverse [42][42]

>>> reverse [2,5,7][7,5,2]

>>> reverse [1..]* Hangs forever *

\mathcal{O}(n). scanl is similar to foldl, but returns a list of successive reduced values from the left:

scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

Note that

last (scanl f z xs) == foldl f z xs

Examples

>>> scanl (+) 0 [1..4][0,1,3,6,10]

>>> scanl (+) 42 [][42]

>>> scanl (-) 100 [1..4][100,99,97,94,90]

>>> scanl (\reversedString nextChar -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']["foo","afoo","bafoo","cbafoo","dcbafoo"]

>>> take 10 (scanl (+) 0 [1..])[0,1,3,6,10,15,21,28,36,45]

>>> take 1 (scanl undefined 'a' undefined)"a"

\mathcal{O}(n). scanl1 is a variant of scanl that has no starting value argument:

scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

Examples

>>> scanl1 (+) [1..4][1,3,6,10]

>>> scanl1 (+) [][]

>>> scanl1 (-) [1..4][1,-1,-4,-8]

>>> scanl1 (&&) [True, False, True, True][True,False,False,False]

>>> scanl1 (||) [False, False, True, True][False,False,True,True]

>>> take 10 (scanl1 (+) [1..])[1,3,6,10,15,21,28,36,45,55]

>>> take 1 (scanl1 undefined ('a' : undefined))"a"

\mathcal{O}(n). scanr is the right-to-left dual of scanl. Note that the order of parameters on the accumulating function are reversed compared to scanl. Also note that

head (scanr f z xs) == foldr f z xs.

Examples

>>> scanr (+) 0 [1..4][10,9,7,4,0]

>>> scanr (+) 42 [][42]

>>> scanr (-) 100 [1..4][98,-97,99,-96,100]

>>> scanr (\nextChar reversedString -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']["abcdfoo","bcdfoo","cdfoo","dfoo","foo"]

>>> force $ scanr (+) 0 [1..]*** Exception: stack overflow

\mathcal{O}(n). scanr1 is a variant of scanr that has no starting value argument.

Examples

>>> scanr1 (+) [1..4][10,9,7,4]

>>> scanr1 (+) [][]

>>> scanr1 (-) [1..4][-2,3,-1,4]

>>> scanr1 (&&) [True, False, True, True][False,False,True,True]

>>> scanr1 (||) [True, True, False, False][True,True,False,False]

>>> force $ scanr1 (+) [1..]*** Exception: stack overflow

span, applied to a predicate p and a list xs, returns a tuple where first element is the longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list:

span p xs is equivalent to (takeWhile p xs, dropWhile p xs), even if p is _|_.

Laziness

>>> span undefined []([],[])>>> fst (span (const False) undefined)*** Exception: Prelude.undefined>>> fst (span (const False) (undefined : undefined))[]>>> take 1 (fst (span (const True) (1 : undefined)))[1]

span produces the first component of the tuple lazily:

>>> take 10 (fst (span (const True) [1..]))[1,2,3,4,5,6,7,8,9,10]

Examples

>>> span (< 3) [1,2,3,4,1,2,3,4]([1,2],[3,4,1,2,3,4])

>>> span (< 9) [1,2,3]([1,2,3],[])

>>> span (< 0) [1,2,3]([],[1,2,3])

splitAt n xs returns a tuple where first element is xs prefix of length n and second element is the remainder of the list:

splitAt is an instance of the more general genericSplitAt, in which n may be of any integral type.

Laziness

It is equivalent to (take n xs, drop n xs) unless n is _|_: splitAt _|_ xs = _|_, not (_|_, _|_)).

The first component of the tuple is produced lazily:

>>> fst (splitAt 0 undefined)[]

>>> take 1 (fst (splitAt 10 (1 : undefined)))[1]

Examples

>>> splitAt 6 "Hello World!"("Hello ","World!")

>>> splitAt 3 [1,2,3,4,5]([1,2,3],[4,5])

>>> splitAt 1 [1,2,3]([1],[2,3])

>>> splitAt 3 [1,2,3]([1,2,3],[])

>>> splitAt 4 [1,2,3]([1,2,3],[])

>>> splitAt 0 [1,2,3]([],[1,2,3])

>>> splitAt (-1) [1,2,3]([],[1,2,3])

take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n >= length xs.

It is an instance of the more general genericTake, in which n may be of any integral type.

Laziness

>>> take 0 undefined[]>>> take 2 (1 : 2 : undefined)[1,2]

Examples

>>> take 5 "Hello World!""Hello"

>>> take 3 [1,2,3,4,5][1,2,3]

>>> take 3 [1,2][1,2]

>>> take 3 [][]

>>> take (-1) [1,2][]

>>> take 0 [1,2][]

takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.

Laziness

>>> takeWhile (const False) undefined*** Exception: Prelude.undefined

>>> takeWhile (const False) (undefined : undefined)[]

>>> take 1 (takeWhile (const True) (1 : undefined))[1]

Examples

>>> takeWhile (< 3) [1,2,3,4,1,2,3,4][1,2]

>>> takeWhile (< 9) [1,2,3][1,2,3]

>>> takeWhile (< 0) [1,2,3][]

The unzip3 function takes a list of triples and returns three lists of the respective components, analogous to unzip.

Examples

>>> unzip3 []([],[],[])

>>> unzip3 [(1, 'a', True), (2, 'b', False)]([1,2],"ab",[True,False])

\mathcal{O}(\min(m,n)). zip takes two lists and returns a list of corresponding pairs.

zip is right-lazy:

>>> zip [] undefined[]>>> zip undefined []*** Exception: Prelude.undefined...

zip is capable of list fusion, but it is restricted to its first list argument and its resulting list.

Examples

>>> zip [1, 2, 3] ['a', 'b', 'c'][(1,'a'),(2,'b'),(3,'c')]

If one input list is shorter than the other, excess elements of the longer list are discarded, even if one of the lists is infinite:

>>> zip [1] ['a', 'b'][(1,'a')]

>>> zip [1, 2] ['a'][(1,'a')]

>>> zip [] [1..][]

>>> zip [1..] [][]

zip3 takes three lists and returns a list of triples, analogous to zip. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.

\mathcal{O}(\min(m,n)). zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

zipWith (,) xs ys == zip xs ys
zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]

zipWith is right-lazy:

>>> let f = undefined>>> zipWith f [] undefined[]

zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

Examples

zipWith (+) can be applied to two lists to produce the list of corresponding sums:

>>> zipWith (+) [1, 2, 3] [4, 5, 6][5,7,9]

>>> zipWith (++) ["hello ", "foo"] ["world!", "bar"]["hello world!","foobar"]

\mathcal{O}(\min(l,m,n)). The zipWith3 function takes a function which combines three elements, as well as three lists and returns a list of the function applied to corresponding elements, analogous to zipWith. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.

zipWith3 (,,) xs ys zs == zip3 xs ys zs
zipWith3 f [x1,x2,x3..] [y1,y2,y3..] [z1,z2,z3..] == [f x1 y1 z1, f x2 y2 z2, f x3 y3 z3..]

Examples

>>> zipWith3 (\x y z -> [x, y, z]) "123" "abc" "xyz"["1ax","2by","3cz"]

>>> zipWith3 (\x y z -> (x * y) + z) [1, 2, 3] [4, 5, 6] [7, 8, 9][11,18,27]

the same as flip (-).

Because - is treated specially in the Haskell grammar, (- e) is not a section, but an application of prefix negation. However, (subtract exp) is equivalent to the disallowed section.

The lex function reads a single lexeme from the input, discarding initial white space, and returning the characters that constitute the lexeme. If the input string contains only white space, lex returns a single successful `lexeme' consisting of the empty string. (Thus lex "" = [("","")].) If there is no legal lexeme at the beginning of the input string, lex fails (i.e. returns []).

This lexer is not completely faithful to the Haskell lexical syntax in the following respects:

• Qualified names are not handled properly

• Octal and hexadecimal numerics are not recognized as a single token

• Comments are not treated properly

readParen True p parses what p parses, but surrounded with parentheses.

readParen False p parses what p parses, but optionally surrounded with parentheses.

raise a number to a non-negative integral power

raise a number to an integral power

General coercion from Integral types.

WARNING: This function performs silent truncation if the result type is not at least as big as the argument's type.

gcd x y is the non-negative factor of both x and y of which every common factor of x and y is also a factor; for example gcd 4 2 = 2, gcd (-4) 6 = 2, gcd 0 4 = 4. gcd 0 0 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)

Note: Since for signed fixed-width integer types, abs minBound < 0, the result may be negative if one of the arguments is minBound (and necessarily is if the other is 0 or minBound) for such types.

lcm x y is the smallest positive integer that both x and y divide.

General coercion to Fractional types.

utility function converting a Char to a show function that simply prepends the character unchanged.

utility function that surrounds the inner show function with parentheses when the Bool parameter is True.

utility function converting a String to a show function that simply prepends the string unchanged.

equivalent to showsPrec with a precedence of 0.

The computation appendFile file str function appends the string str, to the file file.

Note that writeFile and appendFile write a literal string to a file. To write a value of any printable type, as with print, use the show function to convert the value to a string first.

This operation may fail with the same errors as hPutStr and withFile.

Examples

The following example could be more efficently written by acquiring a handle instead with openFile and using the computations capable of writing to handles such as hPutStr.

>>> let fn = "hello_world">>> in writeFile fn "hello" >> appendFile fn " world!" >> (readFile fn >>= putStrLn)"hello world!"

>>> let fn = "foo"; output = readFile' fn >>= putStrLn>>> in output >> appendFile fn (show [1,2,3]) >> outputthis is what's in the filethis is what's in the file[1,2,3]

Read a single character from the standard input device.

getChar is implemented as hGetChar stdin.

This operation may fail with the same errors as hGetChar.

Examples

>>> getChara'a'

>>> getChar>'\n'

The getContents operation returns all user input as a single string, which is read lazily as it is needed.

getContents is implemented as hGetContents stdin.

This operation may fail with the same errors as hGetContents.

Examples

>>> getContents >>= putStr> aaabbbccc :Daaabbbccc :D> I hope you have a great dayI hope you have a great day> ^D

>>> getContents >>= print . length> abc> <3> def ^D11

Read a line from the standard input device.

getLine is implemented as hGetLine stdin.

This operation may fail with the same errors as hGetLine.

Examples

>>> getLine> Hello World!"Hello World!"

>>> getLine>""

interact f takes the entire input from stdin and applies f to it. The resulting string is written to the stdout device.

Note that this operation is lazy, which allows to produce output even before all input has been consumed.

This operation may fail with the same errors as getContents and putStr.

If it doesn't produce output the buffering settings may not be correct, use ^D (ctrl+D) to close stdin which forces the buffer to be consumed.

You may wish to set the buffering style appropriate to your program's needs before using this function, for example:

main :: IO ()
main = do
  hSetBuffering stdin LineBuffering
  hSetBuffering stdout NoBuffering
  interact (concatMap (str -> str ++ str) . L.lines)

Examples

>>> interact (\str -> str ++ str)> hi :)hi :)> ^Dhi :)

>>> interact (const ":D"):D

>>> interact (show . words)> hello world!> I hope you have a great day> ^D["hello","world!","I","hope","you","have","a","great","day"]

The print function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class Show; print converts values to strings for output using the show operation and adds a newline.

print is implemented as putStrLn . show

This operation may fail with the same errors, and has the same issues with concurrency, as hPutStr!

Examples

>>> print [1, 2, 3][1,2,3]

Be careful when using print for outputting strings, as this will invoke show and cause strings to be printed with quotation marks and non-ascii symbols escaped.

>>> print "λ :D""\995 :D"

A program to print the first 8 integers and their powers of 2 could be written as:

>>> print [(n, 2^n) | n <- [0..8]][(0,1),(1,2),(2,4),(3,8),(4,16),(5,32),(6,64),(7,128),(8,256)]

Write a character to the standard output device

putChar is implemented as hPutChar stdout.

This operation may fail with the same errors as hPutChar.

Examples

Note that the following do not put a newline.

>>> putChar 'x'x

>>> putChar '\0042'*

Write a string to the standard output device

putStr is implemented as hPutStr stdout.

This operation may fail with the same errors, and has the same issues with concurrency, as hPutStr!

Examples

Note that the following do not put a newline.

>>> putStr "Hello, World!"Hello, World!

>>> putStr "\0052\0042\0050"4*2

The same as putStr, but adds a newline character.

This operation may fail with the same errors, and has the same issues with concurrency, as hPutStr!

The readFile function reads a file and returns the contents of the file as a string.

The file is read lazily, on demand, as with getContents.

This operation may fail with the same errors as hGetContents and openFile.

Examples

>>> readFile "~/hello_world""Greetings!"

>>> take 5 <$> readFile "/dev/zero""\NUL\NUL\NUL\NUL\NUL"

The readIO function is similar to read except that it signals parse failure to the IO monad instead of terminating the program.

This operation may fail with:

• isUserError if there is no unambiguous parse.

Examples

>>> fmap (+ 1) (readIO "1")2

>>> readIO "not quite ()" :: IO ()*** Exception: user error (Prelude.readIO: no parse)

The readLn function combines getLine and readIO.

This operation may fail with the same errors as getLine and readIO.

Examples

>>> fmap (+ 5) readLn> 2530

>>> readLn :: IO String> this is not a string literal*** Exception: user error (Prelude.readIO: no parse)

The computation writeFile file str function writes the string str, to the file file.

This operation may fail with the same errors as hPutStr and withFile.

Examples

>>> writeFile "hello" "world" >> readFile "hello""world"

>>> writeFile "~/" "D:"*** Exception: ~/: withFile: inappropriate type (Is a directory)

The read function reads input from a string, which must be completely consumed by the input process. read fails with an error if the parse is unsuccessful, and it is therefore discouraged from being used in real applications. Use readMaybe or readEither for safe alternatives.

>>> read "123" :: Int123

>>> read "hello" :: Int*** Exception: Prelude.read: no parse

equivalent to readsPrec with a precedence of 0.

The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness.

A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.

Non-empty data structures that can be folded.

A type f is a Functor if it provides a function fmap which, given any types a and b lets you apply any function from (a -> b) to turn an f a into an f b, preserving the structure of f. Furthermore f needs to adhere to the following:

Identity

fmap id == id

Composition

fmap (f . g) == fmap f . fmap g

Note, that the second law follows from the free theorem of the type fmap and the first law, so you need only check that the former condition holds. See these articles by School of Haskell or David Luposchainsky for an explanation.

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following:

Left identity

return a >>= k = k a

Right identity

m >>= return = m

Associativity

m >>= (\x -> k x >>= h) = (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

• pure = return

• m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

The above laws imply:

• fmap f xs  =  xs >>= return . f

• (>>) = (*>)

and that pure and (<*>) satisfy the applicative functor laws.

The instances of Monad for List, Maybe and System.IO.IO defined in the Prelude satisfy these laws.

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following:

Right identity

x <> mempty = x

Left identity

mempty <> x = x

Associativity

x <> (y <> z) = (x <> y) <> z

(

Semigroup

law)

Concatenation

mconcat = foldr (<>) mempty

You can alternatively define mconcat instead of mempty, in which case the laws are:

Unit

mconcat (pure x) = x

Multiplication

mconcat (join xss) = mconcat (fmap mconcat xss)

Subclass

mconcat (toList xs) = sconcat xs

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Data.Semigroup.Sum and Data.Semigroup.Product.

NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.