## Index

## Overview

The outermost block of the Starlark environment is known as the “predeclared” block.
It defines a number of fundamental values and functions needed by all Starlark programs,
such as `None`

, `True`

, `False`

, and `len`

, and possibly additional
application-specific names.

These names are not reserved words so Starlark programs are free to redefine them in a smaller block such as a function body or even at the top level of a module. However, doing so may be confusing to the reader. Nonetheless, this rule permits names to be added to the predeclared block in later versions of the language (or application-specific dialect) without breaking existing programs.

## None

`None`

is the distinguished value of the type `NoneType`

.

## True and False

`True`

and `False`

are the two values of type `bool`

.

## any

`any(x)`

returns `True`

if any element of the iterable sequence x has a truth value of true.
If the iterable is empty, it returns `False`

.

## all

`all(x)`

returns `False`

if any element of the iterable sequence x has a truth value of false.
If the iterable is empty, it returns `True`

.

## bool

`bool(x)`

interprets `x`

as a Boolean value—`True`

or `False`

.
With no argument, `bool()`

returns `False`

.

## chr

`chr(i)`

returns a string that encodes the single Unicode code point
whose value is specified by the integer `i`

. `chr`

fails unless 0 ≤
`i`

≤ 0x10FFFF.

Example:

```
chr(65) # "A",
chr(1049) # "Й", CYRILLIC CAPITAL LETTER SHORT I
chr(0x1F63F) # "😿", CRYING CAT FACE
```

See also: `ord`

.

**Implementation note:** `chr`

is not provided by the Java implementation.

## dict

`dict`

creates a dictionary. It accepts up to one positional
argument, which is interpreted as an iterable of two-element
sequences (pairs), each specifying a key/value pair in
the resulting dictionary.

`dict`

also accepts any number of keyword arguments, each of which
specifies a key/value pair in the resulting dictionary;
each keyword is treated as a string.

```
dict() # {}, empty dictionary
dict([(1, 2), (3, 4)]) # {1: 2, 3: 4}
dict([(1, 2), ["a", "b"]]) # {1: 2, "a": "b"}
dict(one=1, two=2) # {"one": 1, "two", 1}
dict([(1, 2)], x=3) # {1: 2, "x": 3}
```

With no arguments, `dict()`

returns a new empty dictionary.

`dict(x)`

where x is a dictionary returns a new copy of x.

## dir

`dir(x)`

returns a new sorted list of the names of the attributes (fields and methods) of its operand.
The attributes of a value `x`

are the names `f`

such that `x.f`

is a valid expression.

For example,

```
dir("hello") # ['capitalize', 'count', ...], the methods of a string
```

Several types known to the interpreter, such as list, string, and dict, have methods, but none have fields. However, an application may define types with fields that may be read or set by statements such as these:

```
y = x.f
x.f = y
```

## enumerate

`enumerate(x)`

returns a list of (index, value) pairs, each containing
successive values of the iterable sequence xand the index of the value
within the sequence.

The optional second parameter, `start`

, specifies an integer value to
add to each index.

```
enumerate(["zero", "one", "two"]) # [(0, "zero"), (1, "one"), (2, "two")]
enumerate(["one", "two"], 1) # [(1, "one"), (2, "two")]
```

## fail

The `fail(*args, sep=" ")`

function causes execution to fail
with the specified error message.
Like `print`

, arguments are formatted as if by `str(x)`

and
separated by a space, unless an alternative separator is
specified by a `sep`

named argument.

```
fail("oops") # "fail: oops"
fail("oops", 1, False, sep='/') # "fail: oops/1/False"
```

## float

`float(x)`

interprets its argument as a floating-point number.

If x is a `float`

, the result is x.
if x is an `int`

, the result is the nearest floating point value to x.
If x is a string, the string is interpreted as a floating-point literal.
With no arguments, `float()`

returns `0.0`

.

**Implementation note:**
Floating-point numbers are an optional feature.
The Go implementation of Starlark requires the `-float`

flag to
enable support for floating-point literals, the `float`

built-in
function, and the real division operator `/`

.
The Java implementation does not yet support floating-point numbers.

## getattr

`getattr(x, name)`

returns the value of the attribute (field or method) of x named `name`

.
It is a dynamic error if x has no such attribute.

`getattr(x, "f")`

is equivalent to `x.f`

.

```
getattr("banana", "split")("a") # ["b", "n", "n", ""], equivalent to "banana".split("a")
```

The three-argument form `getattr(x, name, default)`

returns the
provided `default`

value instead of failing.

## hasattr

`hasattr(x, name)`

reports whether x has an attribute (field or method) named `name`

.

## hash

`hash(x)`

returns an integer hash of a string x
such that two equal strings have the same hash.
In other words `x == y`

implies `hash(x) == hash(y)`

.

In the interests of reproducibility of Starlark program behavior over time and across implementations, the specific hash function is the same as that implemented by java.lang.String.hashCode, a simple polynomial accumulator over the UTF-16 transcoding of the string:

```
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
```

`hash`

fails if given a non-string operand,
even if the value is hashable and thus suitable as the key of dictionary.

## int

`int(x[, base])`

interprets its argument as an integer.

If x is an `int`

, the result is x.
If x is a `float`

, the result is the integer value nearest to x,
truncating towards zero; it is an error if x is not finite (`NaN`

,
`+Inf`

, `-Inf`

).
If x is a `bool`

, the result is 0 for `False`

or 1 for `True`

.

If x is a string, it is interpreted as a sequence of digits in the
specified base, decimal by default.
If `base`

is zero, x is interpreted like an integer literal, the base
being inferred from an optional base marker such as `0b`

, `0o`

, or
`0x`

preceding the first digit.
Irrespective of base, the string may start with an optional `+`

or `-`

sign indicating the sign of the result.

## len

`len(x)`

returns the number of elements in its argument.

It is a dynamic error if its argument is not a sequence.

## list

`list`

constructs a list.

`list(x)`

returns a new list containing the elements of the
iterable sequence x.

With no argument, `list()`

returns a new empty list.

## max

`max(x)`

returns the greatest element in the iterable sequence x.

It is an error if any element does not support ordered comparison, or if the sequence is empty.

The optional named parameter `key`

specifies a function to be applied
to each element prior to comparison.

```
max([3, 1, 4, 1, 5, 9]) # 9
max("two", "three", "four") # "two", the lexicographically greatest
max("two", "three", "four", key=len) # "three", the longest
```

## min

`min(x)`

returns the least element in the iterable sequence x.

It is an error if any element does not support ordered comparison, or if the sequence is empty.

```
min([3, 1, 4, 1, 5, 9]) # 1
min("two", "three", "four") # "four", the lexicographically least
min("two", "three", "four", key=len) # "two", the shortest
```

## ord

`ord(s)`

returns the integer value of the sole Unicode code point encoded by the string `s`

.

If `s`

does not encode exactly one Unicode code point, `ord`

fails.
Each invalid code within the string is treated as if it encodes the
Unicode replacement character, U+FFFD.

Example:

```
ord("A") # 65
ord("Й") # 1049
ord("😿") # 0x1F63F
ord("Й"[1:]) # 0xFFFD (Unicode replacement character)
```

See also: `chr`

.

**Implementation note:** `ord`

is not provided by the Java implementation.

`print(*args, sep=" ")`

prints its arguments, followed by a newline.
Arguments are formatted as if by `str(x)`

and separated with a space,
unless an alternative separator is specified by a `sep`

named argument.

Example:

```
print(1, "hi") # "1 hi\n"
print("hello", "world") # "hello world\n"
print("hello", "world", sep=", ") # "hello, world\n"
```

Typically the formatted string is printed to the standard error file, but the exact behavior is a property of the Starlark thread and is determined by the host application.

## range

`range`

returns an immutable sequence of integers defined by the specified interval and stride.

```
range(stop) # equivalent to range(0, stop)
range(start, stop) # equivalent to range(start, stop, 1)
range(start, stop, step)
```

`range`

requires between one and three integer arguments.
With one argument, `range(stop)`

returns the ascending sequence of non-negative integers less than `stop`

.
With two arguments, `range(start, stop)`

returns only integers not less than `start`

.

With three arguments, `range(start, stop, step)`

returns integers
formed by successively adding `step`

to `start`

until the value meets or passes `stop`

.
A call to `range`

fails if the value of `step`

is zero.

A call to `range`

does not materialize the entire sequence, but
returns a fixed-size value of type `"range"`

that represents the
parameters that define the sequence.
The `range`

value is iterable and may be indexed efficiently.

```
list(range(10)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list(range(3, 10)) # [3, 4, 5, 6, 7, 8, 9]
list(range(3, 10, 2)) # [3, 5, 7, 9]
list(range(10, 3, -2)) # [10, 8, 6, 4]
```

The `len`

function applied to a `range`

value returns its length.
The truth value of a `range`

value is `True`

if its length is non-zero.

Range values are comparable: two `range`

values compare equal if they
denote the same sequence of integers, even if they were created using
different parameters.

Range values are not hashable.

The `str`

function applied to a `range`

value yields a string of the
form `range(10)`

, `range(1, 10)`

, or `range(1, 10, 2)`

.

The `x in y`

operator, where `y`

is a range, reports whether `x`

is equal to
some member of the sequence `y`

; the operation fails unless `x`

is a
number.

## repr

`repr(x)`

formats its argument as a string.

All strings in the result are double-quoted.

```
repr(1) # '1'
repr("x") # '"x"'
repr([1, "x"]) # '[1, "x"]'
```

## reversed

`reversed(x)`

returns a new list containing the elements of the iterable sequence x in reverse order.

```
reversed(range(5)) # [4, 3, 2, 1, 0]
reversed("stressed".codepoints()) # ["d", "e", "s", "s", "e", "r", "t", "s"]
reversed({"one": 1, "two": 2}.keys()) # ["two", "one"]
```

## set

`set(x)`

returns a new set containing the elements of the iterable x.
With no argument, `set()`

returns a new empty set.

```
set([3, 1, 4, 1, 5, 9]) # set([3, 1, 4, 5, 9])
```

**Implementation note:**
Sets are an optional feature of the Go implementation of Starlark,
enabled by the `-set`

flag.

## sorted

`sorted(x)`

returns a new list containing the elements of the iterable sequence x,
in sorted order. The sort algorithm is stable.

The optional named parameter `reverse`

, if true, causes `sorted`

to
return results in reverse sorted order.

The optional named parameter `key`

specifies a function of one
argument to apply to obtain the value’s sort key.
The default behavior is the identity function.

```
sorted(set("harbors".codepoints())) # ['a', 'b', 'h', 'o', 'r', 's']
sorted([3, 1, 4, 1, 5, 9]) # [1, 1, 3, 4, 5, 9]
sorted([3, 1, 4, 1, 5, 9], reverse=True) # [9, 5, 4, 3, 1, 1]
sorted(["two", "three", "four"], key=len) # ["two", "four", "three"], shortest to longest
sorted(["two", "three", "four"], key=len, reverse=True) # ["three", "four", "two"], longest to shortest
```

## str

`str(x)`

formats its argument as a string.

If x is a string, the result is x (without quotation). All other strings, such as elements of a list of strings, are double-quoted.

```
str(1) # '1'
str("x") # 'x'
str([1, "x"]) # '[1, "x"]'
```

## tuple

`tuple(x)`

returns a tuple containing the elements of the iterable x.

With no arguments, `tuple()`

returns the empty tuple.

## type

type(x) returns a string describing the type of its operand.

```
type(None) # "NoneType"
type(0) # "int"
type(0.0) # "float"
```

## zip

`zip()`

returns a new list of n-tuples formed from corresponding
elements of each of the n iterable sequences provided as arguments to
`zip`

. That is, the first tuple contains the first element of each of
the sequences, the second element contains the second element of each
of the sequences, and so on. The result list is only as long as the
shortest of the input sequences.

```
zip() # []
zip(range(5)) # [(0,), (1,), (2,), (3,), (4,)]
zip(range(5), "abc") # [(0, "a"), (1, "b"), (2, "c")]
```