L

break

Char(code' 65)

code
Code of the character.

is_digit()
Return true (1B) if character is a digit.

is_alpha()
Return true (1B) if character is an alphabetic.

is_lowercase()
Return true (1B) if character is lowercase.

is_uppercase()
Return true (1B) if character is uppercase.

lowercase()
Return a copy of the character converted to lowercase.

uppercase()
Return a copy of the character converted to uppercase.

len
Length of the string in characters.

last
A last character of the string. (This method is called without parens.)

starts_with(prefix)
Return true (1B) if the string starts with the

prefix

, otherwise return false (0B).

prefix

can also be a tuple of prefixes to look for.

ends_with(suffix)
Return true (1B) if the string ends with the specified

suffix

, otherwise return false (0B).

suffix

can also be a tuple of suffixes to look for.

count(sub)
Return the number of non-overlapping occurrences of substring

sub

.

is_digit()
Return true (1B) if all characters in the string are digits and there is at least one character, false (0B) otherwise.

is_alpha()
Return true (1B) if all characters in the string are alphabetic and there is at least one character, false (0B) otherwise.

find(sub, start = 0)
Return the lowest index in the string where substring

sub

is found. Search begins at

start

. Return

N

/

null

if

sub

is not found.

sub

can also be a tuple of strings to look for.

findi(sub, start = 0)
Return the lowest index in the string where substring

sub

is found. Search begins at

start

. Return

-1

if

sub

is not found.

rfind(sub[, start])
Return the highest index in the string where substring

sub

is found. Search begins at

start

(if

start

is not specified, whole string will be searched). Return

N

/

null

if

sub

is not found.

rfindi(sub, start, end)
Return the highest index in the string where substring

sub

is found, such that

sub

is contained within

s[start.<end]

. Return

-1

if

sub

is not found.

replace(old, new)
Return a copy of the string with all occurrences of

old

replaced by

new

.

old

can be a regular expression.

lowercase()
Return a copy of the string with all the cased characters converted to lowercase.

uppercase()
Return a copy of the string with all the cased characters converted to uppercase.

capitalize()
Return a copy of the string with its first character capitalized.

zfill(width)
Return a copy of the string left filled with ASCII '0' digits to make a string of length

width

.

center(width, fillchar = ‘ ’)
Return centered in a string of length

width

. Padding is done using the specified

fillchar

.

ljust(width, fillchar = ‘ ’)
Return the string left justified in a string of length

width

. Padding is done using the specified

fillchar

.

rjust(width, fillchar = ‘ ’)
Return the string right justified in a string of length

width

. Padding is done using the specified

fillchar

.

split(delim, limit = N, group_delimiters = 0B)
Divides string into substrings based on a delimiter, returning an array of these substrings.

delim

can be a regular expression.

delim

can also be a tuple of characters (example:

s.split((‘ ’, "\t", "\n", "\r"))

). If

limit

is given, at most that number of fields will be returned (if

limit

is 1, the entire string is returned as the only entry in an array). [

limit

argument in 11l is similar to JavaScript, Ruby and PHP, but not Python.]
If

group_delimiters

is

0B

, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example,

‘1,,2’.split(‘,’)

returns

[‘1’, ‘’, ‘2’]

).

ltrim(string[, limit])
Return a copy of the string with leading strings removed. At most

limit

strings are removed.

ltrim(tuple_of_chars[, limit])
Return a copy of the string with leading characters removed. At most

limit

characters are removed.

rtrim(string[, limit])
Return a copy of the string with trailing strings removed. At most

limit

strings are removed.
Example:

‘1.0.0’.rtrim(‘.0’, 1)

returns

‘1.0’

.

rtrim(tuple_of_chars[, limit])
Return a copy of the string with trailing characters removed. At most

limit

characters are removed.
Example:

‘a.,’.rtrim((‘.’, ‘,’))

returns

‘a’

.

trim(string)
Return a copy of the string with leading and trailing strings removed.

trim(tuple_of_chars)
Return a copy of the string with leading and trailing characters removed.

format(args...)
Perform a string formatting operation. The string on which this method is called can contain literal text or replacement fields starting with

#

. Returns a copy of the string where each replacement field is replaced with the string value of the corresponding argument.
Format String Syntax

(1, 2)

(Int, Int)

x

y

z

w

r

g

b

a

+

-

*

/

(x1, y1, z1) + (x2, y2, z2)

(x1 + x2, y1 + y2, z1 + z2)

(x, y, z) * 2

(x*2, y*2, z*2)

[1, 2]

[Int]

len
Length of an array.

last
A last element of the array. (This method is called without parens.)

join(sep)
Return a string which is the concatenation of the strings in an array.

sep

is the separator between elements.

map(function)
Applies

function

to every item of an array and return that new array.

filter(function)
Return a new array consisting of those elements from this array for which

function

returns true (1B).

reduce([initial,] function)
Apply

function

of two arguments cumulatively to the items of the array, from left to right, so as to reduce the array to a single value. For example,

[1, 2, 3].reduce((x, y) -> x + y)

calculates

((1+2)+3)

. If the optional

initial

is present, it is placed before the items of the array in the calculation, and serves as a default when the array is empty.
[Note that order of the arguments is the same as in Java, in Swift and in Rust, but not in Python.]

append(new_element)
Appends

new_element

to the end of this array.

append(arr)
Appends all elements of

arr

to the end of this array.

append(range)
Append all values of

range

to the end of this array. Example: {…

V arr = [-1]
arr.append(1..3)
print(arr) // will print [-1, 1, 2, 3]

}

arr [+]= x
The same as

arr.append(x)

.

pop()
Retrieves the last item of this array and also removes it.

index(x, start = 0)
Return index of the first occurrence of

x

in this array (at or after index

start

).

ValueError

is raised when

x

is not found in this array.

find(x, start = 0)
Return index of the first occurrence of

x

in this array (at or after index

start

), or

N

/

null

if

x

is not found in this array.

x

can also be a tuple of values to look for.

count(x)
Return total number of occurrences of

x

in this array.

sort()
This method sorts the array in place, using only

<

comparisons between items.

sort_range(range)
This method sorts the specified range of an array in place.

reverse()
Reverses the items of array in place.

[‘key1’ = 1, ‘key2’ = 2]

[String = Int]

find(key) -> ValueType?
Finds element with specific key. If no such element is found,

N

/

null

is returned.

get(key, default) -> ValueType
Return the value for

key

if

key

is in the dictionary, else

default

.

keys()
Return an array of the dictionary's keys.

values()
Return an array of the dictionary's values.

filter(function)
Return an array consisting of those elements of dictionary for which

function

returns true (1B).

add(elem)
Add element

elem

to the set.

remove(elem)
Remove element

elem

from the set. Raises

KeyError

if

elem

is not contained in the set.

clear()
Remove all elements from the set.

difference(other)
Return a new set with elements in the set that are not in the

other

.

lower_bound(key) -> KeyType?
Returns the first element which is not less than the given

key

. If no such element is found,

N

/

null

is returned.

upper_bound(key) -> KeyType?
Returns the first element which is greater than the given

key

. If no such element is found,

N

/

null

is returned.

append(x)
Add

x

to the right side of the deque.

append_left(x)
Add

x

to the left side of the deque.

clear()
Remove all elements from the deque leaving it with length 0.

extend(iterable)
Extend the right side of the deque by appending elements from the iterable argument.

extend_left(iterable)
Extend the left side of the deque by appending elements from

iterable

.

index(x, start = 0)
Return the position of

x

in the deque (at or after index

start

). Returns the first match or raises

ValueError

if not found.

insert(i, x)
Insert

x

into the deque at position

i

.

pop()
Remove and return an element from the right side of the deque. If no elements are present, raises an

IndexError

.

pop_left()
Remove and return an element from the left side of the deque. If no elements are present, raises an

IndexError

.

remove(value)
Remove the first occurrence of

value

. If not found, raises a

ValueError

.

File(name, mode = ‘r’)
Open file with the specified name and mode (note: only ‘r’ and ‘w’ are supported at the present moment).

read() -> String
Read a whole file into a string, and return it.
Note: only UTF-8 encoding [with optional BOM] is supported at the present moment.

read_line(keep_newline = 0B) -> String
Read and return one line from the file. If

keep_newline

argument is true (1B), trailing new-line character is left as is.

read_lines(keep_newline = 0B) -> Array[String]
Reads the entire file as individual lines, and returns those lines in an array. If

keep_newline

argument is true (1B), trailing new-line characters are left as is.

read_bytes() -> Array[Byte]
Read a whole file into an array of bytes, and return it.

write(s)
Write the string

s

to the file.

write_bytes(Array[Byte] bytes)
Write bytes to the file.

flush()
Flush the write buffers of the file.