+TODO: This should be autogenerated but that will take work to make h3s appear in this list +
-
-A package is built from one or more source files, each of which consists -of a package specifier followed by declarations. There are no statements at -the top level of a file. +Go is a general-purpose language designed with systems programming +in mind. It is strongly typed and garbage-collected, and has explicit +support for concurrent programming. Programs are constructed from +packages, whose properties allow efficient management of +dependencies. The existing implementations use a traditional +compile/link model to generate executable binaries. +
+-By convention, the package called "main" is the starting point for execution. -It contains a function, also called "main", that is the first function invoked -by the run time system after initialization (if a source file within the program -contains a function "init()", that function will be executed before "main.main()" -is called). -
-Source files can be compiled separately (without the source code of packages -they depend on), but not independently (the compiler does check dependencies -by consulting the symbol information in compiled packages). - - -
-In particular, all identifiers occurring in a package are either declared -explicitly within the package, arise from an import declaration, or belong -to a small set of predeclared identifiers (such as "string"). -
-Scoping follows the usual rules: The scope of an identifier declared within -a ``block'' generally extends from the declaration of the identifier to the -end of the block. An identifier shadows identifiers with the same name declared -in outer scopes. Within a scope, an identifier can be declared at most once. -
-Identifiers may be ``internal'' or ``exported''. Internal identifiers are only -accessible to files belonging to the package in which they are declared. -External identifiers are accessible to other packages. - - -
-Object-oriented programming is supported by interface types. -Different interface types are independent of each -other and no explicit hierarchy is required (such as single or -multiple inheritance explicitly specified through respective type -declarations). Interface types only define a set of methods that a -corresponding implementation must provide. Thus interface and -implementation are strictly separated. -
-An interface is implemented by associating methods with types. If a type -defines all methods of an interface, it implements that interface and thus -can be used where that interface is required. Unless used through a variable -of interface type, methods can always be statically bound (they are not -``virtual''), and invoking them incurs no extra run-time overhead compared -to ordinary functions. -
-Go has no explicit notion of classes, sub-classes, or inheritance. -These concepts are trivially modeled in Go through the use of -functions, structures, embedding of types, associated methods, and interfaces. -
-Go has no explicit notion of type parameters or templates. Instead, -containers (such as stacks, lists, etc.) are implemented through the -use of abstract operations on interface types. - - -
-For example, when calling a function with a struct, the struct is passed -by value, possibly by making a copy. To pass a reference, one must explicitly -pass a pointer to the struct. On the other hand, when calling a function with -a map, a reference to the map is passed implicitly without the need to pass a -pointer to the map; thus the map contents are not copied when a map is assigned -to a variable. - - -
The syntax is specified using Extended Backus-Naur Form (EBNF): +
-Production = production_name "=" Expression .
-Expression = Alternative { "|" Alternative } .
+Production = production_name "=" Expression .
+Expression = Alternative { "|" Alternative } .
Alternative = Term { Term } .
-Term = production_name | token [ "..." token ] | Group | Option | Repetition .
-Group = "(" Expression ")" .
-Option = "[" Expression ")" .
-Repetition = "{" Expression "}" .
+Term = production_name | token [ "..." token ] | Group | Option | Repetition .
+Group = "(" Expression ")" .
+Option = "[" Expression ")" .
+Repetition = "{" Expression "}" .
-Productions are expressions constructed from terms and the following operators:
-
++Productions are expressions constructed from terms and the following +operators, in increasing precedence: +
-| separates alternatives (least binding strength)
-() groups
-[] specifies an option (0 or 1 times)
-{} specifies repetition (0 to n times)
+| alternation
+() grouping
+[] option (0 or 1 times)
+{} repetition (0 to n times)
-Lower-case production names are used to identify productions that cannot
-be broken by white space or comments; they are tokens. Other production
-names are in CamelCase.
-Tokens (lexical symbols) are enclosed in double quotes '''' (the -double quote symbol is written as ''"''). +Lower-case production names are used to identify lexical tokens. +Non-terminals are in CamelCase. Lexical symbols are enclosed in +double quotes "" (the double quote symbol is written as +'"'). +
+-The form "a ... b" represents the set of characters from "a" through "b" as -alternatives. +The form "a ... b" represents the set of characters from +a through b as alternatives. +
+Where possible, recursive productions are used to express evaluation order -and operator precedence syntactically (for instance for expressions). -
-A production may be referenced from various places in this document -but is usually defined close to its first use. Productions and code -examples are indented. - -
+The following terms are used to denote specific Unicode character classes: +
Character and string literals are almost the same as in C, with the following differences: -
+
+A unicode_value takes one of four forms: +
The "string" type represents the set of string values (strings). Strings behave like arrays of bytes, with the following properties: -
+
Types may be ``different'', ``structurally equal'', or ``identical''. Go is a type-safe language; generally different types cannot be mixed in binary operations, and values cannot be assigned to variables of different @@ -1803,7 +1699,7 @@ are equal. Two type literals specify equal types if they have the same literal structure and corresponding components have equal types. Loosely speaking, two types are equal if their values have the same layout in memory. More precisely: -
+
Type identity is defined by these rules: +
Two type names denote identical types if they originate in the same type declaration. Two type literals specify identical types if they have the same literal structure and corresponding components have identical types. More precisely: -
+
denotes the array or map element x. The value x is called the ``array index'' or ``map key'', respectively. The following rules apply: +
For a of type A or *A where A is an array type (§Array types): -
+
For a of type *M, where M is a map type (§Map types): -
+
+The operand types in binary operations must be equal, with the following exceptions: +
+A semicolon may be omitted immediately following: +
+A Go compiler guarantees the following minimal alignment properties: +