wuffur: переводы

→A comma-separated sequence of identifiers is followed by a colon and then the name of a type. Each identifier is declared as having that type and denotes a particular object for the rest of its scope (see Scope). If the declaration contains = and an expression, all the objects are initialized from the value of the expression. In a declaration at the top level (outside a function), the expression must be constant or an array initialized with constant expressions; the bound of any array must be a constant expression. Lists and ref adt types can not be initialized at the top level.
If an object is not explicitly initialized, then it is always set to nil if it has a reference type; if it has arithmetic type, then it is set to 0 at the top level and is undefined if it occurs within a function.

→These forms constitute the basic way for declaring and initializing data:
identifier-list : type; identifier-list : type = expression;

→Data Declarations

→declaration:
identifier-list : type; identifier-list : type = expression; identifier : = expression; ( id-or-nil-list ) : = expression; identifier-list : con expression; identifier-list : import identifier; identifier-list : type type; include string-constant;
identifier-list: identifier identifier-list, identifier
expression-list: expression expression-list, expression

→Declarations take several forms:

→Declarations are used both at the top level (outside of functions) and inside functions and module declarations. Some styles of declaration are allowed only in certain of these places, but all will be discussed together.

→The i mpl ement declaration at the start identifies the type of the module that is being implemented. The rest of the program consists of a sequence of various kinds of declarations and definitions that announces the names of data objects, constants, types, and functions, and it creates and initializes the declarations and definitions. It must include a module declaration for the module being implemented and the objects it announces. It can include declarations for the functions, data objects, types, and constants used privately within the module, as well as declarations for modules used by it.

→At the top level, a program consists of a sequence of declarations. The syntax is:
program:
implement identifier ; top-declaration-sequence
top-declaration-sequence: top-declaration top-declaration-sequence top-declaration
top-declaration: declaration
identifier-list : = expression; identifier-list = expression; ( identifier-list ) : = expression; module-declaration function-definition adt-declaration

→Top Level

→Other files, conventionally named with the suffix . m, contain declarations for things obtainable from other modules. These files are incorporated by an i ncl ude declaration in the implementation modules that need them.

→Limbo source programs that implement modules are stored in files, conventionally named with the suffix . b. Each source file begins with a single i mpl ement directive naming the type of the module, followed by a sequence of declarations.

→This means that the first argument of pri nt is a string and that other arguments can be given when the function is called. The Limbo language itself has no way of accessing these arguments; the notation is an artifice for describing facilities built into the runtime system, such as the Sys module.

→The star character * can be given as the last argument in a function type. It declares that the function is variadic; during a call, actual arguments at its position and following are passed in a manner unspecified by the language. For example, the type of the pri nt function of the Sys module is:
fn (s : string, *) : int

→The following is an example of a function that takes a string argument and returns no value:
fn (nil : string)
The self keyword has a specialized use within adt declarations. It can be used only for the first argument of a function declared within an adt; its meaning is discussed in the ADT Declarations section.

→The denotation of a function type has the keyword f n followed by a comma-separated list of its arguments enclosed in parentheses, and perhaps followed by the type the function returns. Absence of a return value means that the function returns no value; it is a procedure. The names and types of arguments are specified. However, the name of an argument can be replaced by ni 1, making it nameless. For example:
fn (nil : int, nil : int) : int
fn (radius : int, angle : int) : int
fn (radius, angle : int) : int
all denote exactly the same type, namely a function of two integers that returns an integer.

→A function type characterizes the arguments and return value of a function. The syntax is:
function-type:
f n function-arg-ret
function-arg-ret:
(formal-arg-listopt^) (formal-arg-list ^) : data-type
formal-arg-list: formal-arg formal-arg-list, formal-arg
formal-arg:
nil-or-D-list : type
nil-or-D-list : self ref t identifier
nil-or-D-list: nil-or-D nil-or-D, nil-or-D
nil-or-D:
identifier nil

→There is also a ref adt type representing a reference (pointer) to an adt. It is denoted:
ref adt-type
where the identifier is the name of an adt type.
Once an adt has been declared, the identifier associated with it becomes a data-type name.

→An abstract data type or adt is an object that can contain data objects of several different types and can declare functions that operate on them. An adt is denoted:
adt-type:
module-qualified-type identifier

→When a type is declared within a module declaration, the name of that type is not generally visible to the rest of the program unless a specific i mpo r t request is given (see Declarations with Import and Referring to Modules). Without such a request, when objects of that type are declared in a client module, the type name is qualified.
module-qualified-type:
identifier -> identifier
Here the first identifier is either the name of a module or a variable of the module type. The second is the name of a type in the module's declaration.

→Module-qualified type