upd

Author: mattqual

TODO

@@ -88,7 +88,7 @@
   - [ ] Equality allows mixing compatible operands with void and/or null.
   - [ ] Call operator
     - [ ] Base is passed *followedByCall=true*
-    - [ ] Watch for static `meta::call` when calling classes (supports multiple signatures too)
+    - [ ] Watch for class-self-attached `meta::call` when calling classes (supports multiple signatures too)
     - [ ] Perform type inference for omitted generic parameters.
     - [ ] `T(v)` cast - Semantic patch: Exclude null and/or undefined from T
   - [ ] `v is T` operator
@@ -138,6 +138,7 @@
   - [ ] If let statement
     - [ ] For non-nullable assignment, ensure test is not an accidental binding of a function/method (where the user meant to "call" it)
     - [ ] Apply non-nullability to type annotation if any
+    - [ ] Provide context type for algebraic matching pattern
   - [ ] `for each`: `Iterator` and `Iterable` are iterable
   - [ ] `switch type`
     - [ ] Provide context type for type inference on `case(...)` parameters when matching over an algebraic enumeration
@@ -319,7 +320,7 @@
     - [ ] `clone()` returns the same ContextReference reference back without cloning
   - [ ] XML
     - [ ] Implement `Iterable`
-    - [ ] static `meta::call(arg:*):XML`
+    - [ ] self-attached `meta::call(arg:*):XML`
     - [ ] `meta::has(name:QName):boolean`
       - [ ] `@` prefix in name = attribute
     - [ ] `meta::get(index:int):XML` (throws if out of bounds)
@@ -329,7 +330,7 @@
     - [ ] `sibling(n)` - e.g. `sibling(-1)` (previous) and `sibling(1)` (next) - uses `parent` internally.
     - [ ] Attributes
   - [ ] XMLList
-    - [ ] static `meta::call(arg:*):XMLList`
+    - [ ] self-attached `meta::call(arg:*):XMLList`
   - [ ] XMLContext
     - [ ] Represent this as a class and not a record type (object literal works on classes now)
     - [ ] ignoreWhitespace defaults to true, which means "trim any whitespace at the beginning and end of text nodes". Unlike AS3/E4X, XML literals always ignore whitespace. (If whitespace is desired on text nodes, use interpolation.)

src/algebraic-enums.md

@@ -1,11 +1,11 @@
 # Algebraic enumerations
 
-Algebraic enumerations, as opposed to simple enumerations, contain `type X()` definitions instead of just `const X` definitions; they desugar to an one-level hierarchy of classes, with the enum being an abstract class.
+Algebraic enumerations, as opposed to simple enumerations, contain `type X()` definitions instead of just `const X` definitions; they desugar to an one-level hierarchy of classes, with the enum being an abstract class, and each variant into a class with a self-attached `meta::call` method (so you can specify either the defined signature, or an object literal).
 
 ## Example
 
 ```sx
-package com.q.calculator {
+package no.calculator {
     public enum Exp {
         /**
          * @param left Left-hand side.
@@ -17,26 +17,20 @@ package com.q.calculator {
     }
 }
 
-import com.q.calculator.*
+import no.calculator.*
 
-// type inference -
-// use a basemost lexical name
+var exp : Exp
 
-// each variant implements a meta::call multi-method,
-// so it can accept values in different ways.
-var exp : Exp = Empty()
-var exp : Exp = Plus({ left: x, right: y })
-var exp : Exp = Plus(x, y)
+exp = Empty()
+exp = Plus({ left: x, right: y })
+exp = Plus(x, y)
 
 switch type (exp) {
-    case ({ value } : Number) {
-        //
+    case (Number(value)) {
     }
-    case ({ left, right } : Plus) {
-        //
+    case (Plus(x, y)) {
     }
-    case ({} : Empty) {
-        //
+    case (Empty()) {
     }
 }
 ```

src/conversions.md

@@ -2,7 +2,7 @@
 
 This section describes which type conversions are available.
 
-Explicit conversions may occur as either `T(v)` (strict conversion) or `v as T` (optional conversion). The behavior of the call operator over a type may not always be a conversion depending on if `T` implements the static `meta::call()` hook.
+Explicit conversions may occur as either `T(v)` (strict conversion) or `v as T` (optional conversion). The behavior of the call operator over a type may not always be a conversion depending on if `T` implements the self-attached `meta::call()` hook.
 
 ```sx
 v as T     // returns T?. failure returns null

src/lang-statements/switch-statements.md

@@ -1,6 +1,6 @@
 # Switch statements
 
-The switch statement is similiar to that of Java. Unlike in Java, the switch statement does not include fallthroughs.
+The **switch** statement is similiar to that of Java. Unlike Java, the switch statement does not include fallthroughs.
 
 ```sx
 switch (v) {
@@ -16,21 +16,18 @@ The **switch type** statement is used to match the type of a discriminant value.
 
 ```sx
 switch type (v) {
-    case (d : double) {
-        // double
+    case (d : Date) {
     }
     default {
-        // no matching case
     }
 }
 ```
 
-The **switch type** statement also supports matching algebraic data type variants, typically omitting the case's type annotation.
+The **switch type** statement also supports pattern matching on algebraic data types.
 
 ```sx
 switch type (exp) {
     case (Plus(10, right)) {
-        //
     }
 }
 ```

src/meta-methods.md

@@ -4,7 +4,7 @@
 
 ## meta::call()
 
-A static `meta::call()` method may be defined with any number of parameters and any result type, overriding the behavior of calling the class object.
+A class self-attached `meta::call()` method may be defined with any number of parameters and any result type, overriding the behavior of calling the class object.
 
 ```sx
 meta static function call():T {}

src/overview/language-comparison/as3.md

@@ -177,15 +177,20 @@ switch (v) {
 
 ## Switch type
 
-The `switch type` statement allows for simple type matching:
+The `switch type` statement allows for type and pattern matching:
 
 ```sx
 switch type (v) {
     case (d : Date) {
-        //
     }
     default {
-        //
+    }
+}
+
+switch type (exp) {
+    case (Plus(x, y)) {
+    }
+    case (Nothing()) {
     }
 }
 ```

src/overview/namespace-methods.md

@@ -1,6 +1,6 @@
 # Namespace methods
 
-A `class` that implements the static `meta::call` hook may act as a *namespace method*.
+A `class` that implements the self-attached `meta::call` hook may act as a *namespace method*.
 
 ```sx
 package zero.fn {

src/overview/type-matching.md

@@ -10,14 +10,9 @@ v is T
 
 ```sx
 switch type (v) {
-    case (regex : RegExp) {
-        trace("a regex");
-    }
-    case ([x, y] : [double, double]) {
-        trace("a tuple of double");
+    case (d : Date) {
     }
     default {
-        trace("any other");
     }
 }
 ```
@@ -27,7 +22,6 @@ switch type (v) {
 ```sx
 switch type (exp) {
     case (Plus(10, right)) {
-        //
     }
 }
 ```
@@ -36,6 +30,5 @@ switch type (exp) {
 
 ```sx
 if (let Plus(10, right) = exp) {
-    //
 }
 ```