Changeset 1769

Timestamp:

11/16/08 21:02:05 (4 years ago)

Author:

Chuck.Esterbrook

Message:

Regarding "truthfulness" such as found in assert, if and if(...), primitive nilable types such as bool? and int? now have their value examined. Previously, simply being non-nil was enough to be true, but that was not intuitive nor consistent with dynamic?.
ticket:5

Location:

cobra/trunk

Files:

• Developer/IntermediateReleaseNotes.text (modified) (1 diff)
• Source/CobraLang.cs (modified) (3 diffs)
• Source/Expr.cobra (modified) (1 diff)
• Tests/240-generics/200-nilables/102-nilable-int.cobra (modified) (2 diffs)
• Tests/240-generics/200-nilables/940-truth-expr.cobra (added)

cobra/trunk/Developer/IntermediateReleaseNotes.text

@@ -128 +128 @@
 * The default type for vars, properties and method arguments is now `dynamic?`. Also the result type for `d.foo` where `d` is dynamic is now `dynamic?` instead of `dynamic`. These changes reflect the flexibility that was originally intended with default types and dynamic typing.
 
+* Regarding "truthfulness" such as found in `assert`, `if` and `if(...)`, primitive nilable types such as `bool?` and `int?` now have their value examined. Previously, simply being non-nil was enough to be true, but that was not intuitive nor consistent with `dynamic?`. ticket:5
+
 * Added new `all` and `any` unary operators that take something enumerable (such as a list, set or generator) and return a boolean (true or false) indicating if all or any of the elements are true. These operators increase expressiveness in conditions. For example, a contract might use these operators:
 .code

cobra/trunk/Source/CobraLang.cs

@@ -622 +622 @@
     }
 
+    static public bool IsTrue(char? c) {
+        return c!=null && c.Value!='\0';
+    }
+
     static public bool IsTrue(int i) {
         return i!=0;
     }
 
+    static public bool IsTrue(int? i) {
+        return i!=null && i.Value!=0;
+    }
+
     static public bool IsTrue(decimal d) {
         return d!=0;
     }
 
+    static public bool IsTrue(decimal? d) {
+        return d!=null && d.Value!=0;
+    }
+
     static public bool IsTrue(float f) {
         return f!=0;
     }
 
+    static public bool IsTrue(float? f) {
+        return f!=null && f.Value!=0;
+    }
+
     static public bool IsTrue(double d) {
         return d!=0;
+    }
+
+    static public bool IsTrue(double? d) {
+        return d!=null && d.Value!=0;
     }
 
@@ -647 +667 @@
         return c!=null;
     }
+
+/*
+    static public bool IsTrue<T>(Nullable<T> x) where T : struct {
+        if (x == null)
+            return false;
+        else
+            return IsTrue(x.Value);  // would be nice if this respected overloads, but it doesn't. always calls IsTrue(object) which makes this method moot
+    }
+*/
 
     static public bool IsTrue(object x) {
@@ -659 +688 @@
         if (x is decimal)
             return (decimal)x!=0;  // can't believe x.Equals(0) above doesn't work for decimal. *sigh*
+        if (x is double)
+            return (double)x!=0;
+        if (x is float)
+            return (float)x!=0;
         return true;
     }

cobra/trunk/Source/Expr.cobra

@@ -1933 +1933 @@
             _expr.bindImp
         else if type inherits NilableType
-            if type.nonNil inherits DynamicType
+            if type.nonNil inherits DynamicType or type.nonNil inherits PrimitiveType
                 _treatment = Treatment.InvokeRuntime
             else

cobra/trunk/Tests/240-generics/200-nilables/102-nilable-int.cobra

@@ -1 @@
-# can assign int to int?
 class Test
 
     shared
         def main
+            # can assign int to int?
             i as int?
             j as int
@@ -9 +9 @@
             i = j
             assert i==0
+
+