Home   Manual   Type Index   Symbol Index   Topics Index

Symbol Index

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

A ⌂
std:: abs returns the absolute value of its (numerical) argument (function)
std:: all_of tests items of a collection (polymorphic function)
std:: and "short cut" and-operation (polymorphic function)
std:: any_of tests items of a collection (polymorphic function)
std:: append appends two collections to form a single collection (polymorphic attribute)
std:: assign returns all supplied arguments as results (inline-C function)
std_types:: association_list a very primitive kind of a table (inline-C type)

B ⌂
std:: bin returns a string consisting of binary digits (function)
std:: bit_and bitwise and operation (polymorphic attribute)
std:: bit_or bitwise inclusive or operation (polymorphic attribute)
std:: bit_xor bitwise exclusive or operation (polymorphic attribute)
std:: break the "keyword" (function) to exit from a loop (other)

C ⌂
std:: case multi-branch conditional (function)
std:: character returns the character with the specified unicode (inline-C function)
std_types:: character a unicode code point encoded as a 32-bit value (inline-C type)
std:: close closes the specified file without returning success status (function)
std:: close_file closes a resource (polymorphic attribute)
std:: command_line_arguments the application's command line arguments (constant)
std:: cond a multiway conditional expression or statement (function)
std:: contains checks whether a string contains a specific expression (polymorphic function)

D ⌂
std:: debug_string returns a string describing the object (inline-C function)
std:: dec subtracts the number 1 (function)
std:: default_value returns the first argument if it is defined or else the second argument (polymorphic function)
std:: delete the "keyword" (function) to delete the current item and to start the next iteration of a loop (other)
std:: div divide two integer numbers (polymorphic attribute)
std:: do execute a statement sequence (function)
std:: drop removes the last item of a collection without returning it (polymorphic attribute)
std:: dump write an object dump to stdout (function)
std:: dup creates a string containing n copies of the specified string (function)

E ⌂
std:: edump write an object dump to stderr (function)
std:: empty_association_list an empty association list (other)
std:: empty_hash_table an empty hash table (other)
std:: empty_key_order_table an empty key-order table (other)
std:: empty_list an empty list (constant)
std:: empty_string the empty string (constant)
std:: ENCODING used as an option key to specify a text encoding (unique item)
std:: equal compares two objects for equality (polymorphic attribute)
std_types:: error the prototype for all error objects (inline-C type)
std:: eval evaluate a function (function)
std:: ewrite writes its arguments (as a single string) to the error output channel (function)
std:: ewriteln writes its arguments and a trailing newline to the error output channel (function)
std:: extend_to returns the greater of its two arguments (function)

F ⌂
std:: false the boolean value false (other)
std_types:: false the type of the boolean value false (inline-C type)
std_types:: file_descriptor a posix file descriptor (inline-C type)
std:: filter returns a collection containing all the items that fullfill the filter-condition (polymorphic function)
std:: flush flushes all buffers associated with the resource (polymorphic attribute)
std:: for_each iterates over all items of a collection (polymorphic function)
std:: from_to a loop iterating over a sequence of values (function)
std_types:: function the prototype object for all functions (inline-C type)

G ⌂
std_types:: generic_list the prototype object for all kind of lists (including strings) (inline-C type)
std:: get removes and return the first item of a collection (polymorphic attribute)

H ⌂
std:: has_prefix returns true if the second argument is a prefix of the first argument (polymorphic function)
std:: has_suffix returns true if the second argument is a suffix of the first argument (polymorphic function)
std:: hash returns a hash value (polymorphic attribute)
std_types:: hash_table a table for fast random access of items (inline-C type)
std:: hex returns a string consisting of hexadecimal digits (function)

I ⌂
std:: i implicit key for loops (other)
std:: if classic if; can be used as a function or a procedure (polymorphic function)
std:: ignore accepts a single argument and returns nothing (function)
std:: in checks whether an element is contained in a collection (function)
std:: in_case conditionally execute a function (polymorphic function)
std:: inc adds the number 1 (function)
std_types:: integer the prototype object for all integral numbers (inline-C type)
std:: is_a_boolean succeeds for <true> and <false> (polymorphic function)
std:: is_a_character obvious (polymorphic function)
std:: is_a_digit return true for the ASCII-characters from '0' to '9' (function)
std:: is_a_hash_table obvious (polymorphic function)
std:: is_a_key_order_table obvious (polymorphic function)
std:: is_a_key_value_pair obvious (polymorphic function)
std:: is_a_letter_character returns <true> for letter characters (inline-C function)
std:: is_a_list obvious (polymorphic function)
std:: is_a_lower_case_letter_character returns <true> for lower case letter characters (inline-C function)
std:: is_a_number obvious (polymorphic function)
std:: is_a_sequence obvious (polymorphic function)
std:: is_a_string obvious (polymorphic function)
std:: is_a_table obvious (polymorphic function)
std:: is_a_title_case_letter_character returns <true> for title case letter characters (inline-C function)
std:: is_a_tuple obvious (polymorphic function)
std:: is_a_value_range obvious (polymorphic function)
std:: is_a_whitespace_character returns <true> for whitespace characters (inline-C function)
std:: is_an_association_list obvious (polymorphic function)
std:: is_an_error returns true if the argument denotes an error-object (polymorphic function)
std:: is_an_integer obvious (polymorphic function)
std:: is_an_octet_string obvious (polymorphic function)
std:: is_an_upper_case_letter_character returns <true> for upper case letter characters (inline-C function)
std:: is_defined returns true for all "normal" objects" (polymorphic function)
std:: is_empty checks whether a collection contains any items (polymorphic attribute)
std:: is_even return <true> for even integer numbers (function)
std:: is_odd return <true> for odd integer numbers (function)
std:: is_undefined returns true for undefined values (polymorphic function)
std:: it implicit value for loops (other)

K ⌂
std:: key_of the key of a key-value-pair (polymorphic attribute)
std_types:: key_order_table a table which items are stored in key-order (inline-C type)
std:: key_value_pair constructs a key-value-pair (function)
std_types:: key_value_pair the prototype object for all key-value-pair-objects (inline-C type)

L ⌂
std:: LATIN1 used as a value for specifying a text encoding (unique item)
std:: length_of returns the number of items within a collection (polymorphic attribute)
std:: less compares two objects in an object specific way (polymorphic attribute)
std:: list constructs a list from its arguments (inline-C function)
std_types:: list long length LIST_DATA *data (inline-C type)
std:: load loads data from a file or a network resource (function)
std:: loop a simple loop (function)
std:: lower_bound_of the lower bound of a range (polymorphic attribute)

M ⌂
std:: map applies a function to all items of a collection (polymorphic function)
std:: map_reduce combines a map and a reduce operation into a single operation (polymorphic function)
std:: match match the grammar object with the start of the specified string (polymorphic function)
std:: max returns the biggest of its (potentially) many arguments (function)
std:: mersenne_twister creates a pseudo random number generator (function)
std:: min returns the smallest of its (potentially) many arguments (function)
std:: minus subtract two numbers of any kind (polymorphic attribute)
std:: mod compute the remainder of two integer numbers (polymorphic attribute)

N ⌂
std:: negate negate the numeric argument (polymorphic attribute)
std:: new creates a new collection with inherited attributes (polymorphic attribute)
std:: next the "keyword" (function) to start the next iteration of a loop (other)
std:: not negate the boolean argument (polymorphic function)
std_types:: number the prototype object of all numbers (inline-C type)

O ⌂
std:: O_APPEND the respective POSIX flag used to open files (constant)
std:: O_CREAT the respective POSIX flag used to open files (constant)
std:: O_DSYNC the respective POSIX flag used to open files (constant)
std:: O_EXCL the respective POSIX flag used to open files (constant)
std:: O_NOFOLLOW the respective POSIX flag used to open files (constant)
std:: O_NONBLOCK the respective POSIX flag used to open files (constant)
std:: O_RDONLY the respective POSIX flag used to open files (constant)
std:: O_RDWR the respective POSIX flag used to open files (constant)
std:: O_RSYNC the respective POSIX flag used to open files (constant)
std:: O_SYNC the respective POSIX flag used to open files (constant)
std:: O_TRUNC the respective POSIX flag used to open files (constant)
std:: O_WRONLY the respective POSIX flag used to open files (constant)
std_types:: object the prototype object for all "normal" objects (inline-C type)
std:: oct returns a string consisting of octal digits (function)
std_types:: octet_string a string where all characters fit into an octet (inline-C type)
std:: open_file opens a file (inline-C function)
std:: or "short cut" or- operation; (polymorphic function)
std:: over divide two numbers of any kind (polymorphic attribute)

P ⌂
std:: pad_left extends a string to a specified width (function)
std:: pad_right extends a string to a specified width (function)
std:: parameter_count_of number of wanted arguments (polymorphic attribute)
std:: parse_integer extracts an integer value from the start of the string (function)
std:: pass does nothing (inline-C function)
std:: peek returns the last item of a collection without removing it (polymorphic attribute)
std:: plus add two numbers of any kind (polymorphic attribute)
std_types:: polymorphic_function the prototype object for all polymorphic functions (inline-C type)
std_types:: polymorphic_function_with_setter the prototype object for all polymorphic functions with a setter (inline-C type)
std:: pop remove and return the last item of a collection (polymorphic attribute)
std_types:: positive_integer the prototype object for all non-negative integers (inline-C type)
std:: pow returns the its first argument by the power of its second argument (function)
std:: program_name the name of the application program (constant)
std:: push add a single item at the end of a collection (polymorphic attribute)
std:: put adds a single item at the front of a collection (polymorphic attribute)

R ⌂
std:: range returns a subrange of a collection (polymorphic attribute)
std:: read_all_from reads until exhaustion (function)
std:: read_from reads the specified number of bytes (polymorphic attribute)
std:: read_some_bytes_from tries to read the specified number of bytes (polymorphic attribute)
std:: readln reads a line from the standard input channel (function)
std_types:: real the prototype object for all non-integral numbers (inline-C type)
std:: reduce computes a kind of sum from the items of a collection (polymorphic function)
std:: reduce_to returns the lesser of its two arguments (function)
std:: repeat invoke a statement sequence for a specific number of times (function)
std:: result_count returns the expected number of results (inline-C function)

S ⌂
std:: search search from the grammar object from the start of the specified string (polymorphic function)
std:: sequence constructs a sequence (function)
std_types:: sequence the prototype object for all sequences (inline-C type)
std:: serialization_tag_of returns a tag denoting the type of an object (polymorphic attribute)
std:: serialize returns a machine readable string representation of the object (polymorphic function)
std:: sgn returns the sign of its (numerical) argument (function)
std:: shift_left bitwise shift-left operation (polymorphic attribute)
std:: shift_right bitwise shift-right operation (polymorphic attribute)
std:: spaces returns that many spaces (function)
std:: split splits a collection into several parts (polymorphic function)
std:: sqr return the power of 2 of its (numerical) argument (function)
std:: STDERR_FILENO the respective POSIX file descriptor number (constant)
std:: STDIN_FILENO the respective POSIX file descriptor number (constant)
std:: STDOUT_FILENO the respective POSIX file descriptor number (constant)
std:: string returns the concatenation of all its arguments converted to strings (function)
std_types:: string the prototype object for all strings (inline-C type)
std:: subtype_of used to define the subtypes of tuples and lists (polymorphic attribute)

T ⌂
std_types:: table the prototype object for all tables (other)
std:: tabs_and_spaces returns a sequence of tabulator- and space-characters (function)
std:: terminate terminate the process and report successfull completion to the parent (inline-C function)
std:: times multiply two numbers of any kind (polymorphic attribute)
std:: to_integer converts its argument into an integer number (polymorphic attribute)
std:: to_lower_case converts all upper case characters to lower case (polymorphic attribute)
std:: to_number converts its argument into a number (polymorphic attribute)
std:: to_real converts its argument into a real (floating point) number (polymorphic attribute)
std:: to_string returns a human readable presentation of the object (polymorphic attribute)
std:: to_title_case converts the contents to Title Case (polymorphic attribute)
std:: to_upper_case converts all lower case characters to UPPER CASE (polymorphic attribute)
std:: to_utf8 returns an utf8-encoded octet string (polymorphic attribute)
std:: trim removes leading and trailing whitespace (function)
std:: true the boolean value true (other)
std_types:: true the type of the boolean value true (inline-C type)
std:: try recover an error object (function)
std:: tuple constructs a tuple from the specified arguments (inline-C function)
std_types:: tuple the prototype object for all tuples (inline-C type)

U ⌂
std:: undefined a one-of-kind object to represent undefined values (other)
std_types:: undefined the undefined object (inline-C type)
std_types:: unique_item this is the prototype object for all unique items (inline-C type)
std:: unless executes a function unless the condition is true (polymorphic function)
std:: update the "keyword" (function) to update the current item and to start the next iteration of a loop (other)
std:: upper_bound_of the upper bound of a range (polymorphic attribute)
std:: UTF8 used as a value for specifying a text encoding (unique item)

V ⌂
std:: value_of the value of a key-value-pair (polymorphic attribute)
std:: value_range constructs a value-range (function)
std_types:: value_range the prototype object for all value-range-objects (inline-C type)

W ⌂
std:: write writes its arguments (as a single string) to the standard output channel (function)
std:: write_some_bytes_to tries to write the specified number of bytes (polymorphic attribute)
std:: write_to writes its arguments (as a single string) to the specified output channel (function)
std:: writeln writes its arguments and a trailing newline to the standard output channel (function)