From a1065faf7c4a73a7b0659d0559932ad2c68009d1 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 29 Sep 2008 20:37:46 -0700 Subject: [PATCH] - corrections and more on interface types R=r DELTA=35 (12 added, 13 deleted, 10 changed) OCL=16162 CL=16164 --- doc/go_spec.txt | 41 ++++++++++++++++++++--------------------- 1 file changed, 20 insertions(+), 21 deletions(-) diff --git a/doc/go_spec.txt b/doc/go_spec.txt index 850b07c55a0..40b190d30c4 100644 --- a/doc/go_spec.txt +++ b/doc/go_spec.txt @@ -36,7 +36,6 @@ Open issues according to gri: [ ] optional semicolons: too complicated and unclear [ ] like to have assert() in the language, w/ option to disable code gen for it [ ] composite types should uniformly create an instance instead of a pointer -[ ] meaning of nil [ ] clarify slice rules [ ] something on tuples? [ ] semantics of statements @@ -62,6 +61,7 @@ Decisions in need of integration into the doc: for array composites Closed issues: +[x] meaning of nil [x] remove "any" [x] methods for all types [x] should binary <- be at lowest precedence level? when is a send/receive non-blocking? (NO - 9/19/08) @@ -94,13 +94,10 @@ Contents Export declarations Types - Type interfaces - Basic types Arithmetic types Booleans Strings - Array types Struct types Pointer types @@ -743,25 +740,26 @@ There are basic types and composite types. Basic types are predeclared. Composite types are arrays, maps, channels, structures, functions, pointers, and interfaces. They are constructed from other (basic or composite) types. -The 'static type' (or simply 'type') of a variable is the type defined by -the variable's declaration. The 'dynamic type' of a variable is the actual -type of the value stored in a variable at runtime. Except for variables of -interface type, the static and dynamic type of variables is always the same. - -Variables of interface type may hold values of different types during -execution. However, the dynamic type of the variable is always compatible -with the static type of the variable. - Type = TypeName | ArrayType | ChannelType | InterfaceType | FunctionType | MapType | StructType | PointerType . TypeName = QualifiedIdent. +The ``interface'' of a type is the set of methods bound to it +(§Method declarations). The interface of a pointer type is the interface +of the pointer base type (§Pointer types). All types have an interface; +if they have no methods associated with them, their interface is +called the ``empty'' interface. -Type interfaces ----- +The ``static type'' (or simply ``type'') of a variable is the type defined by +the variable's declaration. The ``dynamic type'' of a variable is the actual +type of the value stored in a variable at runtime. Except for variables of +interface type, the dynamic type of a variable is always its static type. + +Variables of interface type may hold values with different dynamic types +during execution. However, its dynamic type is always compatible with +the static type of the interface variable (§Interface types). -TODO fill in this section Basic types ---- @@ -1182,8 +1180,9 @@ Assignment compatibility: A function pointer can be assigned to a function Interface types ---- -An interface type denotes the set of all types that implement the -set of methods specified by the interface type. +Type interfaces may be specified explicitly by interface types. +An interface type denotes the set of all types that implement at least +the set of methods specified by the interface type, and the value "nil". InterfaceType = "interface" "{" [ MethodList [ ";" ] ] "}" . MethodList = MethodSpec { ";" MethodSpec } . @@ -2280,9 +2279,9 @@ A method declaration is a function declaration with a receiver. The receiver is the first parameter of the method, and the receiver type must be specified as a type name, or as a pointer to a type name. The type specified by the type name is called ``receiver base type''. The receiver base type must be a -type declared in the current file. The method is said to be ``bound'' to -the receiver base type; specifically it is declared within the scope of -that type (§Type interfaces). +type declared in the current file, and it must not be a pointer type. +The method is said to be ``bound'' to the receiver base type; specifically +it is declared within the scope of that type (§Types). MethodDecl = "func" Receiver identifier FunctionType ( ";" | Block ) . Receiver = "(" identifier [ "*" ] TypeName ")" .