- print(x1,...,xn)
- Print the arguments to the command-line interface.
The output representations of
the arguments are joined together without any separating character
or spacing. Does print a line break thereafter. If the function is
called with no argument, it only prints a line break.
- put(x1,...,xn)
- Does the same as print, but does not print a line break.
- input(), input(prompt), input(prompt,history)
- Read a line of input from the command-line interface and return
the input as a string. The line break at the end of the input line is
not contained in the string. If the POSIX terminal interface is
accessible, use
history (a list of strings) as a history
to choose from.
- str(x)
- Convert
x into a string.
- str(x,format,precision)
- Convert the floating point number
x into
a string.
# format = "[+|-](f|e|E|g|G)"
s = str(math.pi,"f",4)
- int(x)
- Convert
x into an integer if possible.
- float(x)
- Convert
x into a floating point number
if possible.
- ord(s)
- Take a string of length one and return the code point of the
Unicode character.
- chr(x)
- Take an integer value
x and return the Unicode
character at code point x.
- list(x)
- Convert the iterable object
x into a list.
> list(1..4)
[1, 2, 3, 4]
- map(x)
- Convert the iterable object
x of
[key,value] pairs into a map.
> map([["a",1],["b",2]])
{"a": 1, "b": 2}
- set(x)
- Turn an iterable object
x into a set.
> set(1..4)
{1, 2, 3, 4}
- iter(x)
- Take an iterable object and return an iterator.
> i = iter(1..)
> [i(),i(),i(),i()]
[1, 2, 3, 4]
- cycle(x)
- Take an iterable object and return a cycling iterator.
> cycle(1..4).list(10)
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2]
- size(a)
- Number of elements of
a. The object a
should be a data structure that has this property.
- rand(a..b), rand(a..b,seed)
- Return a random number generator that returns random integers
from
a inclusive to b inclusive.
> r = rand(1..4)
> [r(),r(),r(),r()]
[2, 1, 3, 3]
> r.list(10)
[1, 1, 4, 2, 3, 4, 1, 2, 1, 1]
- rand(a), rand(a,seed)
- Return a random number generator that chooses an element of
the list
a randomly.
- rand(), rand(seed)
- Return a random number generator that returns floats
between zero and one.
- read(id), read(id,mode)
- Read the text file with filename
id and encoding
UTF-8. Return the contents as an
UTF32-string. If mode=='b',
the file is read as a binary file.
- load(id)
- Load the module with filename
id and
return the module object. The function load
can be used in a more general way than import statements
(keyword use). One can achieve dynamic loading
this way.
> math = load("math")
> math.floor(2.4)
2.0
- abs(x)
- Absolute value of
x. Returns an integer if
x is an integer. Takes also complex numbers.
- sgn(x)
- Sign of
x. Returns an integer if
x is an integer.
- max(a,b)
- Return the maximum of
a and b.
- min(a,b)
- Return the minimum of
a and b.
- pow(a,n,m)
- Modular exponentiation: calculate
(a^n)%m fast.
- const(x), const(n,x)
- Shallow freeze a mutable object
x and return it.
If n is given, deep freeze x by
depth n.
If n is null, freeze the complete
tree. Note that const(x) is equivalent to
const(1,x).
- copy(x), copy(n,x)
- Construct a shallow copy of the object
x
and return it. If n is given, return a deep copy
by depth n. If n is null,
return a complete deep copy. Note that copy(x)
is equivalent to copy(1,x).
- object(), object(p), object(p,m)
- Construct a new object with
p as its
prototype and map m as its slot table.
- type(x)
- Prototype of
x.
- record(x)
- Slot table of
x.
- extend(a,b)
- Insert all slots of
b into the slot
table of a. Already existent slots
of a will not be overwritten.
- zip(a1,...,an)
- Take the iterables
a1,...,an and return an iterator
that produces lists [y1,...,yn] for yk
in ak until one of the iterators
is exhausted.
> zip("abcd",[1,2,3,4]).list()
[["a", 1], ["b", 2], ["c", 3], ["d", 4]]
> zip("abcd",1..).list()
[["a", 1], ["b", 2], ["c", 3], ["d", 4]]
> zip(1..,1..).map(|[x,y]| x*y).list(10)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
> (1..).map(|x| x*x).list(10)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Note that, for a list of lists, zip is an involution:
a == zip(*zip(*a).list()).list()
- eval(s), eval(s,m)
- Execute a string as a program. Free variables are from
the current environment (only global variables).
If the map
m
is given, use it as an environment for free/global variables.
> x=12
> eval("2*x")
24
> eval("a=[1,2]")
> a
[1, 2]
> eval("x*y",{x=360,y=240})
86400
- a.push(x)
- Append
x to a.
- a.pop()
- Remove the last element of
a and
return it.
- a.pop(i)
- Remove the element at index
i from a
and return it. Thus, a.pop(0) removes the first element.
- a.insert(i,x)
- Insert the object
x at index i.
Beforehand, all elements from index i inclusive onwards
are shiftet one position to the right.
- a.append(b), a.push(*b)
- Append all elements from
b to a.
- a.clear(), a.clear(n)
- Remove all elements.
Remove all elements, but keep the first
n.
- a.map(f)
- Create a shallow copy of
a, apply the
function f to every element of this copy and return
the result.
> [1,2,3,4].map(|x| 2*x)
[2, 4, 6, 8]
- a.filter(p)
- Filter all elements from
a for which the
predicate p is true.
> [1,2,3,4].filter(|x| x%2==0)
[2, 4]
- a.rev()
- Reverse
a and return it.
Does not construct a shallow copy, a itself will be
modified.
> list(1..4).rev()
[4, 3, 2, 1]
- a.shuffle()
- Shuffle
a randomly and return it.
Does not construct a shallow copy, a itself will be
modified.
> list(1..10).shuffle()
[10, 9, 5, 3, 1, 7, 6, 2, 8, 4]
- a.chain()
- Construct a new list with the same elements, but if elements
of
a are lists or ranges, these will be unpacked.
> [[1,2],[3,4]].chain()
[1, 2, 3, 4]
> [[1,2],11..14,3,4].chain()
[1, 2, 11, 12, 13, 14, 3, 4]
- a.sort(), a.sort(p), a.sort(p,cmp)
- Sort the list and return it. Does not construct a shallow
copy,
a itself will be modified. The function
p is a projection on which the sorting is based.
The function cmp is an alternative binary comparison
function. The sorting algorithm is not required to be stable.
> a = ["oak", "Elm", "willow", "birch"]
> a.sort()
["Elm", "birch", "oak", "willow"]
> a.sort(|x| x.lower())
["birch", "Elm", "oak", "willow"]
> a.sort(size)
["oak", "Elm", "birch", "willow"]
> a.sort(null,|x,y| x>y)
["willow", "oak", "birch", "Elm"]
- a.all(p), a.all()
- Universal quantifier: Return only true if the
predicate
p is true for all elements of a.
> [1,2,3,4].all(|x| x%2==0)
false
- a.any(p), a.any()
- Existential quantifier: Return true if the
predicate
p is true for at least one element
of a.
> [1,2,3,4].any(|x| x%2==0)
true
- a.count(p), a.count()
- Apply predicate
p
to every element of a and
count how often it is true. If no predicate is given, the
total number of elements will be returned.
> [1,2,3,4].count(|x| x%2==0)
2
- a.until(p)
- Return a new iterator that takes elements from
a
as long as the predicate p is false.
isprime = |n| n>1 and (2..).until(|i| i*i>n).all(|i| n%i!=0)
- a.sum(f), a.sum()
- Calculate the sum of all
f(x) for x
in a.
- a.prod(f), a.prod()
- Calculate the product of all
f(x) for x
in a.
- a.reduce(f), a.reduce(e,f)
- Reduce the iterable
a from left to right by the
binary function f. That means, if f is
regarded as a left associative binary operator, this operator is
inserted between all elements of a.
If e is given, it is used as initial element.
# 1+2+3+...+99+100
> (1..100).reduce(|x,y| x+y)
5050
> (1..4).reduce("#",|x,y| x+"/"+str(y))
"#/1/2/3/4"
> fac = |n| (1..n).reduce(1,|x,y| x*y)
> fac(6)
720
- a.map(f)
- Apply the function
f to every element of
a and return a new iterator.
> (1..).map(|x| x^2).list(10)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
- a.filter(p)
- Filter all elements from
a
for which the predicate p is true and
return a new iterator.
> isprime = |n| (1..n).count(|k| n%k==0)==2
> (1..).filter(isprime).list(10)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
- a.max(), a.max(p)
- Return the maximum of a. Return the maximum based on a
projection
p.
- a.min(), a.min(p)
- Return the minimum of a. Return the minimum based on a
projection
p.
> a = [[1,"dca"],[2,"b"],[3,"ab"]]
> a.min(|t| t[0])
[1, "dca"]
> a.min(|t| t[1])
[3, "ab"]
> a.min(|t| size(t[1]))
[2, "b"]
- a.join(sep="",left="",right="")
- Apply
str to each element and join the strings
together.
> (1..4).join()
"1234"
If sep is given, it will be inserted between.
> (1..4).join(", ")
"1, 2, 3, 4"
The result will be surrounded by left
and right, if given.
> (1..4).join(", ","(",")")
"(1, 2, 3, 4)"
- a.enum(), a.enum(start)
- Return an iterator that enumerates the elements of
a.
> "abcd".enum().list()
[[0, "a"], [1, "b"], [2, "c"], [3, "d"]]
> "abcd".enum(1).list()
[[1, "a"], [2, "b"], [3, "c"], [4, "d"]]
- a.list(), a.list(n)
- Take the iterable
a and return its elements
as a list. If n is given, a maximum number of
n elements will be taken. This is equivalent to
a.take(n).list().
> (1..).list(4)
[1, 2, 3, 4]
- a.take(n)
- Return a new iterator that takes a maximum number of
n elements from the iterable a.
- a.skip(n)
- Leave out the next
n elements of the iterable
a.
- a.chunks(n)
- Return a new iterator with the same elements, but the elements
are grouped to chunks of size
n.
> (1..6).chunks(2).list()
[[1, 2], [3, 4], [5, 6]]