Changeset 1564

Timestamp:

07/31/08 05:41:13 (4 months ago)

Author:

Chuck.Esterbrook

Message:

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.

Location:

cobra/trunk

Files:

• Developer/IntermediateReleaseNotes.text (modified) (1 diff)
• Source/CobraLang.cs (modified) (1 diff)
• Source/CobraParser.cobra (modified) (2 diffs)
• Source/Expr.cobra (modified) (1 diff)
• Tests/110-basics-two/604-all-any-ops.cobra (added)
• Tests/500-dynamic/104-dynamic-ops.cobra (modified) (1 diff)

cobra/trunk/Developer/IntermediateReleaseNotes.text

@@ -7 +7 @@
 * Add support for specifying unsigned integers as Hex literals
     e.g. 0x7f  0x7f_8   0x7Fu16  0x7F_u32
+
+* 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
+        def foo(items as IList<of Item>)
+                require all for item in items get item.name.trim.length > 0
 
 * Added generic methods.

cobra/trunk/Source/CobraLang.cs

@@ -521 +521 @@
         }
 
+        static public bool All<T>(IEnumerable<T> items) {
+                foreach (T item in items)
+                        if (!IsTrue(item))
+                                return false;
+                return true;
+        }
+
+        static public bool All(IEnumerable items) {
+                foreach (object item in items)
+                        if (!IsTrue(item))
+                                return false;
+                return true;
+        }
+
+        static public bool Any<T>(IEnumerable<T> items) {
+                foreach (T item in items)
+                        if (IsTrue(item))
+                                return true;
+                return false;
+        }
+
+        static public bool Any(IEnumerable items) {
+                foreach (object item in items)
+                        if (IsTrue(item))
+                                return true;
+                return false;
+        }
+ 
         static public bool In(string a, string b) {
                 return b.Contains(a);

cobra/trunk/Source/CobraParser.cobra

@@ -2380 +2380 @@
                         'TILDE': _binaryOpPrec['PLUS']+1,
                         'NOT':   _binaryOpPrec['AND']+1,
+                        'ALL':   _binaryOpPrec['AND']+1,  # have to admit I'm just guessing at the precendence level for 'any' and 'all'. experience will tell. TODO: fix or not, then retire this comment (2008-07-31)
+                        'ANY':   _binaryOpPrec['AND']+1,
                         'REF':   _binaryOpPrec['STARSTAR']+1,
                         'OLD':   _binaryOpPrec['STARSTAR']+1,
@@ -2479 +2481 @@
                         token = .grab
                         prec = _unaryOpPrec[peek]
+                        unaryExpr = .expression(prec)
                         branch token.which
-                                on 'OLD'
-                                        return OldExpr(token, .expression(prec))
-                                on 'REF'
-                                        refTo = .expression(prec)
-                                        return RefExpr(token, refTo)
-                                else
-                                        return UnaryOpExpr(token, peek, .expression(prec))
+                                on 'ALL', return AllExpr(token, unaryExpr)
+                                on 'ANY', return AnyExpr(token, unaryExpr)
+                                on 'OLD', return OldExpr(token, unaryExpr)
+                                on 'REF', return RefExpr(token, unaryExpr)
+                                else, return UnaryOpExpr(token, peek, unaryExpr)
                 # TODO: make a branch statement
                 else if peek=='LPAREN'

cobra/trunk/Source/Expr.cobra

@@ -2378 +2378 @@
 
 
+class AllOrAnyExpr
+        is abstract
+        inherits Expr
+        """
+        The base class for AllExpr and AnyExpr which have much in common.
+        
+        They are unary prefix operators taking something enumerable and returning a bool.
+        """
+
+        var _expr as Expr
+
+        def init(token as IToken, expr as Expr)
+                base.init(token)
+                _expr = expr
+
+        get opName as String is abstract
+
+        get expr from var
+
+        get hasError as bool
+                if base.hasError, return true
+                if .expr.hasError, return true
+                return false
+
+        get willChangeVar as bool is override
+                if base.willChangeVar, return true
+                if .expr.willChangeVar, return true
+                return false
+
+        def addSubFields is override
+                base.addSubFields
+                .addField('expr', _expr)
+
+        def toCobraSource as String is override
+                return '[.opName] [.expr.toCobraSource]'
+
+        def _bindImp
+                base._bindImp
+                _type = .compiler.boolType
+                _expr.bindImp
+                enumerable = .compiler.libraryBox('System.Collections.IEnumerable')
+                if _expr.type.isDescendantOf(enumerable)
+                        pass
+                else if _expr.type.isDynamic
+                        _expr.contextType = enumerable
+                else
+                        .throwError('Expecting an enumerable expression after "[.opName]", but got an expression of type "[.expr.type.name]".')
+
+        def writeSharpDef(sw as SharpWriter, parens as bool) is override
+                sw.write('CobraImp.[Utils.capped(.opName)](')
+                .expr.writeSharpDefInContext(sw)
+                sw.write(')')
+
+        def writeSharpBreakdownItems(sw as SharpWriter)
+                base.writeSharpBreakdownItems(sw)
+                sw.write(', +1')
+                .expr.writeSharpBreakdownItems(sw)
+                sw.write(', -1')
+
+
+class AllExpr
+        inherits AllOrAnyExpr
+        """
+        all <enumerable> --> true if all elements are true
+        """
+        
+        def init(token as IToken, expr as Expr)
+                base.init(token, expr)
+
+        get opName as String is override
+                return 'all'
+        
+
+class AnyExpr
+        inherits AllOrAnyExpr
+        """
+        any <enumerable> --> true if any element is true
+        """
+        
+        def init(token as IToken, expr as Expr)
+                base.init(token, expr)
+
+        get opName as String is override
+                return 'any'
+
+
 class UnaryOpExpr
         inherits Expr

cobra/trunk/Tests/500-dynamic/104-dynamic-ops.cobra

@@ -175 +175 @@
                 xq = 'aoeu'
                 assert not not xq
+
+                t as dynamic = [1, 2, 3]
+                assert all t
+                assert any t
+                t.add(0)
+                assert not all t
+                assert any t
+                t = [0]
+                assert not all t
+                assert not any t
+                t.clear
+                assert all t
+                assert not any t