Bookhound.FatPrelude

extract :: forall a1 a2 b m. Applicative m => m a1 -> m a2 -> m b -> m b

class Range a  where

Members

• range :: a -> a -> Array a

Instances

• Range Char
• Range Int

maybeToArray :: forall a. Maybe a -> Array a

Operator alias for Bookhound.Utils.Array.range (right-associative / precedence 8)

stringify :: forall t. Foldable t => String -> String -> String -> Int -> t String -> String

hasSome :: forall a t. Foldable t => t a -> Boolean

hasNone :: forall a t. Foldable t => t a -> Boolean

hasMultiple :: forall a t. Foldable t => t a -> Boolean

findJust :: forall a t. Foldable t => t (Maybe a) -> Maybe a

showMap :: forall a. String -> (String -> String) -> (a -> String) -> Map String a -> Array String

class ToString a  where

Members

• toString :: a -> String

Instances

• ToString Char
• ToString String
• ToString Int
• ToString Number
• (ToString a, Foldable m) => ToString (m a)

lines :: String -> Array String

indent :: Int -> String -> String

class UnsafeRead a  where

Members

• unsafeRead :: String -> a

Instances

• UnsafeRead Int
• UnsafeRead Number

zipWithA :: forall m a b c. Applicative m => (a -> b -> m c) -> Array a -> Array b -> m (Array c)

A generalization of zipWith which accumulates results in some Applicative functor.

sndChars = zipWithA (\a b -> charAt 2 (a <> b))
sndChars ["a", "b"] ["A", "B"] = Nothing -- since "aA" has no 3rd char
sndChars ["aa", "b"] ["AA", "BBB"] = Just ['A', 'B']

zipWith :: forall a b c. (a -> b -> c) -> Array a -> Array b -> Array c

Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array.

If one array is longer, elements will be discarded from the longer array.

For example

zipWith (*) [1, 2, 3] [4, 5, 6, 7] == [4, 10, 18]

zip :: forall a b. Array a -> Array b -> Array (Tuple a b)

Takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the longer array are discarded.

zip [1, 2, 3] ["a", "b"] = [Tuple 1 "a", Tuple 2 "b"]

updateAtIndices :: forall t a. Foldable t => t (Tuple Int a) -> Array a -> Array a

Change the elements at the specified indices in index/value pairs. Out-of-bounds indices will have no effect.

updates = [Tuple 0 "Hi", Tuple 2 "." , Tuple 10 "foobar"]

updateAtIndices updates ["Hello", "World", "!"] = ["Hi", "World", "."]

updateAt :: forall a. Int -> a -> Array a -> Maybe (Array a)

Change the element at the specified index, creating a new array, or returning Nothing if the index is out of bounds.

updateAt 1 "World" ["Hello", "Earth"] = Just ["Hello", "World"]
updateAt 10 "World" ["Hello", "Earth"] = Nothing

unzip :: forall a b. Array (Tuple a b) -> Tuple (Array a) (Array b)

Transforms an array of pairs into an array of first components and an array of second components.

unzip [Tuple 1 "a", Tuple 2 "b"] = Tuple [1, 2] ["a", "b"]

unsnoc :: forall a. Array a -> Maybe { init :: Array a, last :: a }

Break an array into its last element and all preceding elements.

unsnoc [1, 2, 3] = Just {init: [1, 2], last: 3}
unsnoc [] = Nothing

Running time: O(n) where n is the length of the array

unsafeIndex :: forall a. Partial => Array a -> Int -> a

Find the element of an array at the specified index.

unsafePartial $ unsafeIndex ["a", "b", "c"] 1 = "b"

Using unsafeIndex with an out-of-range index will not immediately raise a runtime error. Instead, the result will be undefined. Most attempts to subsequently use the result will cause a runtime error, of course, but this is not guaranteed, and is dependent on the backend; some programs will continue to run as if nothing is wrong. For example, in the JavaScript backend, the expression unsafePartial (unsafeIndex [true] 1) has type Boolean; since this expression evaluates to undefined, attempting to use it in an if statement will cause the else branch to be taken.

unionBy :: forall a. (a -> a -> Boolean) -> Array a -> Array a -> Array a

Calculate the union of two arrays, using the specified function to determine equality of elements. Note that duplicates in the first array are preserved while duplicates in the second array are removed.

mod3eq a b = a `mod` 3 == b `mod` 3
unionBy mod3eq [1, 5, 1, 2] [3, 4, 3, 3] = [1, 5, 1, 2, 3]

union :: forall a. Eq a => Array a -> Array a -> Array a

Calculate the union of two arrays. Note that duplicates in the first array are preserved while duplicates in the second array are removed.

Running time: O(n^2)

union [1, 2, 1, 1] [3, 3, 3, 4] = [1, 2, 1, 1, 3, 4]

uncons :: forall a. Array a -> Maybe { head :: a, tail :: Array a }

Break an array into its first element and remaining elements.

Using uncons provides a way of writing code that would use cons patterns in Haskell or pre-PureScript 0.7:

f (x : xs) = something
f [] = somethingElse

Becomes:

f arr = case uncons arr of
  Just { head: x, tail: xs } -> something
  Nothing -> somethingElse

transpose :: forall a. Array (Array a) -> Array (Array a)

The 'transpose' function transposes the rows and columns of its argument. For example,

transpose 
  [ [1, 2, 3]
  , [4, 5, 6]
  ] == 
  [ [1, 4]
  , [2, 5]
  , [3, 6]
  ]

If some of the rows are shorter than the following rows, their elements are skipped:

transpose 
  [ [10, 11]
  , [20]
  , [30, 31, 32]
  ] == 
  [ [10, 20, 30]
  , [11, 31]
  , [32]
  ]

toUnfoldable :: forall f. Unfoldable f => Array ~> f

Convert an Array into an Unfoldable structure.

takeWhile :: forall a. (a -> Boolean) -> Array a -> Array a

Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new array.

takeWhile (_ > 0) [4, 1, 0, -4, 5] = [4, 1]
takeWhile (_ > 0) [-1, 4] = []

takeEnd :: forall a. Int -> Array a -> Array a

Keep only a number of elements from the end of an array, creating a new array.

letters = ["a", "b", "c"]

takeEnd 2 letters = ["b", "c"]
takeEnd 100 letters = ["a", "b", "c"]

take :: forall a. Int -> Array a -> Array a

Keep only a number of elements from the start of an array, creating a new array.

letters = ["a", "b", "c"]

take 2 letters = ["a", "b"]
take 100 letters = ["a", "b", "c"]

tail :: forall a. Array a -> Maybe (Array a)

Get all but the first element of an array, creating a new array, or Nothing if the array is empty

tail [1, 2, 3, 4] = Just [2, 3, 4]
tail [] = Nothing

Running time: O(n) where n is the length of the array

splitAt :: forall a. Int -> Array a -> { after :: Array a, before :: Array a }

Splits an array into two subarrays, where before contains the elements up to (but not including) the given index, and after contains the rest of the elements, from that index on.

>>> splitAt 3 [1, 2, 3, 4, 5]
{ before: [1, 2, 3], after: [4, 5] }

Thus, the length of (splitAt i arr).before will equal either i or length arr, if that is shorter. (Or if i is negative the length will be 0.)

splitAt 2 ([] :: Array Int) == { before: [], after: [] }
splitAt 3 [1, 2, 3, 4, 5] == { before: [1, 2, 3], after: [4, 5] }

span :: forall a. (a -> Boolean) -> Array a -> { init :: Array a, rest :: Array a }

Split an array into two parts:

1. the longest initial subarray for which all elements satisfy the specified predicate
2. the remaining elements

span (\n -> n % 2 == 1) [1,3,2,4,5] == { init: [1,3], rest: [2,4,5] }

Running time: O(n).

sortWith :: forall a b. Ord b => (a -> b) -> Array a -> Array a

Sort the elements of an array in increasing order, where elements are sorted based on a projection. Sorting is stable: the order of elements is preserved if they are equal according to the projection.

sortWith (_.age) [{name: "Alice", age: 42}, {name: "Bob", age: 21}]
   = [{name: "Bob", age: 21}, {name: "Alice", age: 42}]

sortBy :: forall a. (a -> a -> Ordering) -> Array a -> Array a

Sort the elements of an array in increasing order, where elements are compared using the specified partial ordering, creating a new array. Sorting is stable: the order of elements is preserved if they are equal according to the specified partial ordering.

compareLength a b = compare (length a) (length b)
sortBy compareLength [[1, 2, 3], [7, 9], [-2]] = [[-2],[7,9],[1,2,3]]

sort :: forall a. Ord a => Array a -> Array a

Sort the elements of an array in increasing order, creating a new array. Sorting is stable: the order of equal elements is preserved.

sort [2, -3, 1] = [-3, 1, 2]

some :: forall f a. Alternative f => Lazy (f (Array a)) => f a -> f (Array a)

Attempt a computation multiple times, requiring at least one success.

The Lazy constraint is used to generate the result lazily, to ensure termination.

snoc :: forall a. Array a -> a -> Array a

Append an element to the end of an array, creating a new array.

snoc [1, 2, 3] 4 = [1, 2, 3, 4]

slice :: forall a. Int -> Int -> Array a -> Array a

Extract a subarray by a start and end index.

letters = ["a", "b", "c"]
slice 1 3 letters = ["b", "c"]
slice 5 7 letters = []
slice 4 1 letters = []

singleton :: forall a. a -> Array a

Create an array of one element

singleton 2 = [2]

reverse :: forall a. Array a -> Array a

Reverse an array, creating a new array.

reverse [] = []
reverse [1, 2, 3] = [3, 2, 1]

replicate :: forall a. Int -> a -> Array a

Create an array containing a value repeated the specified number of times.

replicate 2 "Hi" = ["Hi", "Hi"]

partition :: forall a. (a -> Boolean) -> Array a -> { no :: Array a, yes :: Array a }

Partition an array using a predicate function, creating a set of new arrays. One for the values satisfying the predicate function and one for values that don't.

partition (_ > 0) [-1, 4, -5, 7] = { yes: [4, 7], no: [-1, -5] }

nubEq :: forall a. Eq a => Array a -> Array a

Remove the duplicates from an array, creating a new array.

This less efficient version of nub only requires an Eq instance.

nubEq [1, 2, 1, 3, 3] = [1, 2, 3]

nubByEq :: forall a. (a -> a -> Boolean) -> Array a -> Array a

Remove the duplicates from an array, where element equality is determined by the specified equivalence relation, creating a new array.

This less efficient version of nubBy only requires an equivalence relation.

mod3eq a b = a `mod` 3 == b `mod` 3
nubByEq mod3eq [1, 3, 4, 5, 6] = [1, 3, 5]

nubBy :: forall a. (a -> a -> Ordering) -> Array a -> Array a

Remove the duplicates from an array, where element equality is determined by the specified ordering, creating a new array.

nubBy compare [1, 3, 4, 2, 2, 1] == [1, 3, 4, 2]

nub :: forall a. Ord a => Array a -> Array a

Remove the duplicates from an array, creating a new array.

nub [1, 2, 1, 3, 3] = [1, 2, 3]

modifyAtIndices :: forall t a. Foldable t => t Int -> (a -> a) -> Array a -> Array a

Apply a function to the element at the specified indices, creating a new array. Out-of-bounds indices will have no effect.

indices = [1, 3]
modifyAtIndices indices toUpper ["Hello", "World", "and", "others"]
   = ["Hello", "WORLD", "and", "OTHERS"]

modifyAt :: forall a. Int -> (a -> a) -> Array a -> Maybe (Array a)

Apply a function to the element at the specified index, creating a new array, or returning Nothing if the index is out of bounds.

modifyAt 1 toUpper ["Hello", "World"] = Just ["Hello", "WORLD"]
modifyAt 10 toUpper ["Hello", "World"] = Nothing

mapWithIndex :: forall a b. (Int -> a -> b) -> Array a -> Array b

Apply a function to each element in an array, supplying a generated zero-based index integer along with the element, creating an array with the new elements.

prefixIndex index element = show index <> element

mapWithIndex prefixIndex ["Hello", "World"] = ["0Hello", "1World"]

mapMaybe :: forall a b. (a -> Maybe b) -> Array a -> Array b

Apply a function to each element in an array, keeping only the results which contain a value, creating a new array.

parseEmail :: String -> Maybe Email
parseEmail = ...

mapMaybe parseEmail ["a.com", "hello@example.com", "--"]
   = [Email {user: "hello", domain: "example.com"}]

many :: forall f a. Alternative f => Lazy (f (Array a)) => f a -> f (Array a)

Attempt a computation multiple times, returning as many successful results as possible (possibly zero).

The Lazy constraint is used to generate the result lazily, to ensure termination.

last :: forall a. Array a -> Maybe a

Get the last element in an array, or Nothing if the array is empty

Running time: O(1).

last [1, 2] = Just 2
last [] = Nothing

intersperse :: forall a. a -> Array a -> Array a

Inserts the given element in between each element in the array. The array must have two or more elements for this operation to take effect.

intersperse " " [ "a", "b" ] == [ "a", " ", "b" ]
intersperse 0 [ 1, 2, 3, 4, 5 ] == [ 1, 0, 2, 0, 3, 0, 4, 0, 5 ]

If the array has less than two elements, the input array is returned.

intersperse " " [] == []
intersperse " " ["a"] == ["a"]

intersectBy :: forall a. (a -> a -> Boolean) -> Array a -> Array a -> Array a

Calculate the intersection of two arrays, using the specified equivalence relation to compare elements, creating a new array. Note that duplicates in the first array are preserved while duplicates in the second array are removed.

mod3eq a b = a `mod` 3 == b `mod` 3
intersectBy mod3eq [1, 2, 3] [4, 6, 7] = [1, 3]

intersect :: forall a. Eq a => Array a -> Array a -> Array a

Calculate the intersection of two arrays, creating a new array. Note that duplicates in the first array are preserved while duplicates in the second array are removed.

intersect [1, 1, 2] [2, 2, 1] = [1, 1, 2]

insertBy :: forall a. (a -> a -> Ordering) -> a -> Array a -> Array a

Insert an element into a sorted array, using the specified function to determine the ordering of elements.

invertCompare a b = invert $ compare a b

insertBy invertCompare 10 [21, 20, 2, 1] = [21, 20, 10, 2, 1]

insertAt :: forall a. Int -> a -> Array a -> Maybe (Array a)

Insert an element at the specified index, creating a new array, or returning Nothing if the index is out of bounds.

insertAt 2 "!" ["Hello", "World"] = Just ["Hello", "World", "!"]
insertAt 10 "!" ["Hello"] = Nothing

insert :: forall a. Ord a => a -> Array a -> Array a

Insert an element into a sorted array.

insert 10 [1, 2, 20, 21] = [1, 2, 10, 20, 21]

init :: forall a. Array a -> Maybe (Array a)

Get all but the last element of an array, creating a new array, or Nothing if the array is empty.

init [1, 2, 3, 4] = Just [1, 2, 3]
init [] = Nothing

Running time: O(n) where n is the length of the array

index :: forall a. Array a -> Int -> Maybe a

This function provides a safe way to read a value at a particular index from an array.

sentence = ["Hello", "World", "!"]

index sentence 0 = Just "Hello"
index sentence 7 = Nothing

head :: forall a. Array a -> Maybe a

Get the first element in an array, or Nothing if the array is empty

Running time: O(1).

head [1, 2] = Just 1
head [] = Nothing

groupBy :: forall a. (a -> a -> Boolean) -> Array a -> Array (NonEmptyArray a)

Group equal, consecutive elements of an array into arrays, using the specified equivalence relation to determine equality.

groupBy (\a b -> odd a && odd b) [1, 3, 2, 4, 3, 3]
   = [NonEmptyArray [1, 3], NonEmptyArray [2], NonEmptyArray [4], NonEmptyArray [3, 3]]

groupAllBy :: forall a. (a -> a -> Ordering) -> Array a -> Array (NonEmptyArray a)

Group equal elements of an array into arrays, using the specified comparison function to determine equality.

groupAllBy (comparing Down) [1, 3, 2, 4, 3, 3]
   = [NonEmptyArray [4], NonEmptyArray [3, 3, 3], NonEmptyArray [2], NonEmptyArray [1]]

groupAll :: forall a. Ord a => Array a -> Array (NonEmptyArray a)

Group equal elements of an array into arrays.

groupAll [1, 1, 2, 2, 1] == [NonEmptyArray [1, 1, 1], NonEmptyArray [2, 2]]

group :: forall a. Eq a => Array a -> Array (NonEmptyArray a)

Group equal, consecutive elements of an array into arrays.

group [1, 1, 2, 2, 1] == [NonEmptyArray [1, 1], NonEmptyArray [2, 2], NonEmptyArray [1]]

fromFoldable :: forall f. Foldable f => f ~> Array

Convert a Foldable structure into an Array.

fromFoldable (Just 1) = [1]
fromFoldable (Nothing) = []

foldRecM :: forall m a b. MonadRec m => (b -> a -> m b) -> b -> Array a -> m b

findLastIndex :: forall a. (a -> Boolean) -> Array a -> Maybe Int

Find the last index for which a predicate holds.

findLastIndex (contains $ Pattern "b") ["a", "bb", "b", "d"] = Just 2
findLastIndex (contains $ Pattern "x") ["a", "bb", "b", "d"] = Nothing

findIndex :: forall a. (a -> Boolean) -> Array a -> Maybe Int

Find the first index for which a predicate holds.

findIndex (contains $ Pattern "b") ["a", "bb", "b", "d"] = Just 1
findIndex (contains $ Pattern "x") ["a", "bb", "b", "d"] = Nothing

filterA :: forall a f. Applicative f => (a -> f Boolean) -> Array a -> f (Array a)

Filter where the predicate returns a Boolean in some Applicative.

powerSet :: forall a. Array a -> Array (Array a)
powerSet = filterA (const [true, false])

filter :: forall a. (a -> Boolean) -> Array a -> Array a

Filter an array, keeping the elements which satisfy a predicate function, creating a new array.

filter (_ > 0) [-1, 4, -5, 7] = [4, 7]

elemLastIndex :: forall a. Eq a => a -> Array a -> Maybe Int

Find the index of the last element equal to the specified element.

elemLastIndex "a" ["a", "b", "a", "c"] = Just 2
elemLastIndex "Earth" ["Hello", "World", "!"] = Nothing

elemIndex :: forall a. Eq a => a -> Array a -> Maybe Int

Find the index of the first element equal to the specified element.

elemIndex "a" ["a", "b", "a", "c"] = Just 0
elemIndex "Earth" ["Hello", "World", "!"] = Nothing

dropWhile :: forall a. (a -> Boolean) -> Array a -> Array a

Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new array.

dropWhile (_ < 0) [-3, -1, 0, 4, -6] = [0, 4, -6]

dropEnd :: forall a. Int -> Array a -> Array a

Drop a number of elements from the end of an array, creating a new array.

letters = ["a", "b", "c", "d"]

dropEnd 2 letters = ["a", "b"]
dropEnd 10 letters = []

drop :: forall a. Int -> Array a -> Array a

Drop a number of elements from the start of an array, creating a new array.

letters = ["a", "b", "c", "d"]

drop 2 letters = ["c", "d"]
drop 10 letters = []

difference :: forall a. Eq a => Array a -> Array a -> Array a

Delete the first occurrence of each element in the second array from the first array, creating a new array.

difference [2, 1] [2, 3] = [1]

Running time: O(n*m), where n is the length of the first array, and m is the length of the second.

deleteBy :: forall a. (a -> a -> Boolean) -> a -> Array a -> Array a

Delete the first element of an array which matches the specified value, under the equivalence relation provided in the first argument, creating a new array.

mod3eq a b = a `mod` 3 == b `mod` 3
deleteBy mod3eq 6 [1, 3, 4, 3] = [1, 4, 3]

deleteAt :: forall a. Int -> Array a -> Maybe (Array a)

Delete the element at the specified index, creating a new array, or returning Nothing if the index is out of bounds.

deleteAt 0 ["Hello", "World"] = Just ["World"]
deleteAt 10 ["Hello", "World"] = Nothing

delete :: forall a. Eq a => a -> Array a -> Array a

Delete the first element of an array which is equal to the specified value, creating a new array.

delete 7 [1, 7, 3, 7] = [1, 3, 7]
delete 7 [1, 2, 3] = [1, 2, 3]

Running time: O(n)

cons :: forall a. a -> Array a -> Array a

Attaches an element to the front of an array, creating a new array.

cons 1 [2, 3, 4] = [1, 2, 3, 4]

Note, the running time of this function is O(n).

concatMap :: forall a b. (a -> Array b) -> Array a -> Array b

Apply a function to each element in an array, and flatten the results into a single, new array.

concatMap (split $ Pattern " ") ["Hello World", "other thing"]
   = ["Hello", "World", "other", "thing"]

concat :: forall a. Array (Array a) -> Array a

Flatten an array of arrays, creating a new array.

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

catMaybes :: forall a. Array (Maybe a) -> Array a

Filter an array of optional values, keeping only the elements which contain a value, creating a new array.

catMaybes [Nothing, Just 2, Nothing, Just 4] = [2, 4]

alterAt :: forall a. Int -> (a -> Maybe a) -> Array a -> Maybe (Array a)

Update or delete the element at the specified index by applying a function to the current value, returning a new array or Nothing if the index is out-of-bounds.

alterAt 1 (stripSuffix $ Pattern "!") ["Hello", "World!"]
   = Just ["Hello", "World"]

alterAt 1 (stripSuffix $ Pattern "!!!!!") ["Hello", "World!"]
   = Just ["Hello"]

alterAt 10 (stripSuffix $ Pattern "!") ["Hello", "World!"] = Nothing

Operator alias for Data.Array.difference (non-associative / precedence 5)

Operator alias for Data.Array.index (left-associative / precedence 8)

An infix version of index.

sentence = ["Hello", "World", "!"]

sentence !! 0 = Just "Hello"
sentence !! 7 = Nothing

class Bifunctor :: (Type -> Type -> Type) -> Constraintclass Bifunctor f  where

A Bifunctor is a Functor from the pair category (Type, Type) to Type.

A type constructor with two type arguments can be made into a Bifunctor if both of its type arguments are covariant.

The bimap function maps a pair of functions over the two type arguments of the bifunctor.

Laws:

• Identity: bimap identity identity == identity
• Composition: bimap f1 g1 <<< bimap f2 g2 == bimap (f1 <<< f2) (g1 <<< g2)

Members

• bimap :: forall a b c d. (a -> b) -> (c -> d) -> f a c -> f b d

Instances

• Bifunctor Either
• Bifunctor Tuple
• Bifunctor Const

rmap :: forall f a b c. Bifunctor f => (b -> c) -> f a b -> f a c

Map a function over the second type arguments of a Bifunctor.

lmap :: forall f a b c. Bifunctor f => (a -> b) -> f a c -> f b c

Map a function over the first type argument of a Bifunctor.

toCharCode :: Char -> Int

Returns the numeric Unicode value of the character.

fromCharCode :: Int -> Maybe Char

Constructs a character from the given Unicode numeric value.

toUpperSimple :: CodePoint -> CodePoint

Convert a code point to the corresponding upper-case code point, if any. Any other character is returned unchanged.

toTitleSimple :: CodePoint -> CodePoint

Convert a code point to the corresponding title-case or upper-case code point, if any. (Title case differs from upper case only for a small number of ligature characters.) Any other character is returned unchanged.

toLowerSimple :: CodePoint -> CodePoint

Convert a code point to the corresponding lower-case code point, if any. Any other character is returned unchanged.

isUpper :: CodePoint -> Boolean

Selects upper-case or title-case alphabetic Unicode characters (letters). Title case is used by a small number of letter ligatures like the single-character form of /Lj/.

isSymbol :: CodePoint -> Boolean

Selects Unicode symbol characters, including mathematical and currency symbols.

This function returns true if its argument has one of the following GeneralCategorys, or false otherwise:

• MathSymbol
• CurrencySymbol
• ModifierSymbol
• OtherSymbol

These classes are defined in the Unicode Character Database, part of the Unicode standard. The same document defines what is and is not a "Symbol".

Examples

Basic usage:

>>> isSymbol (codePointFromChar 'a')
false
>>> isSymbol (codePointFromChar '6')
false
>>> isSymbol (codePointFromChar '=')
true

The definition of "math symbol" may be a little counter-intuitive depending on one's background:

>>> isSymbol (codePointFromChar '+')
true
>>> isSymbol (codePointFromChar '-')
false

isSpace :: CodePoint -> Boolean

Returns true for any Unicode space character, and the control characters \t, \n, \r, \f, \v.

isSpace includes non-breaking space.

isSeparator :: CodePoint -> Boolean

Selects Unicode space and separator characters.

This function returns true if its argument has one of the following GeneralCategorys, or false otherwise:

• Space
• LineSeparator
• ParagraphSeparator

These classes are defined in the Unicode Character Database part of the Unicode standard. The same document defines what is and is not a "Separator".

Examples

Basic usage:

>>> isSeparator (codePointFromChar 'a')
false
>>> isSeparator (codePointFromChar '6')
false
>>> isSeparator (codePointFromChar ' ')
true
>>> isSeparator (codePointFromChar '-')
false

Warning: newlines and tab characters are not considered separators.

>>> isSeparator (codePointFromChar '\n')
false
>>> isSeparator (codePointFromChar '\t')
false

But some more exotic characters are (like HTML's @ @):

>>> isSeparator (codePointFromChar '\xA0')
true

isPunctuation :: CodePoint -> Boolean

Selects Unicode punctuation characters, including various kinds of connectors, brackets and quotes.

This function returns true if its argument has one of the following GeneralCategorys, or false otherwise:

• ConnectorPunctuation
• DashPunctuation
• OpenPunctuation
• ClosePunctuation
• InitialQuote
• FinalQuote
• OtherPunctuation

These classes are defined in the [Unicode Character Database])http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_Table) part of the Unicode standard. The same document defines what is and is not a "Punctuation".

Examples

Basic usage:

>>> isPunctuation (codePointFromChar 'a')
false
>>> isPunctuation (codePointFromChar '7')
false
>>> isPunctuation (codePointFromChar '♥')
false
>>> isPunctuation (codePointFromChar '"')
true
>>> isPunctuation (codePointFromChar '?')
true
>>> isPunctuation (codePointFromChar '—')
true

isPrint :: CodePoint -> Boolean

Selects printable Unicode characters (letters, numbers, marks, punctuation, symbols and spaces).

isOctDigit :: CodePoint -> Boolean

Selects ASCII octal digits, i.e. 0..7.

isNumber :: CodePoint -> Boolean

Selects Unicode numeric characters, including digits from various scripts, Roman numerals, et cetera.

This function returns true if its argument has one of the following GeneralCategorys, or false otherwise:

• DecimalNumber
• LetterNumber
• OtherNumber

These classes are defined in the Unicode Character Database, part of the Unicode standard. The same document defines what is and is not a "Number".

Examples

Basic usage:

>>> isNumber (codePointFromChar 'a')
false
>>> isNumber (codePointFromChar '%')
false
>>> isNumber (codePointFromChar '3')
true

ASCII @'0'@ through @'9'@ are all numbers:

>>> and $ map (isNumber <<< codePointFromChar) (enumFromTo '0' '9' :: Array Char)
true

Unicode Roman numerals are "numbers" as well:

>>> isNumber (codePointFromChar 'Ⅸ')
true

isMark :: CodePoint -> Boolean

Selects Unicode mark characters, for example accents and the like, which combine with preceding characters.

This function returns true if its argument has one of the following GeneralCategorys, or false otherwise:

• NonSpacingMark
• SpacingCombiningMark
• EnclosingMark

These classes are defined in the Unicode Character Database, part of the Unicode standard. The same document defines what is and is not a "Mark".

Examples

Basic usage:

>>> isMark (codePointFromChar 'a')
false
>>> isMark (codePointFromChar '0')
false

Combining marks such as accent characters usually need to follow another character before they become printable:

>>> map isMark (toCodePointArray "ò")
[false,true]

Puns are not necessarily supported:

>>> isMark (codePointFromChar '✓')
false

isLower :: CodePoint -> Boolean

Selects lower-case alphabetic Unicode characters (letters).

isLetter :: CodePoint -> Boolean

Selects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters).

This function returns true if its argument has one of the following GeneralCategorys, or false otherwise:

• UppercaseLetter
• LowercaseLetter
• TitlecaseLetter
• ModifierLetter
• OtherLetter

These classes are defined in the Unicode Character Database part of the Unicode standard. The same document defines what is and is not a "Letter".

Examples

Basic usage:

>>> isLetter (codePointFromChar 'a')
true
>>> isLetter (codePointFromChar 'A')
true
>>> isLetter (codePointFromChar '0')
false
>>> isLetter (codePointFromChar '%')
false
>>> isLetter (codePointFromChar '♥')
false
>>> isLetter (codePointFromChar '\x1F')
false

Ensure that 'isLetter' and 'isAlpha' are equivalent.

>>> chars = enumFromTo bottom top :: Array CodePoint
>>> letters = map isLetter chars
>>> alphas = map isAlpha chars
>>> letters == alphas
true

isLatin1 :: CodePoint -> Boolean

Selects the first 256 characters of the Unicode character set, corresponding to the ISO 8859-1 (Latin-1) character set.

isHexDigit :: CodePoint -> Boolean

Selects ASCII hexadecimal digits, i.e. 0..9, A..F, a..f.

isDigit :: Warn (Text "\'isDigit\' is deprecated, use \'isDecDigit\', \'isHexDigit\', or \'isOctDigit\' instead") => CodePoint -> Boolean

isDecDigit :: CodePoint -> Boolean

Selects ASCII decimal digits, i.e. 0..9.

isControl :: CodePoint -> Boolean

Selects control characters, which are the non-printing characters of the Latin-1 subset of Unicode.

isAsciiUpper :: CodePoint -> Boolean

Selects ASCII upper-case letters, i.e. characters satisfying both isAscii and isUpper.

isAsciiLower :: CodePoint -> Boolean

Selects ASCII lower-case letters, i.e. characters satisfying both isAscii and isLower.

isAscii :: CodePoint -> Boolean

Selects the first 128 characters of the Unicode character set, corresponding to the ASCII character set.

isAlphaNum :: CodePoint -> Boolean

Selects alphabetic or numeric digit Unicode characters.

Note that numeric digits outside the ASCII range are selected by this function but not by isDigit. Such digits may be part of identifiers but are not used by the printer and reader to represent numbers.

isAlpha :: CodePoint -> Boolean

Selects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters).

caseFoldSimple :: CodePoint -> CodePoint

Convert a code point to the corresponding case-folded code point. Any other character is returned unchanged.

data Either a b

The Either type is used to represent a choice between two types of value.

A common use case for Either is error handling, where Left is used to carry an error value and Right is used to carry a success value.

Constructors

• Left a
• Right b

Instances

• Functor (Either a)

  The Functor instance allows functions to transform the contents of a Right with the <$> operator:

  f <$> Right x == Right (f x)
  

  Left values are untouched:

  f <$> Left y == Left y
  

• Generic (Either a b) _
• Invariant (Either a)
• Apply (Either e)

  The Apply instance allows functions contained within a Right to transform a value contained within a Right using the (<*>) operator:

  Right f <*> Right x == Right (f x)
  

  Left values are left untouched:

  Left f <*> Right x == Left f
  Right f <*> Left y == Left y
  

  Combining Functor's <$> with Apply's <*> can be used to transform a pure function to take Either-typed arguments so f :: a -> b -> c becomes f :: Either l a -> Either l b -> Either l c:

  f <$> Right x <*> Right y == Right (f x y)
  

  The Left-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Left means the whole result becomes Left also, taking the first Left value found:

  f <$> Left x <*> Right y == Left x
  f <$> Right x <*> Left y == Left y
  f <$> Left x <*> Left y == Left x
  

• Applicative (Either e)

  The Applicative instance enables lifting of values into Either with the pure function:

  pure x :: Either _ _ == Right x
  

  Combining Functor's <$> with Apply's <*> and Applicative's pure can be used to pass a mixture of Either and non-Either typed values to a function that does not usually expect them, by using pure for any value that is not already Either typed:

  f <$> Right x <*> pure y == Right (f x y)
  

  Even though pure = Right it is recommended to use pure in situations like this as it allows the choice of Applicative to be changed later without having to go through and replace Right with a new constructor.

• Alt (Either e)

  The Alt instance allows for a choice to be made between two Either values with the <|> operator, where the first Right encountered is taken.

  Right x <|> Right y == Right x
  Left x <|> Right y == Right y
  Left x <|> Left y == Left y
  

• Bind (Either e)

  The Bind instance allows sequencing of Either values and functions that return an Either by using the >>= operator:

  Left x >>= f = Left x
  Right x >>= f = f x
  

  Either's "do notation" can be understood to work like this:

  x :: forall e a. Either e a
  x = --
  
  y :: forall e b. Either e b
  y = --
  
  foo :: forall e a. (a -> b -> c) -> Either e c
  foo f = do
    x' <- x
    y' <- y
    pure (f x' y')
  

  ...which is equivalent to...

  x >>= (\x' -> y >>= (\y' -> pure (f x' y')))
  

  ...and is the same as writing...

  foo :: forall e a. (a -> b -> c) -> Either e c
  foo f = case x of
    Left e ->
      Left e
    Right x -> case y of
      Left e ->
        Left e
      Right y ->
        Right (f x y)
  

• Monad (Either e)

  The Monad instance guarantees that there are both Applicative and Bind instances for Either.

• Extend (Either e)

  The Extend instance allows sequencing of Either values and functions that accept an Either and return a non-Either result using the <<= operator.

  f <<= Left x = Left x
  f <<= Right x = Right (f (Right x))
  

• (Show a, Show b) => Show (Either a b)

  The Show instance allows Either values to be rendered as a string with show whenever there is an Show instance for both type the Either can contain.

• (Eq a, Eq b) => Eq (Either a b)

  The Eq instance allows Either values to be checked for equality with == and inequality with /= whenever there is an Eq instance for both types the Either can contain.

• (Eq a) => Eq1 (Either a)
• (Ord a, Ord b) => Ord (Either a b)

  The Ord instance allows Either values to be compared with compare, >, >=, < and <= whenever there is an Ord instance for both types the Either can contain.

  Any Left value is considered to be less than a Right value.

• (Ord a) => Ord1 (Either a)
• (Bounded a, Bounded b) => Bounded (Either a b)
• (Semigroup b) => Semigroup (Either a b)

note' :: forall a b. (Unit -> a) -> Maybe b -> Either a b

Similar to note, but for use in cases where the default value may be expensive to compute.

note' (\_ -> "default") Nothing = Left "default"
note' (\_ -> "default") (Just 1) = Right 1

note :: forall a b. a -> Maybe b -> Either a b

Takes a default and a Maybe value, if the value is a Just, turn it into a Right, if the value is a Nothing use the provided default as a Left

note "default" Nothing = Left "default"
note "default" (Just 1) = Right 1

isRight :: forall a b. Either a b -> Boolean

Returns true when the Either value was constructed with Right.

isLeft :: forall a b. Either a b -> Boolean

Returns true when the Either value was constructed with Left.

hush :: forall a b. Either a b -> Maybe b

Turns an Either into a Maybe, by throwing potential Left values away and converting them into Nothing. Right values get turned into Justs.

hush (Left "ParseError") = Nothing
hush (Right 42) = Just 42

fromRight' :: forall a b. (Unit -> b) -> Either a b -> b

Similar to fromRight but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard fromRight has to evaluate the default value before returning the result, whereas here the value is only computed when the Either is known to be Left.

fromRight :: forall a b. b -> Either a b -> b

A function that extracts the value from the Right data constructor. The first argument is a default value, which will be returned in the case where a Left is passed to fromRight.

fromLeft' :: forall a b. (Unit -> a) -> Either a b -> a

Similar to fromLeft but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard fromLeft has to evaluate the default value before returning the result, whereas here the value is only computed when the Either is known to be Right.

fromLeft :: forall a b. a -> Either a b -> a

A function that extracts the value from the Left data constructor. The first argument is a default value, which will be returned in the case where a Right is passed to fromLeft.

either :: forall a b c. (a -> c) -> (b -> c) -> Either a b -> c

Takes two functions and an Either value, if the value is a Left the inner value is applied to the first function, if the value is a Right the inner value is applied to the second function.

either f g (Left x) == f x
either f g (Right y) == g y

choose :: forall m a b. Alt m => m a -> m b -> m (Either a b)

Combine two alternatives.

blush :: forall a b. Either a b -> Maybe a

Turns an Either into a Maybe, by throwing potential Right values away and converting them into Nothing. Left values get turned into Justs.

blush (Left "ParseError") = Just "Parse Error"
blush (Right 42) = Nothing

class Foldable :: (Type -> Type) -> Constraintclass Foldable f  where

Foldable represents data structures which can be folded.

• foldr folds a structure from the right
• foldl folds a structure from the left
• foldMap folds a structure by accumulating values in a Monoid

Default implementations are provided by the following functions:

• foldrDefault
• foldlDefault
• foldMapDefaultR
• foldMapDefaultL

Note: some combinations of the default implementations are unsafe to use together - causing a non-terminating mutually recursive cycle. These combinations are documented per function.

Members

• foldr :: forall a b. (a -> b -> b) -> b -> f a -> b
• foldl :: forall a b. (b -> a -> b) -> b -> f a -> b
• foldMap :: forall a m. Monoid m => (a -> m) -> f a -> m

Instances

• Foldable Array
• Foldable Maybe
• Foldable First
• Foldable Last
• Foldable Additive
• Foldable Dual
• Foldable Disj
• Foldable Conj
• Foldable Multiplicative
• Foldable (Either a)
• Foldable (Tuple a)
• Foldable Identity
• Foldable (Const a)
• (Foldable f, Foldable g) => Foldable (Product f g)
• (Foldable f, Foldable g) => Foldable (Coproduct f g)
• (Foldable f, Foldable g) => Foldable (Compose f g)
• (Foldable f) => Foldable (App f)

traverse_ :: forall a b f m. Applicative m => Foldable f => (a -> m b) -> f a -> m Unit

Traverse a data structure, performing some effects encoded by an Applicative functor at each value, ignoring the final result.

For example:

traverse_ print [1, 2, 3]

surroundMap :: forall f a m. Foldable f => Semigroup m => m -> (a -> m) -> f a -> m

foldMap but with each element surrounded by some fixed value.

For example:

> surroundMap "*" show []
= "*"

> surroundMap "*" show [1]
= "*1*"

> surroundMap "*" show [1, 2]
= "*1*2*"

> surroundMap "*" show [1, 2, 3]
= "*1*2*3*"

surround :: forall f m. Foldable f => Semigroup m => m -> f m -> m

fold but with each element surrounded by some fixed value.

For example:

> surround "*" []
= "*"

> surround "*" ["1"]
= "*1*"

> surround "*" ["1", "2"]
= "*1*2*"

> surround "*" ["1", "2", "3"]
= "*1*2*3*"

sum :: forall a f. Foldable f => Semiring a => f a -> a

Find the sum of the numeric values in a data structure.

sequence_ :: forall a f m. Applicative m => Foldable f => f (m a) -> m Unit

Perform all of the effects in some data structure in the order given by the Foldable instance, ignoring the final result.

For example:

sequence_ [ trace "Hello, ", trace " world!" ]

product :: forall a f. Foldable f => Semiring a => f a -> a

Find the product of the numeric values in a data structure.

or :: forall a f. Foldable f => HeytingAlgebra a => f a -> a

The disjunction of all the values in a data structure. When specialized to Boolean, this function will test whether any of the values in a data structure is true.

null :: forall a f. Foldable f => f a -> Boolean

Test whether the structure is empty. Optimized for structures that are similar to cons-lists, because there is no general way to do better.

notElem :: forall a f. Foldable f => Eq a => a -> f a -> Boolean

Test whether a value is not an element of a data structure.

minimumBy :: forall a f. Foldable f => (a -> a -> Ordering) -> f a -> Maybe a

Find the smallest element of a structure, according to a given comparison function. The comparison function should represent a total ordering (see the Ord type class laws); if it does not, the behaviour is undefined.

minimum :: forall a f. Ord a => Foldable f => f a -> Maybe a

Find the smallest element of a structure, according to its Ord instance.

maximumBy :: forall a f. Foldable f => (a -> a -> Ordering) -> f a -> Maybe a

Find the largest element of a structure, according to a given comparison function. The comparison function should represent a total ordering (see the Ord type class laws); if it does not, the behaviour is undefined.

maximum :: forall a f. Ord a => Foldable f => f a -> Maybe a

Find the largest element of a structure, according to its Ord instance.

lookup :: forall a b f. Foldable f => Eq a => a -> f (Tuple a b) -> Maybe b

Lookup a value in a data structure of Tuples, generalizing association lists.

length :: forall a b f. Foldable f => Semiring b => f a -> b

Returns the size/length of a finite structure. Optimized for structures that are similar to cons-lists, because there is no general way to do better.

intercalate :: forall f m. Foldable f => Monoid m => m -> f m -> m

Fold a data structure, accumulating values in some Monoid, combining adjacent elements using the specified separator.

For example:

> intercalate ", " ["Lorem", "ipsum", "dolor"]
= "Lorem, ipsum, dolor"

> intercalate "*" ["a", "b", "c"]
= "a*b*c"

> intercalate [1] [[2, 3], [4, 5], [6, 7]]
= [2, 3, 1, 4, 5, 1, 6, 7]

indexr :: forall a f. Foldable f => Int -> f a -> Maybe a

Try to get nth element from the right in a data structure

indexl :: forall a f. Foldable f => Int -> f a -> Maybe a

Try to get nth element from the left in a data structure

for_ :: forall a b f m. Applicative m => Foldable f => f a -> (a -> m b) -> m Unit

A version of traverse_ with its arguments flipped.

This can be useful when running an action written using do notation for every element in a data structure:

For example:

for_ [1, 2, 3] \n -> do
  print n
  trace "squared is"
  print (n * n)

foldrDefault :: forall f a b. Foldable f => (a -> b -> b) -> b -> f a -> b

A default implementation of foldr using foldMap.

Note: when defining a Foldable instance, this function is unsafe to use in combination with foldMapDefaultR.

foldlDefault :: forall f a b. Foldable f => (b -> a -> b) -> b -> f a -> b

A default implementation of foldl using foldMap.

Note: when defining a Foldable instance, this function is unsafe to use in combination with foldMapDefaultL.

foldMapDefaultR :: forall f a m. Foldable f => Monoid m => (a -> m) -> f a -> m

A default implementation of foldMap using foldr.

Note: when defining a Foldable instance, this function is unsafe to use in combination with foldrDefault.

foldMapDefaultL :: forall f a m. Foldable f => Monoid m => (a -> m) -> f a -> m

A default implementation of foldMap using foldl.

Note: when defining a Foldable instance, this function is unsafe to use in combination with foldlDefault.

foldM :: forall f m a b. Foldable f => Monad m => (b -> a -> m b) -> b -> f a -> m b

Similar to 'foldl', but the result is encapsulated in a monad.

Note: this function is not generally stack-safe, e.g., for monads which build up thunks a la Eff.

fold :: forall f m. Foldable f => Monoid m => f m -> m

Fold a data structure, accumulating values in some Monoid.

findMap :: forall a b f. Foldable f => (a -> Maybe b) -> f a -> Maybe b

Try to find an element in a data structure which satisfies a predicate mapping.

find :: forall a f. Foldable f => (a -> Boolean) -> f a -> Maybe a

Try to find an element in a data structure which satisfies a predicate.

elem :: forall a f. Foldable f => Eq a => a -> f a -> Boolean

Test whether a value is an element of a data structure.

any :: forall a b f. Foldable f => HeytingAlgebra b => (a -> b) -> f a -> b

any f is the same as or <<< map f; map a function over the structure, and then get the disjunction of the results.

and :: forall a f. Foldable f => HeytingAlgebra a => f a -> a

The conjunction of all the values in a data structure. When specialized to Boolean, this function will test whether all of the values in a data structure are true.

all :: forall a b f. Foldable f => HeytingAlgebra b => (a -> b) -> f a -> b

all f is the same as and <<< map f; map a function over the structure, and then get the conjunction of the results.

on :: forall a b c. (b -> b -> c) -> (a -> b) -> a -> a -> c

The on function is used to change the domain of a binary operator.

For example, we can create a function which compares two records based on the values of their x properties:

compareX :: forall r. { x :: Number | r } -> { x :: Number | r } -> Ordering
compareX = compare `on` _.x

data List a

Constructors

• Nil
• Cons a (List a)

Instances

• (Show a) => Show (List a)
• (Eq a) => Eq (List a)
• Eq1 List
• (Ord a) => Ord (List a)
• Ord1 List
• Semigroup (List a)
• Monoid (List a)
• Functor List
• FunctorWithIndex Int List
• Foldable List
• FoldableWithIndex Int List
• Unfoldable1 List
• Unfoldable List
• Traversable List
• TraversableWithIndex Int List
• Apply List
• Applicative List
• Bind List
• Monad List
• Alt List
• Plus List
• Alternative List
• MonadPlus List
• Extend List

Operator alias for Data.List.Types.Cons (right-associative / precedence 6)

data Map k v

Map k v represents maps from keys of type k to values of type v.

Instances

• (Eq k) => Eq1 (Map k)
• (Eq k, Eq v) => Eq (Map k v)
• (Ord k) => Ord1 (Map k)
• (Ord k, Ord v) => Ord (Map k v)
• (Show k, Show v) => Show (Map k v)
• (Warn (Text "Data.Map\'s `Semigroup` instance is now unbiased and differs from the left-biased instance defined in PureScript releases <= 0.13.x."), Ord k, Semigroup v) => Semigroup (Map k v)
• (Warn (Text "Data.Map\'s `Semigroup` instance is now unbiased and differs from the left-biased instance defined in PureScript releases <= 0.13.x."), Ord k, Semigroup v) => Monoid (Map k v)
• (Ord k) => Alt (Map k)
• (Ord k) => Plus (Map k)
• Functor (Map k)
• FunctorWithIndex k (Map k)
• (Ord k) => Apply (Map k)
• (Ord k) => Bind (Map k)
• Foldable (Map k)
• FoldableWithIndex k (Map k)
• Traversable (Map k)
• TraversableWithIndex k (Map k)

data Maybe a

The Maybe type is used to represent optional values and can be seen as something like a type-safe null, where Nothing is null and Just x is the non-null value x.

Constructors

• Nothing
• Just a

Instances

• Functor Maybe

  The Functor instance allows functions to transform the contents of a Just with the <$> operator:

  f <$> Just x == Just (f x)
  

  Nothing values are left untouched:

  f <$> Nothing == Nothing
  

• Apply Maybe

  The Apply instance allows functions contained within a Just to transform a value contained within a Just using the apply operator:

  Just f <*> Just x == Just (f x)
  

  Nothing values are left untouched:

  Just f <*> Nothing == Nothing
  Nothing <*> Just x == Nothing
  

  Combining Functor's <$> with Apply's <*> can be used transform a pure function to take Maybe-typed arguments so f :: a -> b -> c becomes f :: Maybe a -> Maybe b -> Maybe c:

  f <$> Just x <*> Just y == Just (f x y)
  

  The Nothing-preserving behaviour of both operators means the result of an expression like the above but where any one of the values is Nothing means the whole result becomes Nothing also:

  f <$> Nothing <*> Just y == Nothing
  f <$> Just x <*> Nothing == Nothing
  f <$> Nothing <*> Nothing == Nothing
  

• Applicative Maybe

  The Applicative instance enables lifting of values into Maybe with the pure function:

  pure x :: Maybe _ == Just x
  

  Combining Functor's <$> with Apply's <*> and Applicative's pure can be used to pass a mixture of Maybe and non-Maybe typed values to a function that does not usually expect them, by using pure for any value that is not already Maybe typed:

  f <$> Just x <*> pure y == Just (f x y)
  

  Even though pure = Just it is recommended to use pure in situations like this as it allows the choice of Applicative to be changed later without having to go through and replace Just with a new constructor.

• Alt Maybe

  The Alt instance allows for a choice to be made between two Maybe values with the <|> operator, where the first Just encountered is taken.

  Just x <|> Just y == Just x
  Nothing <|> Just y == Just y
  Nothing <|> Nothing == Nothing
  

• Plus Maybe

  The Plus instance provides a default Maybe value:

  empty :: Maybe _ == Nothing
  

• Alternative Maybe

  The Alternative instance guarantees that there are both Applicative and Plus instances for Maybe.

• Bind Maybe

  The Bind instance allows sequencing of Maybe values and functions that return a Maybe by using the >>= operator:

  Just x >>= f = f x
  Nothing >>= f = Nothing
  

• Monad Maybe

  The Monad instance guarantees that there are both Applicative and Bind instances for Maybe. This also enables the do syntactic sugar:

  do
    x' <- x
    y' <- y
    pure (f x' y')
  

  Which is equivalent to:

  x >>= (\x' -> y >>= (\y' -> pure (f x' y')))
  

  Which is equivalent to:

  case x of
    Nothing -> Nothing
    Just x' -> case y of
      Nothing -> Nothing
      Just y' -> Just (f x' y')
  

• Extend Maybe

  The Extend instance allows sequencing of Maybe values and functions that accept a Maybe a and return a non-Maybe result using the <<= operator.

  f <<= Nothing = Nothing
  f <<= x = Just (f x)
  

• Invariant Maybe
• (Semigroup a) => Semigroup (Maybe a)

  The Semigroup instance enables use of the operator <> on Maybe values whenever there is a Semigroup instance for the type the Maybe contains. The exact behaviour of <> depends on the "inner" Semigroup instance, but generally captures the notion of appending or combining things.

  Just x <> Just y = Just (x <> y)
  Just x <> Nothing = Just x
  Nothing <> Just y = Just y
  Nothing <> Nothing = Nothing
  

• (Semigroup a) => Monoid (Maybe a)
• (Semiring a) => Semiring (Maybe a)
• (Eq a) => Eq (Maybe a)

  The Eq instance allows Maybe values to be checked for equality with == and inequality with /= whenever there is an Eq instance for the type the Maybe contains.

• Eq1 Maybe
• (Ord a) => Ord (Maybe a)

  The Ord instance allows Maybe values to be compared with compare, >, >=, < and <= whenever there is an Ord instance for the type the Maybe contains.

  Nothing is considered to be less than any Just value.

• Ord1 Maybe
• (Bounded a) => Bounded (Maybe a)
• (Show a) => Show (Maybe a)

  The Show instance allows Maybe values to be rendered as a string with show whenever there is an Show instance for the type the Maybe contains.

• Generic (Maybe a) _

optional :: forall f a. Alt f => Applicative f => f a -> f (Maybe a)

One or none.

optional empty = pure Nothing

The behaviour of optional (pure x) depends on whether the Alt instance satisfy the left catch law (pure a <|> b = pure a).

Either e does:

optional (Right x) = Right (Just x)

But Array does not:

optional [x] = [Just x, Nothing]

maybe' :: forall a b. (Unit -> b) -> (a -> b) -> Maybe a -> b

Similar to maybe but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard maybe has to evaluate the default value before returning the result, whereas here the value is only computed when the Maybe is known to be Nothing.

maybe' (\_ -> x) f Nothing == x
maybe' (\_ -> x) f (Just y) == f y

maybe :: forall a b. b -> (a -> b) -> Maybe a -> b

Takes a default value, a function, and a Maybe value. If the Maybe value is Nothing the default value is returned, otherwise the function is applied to the value inside the Just and the result is returned.

maybe x f Nothing == x
maybe x f (Just y) == f y

isNothing :: forall a. Maybe a -> Boolean

Returns true when the Maybe value is Nothing.

isJust :: forall a. Maybe a -> Boolean

Returns true when the Maybe value was constructed with Just.

fromMaybe' :: forall a. (Unit -> a) -> Maybe a -> a

Similar to fromMaybe but for use in cases where the default value may be expensive to compute. As PureScript is not lazy, the standard fromMaybe has to evaluate the default value before returning the result, whereas here the value is only computed when the Maybe is known to be Nothing.

fromMaybe' (\_ -> x) Nothing == x
fromMaybe' (\_ -> x) (Just y) == y

fromMaybe :: forall a. a -> Maybe a -> a

Takes a default value, and a Maybe value. If the Maybe value is Nothing the default value is returned, otherwise the value inside the Just is returned.

fromMaybe x Nothing == x
fromMaybe x (Just y) == y

fromJust :: forall a. Partial => Maybe a -> a

A partial function that extracts the value from the Just data constructor. Passing Nothing to fromJust will throw an error at runtime.

class (Coercible t a) <= Newtype t a | t -> a

A type class for newtypes to enable convenient wrapping and unwrapping, and the use of the other functions in this module.

The compiler can derive instances of Newtype automatically:

newtype EmailAddress = EmailAddress String

derive instance newtypeEmailAddress :: Newtype EmailAddress _

Note that deriving for Newtype instances requires that the type be defined as newtype rather than data declaration (even if the data structurally fits the rules of a newtype), and the use of a wildcard for the wrapped type.

Instances

• Newtype (Additive a) a
• Newtype (Multiplicative a) a
• Newtype (Conj a) a
• Newtype (Disj a) a
• Newtype (Dual a) a
• Newtype (Endo c a) (c a a)
• Newtype (First a) a
• Newtype (Last a) a

unwrap :: forall t a. Newtype t a => t -> a

newtype Set a

Set a represents a set of values of type a

Instances

• (Eq a) => Eq (Set a)
• Eq1 Set
• (Show a) => Show (Set a)
• (Ord a) => Ord (Set a)
• Ord1 Set
• (Ord a) => Monoid (Set a)
• (Ord a) => Semigroup (Set a)
• Foldable Set

newtype CodePoint

CodePoint is an Int bounded between 0 and 0x10FFFF, corresponding to Unicode code points.

Instances

• Eq CodePoint
• Ord CodePoint
• Show CodePoint
• Bounded CodePoint
• Enum CodePoint
• BoundedEnum CodePoint

codePointFromChar :: Char -> CodePoint

Creates a CodePoint from a given Char.

>>> codePointFromChar 'B'
CodePoint 0x42 -- represents 'B'

toCharArray :: String -> Array Char

Converts the string into an array of characters.

toCharArray "Hello☺\n" == ['H','e','l','l','o','☺','\n']

toChar :: String -> Maybe Char

Converts the string to a character, if the length of the string is exactly 1.

toChar "l" == Just 'l'
toChar "Hi" == Nothing -- since length is not 1

fromCharArray :: Array Char -> String

Converts an array of characters into a string.

fromCharArray ['H', 'e', 'l', 'l', 'o'] == "Hello"

charAt :: Int -> String -> Maybe Char

Returns the character at the given index, if the index is within bounds.

charAt 2 "Hello" == Just 'l'
charAt 10 "Hello" == Nothing

trim :: String -> String

Removes whitespace from the beginning and end of a string, including whitespace characters and line terminators.

trim "   Hello  \n World\n\t    " == "Hello  \n World"

toUpper :: String -> String

Returns the argument converted to uppercase.

toUpper "Hello" == "HELLO"

toLower :: String -> String

Returns the argument converted to lowercase.

toLower "hElLo" == "hello"

split :: Pattern -> String -> Array String

Returns the substrings of the second string separated along occurences of the first string.

split (Pattern " ") "hello world" == ["hello", "world"]

replaceAll :: Pattern -> Replacement -> String -> String

Replaces all occurences of the pattern with the replacement string.

replaceAll (Pattern "<=") (Replacement "≤") "a <= b <= c" == "a ≤ b ≤ c"

replace :: Pattern -> Replacement -> String -> String

Replaces the first occurence of the pattern with the replacement string.

replace (Pattern "<=") (Replacement "≤") "a <= b <= c" == "a ≤ b <= c"

localeCompare :: String -> String -> Ordering

Compare two strings in a locale-aware fashion. This is in contrast to the Ord instance on String which treats strings as arrays of code units:

"ä" `localeCompare` "b" == LT
"ä" `compare` "b" == GT

joinWith :: String -> Array String -> String

Joins the strings in the array together, inserting the first argument as separator between them.

joinWith ", " ["apple", "banana", "orange"] == "apple, banana, orange"

type Accum s a = { accum :: s, value :: a }

class Traversable :: (Type -> Type) -> Constraintclass (Functor t, Foldable t) <= Traversable t  where

Traversable represents data structures which can be traversed, accumulating results and effects in some Applicative functor.

• traverse runs an action for every element in a data structure, and accumulates the results.
• sequence runs the actions contained in a data structure, and accumulates the results.

import Data.Traversable
import Data.Maybe
import Data.Int (fromNumber)

sequence [Just 1, Just 2, Just 3] == Just [1,2,3]
sequence [Nothing, Just 2, Just 3] == Nothing

traverse fromNumber [1.0, 2.0, 3.0] == Just [1,2,3]
traverse fromNumber [1.5, 2.0, 3.0] == Nothing

traverse logShow [1,2,3]
-- prints:
   1
   2
   3

traverse (\x -> [x, 0]) [1,2,3] == [[1,2,3],[1,2,0],[1,0,3],[1,0,0],[0,2,3],[0,2,0],[0,0,3],[0,0,0]]

The traverse and sequence functions should be compatible in the following sense:

• traverse f xs = sequence (f <$> xs)
• sequence = traverse identity

Traversable instances should also be compatible with the corresponding Foldable instances, in the following sense:

• foldMap f = runConst <<< traverse (Const <<< f)

Default implementations are provided by the following functions:

• traverseDefault
• sequenceDefault

Members

• traverse :: forall a b m. Applicative m => (a -> m b) -> t a -> m (t b)
• sequence :: forall a m. Applicative m => t (m a) -> m (t a)

Instances

• Traversable Array
• Traversable Maybe
• Traversable First
• Traversable Last
• Traversable Additive
• Traversable Dual
• Traversable Conj
• Traversable Disj
• Traversable Multiplicative
• Traversable (Either a)
• Traversable (Tuple a)
• Traversable Identity
• Traversable (Const a)
• (Traversable f, Traversable g) => Traversable (Product f g)
• (Traversable f, Traversable g) => Traversable (Coproduct f g)
• (Traversable f, Traversable g) => Traversable (Compose f g)
• (Traversable f) => Traversable (App f)

traverseDefault :: forall t a b m. Traversable t => Applicative m => (a -> m b) -> t a -> m (t b)

A default implementation of traverse using sequence and map.

sequenceDefault :: forall t a m. Traversable t => Applicative m => t (m a) -> m (t a)

A default implementation of sequence using traverse.

scanr :: forall a b f. Traversable f => (a -> b -> b) -> b -> f a -> f b

Fold a data structure from the right, keeping all intermediate results instead of only the final result. Note that the initial value does not appear in the result (unlike Haskell's Prelude.scanr).

scanr (+) 0 [1,2,3] = [6,5,3]
scanr (flip (-)) 10 [1,2,3] = [4,5,7]

scanl :: forall a b f. Traversable f => (b -> a -> b) -> b -> f a -> f b

Fold a data structure from the left, keeping all intermediate results instead of only the final result. Note that the initial value does not appear in the result (unlike Haskell's Prelude.scanl).

scanl (+) 0  [1,2,3] = [1,3,6]
scanl (-) 10 [1,2,3] = [9,7,4]

mapAccumR :: forall a b s f. Traversable f => (s -> a -> Accum s b) -> s -> f a -> Accum s (f b)

Fold a data structure from the right, keeping all intermediate results instead of only the final result.

Unlike scanr, mapAccumR allows the type of accumulator to differ from the element type of the final data structure.

mapAccumL :: forall a b s f. Traversable f => (s -> a -> Accum s b) -> s -> f a -> Accum s (f b)

Fold a data structure from the left, keeping all intermediate results instead of only the final result.

Unlike scanl, mapAccumL allows the type of accumulator to differ from the element type of the final data structure.

data Tuple a b

A simple product type for wrapping a pair of component values.

Constructors

• Tuple a b

Instances

• (Show a, Show b) => Show (Tuple a b)

  Allows Tuples to be rendered as a string with show whenever there are Show instances for both component types.

• (Eq a, Eq b) => Eq (Tuple a b)

  Allows Tuples to be checked for equality with == and /= whenever there are Eq instances for both component types.

• (Eq a) => Eq1 (Tuple a)
• (Ord a, Ord b) => Ord (Tuple a b)

  Allows Tuples to be compared with compare, >, >=, < and <= whenever there are Ord instances for both component types. To obtain the result, the fsts are compared, and if they are EQual, the snds are compared.

• (Ord a) => Ord1 (Tuple a)
• (Bounded a, Bounded b) => Bounded (Tuple a b)
• Semigroupoid Tuple
• (Semigroup a, Semigroup b) => Semigroup (Tuple a b)

  The Semigroup instance enables use of the associative operator <> on Tuples whenever there are Semigroup instances for the component types. The <> operator is applied pairwise, so:

  (Tuple a1 b1) <> (Tuple a2 b2) = Tuple (a1 <> a2) (b1 <> b2)
  

• (Monoid a, Monoid b) => Monoid (Tuple a b)
• (Semiring a, Semiring b) => Semiring (Tuple a b)
• (Ring a, Ring b) => Ring (Tuple a b)
• (CommutativeRing a, CommutativeRing b) => CommutativeRing (Tuple a b)
• (HeytingAlgebra a, HeytingAlgebra b) => HeytingAlgebra (Tuple a b)
• (BooleanAlgebra a, BooleanAlgebra b) => BooleanAlgebra (Tuple a b)
• Functor (Tuple a)

  The Functor instance allows functions to transform the contents of a Tuple with the <$> operator, applying the function to the second component, so:

  f <$> (Tuple x y) = Tuple x (f y)
  

• Generic (Tuple a b) _
• Invariant (Tuple a)
• (Semigroup a) => Apply (Tuple a)

  The Apply instance allows functions to transform the contents of a Tuple with the <*> operator whenever there is a Semigroup instance for the fst component, so:

  (Tuple a1 f) <*> (Tuple a2 x) == Tuple (a1 <> a2) (f x)
  

• (Monoid a) => Applicative (Tuple a)
• (Semigroup a) => Bind (Tuple a)
• (Monoid a) => Monad (Tuple a)
• Extend (Tuple a)
• Comonad (Tuple a)
• (Lazy a, Lazy b) => Lazy (Tuple a b)

uncurry :: forall a b c. (a -> b -> c) -> Tuple a b -> c

Turn a function of two arguments into a function that expects a tuple.

swap :: forall a b. Tuple a b -> Tuple b a

Exchange the first and second components of a tuple.

snd :: forall a b. Tuple a b -> b

Returns the second component of a tuple.

fst :: forall a b. Tuple a b -> a