sysml-validate 0.10.18 → 0.14.2

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/BaseFunctions.kerml

@@ -1,80 +1,80 @@
-standard library package BaseFunctions {
-	doc
-	/*
-	 * This package defines a basic set of functions defined on all kinds of values. 
-	 * Most correspond to similarly named operators in the KerML expression syntax.
-	 */
-
-	private import Base::Anything;
-	private import Objects::Object;
-	private import Metaobjects::Metaobject;
-	private import KerML::Metaclass;
-	private import ScalarValues::*;
-	
-	abstract function '=='{ in x: Anything[0..1]; in y: Anything[0..1]; 
-		return : Boolean[1];
-	}
-	function '!='{ in x: Anything[0..1]; in y: Anything[0..1]; 
-		return : Boolean[1] = not (x == y);
-	}
-	
-	abstract function '==='{ in x: Anything[0..1]; in y: Anything[0..1]; 
-		return : Boolean[1];
-	}
-	function '!=='{ in x: Anything[0..1]; in y: Anything[0..1]; 
-		return : Boolean[1] = not (x === y);
-	}
-	
-	abstract function ToString{ in x: Anything[0..1]; 
-		return : String;
-	}
-	
-	abstract function '['{ in x: Anything[0..*] nonunique; in y: Anything[0..*] nonunique; 
-		return : Anything[0..*] nonunique;
-	}
-	abstract function '#'{ in seq: Anything[0..*] ordered nonunique; in index: Positive[1..*] ordered nonunique; 
-		return : Anything[0..1];
-	}
-	abstract function ','{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique; 
-		return : Anything[0..*] ordered nonunique;
-	}
-	
-    abstract function 'all'{
-     	return : Object[0..*];
-    }
-    
-	abstract function 'istype'{ 
-		in seq: Anything[0..*];
-		in 'type': Anything;
-		return : Boolean[1];
-	}
-	
-	abstract function 'hastype'{ 
-		in seq: Anything[0..*];
-		in 'type': Anything;
-		return : Boolean;
-	}
-	
-	abstract function '@'{ 
-		in seq: Anything[0..*];
-		in 'type': Anything;
-		return : Boolean[1];
-	}
-	
-	abstract function '@@'{ 
-		in seq: Metaobject[0..*];
-		in 'type': Metaobject;
-		return : Boolean[1];
-	}
-	
-	abstract function 'as'{ 
-		in seq: Anything[0..*] ordered nonunique; 
-		return : Anything[0..*] ordered nonunique;
-	}
-	
-	abstract function 'meta'{ 
-		in seq: Metaobject[0..*] ordered nonunique; 
-		return : Metaobject[0..*] ordered nonunique;
-	}
-	
+standard library package BaseFunctions {
+	doc
+	/*
+	 * This package defines a basic set of functions defined on all kinds of values. 
+	 * Most correspond to similarly named operators in the KerML expression syntax.
+	 */
+
+	private import Base::Anything;
+	private import Objects::Object;
+	private import Metaobjects::Metaobject;
+	private import KerML::Metaclass;
+	private import ScalarValues::*;
+	
+	abstract function '=='{ in x: Anything[0..1]; in y: Anything[0..1]; 
+		return : Boolean[1];
+	}
+	function '!='{ in x: Anything[0..1]; in y: Anything[0..1]; 
+		return : Boolean[1] = not (x == y);
+	}
+	
+	abstract function '==='{ in x: Anything[0..1]; in y: Anything[0..1]; 
+		return : Boolean[1];
+	}
+	function '!=='{ in x: Anything[0..1]; in y: Anything[0..1]; 
+		return : Boolean[1] = not (x === y);
+	}
+	
+	abstract function ToString{ in x: Anything[0..1]; 
+		return : String;
+	}
+	
+	abstract function '['{ in x: Anything[0..*] nonunique; in y: Anything[0..*] nonunique; 
+		return : Anything[0..*] nonunique;
+	}
+	abstract function '#'{ in seq: Anything[0..*] ordered nonunique; in index: Positive[1..*] ordered nonunique; 
+		return : Anything[0..1];
+	}
+	abstract function ','{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique; 
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+    abstract function 'all'{
+     	return : Object[0..*];
+    }
+    
+	abstract function 'istype'{ 
+		in seq: Anything[0..*];
+		in 'type': Anything;
+		return : Boolean[1];
+	}
+	
+	abstract function 'hastype'{ 
+		in seq: Anything[0..*];
+		in 'type': Anything;
+		return : Boolean;
+	}
+	
+	abstract function '@'{ 
+		in seq: Anything[0..*];
+		in 'type': Anything;
+		return : Boolean[1];
+	}
+	
+	abstract function '@@'{ 
+		in seq: Metaobject[0..*];
+		in 'type': Metaobject;
+		return : Boolean[1];
+	}
+	
+	abstract function 'as'{ 
+		in seq: Anything[0..*] ordered nonunique; 
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function 'meta'{ 
+		in seq: Metaobject[0..*] ordered nonunique; 
+		return : Metaobject[0..*] ordered nonunique;
+	}
+	
 }

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/BooleanFunctions.kerml

@@ -1,22 +1,22 @@
-standard library package BooleanFunctions {
-	doc
-	/*
-	 * This package defines functions on Boolean values, including those corresponding to 
-	 * (non-conditional) logical operators in the KerML expression notation.
-	 */
-
-	public import ScalarValues::*;
-	
-	function 'not' specializes ScalarFunctions::'not' { in x: Boolean[1]; return : Boolean[1]; }
-	function 'xor' specializes ScalarFunctions::'xor' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
-	
-	function '|' specializes ScalarFunctions::'|' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
-	function '&' specializes ScalarFunctions::'&' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
-	
-	function '==' specializes DataFunctions::'==' { in x: Boolean[0..1]; in y: Boolean[0..1]; return : Boolean[1]; }
-	
-	function ToString specializes BaseFunctions::ToString { in x: Boolean[1]; return : String[1]; }
-	function ToBoolean { in x: String[1]; return : Boolean[1]; }
-	
-}
-	
+standard library package BooleanFunctions {
+	doc
+	/*
+	 * This package defines functions on Boolean values, including those corresponding to 
+	 * (non-conditional) logical operators in the KerML expression notation.
+	 */
+
+	public import ScalarValues::*;
+	
+	function 'not' specializes ScalarFunctions::'not' { in x: Boolean[1]; return : Boolean[1]; }
+	function 'xor' specializes ScalarFunctions::'xor' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
+	
+	function '|' specializes ScalarFunctions::'|' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
+	function '&' specializes ScalarFunctions::'&' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
+	
+	function '==' specializes DataFunctions::'==' { in x: Boolean[0..1]; in y: Boolean[0..1]; return : Boolean[1]; }
+	
+	function ToString specializes BaseFunctions::ToString { in x: Boolean[1]; return : String[1]; }
+	function ToBoolean { in x: String[1]; return : Boolean[1]; }
+	
+}
+	

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/CollectionFunctions.kerml

@@ -1,68 +1,68 @@
-standard library package CollectionFunctions {
-	doc
-	/*
-	 * This package defines functions on Collections (as defined in the Collections package). 
-	 * For functions on general sequences of values, see the SequenceFunctions package.
-	 */
-
-	private import Base::Anything;
-	private import ScalarValues::*;
-	private import SequenceFunctions::equals;
-	private import SequenceFunctions::includes;
-	private import ControlFunctions::exists;
-	public import Collections::*;
-	
-	function '==' specializes BaseFunctions::'==' { in col1: Collection[0..1]; in col2: Collection[0..1];
-		return : Boolean[1] = col1.elements->equals(col2.elements);
-	}
-	
-	function size { in col: Collection[1];
-		return : Natural[1] = SequenceFunctions::size(col.elements);
-	}
-	
-	function isEmpty { in col: Collection[1]; 
-		return : Boolean[1] = SequenceFunctions::isEmpty(col.elements);
-	}
-	
-	function notEmpty { in col: Collection[1]; 
-		return : Boolean[1] = SequenceFunctions::notEmpty(col.elements);
-	}
-	
-	function contains { in col: Collection[1]; in values: Anything[*];
-		return : Boolean[1] = col.elements->includes(values);
-	}
-	
-	function containsAll { in col1: Collection[1]; in col2: Collection[2]; 
-		return : Boolean[1] = contains(col1, col2.elements);
-	}	
-	
-	function head { in col: OrderedCollection[1]; 
-		return : Anything[0..1] = SequenceFunctions::head(col.elements);
-	}
-	
-	function tail { in col: OrderedCollection[1]; 
-		return : Anything[0..*] ordered nonunique = SequenceFunctions::tail(col.elements);	
-	}
-	
-	function last { in col: OrderedCollection[1]; 
-		return : Anything[0..1] = SequenceFunctions::last(col.elements);
-	}
-	
-	function '#' specializes BaseFunctions::'#' { in col: OrderedCollection[1]; in index: Positive[1];
-		// Cast ensures this function is not called recursively if the elements of col are OrderedCollections.
-		return : Anything[0..1] = (col.elements as Anything)#(index);		
-	}
-	
-	function 'array#' specializes BaseFunctions::'#' { in arr: Array[1]; in indexes: Positive[n] ordered nonunique;		
-		private feature n : Natural[1] = arr.rank;
-		
-		// Assumes row-major ordering for elements.
-		private function index { in arr: Array[1]; in i : Natural; in indexes : Positive[1..*];
-			if i <= 1? indexes#(1) else arr.dimensions#(i) * (index(arr, i-1, indexes) - 1) + indexes#(i)
-		}
-		
-		return : Anything[0..1] =
-			if n == 0 or (1..n)->exists {in i; indexes#(i) > arr.dimensions#(i)}? null 
-			else arr.elements#(index(arr, n, indexes));
-	}	
-}
+standard library package CollectionFunctions {
+	doc
+	/*
+	 * This package defines functions on Collections (as defined in the Collections package). 
+	 * For functions on general sequences of values, see the SequenceFunctions package.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::*;
+	private import SequenceFunctions::equals;
+	private import SequenceFunctions::includes;
+	private import ControlFunctions::exists;
+	public import Collections::*;
+	
+	function '==' specializes BaseFunctions::'==' { in col1: Collection[0..1]; in col2: Collection[0..1];
+		return : Boolean[1] = col1.elements->equals(col2.elements);
+	}
+	
+	function size { in col: Collection[1];
+		return : Natural[1] = SequenceFunctions::size(col.elements);
+	}
+	
+	function isEmpty { in col: Collection[1]; 
+		return : Boolean[1] = SequenceFunctions::isEmpty(col.elements);
+	}
+	
+	function notEmpty { in col: Collection[1]; 
+		return : Boolean[1] = SequenceFunctions::notEmpty(col.elements);
+	}
+	
+	function contains { in col: Collection[1]; in values: Anything[*];
+		return : Boolean[1] = col.elements->includes(values);
+	}
+	
+	function containsAll { in col1: Collection[1]; in col2: Collection[2]; 
+		return : Boolean[1] = contains(col1, col2.elements);
+	}	
+	
+	function head { in col: OrderedCollection[1]; 
+		return : Anything[0..1] = SequenceFunctions::head(col.elements);
+	}
+	
+	function tail { in col: OrderedCollection[1]; 
+		return : Anything[0..*] ordered nonunique = SequenceFunctions::tail(col.elements);	
+	}
+	
+	function last { in col: OrderedCollection[1]; 
+		return : Anything[0..1] = SequenceFunctions::last(col.elements);
+	}
+	
+	function '#' specializes BaseFunctions::'#' { in col: OrderedCollection[1]; in index: Positive[1];
+		// Cast ensures this function is not called recursively if the elements of col are OrderedCollections.
+		return : Anything[0..1] = (col.elements as Anything)#(index);		
+	}
+	
+	function 'array#' specializes BaseFunctions::'#' { in arr: Array[1]; in indexes: Positive[n] ordered nonunique;		
+		private feature n : Natural[1] = arr.rank;
+		
+		// Assumes row-major ordering for elements.
+		private function index { in arr: Array[1]; in i : Natural; in indexes : Positive[1..*];
+			if i <= 1? indexes#(1) else arr.dimensions#(i) * (index(arr, i-1, indexes) - 1) + indexes#(i)
+		}
+		
+		return : Anything[0..1] =
+			if n == 0 or (1..n)->exists {in i; indexes#(i) > arr.dimensions#(i)}? null 
+			else arr.elements#(index(arr, n, indexes));
+	}	
+}

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/ComplexFunctions.kerml

@@ -1,47 +1,47 @@
-standard library package ComplexFunctions {
-	doc
-	/*
-	 * This package defines functions on Complex values, including concrete specializations of the 
-	 * general arithmetic and comparison operations.
-	 */
-
-	public import ScalarValues::*;
-		
-	feature i: Complex[1] = rect(0.0, 1.0);
-	
-	function rect { in re: Real[1]; in im: Real[1]; return : Complex[1]; }
-	function polar { in abs: Real[1]; in arg: Real[1]; return : Complex[1]; }
-	
-	function re { in x: Complex[1]; return : Real[1]; }
-	function im { in x: Complex[1]; return : Real[1]; }
-	
-	function isZero specializes NumericalFunctions::isZero { in x : Complex[1];
-		return : Boolean[1] = re(x) == 0.0 and im(x) == 0.0;
-	}
-	function isUnit specializes NumericalFunctions::isUnit { in x : Complex[1];
-		return : Boolean[1] = re(x) == 1.0 and im(x) == 0.0;
-	}
-	
-	function abs specializes NumericalFunctions::abs { in x: Complex[1]; return : Real[1]; }
-	function arg { in x: Complex[1]; return : Real[1]; }
-	
-	function '+' specializes NumericalFunctions::'+' { in x: Complex[1]; in y: Complex[0..1]; return : Complex[1]; }
-	function '-' specializes NumericalFunctions::'-' { in x: Complex[1]; in y: Complex[0..1]; return : Complex[1]; }
-	function '*' specializes NumericalFunctions::'*' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
-	function '/' specializes NumericalFunctions::'/' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
-	function '**' specializes NumericalFunctions::'**' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
-	function '^' specializes NumericalFunctions::'^' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
-	
-	function '==' specializes DataFunctions::'==' { in x: Complex[0..1]; in y: Complex[0..1]; return : Boolean[1]; }
-	
-	function ToString specializes BaseFunctions::ToString { in x: Complex[1]; return : String[1]; }
-	function ToComplex { in x: String[1]; return : Complex[1]; }
-	
-	function sum specializes NumericalFunctions::sum { in collection: Complex[0..*];
-		return : Complex[1] default NumericalFunctions::sum0(collection, rect(0.0, 0.0));
-	}
-	
-	function product specializes NumericalFunctions::product { in collection: Complex[0..*];
-		return : Complex[1] default NumericalFunctions::product1(collection, rect(1.0, 0.0));
-	}	
-}
+standard library package ComplexFunctions {
+	doc
+	/*
+	 * This package defines functions on Complex values, including concrete specializations of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+		
+	feature i: Complex[1] = rect(0.0, 1.0);
+	
+	function rect { in re: Real[1]; in im: Real[1]; return : Complex[1]; }
+	function polar { in abs: Real[1]; in arg: Real[1]; return : Complex[1]; }
+	
+	function re { in x: Complex[1]; return : Real[1]; }
+	function im { in x: Complex[1]; return : Real[1]; }
+	
+	function isZero specializes NumericalFunctions::isZero { in x : Complex[1];
+		return : Boolean[1] = re(x) == 0.0 and im(x) == 0.0;
+	}
+	function isUnit specializes NumericalFunctions::isUnit { in x : Complex[1];
+		return : Boolean[1] = re(x) == 1.0 and im(x) == 0.0;
+	}
+	
+	function abs specializes NumericalFunctions::abs { in x: Complex[1]; return : Real[1]; }
+	function arg { in x: Complex[1]; return : Real[1]; }
+	
+	function '+' specializes NumericalFunctions::'+' { in x: Complex[1]; in y: Complex[0..1]; return : Complex[1]; }
+	function '-' specializes NumericalFunctions::'-' { in x: Complex[1]; in y: Complex[0..1]; return : Complex[1]; }
+	function '*' specializes NumericalFunctions::'*' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
+	function '/' specializes NumericalFunctions::'/' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
+	function '**' specializes NumericalFunctions::'**' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
+	function '^' specializes NumericalFunctions::'^' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
+	
+	function '==' specializes DataFunctions::'==' { in x: Complex[0..1]; in y: Complex[0..1]; return : Boolean[1]; }
+	
+	function ToString specializes BaseFunctions::ToString { in x: Complex[1]; return : String[1]; }
+	function ToComplex { in x: String[1]; return : Complex[1]; }
+	
+	function sum specializes NumericalFunctions::sum { in collection: Complex[0..*];
+		return : Complex[1] default NumericalFunctions::sum0(collection, rect(0.0, 0.0));
+	}
+	
+	function product specializes NumericalFunctions::product { in collection: Complex[0..*];
+		return : Complex[1] default NumericalFunctions::product1(collection, rect(1.0, 0.0));
+	}	
+}

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/ControlFunctions.kerml

@@ -1,117 +1,117 @@
-standard library package ControlFunctions {
-	doc
-	/*
-	 * This package defines functions that correspond to operators in the KerML expression notation 
-	 * for which one or more operands are expressions whose evaluation is determined by another operand.
-	 */
-
-	private import Base::Anything;
-	private import ScalarValues::ScalarValue;
-	private import ScalarValues::Boolean;
-	private import ScalarFunctions::min;
-	private import ScalarFunctions::max;
-	
-	abstract function '.' {
-		in feature source : Anything[0..*] nonunique {
-	  		abstract feature target : Anything[0..*] nonunique;
-	  	}	  	
-	  	private feature chain chains source.target;
-	    chain
-	}
-	
-	abstract function 'if' { 
-		in test: Boolean[1];
-		in expr thenValue[0..1] { return : Anything[0..*] ordered nonunique; }
-		in expr elseValue[0..1] { return : Anything[0..*] ordered nonunique; }
-		return : Anything[0..*] ordered nonunique;
-	}
-	
-	abstract function '??' {
-		in firstValue: Anything[0..*] ordered nonunique;
-		in expr secondValue[0..1] { return : Anything[0..*] ordered nonunique; }
-		return : Anything[0..*] ordered nonunique;
-	}
-	
-	function 'and' {
-		in firstValue: Boolean[1];
-		in expr secondValue[0..1] { return : Boolean[1]; }
-		return : Boolean[1];
-	}
-	
-	function 'or'{
-		in firstValue: Boolean[1];
-		in expr secondValue[0..1] { return : Boolean[1]; }
-		return : Boolean[1];
-	}
-	
-	function 'implies'{
-		in firstValue: Boolean[1];
-		in expr secondValue[0..1] { return : Boolean[1]; }
-		return : Boolean[1];
-	}
-	
-	abstract function collect { 
-		in collection: Anything[0..*] ordered nonunique;
-		in expr mapper[0..*] { in argument: Anything[1]; return : Anything[0..*] ordered nonunique; }
-		return : Anything[0..*] ordered nonunique;
-	}
-	
-	abstract function select { 
-		in collection: Anything[0..*] ordered nonunique; 
-		in expr selector[0..*] { in argument: Anything[1]; return : Boolean[1]; }
-		return : Anything[0..*] ordered nonunique;
-	}
-	
-	function selectOne { 
-		in collection: Anything[0..*] ordered nonunique;
-		in expr selector1[0..*] { in argument: Anything[1]; return : Boolean[1]; }
-		return : Anything[0..1] = collection->select {in x; selector1(x)}#(1);
-	}
-	
-	abstract function reject{ 
-		in collection: Anything[0..*] ordered nonunique; 
-		in expr rejector[0..*] { in argument: Anything[1]; return : Boolean[1]; }
-		return : Anything[0..*] ordered nonunique;
-	}
-	
-	abstract function reduce { 
-		in collection: Anything[0..*] ordered nonunique; 
-		in expr reducer[0..*] { in firstArg: Anything[1]; in secondArg: Anything[1]; return : Anything[1]; }
-		return : Anything[0..*] ordered nonunique;
-	}
-	
-	abstract function forAll { 
-		in collection: Anything[0..*] ordered nonunique; 
-		in expr test[0..*] { in argument: Anything[1]; return : Boolean[1]; }
-		return : Boolean[1];
-	}
-	
-	abstract function exists { 
-		in collection: Anything[0..*] ordered nonunique;
-		in expr test[0..*] { in argument: Anything[1]; return : Boolean[1]; }
-		return : Boolean[1];
-	}
-	
-	function allTrue {
-		in collection: Boolean[0..*]; 
-		return : Boolean[1] = collection->forAll {in x; x};
-	}
-	
-	function anyTrue {
-		in collection: Boolean[0..*];
-		return : Boolean[1] = collection->exists {in x; x};
-	}
-	
-	function minimize {
-		in collection: ScalarValue[1..*];
-		in expr fn[0..*] { in argument: ScalarValue[1]; return : ScalarValue[1]; }
-		return : ScalarValue[1] = collection->collect {in x; fn(x)}->reduce min;
-	}
-	
-	function maximize { 
-		in collection: ScalarValue[1..*];
-		in expr fn[0..*] { in argument: ScalarValue[1]; return : ScalarValue[1]; }
-		return : ScalarValue = collection->collect {in x; fn(x)}->reduce max;
-	}
-	
+standard library package ControlFunctions {
+	doc
+	/*
+	 * This package defines functions that correspond to operators in the KerML expression notation 
+	 * for which one or more operands are expressions whose evaluation is determined by another operand.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::ScalarValue;
+	private import ScalarValues::Boolean;
+	private import ScalarFunctions::min;
+	private import ScalarFunctions::max;
+	
+	abstract function '.' {
+		in feature source : Anything[0..*] nonunique {
+	  		abstract feature target : Anything[0..*] nonunique;
+	  	}	  	
+	  	private feature chain chains source.target;
+	    chain
+	}
+	
+	abstract function 'if' { 
+		in test: Boolean[1];
+		in expr thenValue[0..1] { return : Anything[0..*] ordered nonunique; }
+		in expr elseValue[0..1] { return : Anything[0..*] ordered nonunique; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function '??' {
+		in firstValue: Anything[0..*] ordered nonunique;
+		in expr secondValue[0..1] { return : Anything[0..*] ordered nonunique; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	function 'and' {
+		in firstValue: Boolean[1];
+		in expr secondValue[0..1] { return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	function 'or'{
+		in firstValue: Boolean[1];
+		in expr secondValue[0..1] { return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	function 'implies'{
+		in firstValue: Boolean[1];
+		in expr secondValue[0..1] { return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	abstract function collect { 
+		in collection: Anything[0..*] ordered nonunique;
+		in expr mapper[0..*] { in argument: Anything[1]; return : Anything[0..*] ordered nonunique; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function select { 
+		in collection: Anything[0..*] ordered nonunique; 
+		in expr selector[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	function selectOne { 
+		in collection: Anything[0..*] ordered nonunique;
+		in expr selector1[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Anything[0..1] = collection->select {in x; selector1(x)}#(1);
+	}
+	
+	abstract function reject{ 
+		in collection: Anything[0..*] ordered nonunique; 
+		in expr rejector[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function reduce { 
+		in collection: Anything[0..*] ordered nonunique; 
+		in expr reducer[0..*] { in firstArg: Anything[1]; in secondArg: Anything[1]; return : Anything[1]; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function forAll { 
+		in collection: Anything[0..*] ordered nonunique; 
+		in expr test[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	abstract function exists { 
+		in collection: Anything[0..*] ordered nonunique;
+		in expr test[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	function allTrue {
+		in collection: Boolean[0..*]; 
+		return : Boolean[1] = collection->forAll {in x; x};
+	}
+	
+	function anyTrue {
+		in collection: Boolean[0..*];
+		return : Boolean[1] = collection->exists {in x; x};
+	}
+	
+	function minimize {
+		in collection: ScalarValue[1..*];
+		in expr fn[0..*] { in argument: ScalarValue[1]; return : ScalarValue[1]; }
+		return : ScalarValue[1] = collection->collect {in x; fn(x)}->reduce min;
+	}
+	
+	function maximize { 
+		in collection: ScalarValue[1..*];
+		in expr fn[0..*] { in argument: ScalarValue[1]; return : ScalarValue[1]; }
+		return : ScalarValue = collection->collect {in x; fn(x)}->reduce max;
+	}
+	
 }