map -package:Cabal -package:base -package:case-insensitive -package:bytestring -package:blaze-html -package:containers -package:aeson -package:hedgehog -package:vector -package:conduit -package:unordered-containers -package:rio

O(n) map f t is the Text obtained by applying f to each element of t. Example:

>>> let message = pack "I am not angry. Not at all."

>>> T.map (\c -> if c == '.' then '!' else c) message
"I am not angry! Not at all!"

Performs replacement on invalid scalar values.

O(n) map f xs is the Stream Char obtained by applying f to each element of xs. Properties

unstream . map f . stream = map f

O(n) map f t is the Text obtained by applying f to each element of t. Performs replacement on invalid scalar values.

O(n) map f xs is the ShortByteString obtained by applying f to each element of xs.

O(n) map f xs is the ShortByteString obtained by applying f to each element of xs.

Apply a function to each element of a Stream, lazily

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, ...]

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

Apply a function to all values flowing downstream

map id = cat

map (g . f) = map f >-> map g

map f xs is the DList obtained by applying f to each element of xs. <math>(length (toList xs)). map obeys the law:

toList (map f xs) = map f (toList xs)

map f xs is the DNonEmpty obtained by applying f to each element of xs. <math>(length (toNonEmpty xs)). map obeys the law:

toNonEmpty (map f xs) = map f (toNonEmpty xs)

Map a function over a NonEmpty stream.

Fold pairs into a map.

Maps a pure function over an InputStream. map f s passes all output from s through the function f. Satisfies the following laws:

Streams.map (g . f) === Streams.map f >=> Streams.map g
Streams.map id === Streams.makeInputStream . Streams.read

Standard map on the elements of a stream.

>>> S.stdoutLn $ S.map reverse $ each (words "alpha beta")
ahpla
ateb

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, ...]

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

Decode a Map from a toMap expression or generally a Prelude.Map.Type.

>>> input (Dhall.map strictText bool) "toMap { a = True, b = False }"
fromList [("a",True),("b",False)]

>>> input (Dhall.map strictText bool) "[ { mapKey = \"foo\", mapValue = True } ]"
fromList [("foo",True)]

If there are duplicate mapKeys, later mapValues take precedence:

>>> let expr = "[ { mapKey = 1, mapValue = True }, { mapKey = 1, mapValue = False } ]"

>>> input (Dhall.map natural bool) expr
fromList [(1,False)]

Apply a transformation to each Word8 in the stream

O(n*log n) Map a function over all the left keys in the map. Version 0.3

Apply a function to each element, returning any other valid ListLike. rigidMap will always be at least as fast, if not faster, than this function and is recommended if it will work for your purposes. See also mapM.

O(n) map f xs is the ByteStream obtained by applying f to each element of xs.