upd

Author: mattqual

notes/global-objects.md

@@ -30,7 +30,7 @@
 - [ ] DecimalContext
   - [ ] Supports "precision" and "rounding" options for now (look at decimal.js's API to get some ideas)
 - [ ] Iterator.\<T> (interface)
-  - [ ] required `next() : [t]?` (the returned array must be of length 1)
+  - [ ] required `next() : [t?,boolean]` (returns `[item, done]`)
   - [ ] `length():int` (consumes the whole iterator)
   - [ ] `skip(count:int):void`
   - [ ] `meta::filter(...)` (returns another iterator)

notes/semantics-and-verification.md

@@ -121,8 +121,7 @@
 - [x] ShockScript: Type expressions
   - [ ] `map {}` and `tap {}` must not appear everywhere; they are only allowed as the right side of an alias `type` definition.
 - [x] ShockScript: Patterns
-  - [ ] Structural matching automatically asserts objects as non-null not always necessarily throwing an error depending on pattern context (that way, the language doesn't need a "!" operator inside patterns)
-    - [ ] This is also particularly useful for if let applied to iterator results (e.g. `if (let [ch] = characters.next()) { ... }`)
+  - [ ] Structural matching automatically asserts objects as non-null not always necessarily throwing an error depending on pattern context. Although, the non-null operator is included within patterns as it's still useful for, say, identifier binding patterns.
 - [x] ShockScript: Statements
   - [ ] If statement
   - [ ] If let statement

src/conversions.md

@@ -52,6 +52,7 @@ Implicit coercions occur implicitly both at compile-time and runtime, after tryi
 | From union member to union                | |
 | From union to a common base type          | For example, given `type U = (B, C)`, a `var a:A = u;` declaration is valid as long as B and C share A as a base type. |
 | From structural function type to another compatible function type | |
+| From `t` type parameter to `t?`           | |
 
 > **Note**: `interface` types inherit `Object`.
 

src/lang-patterns.md

@@ -12,7 +12,8 @@ Where applicable, expressions are disambiguated into those patterns, in which ca
         [lookahead ≠ <b>undefined</b> if pattern is nested] <i>IdentifierPattern</i><br>
         <i>ArrayPattern</i><br>
         <i>ObjectPattern</i><br>
-        <i>ConstantPattern</i> [if pattern is nested]
+        <i>ConstantPattern</i> [if pattern is nested]<br>
+        <i>Pattern</i> <i>NonNull</i>
     </ul>
 </ul>
 

src/lang-statements/if-let-statement.md

@@ -19,7 +19,7 @@ if (let node = parseAtom()) {
 `if..let` can also be useful for, say, iterator results.
 
 ```sx
-if (let [x] = characters.next()) {
+if (let [x!,false] = characters.next()) {
     //
 } else {
     break;

src/types/record.md

@@ -4,7 +4,7 @@ Record types **\{\}** are simple property records.
 
 Specifically, there are variations of the record type, which are each represented and used in a different way.
 
-**map \{\}** types are like a hash-map internally, using boxing for primitive types. Fields that are not specified are not inserted into the structure. **map \{\}** **MUST NOT** appear anywhere but at the right side of an alias `type` definition.
+**map \{\}** types are like a hash-map internally, using boxing for primitive types. Fields that are not specified are not inserted into the structure.
 
 ```sx
 type Options = map {
@@ -13,7 +13,7 @@ type Options = map {
 };
 ```
 
-**tap \{\}** types are similar to **map \{\}**, but their creation and field accessors are implementation-defined, and they desugar to classes. **tap \{\}** **MUST NOT** appear anywhere but at the right side of an alias `type` definition.
+**tap \{\}** types are similar to **map \{\}**, but their creation and field accessors are implementation-defined, and they desugar to classes.
 
 Although **map \{\}** and **tap \{\}** types appear as type expressions, they are unique; structurally-matching records cannot be assigned to the other, or vice versa.
 

src/types/tuple.md

@@ -1,7 +1,7 @@
 # Tuple types
 
-Tuple types, of the form `[T1, T2, ...TN]`, are immutable sequences consisting of known element types at compile time. A tuple type contains at least two elements.
+Tuple types, of the form `[t1,t2,tN]`, are immutable sequences consisting of known element types at compile time. A tuple type contains at least two elements.
 
 ```sx
-[boolean, float]
+[boolean,float]
 ```

src/types/union.md

@@ -1,6 +1,6 @@
 # Union types
 
-The structural union type, written `(t1, t2, tN)`, consists of two or more member types, containing all possible values of the member types.
+The structural union type, written `(t1,t2,tN)`, consists of two or more member types, containing all possible values of the member types.
 
 ```sx
 (decimal,string)