Int -> [a] -> a
List index (subscript) operator, starting from 0. It is an instance of the more general Data.List.genericIndex, which takes an index of any integral type.
drop n xs returns the suffix of xs after the first n elements, or  if n > length xs:
> 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]
It is an instance of the more general Data.List.genericDrop, in which n may be of any integral type.
take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > length xs:
> 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] == 
It is an instance of the more general Data.List.genericTake, in which n may be of any integral type.
The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example,
> intersperse ',' "abcde" == "a,b,c,d,e"
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.
replicate n x is a list of length n with x the value of every element. It is an instance of the more general Data.List.genericReplicate, in which n may be of any integral type.
O(log n). replicate n x is a sequence consisting of n copies of x.
Evaluates its first argument to head normal form, and then returns its second argument as the result.
Indicates that it may be beneficial to evaluate the first argument in parallel with the second. Returns the value of the second argument.
a `par` b is exactly equivalent semantically to b.
par is generally used when the value of a is likely to be required later, but not immediately. Also it is a good idea to ensure that a is not a trivial computation, otherwise the cost of spawning it in parallel overshadows the benefits obtained by running it in parallel.
Note that actual parallelism is only supported by certain implementations (GHC with the -threaded option, and GPH, for now). On other implementations, par a b = b.
Semantically identical to seq, but with a subtle operational difference: seq is strict in both its arguments, so the compiler may, for example, rearrange a `seq` b into b `seq` a `seq` b. This is normally no problem when using seq to express strictness, but it can be a problem when annotating code for parallelism, because we need more control over the order of evaluation; we may want to evaluate a before b, because we know that b has already been sparked in parallel with par.
This is why we have pseq. In contrast to seq, pseq is only strict in its first argument (as far as the compiler is concerned), which restricts the transformations that the compiler can do, and ensures that the user can retain control of the evaluation order.
O(min(n,W)). The expression (findWithDefault def k map) returns the value at key k or returns def when the key is not an element of the map.
> findWithDefault 'x' 1 (fromList [(5,'a'), (3,'b')]) == 'x'
> findWithDefault 'x' 5 (fromList [(5,'a'), (3,'b')]) == 'a'
O(1). A map of one element.
> singleton 1 'a' == fromList [(1, 'a')]
> size (singleton 1 'a') == 1
O(1) drop n xs returns the suffix of xs after the first n elements, or  if n > length xs.
O(1) take n, applied to a ByteString xs, returns the prefix of xs of length n, or xs itself if n > length xs.
A variety of drop which omits the checks on n so there is an obligation on the programmer to provide a proof that 0 <= n <= length xs.
A variety of take which omits the checks on n so there is an obligation on the programmer to provide a proof that 0 <= n <= length xs.
O(n) drop n, applied to a Text, returns the suffix of the Text after the first n characters, or the empty Text if n is greater than the length of the Text. Subject to fusion.
O(1) Unchecked drop of k Word16s from the front of a Text.
O(n*m) replicate n t is a Text consisting of the input t repeated n times.
O(n) take n, applied to a Text, returns the prefix of the Text of length n, or the Text itself if n is greater than the length of the Text. Subject to fusion.
O(1) Unchecked take of k Word16s from the front of a Text.
The non-overloaded version of insert.
The deleteBy function behaves like delete, but takes a user-supplied equality predicate.
When called, trace outputs the string in its first argument, before returning the second argument as its result. The trace function is not referentially transparent, and should only be used for debugging, or for monitoring execution. Some implementations of trace may decorate the string that's output to indicate that you're tracing. The function is implemented on top of putTraceMsg.
O(min(n,W)). Delete a value in the set. Returns the original set when the value was not present.
O(min(n,W)). Add a value to the set. There is no left- or right bias for IntSets.
foldl, applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:
> foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
The list must be finite.
A strict version of foldl.
foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:
> foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
The genericDrop function is an overloaded version of drop, which accepts any Integral value as the number of elements to drop.
The genericTake function is an overloaded version of take, which accepts any Integral value as the number of elements to take.
O(n). Constructs a sequence by repeated application of a function to a seed value.
> iterateN n f x = fromList (Prelude.take n (Prelude.iterate f x))
O(log(min(i,n-i))). Replace the element at the specified position. If the position is out of range, the original sequence is returned.
Append 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.
Increments the line number of a source position.
Show more results