4. Types and values

4.1 Value types

Taught in 1. Hello, 2. Values, 3. Time, 6. Decisions

4.2 Structural types

Taught in 2. Values, 4. First node, 5. Messages, 7. Phrases, 8. Many nodes, 10. Faults, 12. Looks, 13. Story

A record type name is a valid hole type, and msg accepts any record. Types nest: [ns: list of node], [m: map of node to number], list of list of node. Bare list and map are not types.

4.3 Records

Taught in 5. Messages

A record type is declared with has; each line gives a field and its initial value:

Promise has
  set number to 0
  set prior to 0
  set priorValue to ""

A record value is built with message … with, naming fields (here in node code, where n is the receiver):

message Promise with number n.Promised, prior n.AcceptedBallot, priorValue n.AcceptedValue

• Fields not named keep their initial value. Naming a field with its initial value is allowed. A setting is a field word and one item (a x plus 1 needs parentheses: a (x plus 1); otherwise unknown-phrase); a word that is not a field of the record is unknown-phrase; a field named twice is duplicate-name.
• Initial values in has are constants: literals, {}, list literals, message … with over constants, sim.Nobody, and operators over these (context otherwise).
• Fields are read with .: Promise.number, p.prior. Record fields are never package-qualified: api.Get.Key reads Key of the record bound as api.Get, and r.Key reads it from a local r of type api.Get. A record field belongs to its record type, which already names the package.
• A field is read from a value whose record type is known at compile time. A msg value has no readable fields.
• Record values are immutable: set cannot target a record field (bad-place). Messages and events are both records.
• Capitalized fields are readable from other packages; lower-case fields only inside the declaring package.

Node has uses the same form to declare the fields of the package's node type (see spec/05).

4.4 Lists and maps

Taught in 2. Values, 8. Many nodes

• {} is an empty list or an empty map. Its type (list or map, and its element types) comes from the type expected where it appears (the field or local it is assigned to, the hole it fills), and otherwise from how that place is used anywhere in the package: std/lists phrases imply a list; std/maps phrases and set item k of x with a non-number key imply a map; the items added fix the element types. When a native's result has the same type as one of its holes (as disk.Read … or [d: value] does), the type expected for the result is also expected for that hole, so disk.Read "pages" on n or {} takes the type of the field or local it is assigned to. If the compiler cannot tell, it is an ambiguous-empty error.
• Element types are known at compile time: in when [n: Node] (net.Received Promise from acceptor), which binds the record Promise, lists.Append Promise to n.promises makes n.promises a list of Promise, and adding an item of another type is a type-mismatch.
• Element access: item 0 of n.peers, item k of n.Known. Reading a missing index or key is a run-time error; check with is in first.
• Update: set item k of n.Known to v. Lists and maps are values; set item replaces the place's value with an updated copy.
• Membership: k is in n.Known (map keys), n is in n.peers (list items).
• Iteration, shaped like Go's range:

each p in n.peers
  net.Send ping from n to p

each i, p in n.peers
  set item i of n.Last to p

each k in n.Known
  set n.Seen to (lists.Append k to n.Seen)

each k, v in n.Known
  set item k of n.Copy to v

Over a list, p is the item and i the index; over a map, k is the key and v the value. (These four loops are a fragment, not a complete file.)

Unused locals and each names are compile errors (as in Go), so only the form you need compiles. A name is used when it is read or is the base of set item … of x; setting it again is not a use. Names bound by a when pattern and hole parameters may go unused, like Go function parameters. Maps iterate in ascending key order (nodes order by creation), so runs are deterministic.

4.5 Operators

Taught in 2. Values, 6. Decisions

time times number, number times time and time divided by number round down to a whole microsecond. -0 is 0: no operator yields a negative zero. A non-finite result is a number-range run-time error.

Comparing two values whose types are not accepted as one another (§4.7) is a type-mismatch compile error. Division by zero is a run-time error.

4.6 Type inference

• Local, node-field and record-field types are inferred from their initial value and every assignment; they never change. The type of a place is the join of its initial value and every assignment (§4.7); if they do not join, the later one is a type-mismatch. Two unrelated node types do not join to node.
• Hole types are declared, element types included. Value phrase result types are inferred.
• There are no conversions except through phrases (text.From).

4.7 Accepted types

A value of type S is accepted where type T is expected when one of these holds:

• S is T;
• S is a node type and T is node;
• S is p.Node, T is q.Node, and running p runs q (p is q or uses it, directly or transitively; spec/05 §5.1);
• S is a record type and T is msg;
• S is list of A, T is list of B, and A is accepted as B; map of K1 to V1 is accepted as map of K2 to V2 when K1 is accepted as K2 and V1 as V2.

{} is accepted as any list or map type. The join of two types is the one that accepts both: if S is accepted as T it is T; lists and maps join item-wise; otherwise they do not join. is and is not compare two values when the type of one is accepted as the type of the other.