"""The type of the [[null]] value. Any union type of form 
   `Null|T` is considered an _optional_ type, whose values
   include `null`. Any type of this form may be written as
   `T?` for convenience.
   
   The `if (exists ... )` construct, or, alternatively,
   `assert (exists ...)`, may be used to narrow an optional 
   type to a _definite_ type, that is, a subtype of 
   [[Object]]:
   
       String? firstArg = process.arguments.first;
       if (exists firstArg) {
           print("hello " + firstArg);
       }
   
   The `else` operator evaluates its second operand if and 
   only if its first operand is `null`:
   
       String name = process.arguments.first else "world";
   
   The `then` operator evaluates its second operand when
   its first operand evaluates to `true`, and produces `null` 
   otherwise:
   
       Float? diff = x>=y then x-y;
   
   The `?.` operator may be used to evaluate an attribute
   or invoke a method of an optional type, evaluating to
   `null` when the receiver is missing:
   
       value [firstName, lastName] =
               let (fullName = process.arguments.first?.trimmed,
                    bits = fullName?.split()?.sequence() else []) 
                       [bits[0], bits[1]];
       assert (exists firstName, exists lastName);
   
   No equivalence relation is defined for `Null`. In 
   particular, neither `null==null` nor `null===null` are
   considered meaningful. Therefore, `Null` is neither
   [[Identifiable]], nor does it define 
   [[value equality|Object.equals]]."""​
​see (`value null`)
​by ("Gavin") 
​tagged("Basic types")
​shared abstract class Null() 
        of null​
        extends Anything() {}
​
"The null value."​
​by ("Gavin")
​tagged("Basic types")
​shared object null extends Null() {}
​