Parameters:

x (required)

Returns:

the absolute value of x

Testcases:

functional_api

Takes a predicate pred and a list xs and returns 1 if all elements of xs fulfill pred. Examples: f::all f::even_p {2 44 64 80 10} = 1 f::all f::even_p {2 44 65 80 10} = 0

Parameters:

pred (required)

xs (required)

Returns:

boolean

Testcases:

functional_api

Reduces a list of boolean values using && Examples: f::and {1 1 0 1} = 0 f::and {1 1 1 1} = 1

Parameters:

xs (required)

Returns:

boolean

Testcases:

functional_api

Takes a predicate pred and a list xs and returns 1 if there exists an element of xs that fulfills pred. Examples: f::any f::odd_p {2 44 64 80 10} = 0 f::any odd_p {2 44 65 80 10} = 1

Parameters:

pred (required)

xs (required)

Returns:

boolean

Testcases:

functional_api

Binds args to the first k arguments of the n-ary function f and returns the resulting (n-k)-ary function.

Parameters:

f (required)

Testcases:

functional_api

Binds arg to the 2nd argument of f.

Parameters:

f (required)

arg (required)

Testcases:

functional_api

Here's how to compute 'n choose k' like a real nerd.

Parameters:

n (required)

k (required)

Testcases:

No testcase defined.

function composition: evaluates f (g x) Example: f::map [f::bind compose sqr [f::bind + 7]] {1 2 3 4 5} = {64 81 100 121 144} Algebraic Property: f::map [f::bind f::compose f g] $xs = f::map f [f::map g $xs]

Parameters:

f (required)

g (required)

x (required)

Testcases:

functional_api

Inserts x at the front of the list xs.

Parameters:

x (required)

xs (required)

Returns:

list

Testcases:

functional_api

Returns a unary function that ignores its argument and constantly returns k. Example: f::map [f::const 7] [list 1 2 3 4 5] = {7 7 7 7 7}

Parameters:

k (required)

Testcases:

functional_api

Example: f::copy 10 7 = {7 7 7 7 7 7 7 7 7 7}

Parameters:

n (required)

x (required)

Returns:

list of n copies of x

Testcases:

functional_api

Converts a function that takes one tuple as an argument into a function that takes a series of single arguments.

Parameters:

f (required)

Testcases:

functional_api

Example: f::cycle 4 {1 2 3} = {1 2 3 1 2 3 1 2 3 1 2 3}

Parameters:

n (required)

xs (required)

Returns:

concatenated list of n copies of xs

Testcases:

functional_api

Parameters:

n (required)

xs (required)

Returns:

the remaining elements of xs (without the first n)

Testcases:

functional_api

Parameters:

p (required)

xs (required)

Returns:

the remaining portion of the list

Testcases:

functional_api

Checks if x is contained in s.

Parameters:

x (required)

xs (required)

Returns:

boolean

Testcases:

functional_api

Generates {lo lo+1 ... hi-1 hi}

Parameters:

lo (required)

hi (required)

Returns:

list

Testcases:

functional_api

Parameters:

n (required)

Returns:

1 if n is even and 0 otherwise

Testcases:

functional_api

Compute n!

Parameters:

n (required)

Testcases:

functional_api

Examples: f::filter f::even_p {3 1 4 1 5 9 2 6} = {4 2 6} f::filter [f::lambda {x} {expr $x>500}] {317 826 912 318} = {826 912}

Parameters:

pred (required)

xs (required)

Returns:

all elements of the list 'xs' that fulfill the predicate 'pred'.

Testcases:

functional_api

Takes a binary function 'f' and two arguments 'a' and 'b' and returns f b a (arguments are flipped). Example: flip lindex 0 {42 37 59 14} = 42

Parameters:

f (required)

a (required)

b (required)

Testcases:

functional_api

Takes a binary function f, a start element e and a list {x1 x2 ...} and returns f (...(f (f (f e x1) x2) x3)...). Examples: f::fold + 0 [list 1 2 3 4] = 10 f::fold * 1 [list 1 2 3 4] = 24

Parameters:

f (required)

e (required)

xs (required)

Testcases:

functional_api

Takes a binary function f and a list {x1 x2 x3 ...} and returns (...(f (f (f x1 x2) x3) x4)...). "fold1" behaves like "fold", but does not take a start element and does not work for empty lists. Examples: f::fold1 min [list 3 1 4 1 5 9 2 6] = 1 f::fold1 max [list 3 1 4 1 5 9 2 6] = 9

Parameters:

f (required)

xs (required)

See Also:

• fold1

Testcases:

functional_api

Parameters:

x (required)

y (required)

Returns:

the greatest common divisor of x and y

Testcases:

functional_api

Parameters:

xs (required)

Returns:

first element of a list

Testcases:

functional_api

Identity function: just returns its argument. I'm not kidding! An identity function can be useful sometimes, e.g. as a default initializer for optional arguments of functional kind.

Parameters:

x (required)

Testcases:

functional_api

Parameters:

xs (required)

Returns:

all elements of a list but the last

Testcases:

functional_api

Examples: f::iterate 10 [f::lambda {x} {expr $x+1}] 5 = {5 6 7 8 9 10 11 12 13 14} f::iterate 10 [f::lambda {x} {expr $x*2}] 1 = {1 2 4 8 16 32 64 128 256 512} f::iterate 4 f::tail {1 2 3 4 5} = {{1 2 3 4 5} {2 3 4 5} {3 4 5} {4 5}}

Parameters:

n (required)

f (required)

x (required)

Returns:

\{x (f x) (f (f x) (f (f (f x))) ...\}\}.

Testcases:

functional_api

The lambda function - one of the foundations of functional programming - defines an anonymous proc and returns it. This is useful if you quickly need an auxiliary function for a small task. I know, I know - it looks sooo harmless. But it unleashes the real power of Tcl. It defines a proc with name "args.body" (weird, but unique name) that takes "args" as arguments and has the body "body". Then, this proc is returned. Examples: [f::lambda {x} {expr $x*$x}] 5 = 25 f::map [f::lambda {x} {expr $x*$x}] {1 2 3 4 5} = {1 4 9 16 25} f::zip_with [f::lambda {x y} {return "$x and $y"}] {1 2 3} {4 5 6} = "1 and 4" "2 and 5" "3 and 6" Note: Although lambda defines a proc and therefore consumes memory, executing the same lambda expression twice will just re-define this proc. Thus, there is no memory leak, if you have a lambda inside a loop.

Parameters:

args (required)

body (required)

Returns:

a proc name

Testcases:

functional_api

Parameters:

xs (required)

Returns:

last element of a list

Testcases:

functional_api

Parameters:

x (required)

y (required)

Returns:

the least common multiple of x and y

Testcases:

functional_api

Parameters:

xs (required)

Returns:

the maximum element of the list xs

Testcases:

functional_api

Parameters:

xs (required)

Returns:

the minimum element of the list xs

Testcases:

functional_api

Takes a function f and a list { x1 x2 x3 ...}, applies the function on each element of the list and returns the result, i.e. { f x1, f x2, f x3, ...}. Examples: (fib = fibonacci function, sqr = square function) Applying a function to each element of a list: f::map fib [list 0 1 2 3 4 5 6 7 8] = {0 1 1 2 3 5 8 13 21} Applying a function to each element of a matrix (a list of lists) can be done with a nested call: f::map [f::lambda {row} {f::map sqr $row}] [list [list 1 2 3] [list 4 5 6]] = {{1 4 9} {16 25 36}}

Parameters:

f (required)

xs (required)

Testcases:

functional_api

Parameters:

x (required)

y (required)

Returns:

the maximum of x and y

Testcases:

functional_api

Parameters:

x (required)

y (required)

Returns:

the minimum of x and y

Testcases:

functional_api

Multiplies n with a fraction (given as a tuple)

Parameters:

n (required)

fraction (required)

Testcases:

functional_api

Checks if x is not contained in s.

Parameters:

x (required)

xs (required)

Returns:

boolean

Testcases:

functional_api

Removes duplicates from xs.

Parameters:

xs (required)

Testcases:

functional_api

Checks if xs is the empty list.

Parameters:

xs (required)

Returns:

boolean

Testcases:

functional_api

Parameters:

n (required)

Returns:

1 if n is odd and 0 otherwise

Testcases:

functional_api

Reduces a list of boolean values using || Example: f::or {1 1 0 1} = 1 f::or {0 0 0 0} = 0

Parameters:

xs (required)

Returns:

boolean

Testcases:

functional_api

Prints Pascal's triangle

Parameters:

size (required)

Testcases:

No testcase defined.

Example: f::filter f::prime_p [f::enum_from_to 1 100] = {2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97}

Parameters:

n (required)

Returns:

boolean, 1 if n is prime

Testcases:

functional_api

Parameters:

xs (required)

Returns:

the product of the elements of the list xs

Testcases:

functional_api

Parameters:

xs (required)

Returns:

the list of partial products of the list xs

Testcases:

functional_api

Sorts a sequence with the quicksort algorithm. Examples: f::qsort {5 2 9 4} = 2 4 5 9 f::qsort {Oracle ArsDigita SAP Vignette} [lambda {s} {string length $s}] = {SAP Oracle Vignette ArsDigita}

Parameters:

xs (required)

value (optional, defaults to "id")

Testcases:

functional_api

Reverses the list xs. Tcl has a built-in support for reversing lists: "lreverse". Use this instead.

Parameters:

xs (required)

See Also:

• lreverse

Testcases:

No testcase defined.

Takes a binary function f, a start element e and a list {x1 x2 ...} and returns {e (f e x1) (f (f e x1) x2) ...}. Example: scanl + 0 [list 1 2 3 4] = {0 1 3 6 10} scanl * 1 [list 1 2 3 4] = {1 1 2 6 24}

Parameters:

f (required)

e (required)

xs (required)

Testcases:

functional_api

Takes a binary function f and a list {x1 x2 x3 ...} and returns {x1 (f x1 x2) (f (f x1 x2) x3) ...}. "scanl1" behaves like "scanl", but does not take a start element and does not work for empty lists. Examples: scanl1 min [list 3 1 4 1 5 9 2 6] = {3 1 1 1 1 1 1 1} scanl1 max [list 3 1 4 1 5 9 2 6] = {3 3 4 4 5 9 9 9}

Parameters:

f (required)

xs (required)

See Also:

• scanl

Testcases:

functional_api

Splits a list using take_while and drop_while. Usage span p xs = (takeWhile p xs, dropWhile p xs)

Parameters:

p (required)

xs (required)

Testcases:

functional_api

Splits a list using take and drop. Usage: split_at n xs = (take n xs, drop n xs)

Parameters:

n (required)

xs (required)

Testcases:

functional_api

Parameters:

xs (required)

Returns:

the sum of the elements of the list xs

Testcases:

functional_api

Parameters:

xs (required)

Returns:

the list of partial sums of the list xs

Testcases:

functional_api

Parameters:

xs (required)

Returns:

all elements of a list but the first

Testcases:

functional_api

Parameters:

n (required)

xs (required)

Returns:

the first n elements of xs

Testcases:

functional_api

Parameters:

p (required)

xs (required)

Returns:

the list of elements up to and including the first element of xs which satisfies p

Testcases:

functional_api

Parameters:

p (required)

xs (required)

Returns:

the longest initial segment of xs whose elements satisfy p

Testcases:

functional_api

Transposes a matrix (a list of lists)

Parameters:

lists (required)

Testcases:

functional_api

Converts a function that takes a series of single arguments into a function that takes one tuple as an argument. Example: f::min 3 5 = 3 f::min {3 5} = error (because min expects two arguments) f::uncurry min {3 5} = 3

Parameters:

f (required)

tuple (required)

Testcases:

functional_api

Unzip takes a list of tuples {x1 y1} {x2 y2} {x3 y3} ... and returns a tuple of lists {x1 x2 x3 ...} {y1 y2 y3 ...}. It is just a special case of the function "transpose" and is here just for completeness.

Parameters:

xs (required)

Testcases:

functional_api

Takes two lists {x1 x2 x3 ...} and {y1 y2 y3 ...} and returns a list of tuples {x1 y1} {x2 y2} {x3 y3} ... Works analogously with 3 or more lists. Example: % set first_names {Nicole Tom} % set last_names {Kidman Cruise} f::zip $first_names $last_names = {{Nicole Kidman} {Tom Cruise}} f::map [f::bind f::flip join _] [f::zip $first_names $last_names] = Nicole_Kidman Tom_Cruise

Testcases:

functional_api

Takes two lists {x1 x2 x3 ...} and {y1 y2 y3 ...} and returns the list {(f x1 y1) (f x2 y2) (f x3 y3) ...} Example: % set first_names {Sandra Catherine Nicole} % set last_names {Bullock Zeta-Jones Kidman} f::zip_with [f::lambda {f l} {return "$f $l"}] $first_names $last_names = {{Sandra Bullock} {Catherine Zeta-Jones} {Nicole Kidman}}

Parameters:

f (required)

xs (required)

ys (required)

Testcases:

functional_api