Data type representing truth values True and False.

Boolean conjunction (and). The function is a macro that evaluates the second parameter only if the first parameter is True.

Boolean disjunction (or). The function is a macro that evaluates the second parameter only if the first parameter is False.

Boolean negation

Conjunction over a list.

Disjunction over a list.

all pred lst tests whether the predicate pred holds for all elements of lst. It returns immediately when it encounters the first value not satisfying the predicate.

any pred lst tests whether the predicate pred holds some element of lst. It returns immediately when it encounters the first value satisfying the predicate.

Equivalent to the boolean value True. The value is meant to be used in guard patterns:

min a b | a < b     = a
        | otherwise = b

The class of linearly ordered types. Method compare must be implemented in instances.

Minimum over a list

Maximum over a list

As minimum but compares the elements by the given projection. For example

minimumBy snd l

returns a pair with the smallest second component.

As maximum but compares the elements by the given projection.

Combines two integers such that if the first one is non-zero, it is returned, otherwise the second-one. The second parameter is not implemented, if it is not needed.

The function is useful for implementing efficient recursive comparison of structures, for example:

compare (x1,y1,z1) (x2,y2,z2) = compare x1 x2 &<& compare y1 y2 &<& compare z1 z2

Returns true, if the given character is a digit.

16-bit signed integer

32-bit signed integer

64-bit signed integer

32-bit floating point number

64-bit floating point number

The Additive class is used for types that are additive monoids. The operations must satisfy the following laws (at least approximately, when implemented for floating point numbers): (a + b) + c = a + (b + c) a + 0 = 0 + a = a

x + zero == x
zero + x == x

sum [e1,e2,...,eN] = e1 + e2 + ... + eN

The Ring class is used for types that are algebraic rings. The operations must satisfy the following laws (at least approximately) in addition to the laws of Additive:

a + b         = b + a
a - b         = a + (neg b)
a - a         = 0
(a * b) * c   = a * (b * c)
a * 1 = 1 * a = a
a * (b + c)   = a * b + a * c
(a + b) * c   = a * c + b * c

The OrderedRing class combines the Ring and Ord classes. It additionally supports absolute value function.

The Real class is used for types that represent some approximation of real numbers.

x = cos (atan2 y x)
y = sin (atan2 y x)

atan2 y x = atan (y/x)

The Integer class is used for types that represent either all integers or some range of them.

Gives the first element of a pair.

Gives the second element of a pair.

Transforms a function taking a pair as a parameter to a function taking two values as a parameter.

Transforms a function two values as a parameter to a function taking a pair as a parameter.

Transforms a function taking a triple as a parameter to a function taking three values as a parameter.

Transforms a function three values as a parameter to a function taking a priple as a parameter.

Swaps the order of elements of a pair (2-tuple).

Represents an optional value.

Given Just x this function returns x. If the parameter is Nothing, the function raises an exception.

fromMaybe def v returns def if v=Nothing and x if v=Just x.

execJust v f executes the function f with parameter value x, if v=Just x. If v=Nothing, the function does nothing.

Takes those elements of the input list that match (Just x) and adds the contents to the resulting list. For example,

filterJust [Just 1, Nothing, Just 5] = [1, 5]

Provides a default value if the first parameter is Nothing. The default value is evaluated only if needed. The function can be used as an operator and is right associative so that the following is possible:

tryWithTheFirstMethod
    `orElse` tryWithTheSecondMethod
    `orElse` fail "Didn't succeed."

elemMaybe v1 (Just v2) returns true if v1 == v2. elemMaybe v1 Nothing is always false.

The Either type represents values with two possibilities: a value of type Either a b is either Left a or Right b.

The Either type is sometimes used to represent a value which is either correct or an error; by convention, the Left constructor is used to hold an error value and the Right constructor is used to hold a correct value (mnemonic: "right" also means "correct").

Applies the given function to all elements of the list. Produces two lists: the first contains all elements x for which the function returned Left x and the second list contains all elements y for which the function returned Right y.

A type class for sequences. All sequences must support indexing by integers.

seq ! i returns the ith element of the sequence seq. Indexing starts from zero.

getList l i returns the ith element of the list l. Indexing starts from zero. You can also use the ! infix function for this purpose.

elem el lst return true, if el occurs in the list lst.

elemIndex el lst returns the index of the first element in the given list lst which is equal (by ==) to the query element, or Nothing if there is no such element.

concatMap combines map and join functions. It maps the elements of a given list to lists with the given function and concatenates the results.

concatMap f lst = join (map f lst) = [y | x <- lst, y <- f x]

foldl op initialValue list

applies a binary operator op to all elements of list from left to right starting with initialValue. For example,

foldl op init [x1, x2, x3, x4] = (((init `op` x1) `op` x2) `op` x3) `op` x4

Like foldl but assumes that the list is non-empty so the initial is not needed.

foldr is defined like foldl but it process the list from right to left.

Works like unfoldr but generates the list from right to left.

Generates a list from a given starting state and iteration function. For example

let nextState 0 = Nothing
    nextState i = Just (i, i `div` 2)
in  unfoldr nextState 30

produces

[30, 15, 7, 3, 1]

Combines two lists into one list of pairs. The length of the resulting list is the length of the smallest input list.

zip [1, 2, 3, 4, 5] ['a', 'b', 'c'] = [(1, 'a'), (2, 'b'), (3, 'c')]

Combines two lists by using the given function for combining the elements. The length of the resulting list is the length of the smallest input list.

Produces two lists from one list of pairs.

unzip [(1, 'a'), (2, 'b'), (3, 'c')] = ([1, 2, 3], ['a', 'b', 'c'])

Sorts the given list using its default order.

Sorts the lists by the values computed by the first function. For example

sortBy snd [(1,5), (2,3), (3,4)] = [(2,3), (3,4), (1,5)]

Sorts the list using the given comparator.

Given a list of key-value pairs, the function produces a function that finds a value efficiently for the given key.

Given a list of values and a function computing a key for each value, the function produces a function that finds a value effeciently for the given key.

Works like index but uses the given functions as hash codes and equality.

Removes duplicates (all but the first occurrence) from the list but otherwise preserves the order of the elements.

Like unique, but uses the given function for finding the key values used for uniqueness testing.

Removes the first element of the list, if the list is non-empty.

Reverses a given list. For example, reverse [1,2,3] = [3,2,1]

range begin end produces a list of consecutive integers starting from begin and ending to end (including end). The compiler supports syntactic sugar [begin..end] for this function.

a \\ b removes all elements of b from the list a.

Works like \\ but uses the given function for equality tests.

Iterates the elements of the given collection. Same as iter but parameters flipped.

Iterates the elements of the given collection providing also the indices of the elements. Same as iterI but parameters flipped.

Tries to find the given key from the list of key-value pairs and returns the corresponding value.

Adds the given value to the end of the list.

Groups a list values by a key computed by the given function.

Computes a list that contains only elements that belongs to both input lists.

Returns the first element of the list satisfying the given condition, or Nothing if there is no such element.

Creates a list with exectly one element.

Groups a list of key-value pairs by the keys.

Applies the given function to the elements of the lists until the function returns something else than Nothing. This return value is also returned as a result of this function.

mapMaybe combines map and filter functions. It applies the given function to every element of the input list. If the result is Just x, then x is added to the resulting list.

mapMaybe f lst = [y | x <- lst, Just y = f x]

A primitive for constructing a list by empty and cons operations given to the function given as a parameter to this function. For example:

build (\empty cons -> cons (cons (cons empty 1) 2) 3)

produces

[1, 2, 3]

The SCL compiler makes the following optimization when encountering build and foldl functions after inlining:

foldl f i (build g) = g i f

Works like unique but uses the given function for equality tests.

Transposes the rows and columns of its argument. For example,

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

takeWhile p l, returns the longest prefix (possibly empty) of list l of elements that satisfy p

Removes leading and trailing whitespace from the string.

splitString text pattern splits the string into a list of string where the parts are sepratated in the original list by the given pattern.

indexOf string s finds the first occurrence of s from string and returns its index. If the s does not occur in the string, return -1."

Works like indexOf but returns the index of the last occurrence.

startsWith string prefix returns true if the string begins with the given prefix.

endsWith string suffix returns true if the string ends with the given prefix.

regionMatches str1 offset1 str2 offset2 len tests whether sub str1 offset1 (offset1+len) == sub str2 offset2 (offset2+len).

replaceString original pattern replacement replaces all occurrences of pattern in the string by replacement.

contains string s returns true if string contains s as a substring.

charAt string i returns the ith character of the string.

Returns true, if the given character is a letter.

Adds a given integer to the character code.

Subtracts a given integer from the character code.

The intercalate function takes a String and a list of Strings and concatenates the list after interspersing the first argument between each element of the list.

See also more generic joinWithSeparator which escapes its arguments using show.

Creates a string from a vector of characters.

Joins the string representations of the list of values with the given separator.

See intercalate for an alternative that works with Strings and doesn't escape its arguments.

Appends the string representations of all elements of the list to the string builder and separates the values with the given separator.

split pattern text splits text around matches of the given regular expression pattern.

This function works as if by invoking the two-argument split method with the given expression and a limit argument of zero. Trailing empty strings are therefore not included in the resulting array.

The string "boo:and:foo", for example, yields the following results with these expressions:

Regex   Result
:       { "boo", "and", "foo" }
o       { "b", "", ":and:f" }

Creates a constant function. const x defines a function that always returns x.

Function application. f $ x is equivalent with f x. The function has two uses. First is to remove parentheses from deeply nested expressions:

f (g (h x))  ==  f $ g $ h x

The second use is with higher order functions:

map ($ parameter) functions

Composes two functions (f . g) x = f (g x)

Identity function.

Flips the parameters of a binary function.

Ignores the given value. This function is used in a situation where a function returns a value in a context where the value is not expected.

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

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

A class of types that can be mapped over with effectful mapping functions.

map f [e1, e2, ..., eN] = [f e1, f e2, ..., f eN]

map (*2) [1..5] = [2, 4, 6, 8, 10]

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 SCL programmer, however, it is best to think of a monad as an abstract datatype of actions. SCL's `mdo expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following laws:

return a >>= k  ==  k a
m >>= return  ==  m
m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h
fmap f xs  ==  xs >>= return . f

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

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages."

Left-to-right Kleisli composition of monads.

Sequences the given monadic value infinitely:

repeatForever m = m >> m >> m >> ...

A class of monads with zero element satisfying

mzero >>= f = mzero

Injects a boolean test to a type beloning to MonadZero.

A class of monads with associative binary operator mplus satisfying the following laws:

mplus mzero b = b
mplus a mzero = a
mplus (mplus a b) c = mplus a (mplus b c)
mplus a b >>= k = mplus (a >>= k) (b >>= k)

A class of monads with associative binary operator morelse satisfying the following laws:

morelse mzero b = b
morelse a mzero = a
morelse (morelse a b) c = morelse a (morelse b c)
morelse (return a) b = return a

An effectful version of the Kleisli composition operator (>=>)

A mutable reference to a value of type a.

Creates a new reference with the given initial value.

Returns the current value of the reference.

Sets a new value for the reference.

Throws a runtime exeception with the given string as a description.

While loop. while cond body executes the body while the cond is true.

forN n f calls f for all integers 0, ..., n-1

Prints the given value in the console.

Prints the given string to the console.

Prints an error message to the console.

printErrorsAsNormalPrints expression executes the expression so that all its error prints are printed as normal prints. This is useful mainly in testing scripts for checking that the implementations give proper error messages with invalid inputs.

printingToFile "fileName" expression executes the expression so that all its console prints are written to the file given as a first parameter.

Reports that certain amount of work has been done for the current task.

Checks whether the current thread has been interrupted and throws an exception if it is.

Returns True if the current thread has been interrupted.

Generates a random identifier.

The class of types whose elements can be converted to a string representation. Method show or (<+) must be implemented.

Appends a string to the string builder.

Par data type is used to control the placement of parentheses when converting values to string. Value Par prec val is converted to string like val but parentheses are put around, if the precedence of the value is greater than prec.

Type class for parsing strings to values.

Converts all letters of the string to lower case.

Converts all letters of the string to upper case.

Converts a list of doubles to a double array.

Converts a double array to a list of doubles.

Converts an array to a list.

Converts a list to an array.

Binding represents a data type in the form supported by Databoard library. It is used to serialize and deserialize values.

A class of types having a Binding

Gives a binding for the required type.

Represents an SCL data type.

A class of types that can be reified with typeOf function.

Returns the type of the value given as a parameter.

A data type that can represent any value.

Converts a value to Dynamic type.

Converts a Dynamic value to a required value, or fails if the conversion is not possible.

Executes the given expression and catches certain class of exceptions (specified by the catch handler that is given as a second parameter.)

disablePrintingForCommand expression executes the expression so that it does not print return values. Errors are printed normally.

Converts 64-bit floating point number to a 64-bit integer with the same byte level representation.

filter pred lst returns those elements of lst that the predicate pred accepts. For example

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

Returns the first element of a sequence

Converts 32-bit floating point number to a 32-bit integer with the same byte level representation.

guardList v returns a singleton [()] if v=True and the empty list if v=False.

Composition of index and group.

Composition of index and groupBy.

Works like indexOf but starts searching from the given index instead of the beginning of the string.

Given a list of elements, the function produces its characteristic function.

A specific implementation of iterI for lists.

A specific implementation of iter for lists.

Returns the last element of a sequence

Works like lastIndexOf but starts searching from the given index instead of the end of the string.

A specific implementation of fmap for lists.

maybe def f v returns def if v=Nothing and f x if v=Just x.

replicate n v returns a list of length n such that each element is a copy of v.