Utility Operations

x_xs " [GENERATOR] "

" x_xs " is a convenience function that returns the head and tail of a passed in generator. " x_xs " uses $_ without an argument.

seq " LIST "

forces immediate evaluation of the elements in " LIST " and returns the list

flip " {CODE} "

" flip " converts " CODE " into a function that takes it's arguments reversed

    my $idx = \&head . flip \&drop;

    $idx->($gen, 5)  ==  $gen->$idx(5)  ==  $gen->get(5)
    

List operations

Map " {CODE} LIST "

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

    $x = &map(sub {$_**2}, $gen);
    $x = Map {$_**2} $gen;
    

that usage is the same as " List::Gen::gen ", but this is something that " gen " can't do:

    my $pow_2 = Map {$_**2};  # partial application, needs at least 1 more
                              # argument to evaluate, but can be passed a list
    my $ints = <0..>;

    my $squares = $ints->$pow_2;

    say "@$squares[0 .. 10]"; # 0 1 4 9 16 25 36 49 64 81 100
    

and this:

    my $src;
    my $square_of_src = Map {$_ ** 2} $src;

    $src = <1.. by 2>;

    say "@$square_of_src[0 .. 4]"; # 1 9 25 49 81
    

filter " {CODE} LIST "

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]
    

head " GENERATOR "

Extract the first element of a list, which must be non-empty.

Last " GENERATOR "

Extract the last element of a list, which must be finite and non-empty.

tail " GENERATOR "

Extract the elements after the head of a list, which must be non-empty.

init " GENERATOR "

Return all the elements of a list except the last one. The list must be non-empty.

null " GENERATOR "

Test whether a list is empty.

Length " GENERATOR "

Reverse " LIST "

reverse xs returns the elements of xs in reverse order. xs must be finite.

Reducing lists (folds)

foldl " {CODE} ITEM LIST "

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.

foldl1 " {CODE} LIST "

" foldl1 " is a variant of " foldl " that has no starting value argument, and thus must be applied to non-empty lists.

foldr " {CODE} ITEM LIST "

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)...)
    

foldr1 " {CODE} LIST "

" foldr1 " is a variant of " foldr " that has no starting value argument, and thus must be applied to non-empty lists.

Special folds

And " LIST "

and returns the conjunction of a Boolean list. For the result to be True, the list must be finite; False, however, results from a False value at a finite index of a finite or infinite list.

Or " LIST "

or returns the disjunction of a Boolean list. For the result to be False, the list must be finite; True, however, results from a True value at a finite index of a finite or infinite list.

any " {CODE} LIST "

Applied to a predicate and a list, any determines if any element of the list satisfies the predicate.

all " {CODE} LIST "

Applied to a predicate and a list, all determines if all elements of the list satisfy the predicate.

sum " LIST "

The sum function computes the sum of a finite list of numbers.

product " LIST "

The product function computes the product of a finite list of numbers.

concat " GENERATOR "

Concatenate a list of lists.

concatMap " {CODE} LIST "

Map a function over a list and concatenate the results.

maximum " LIST "

maximum returns the maximum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of maximumBy, which allows the programmer to supply their own comparison function.

minimum " LIST "

minimum returns the minimum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of minimumBy, which allows the programmer to supply their own comparison function.

Building lists

scanl " {CODE} LIST "

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.
    

scanr " {CODE} LIST "

scanr is the right-to-left dual of scanl. Note that

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

Infinite lists

iterate " {CODE} ITEM "

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

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

repeat " ITEM "

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

hs_repeat " ITEM "

    my $repeat; $repeat = lazy $x, $repeat;
    

replicate " NUM ITEM "

replicate n x is a list of length n with x the value of every element.

cycle " LIST "

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.

hs_cycle " LIST "

hs_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.

it is defined in perl as:

   my $cycle; $cycle = lazy $xs, $cycle;
    

Sublists

take " NUM LIST "

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

    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] == []
    

drop " NUM LIST "

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

    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]
    

splitAt " NUM LIST "

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 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])
    

It is equivalent to (take n xs, drop n xs).

takeWhile " {CODE} LIST "

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

    take_while (< 3) [1,2,3,4,1,2,3,4] == [1,2]
    take_while (< 9) [1,2,3] == [1,2,3]
    take_while (< 0) [1,2,3] == []
    

dropWhile " {CODE} LIST "

dropWhile p xs returns the suffix remaining after take_while p xs:

    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]
    

span " {CODE} LIST "

span, 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 satisfy p and second element is the remainder of the list:

    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])
    

span p xs is equivalent to (takeWhile p xs, dropWhile p xs)

break " {CODE} LIST "

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 (> 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],[])
    

break p is equivalent to span (not . p)

Searching lists

elem " ITEM LIST "

elem is the list membership predicate, usually written in infix form, e.g., x `elem` xs.

notElem " ITEM LIST "

notElem is the negation of elem.

Zipping and unzipping lists

zip " LIST "

zip takes 2+ lists and returns a single interleaved list. If one input list is short, excess elements of the longer lists are discarded. unlike the haskell version, the zip returns a flat generator.

"zip" is the same as "zipWith {\@_}"

zipWith " {CODE} LIST "

zipWith generalizes zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums.

zipWithAB " {$a * $b} $gen1, $gen2 "

The zipWithAB function takes a function which uses $a and $b , as well as two lists and returns a list analogous to zipWith.

unzip " GENERATOR "

unzip transforms a list into two lists of the even and odd elements.

    zs = zip xs, ys
    (xs, ys) == unzip zs
    

unzipn " NUM GENERATOR "

The unzipn function is the n-dimentional precursor to " unzip "

   unzip xs = unzipn 2, xs
    

Functions on strings

lines " STRING "

lines breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines. the newline sequence is taken from the value of the input record separator $/

words " STRING "

words breaks a string up into a list of words, which were delimited by white space.

unlines " LIST "

unlines is an inverse operation to lines. It joins lines, after appending a terminating newline to each. the newline sequence is taken from the value of the input record separator $/

unwords " LIST "

unwords is an inverse operation to words. It joins words with separating spaces.