Changeset 1769

Timestamp:

11/16/08 16:02:05 (7 weeks 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
+
+