Changes between Version 7 and Version 8 of ExpressionTour

Timestamp:

05/28/13 13:20:19 (11 years ago)

Author:

hopscc

Comment:

--

ExpressionTour

@@ -47 +47 @@
 
 == Bitwise ==
-
-to-do (& | ^ << >> ~)
+Standard bit operations.
+  - & = bitwise 'and'
+  - | = bitwise 'or'
+  - ~ = bitwise not (flip)
+  - !^ = bitwise Xor
+  - << = left shift
+  - >> = right shift 
+
 
 == Boolean ==
@@ -89 +95 @@
 to-do (inherits, implements, if-inherits, alternative is virtual method)
 
-== Casting ==
-
-to-do (to, to?)
+== Casting to Type or Nilability ==
+
+Cast an expression to a particular Type (nilable or not).
+Cast to or away from nilability.
+
+EXPR to TYPE 
+   - cast the expression to the given TYPE, cast failing throws an Exception.
+   - ("cast or throw Exception")
+   
+EXPR to? TYPE
+   - cast the expression to the given TYPE, if the cast fails return nil 
+   - ("cast or return nil")
+
+   - Note: single token 'to?' no spaces
+
+EXPR to ?
+  - cast the type of EXPR to the nilable version of same type  (EXPR.typeOf?)
+  - Note space between 'to' and '?'
+
+EXPR to ! 
+  - cast the type of EXPR to the non-nilable version of same type( EXPR.typeOf!) 
+
+{{{
+#!cobra
+
+s = 'String'
+sObj = s to Object
+assert sObj.typeof is Object
+
+ds as dynamic = 'xyzzy'
+s = ds to String
+
+i = 99
+s = i to? String
+assert s is nil
+
+s = 'xyzzy'  # nonnilable
+sNil = s to ? #cast to nilable
+
+s as String? = 'xyzzy'
+sNotNil = s to ! # non nilable
+ 
+}}}
 
 == If Expression ==
-
-to-do
+Trinary operator on an expression.
+If the conditional expression evaluates to true  give the first Expr otherwise give the second. 
+
+Note: no space between the if and the '(' - single token 'if('
+
+=== Grammar ===
+if( COND-EXPR, EXPR1, EXPR2 )
+
+{{{
+#!cobra
+i=22
+z = if( i>10, 100, 0) 
+assert z == 100
+
+name = if( s.length, s, 'empty')
+
+o = if(o, o, default)
+# set o to 'default' if it is nil - but see nil coalesce below
+}}}
 
 == For Expression ==
-
-to-do
+Apply an expression across a collection or range or a filtered subset thereof.
+
+=== Grammar ===
+for VAR in EXPR [where EXPR ] get EXPR
+
+for VAR in EXPR where EXPR 
+  - same as   for VAR in EXPR where EXPR get VAR
+
+for VAR in START-EXPR : STOP-EXPR [: STEP_EXPR] [where EXPR] get EXPR 
+
+{{{
+#!cobra
+a = for i in 1:4 get i*2
+assert a == [2,4,6]
+
+a = for i in [1, 2, 3] get i*10
+assert a == [10, 20, 30]  
+
+a = for i in 10 where i>5 get i
+assert a == [6, 7, 8, 9]
+
+c = ['how', 'now', 'brown', 'cow']
+d = for k in c where k.endsWith('ow') get k
+assert d == ['how', 'now', 'cow']
+
+
+tmpFiles = for fileName in Directory.getFiles('.') where '.tmp' in fileName
+
+}}}
+
+
+== Try-Catch-Get Expression ==
+
+This is a shorthand for a try-catch statement wrapping a single statement assigning an expression.[[BR]]
+The value of the expression is the value of the expr following 'try' or if an exception is thrown the value of the expression after the 'get'.
+
+If an Exception-Type is not given it will catch all Exceptions.
+ 
+=== Grammar ===
+try EXPR catch [ EXCEPTION-TYPE ] get EXPR 
+
+{{{
+#!cobra
+inVal = '..' #an int string presumably
+x = try int.parse(inVal) catch FormatException get 0 #  return 0 if inVal not an int String
+
+# Catch all exceptions
+dflt = '---'
+s1 = try String.format('{1:P}', 0.123) catch get dflt
+assert s1 == '---'
+}}}
 
 == Nil ==
 
-to-do (nil, to ?, to !, coalesce ? and ?=, ! and !=)
+Operations and literals around nil/null values.[[BR]]
+'''nil''' is the nil/null literal
+
+EXPR to ?
+  - cast the type of EXPR to the nilable form of the same type (EXPR.typeOf?, nilable EXPR.typeof)
+
+EXPR to ! 
+  - cast the type of EXPR to the the non-nilable form of same type( EXPR.typeOf!) 
+
+EXPR ? EXPR1
+   - nil coalesce - if EXPR is nil return EXPR1
+
+EXPR ! EXPR
+   - non-nil coalesce - if EXPR is non nil return EXPR1
+
+EXPR1 ?= EXPR1
+    - nil coalesce EXPR1 to itself or EXPR2
+    - same as EXPR1 = EXPR1 ? EXPR2
+
+EXPR1 != EXPR1
+    - non-nil coalesce EXPR1 to itself or EXPR2
+    - same as EXPR = EXPR1 ! EXPR2
+
+     - Note: gotcha Warning
+     b != a   This is NOT 'b not equals (<>) a' -  is same as b = b ! a  OR  b = if( b <> nil, a, nil)
+
+{{{
+#!cobra
+
+if a is nil, print 'Bad a'
+
+y = a ? b    # coalesce nil : y gets a if a non nil, b otherwise
+#same as y = if(a, a, b) except a evaluated only once
+
+a = a ? default    # a if a nonnil, default otherwise
+# above is same as 
+a ?= default
+
+
+y = b ! a    # coalesce non nil : y gets b if b is nil, a otherwise  
+# same as y = if(b <> nil, a, nil)  OR y = if(not b, a, nil)
+
+i as int? = input ! int.parse(input)  
+#( equiv to i = if(input <> nil ? int.parse(input),  nil)
+}}}
+
 
 == Method References ==