GELLO: A Common Expression Language

Context [alias: ]Class 
GELLO expressions with a reference to either alias or class name
						

Context Patient
…  GELLO expressions with Patient
						

Context p: Patient
p.age> 50
						

Context Patient
Self. ID = "123abc"
						

ProblemList → exists(Code.equals(Factory.CodedValue("Asthma")))
within the previously defined patient context, this expression is equivalent to:
					
ProblemList → exists(Code.equals(Factory.CodedValue("Asthma")) and PatientID="123abc")
						

Package packageName ::
   Context contextName :
      GELLOexpressions
EndPackage

packageName :: [packageNamei ::]* TypeName
						

context Object :
   self.associatedObject
						

context Patient:
   self.Medications
					   

context Patient:
   self.Medications["aspirin"]
						

let  variableName: type = Factory.class("argument list")
						

let aQuantity: PhysicalQuantity = Factory.PhysicalQuantity("76 kg")
						
Where "76 kg" is the literal form of an instance of PhysicalQuantity, 
with 76 being the value and "kg" being the code for kilogram 
in the Unified Code for Units of Measure (UCUM).
						

	
F+(V1,V2)= V1 + V2     If V1 and V2 are both integers or reals
         = undefined   otherwise 

Types for "+":
• (integer x integer) → integer
• (integer x real) → real
• (real x integer) → real
• (real x real) → real
						

		
F/ (V1,V2)= V1 / V2     If V1 and V2 are either integers or reals, and V2 <> 0
          = undefined   otherwise 

Types for "/":
• (integer x integer) → real
• (integer x real) → real
• (real x integer) → real
• (real x real) → real

Fdiv(V1,V2)= V1 div V2     If V1 and V2 are both integers and V2 <> 0
           = undefined     otherwise 

Type "div" and "mod":
• (integer x integer) → integer	
					

					
F-(V1)= -V1         If V1 is either an integer or a real 
      = undefined   otherwise 

Types for unary minus "-":
• (integer) → integer
• (real) → real
					

					
Types for "=", ">", "<", ">=", "<=", "><":
• (real x real)→ truth_value   
• (real x integer)→ truth_value   
• (integer x real)→  truth_value   
• (integer x integer)→ truth_value
• (string x string)→ truth_value       Only valid for "=" and <> 
• (boolean x boolean)→ truth_value     Only valid for "=" and <>  
					

F>(V1,V2)= true        If V1 and V2  are both either integers or reals and V1 > V2 
         = false       Else if V1 and V2 are both either integers or reals and V1 ≤ V2
         = undefined   otherwise 
					

F=(V1,V2)= true         If V1 and V2  are both strings or Booleans  and V1 = V2 
         = false        Else if V1 and V2  are both strings or Booleans  and V1 <> V2
         = undefined    otherwise 
					

Fabs(V1)= V1          If V1 is  a positive integer or real number
	= -V1         Else if V1 is a negative integer or real number
        = undefined   otherwise 

Type "abs"
• (integer) → integer	
• (real) → real	

Facos(V1)= acos(V1)    If V1 is  an  integer or real number and abs(V1) ≤ 1
         = undefined   otherwise 

Type "acos"
• (integer) → real	
• (real) → real	

Fasin(V1)= asin(V1)    If V1 is  an  integer or real number and abs(V1) ≤ 1
         = 0           Else if V1 = 0
         = undefined   otherwise 

Type "asin"
• (integer) → real	
• (real) → real	

Fatan(V1)= atan(V1)    If V1 is  an  integer or real number and abs(V1) ≤ 1
         = 0           Else if V1 = 0
         = undefined   otherwise 

Type "atan"
• (integer) → real	
• (real) → real	

Fceiling(V1)= ceiling(V1) If V1 is  a real
            = V1          Else if V1 an  integer 
            = 0           Else if V1 = 0
            = -0          Else if V1 < 0 and V1 > -1.0
            = undefined   otherwise 

Type "ceiling"
• (integer) → integer	
• (real) → integer	

Fcos(V1)= cos(V1)    If V1 is  an  integer or real number and V1 is the value of an angle in radians
        = undefined  otherwise 

Type "cos"
• (integer) → real	
• (real) → real	

Fexp(V1)= e^(V1)       If V1 is  an  integer or real number 
         = + infinity  Else if V1 is positive infinity
         = 0           Else if V1 is negative infinity
         = undefined   otherwise 

Type "exp"
• (integer) → real	
• (real) → real	

Ffloor(V1)= floor(V1)   If V1 is a real number
          = V1          Else if V1 an integer number
          = V1          Else if V1= 0 or V1= infinity
          = undefined   otherwise 

Type "floor"
• (integer) → integer	
• (real) → integer	

Flog(V1)= log(V1)      If V1 is  an  integer or real number > 0
        = + infinity   Else if V1 is positive infinity
        = - infinity   Else if V1 = 0
        = undefined    otherwise 

Type "log"
• (integer) → real	
• (real) → real	

Fmax(V1,V2)= V1          If V1 > V2
           = V1          Else if V1 = V2
           = V2          Else if V2 > V1
           = undefined   otherwise 

Type "max"
• (integer x integer) → integer
• (integer x real) → real
• (real x integer) → real
• (real x real) → real	

Fmin(V1,V2)= V1          If V1 < V2
           = V1          Else if V1 = V2
           = V2          Else if V2 < V1
           = undefined   otherwise 

Type "min"
• (integer x integer) → integer
• (integer x real) → real
• (real x integer) → real
• (real x real) → real	

Fpower(V1,V2)= V1^V2         If V1 and V2 are valid arguments
             = 1             Else if V2= 0
             = V1            Else if V2= 1
             = abs(V1)^V2    Else if V1< 0 and V2 is a finite even integer
             = -(abs(V1)^V2) Else if V1< 0 and V2 is a finite odd integer
             = undefined     Else if V1< 0 and V2 finite and not an integer
             = undefined     Else if V2 is undefined
             = undefined     Else if V1 is undefined and V2!= 0
             = + infinity    Else if abs(V1)> 1 and V2= + infinity 
             = + infinity    Else if V1= 0 and V2< 0 or V1= + infinity and V2> 0
             = + infinity    Else if V1= -0 and V2< 0 and V2 is negative finite odd integer  or  
                             V1= -infinity and V2> 0 and V2 != finite odd integer  
             = - infinity    Else if V1=-0 and V2 is a negative finite odd integer  or V1= -infinity and 
                             V2 is a positive finite odd integer                     
             = 0             Else if abs(V1)> 1 and V2 = -infinity or abs(V1)< 1 and V2 = +infinity
             = 0             Else if V1=0 and V2> 0 or V1=+ infinity and V2< 0
             = 0             Else if V1= -0 and V2> 0 and V2!= finite odd number  or V1= -infinity 
                             and V2< 0 and V2!= finite odd integer 
             = -0            Else if V1=-0 and  V2= positive odd number or V1= -infinity  and V2  is  
                             a negative odd integer                  
             = V2            Else if V2< V1
             = undefined     otherwise 

Type "power"
• (integer x integer) → integer
• (integer x real) → real
• (real x integer) → real
• (real x real) → real	

Frand()= V1   Where 0.0 ≤ V1 < 1.0

Type "rand"
• () → real

Fsin(V1)=  sin(V1)    If V1 is an integer or real number representing the value of an angle in radians
        = 0           Else if V1 = 0
        = undefined   otherwise 

Type "sin"
• (integer) → real
• (real) → real	

Fsqrt(V1)=  +sqrt(V1)  If V1 is an integer or real number and V1 >= 0
         = 0           Else if V1 = 0
         = undefined   Else if V1 < 0
         = undefined   otherwise 

Type "sqrt"
• (integer) → real
• (integer) → integer
• (real) → real	

Ftan(V1)=  tan(V1)    If V1 is an integer or real number representing the value of an angle in radians
        = 0           Else if V1 = 0
        = undefined   otherwise 

Type "tan"
• (integer) → real
• (real) → real	

Types for "and", "or", "xor"and "implies":
(truth_value x truth_value) → truth_value

Types for "not":
(truth_value) → truth_value
					

Type for "size"
• (string) →  integer

Definition of evaluation function for Fsize(V)
Fsize(V)= integer       If V is a string  
        = undefined 	otherwise

Type for "concat"
• (string x string) →  string

Definition of evaluation function for Fconcat(V1, V2)
Fconcat(V1, V2)= string      If V1 and V2 are both strings  
               = undefined   otherwise

Type for "toUpper", "toLower" 
• (string) →  string

Definition of evaluation function for FtoUpper(V). The same applied for "toLower" operator.
FtoUpper(V)= string all in upper characters     If V is a string  
           = undefined      otherwise

Type for "substring"
• (string x integer x iinteger) →  string

Definition of evaluation function for Fsubstring(V1,V2,V3)
Fsubstring(V1,V2,V3)=  returns a substring of length V3, at a given starting point V2. 
                     •  V1 is a string and V2 and V3 are integers
               If    •  0 ≤ V2 < size(v1)
                     •  0 ≤ V3 < size(v1)
                     •  V2 + V3 ≤ size(V1)
                    = undefined     otherwise
	                
Type for "=" and "<>"
• (string x string) →  truth_value     

Definition of the evaluation function F= (V1, V2). The evaluation function is the same for
F<> (V1, V2) when the operands are both strings.

F=(V1,V2) = true         If V1 and V2  are both strings and V1 = V2 
          = false        Else if V1 and V2 are both strings and V1 <> V2
          = undefined    otherwise
							

Type for "tochar"
• (integer) →  string
• (real) →  string

Definition of evaluation function for Ftochar(V)
Fsize(V)= string       If V is an integer or a real number 
        = undefined    otherwise

Type for "lpad", "rpad" 
• (string x integer x string) →  string

Definition of evaluation function for Flpad(V). The same applies for "rpad" operator.
Flpad(V1, V2, V3)= string     If V1 is a string that could be padded on its left, 
                              V2 is an integer denoting the length to pad the text to, 
                              and V3 is a string to path with  
                 = undefined  otherwise

Type for "ltrim", "rtrim"
• (string x string) →  string

Definition of evaluation function for Fltrim(V1,V2). The same applies for "rtrim" operator.
Fltrim(V1,V2)= string     If V1 and V2 are strings. The resulting string 
                          has all the ocurrences of V2 that appear on 
                          the left removed
             = undefined  otherwise
	                
Type for "replace"
• (string x string x string) →  string    

Definition of the evaluation function Freplace (V1, V2,V3). 

F=(V1,V2,V3) = string       If V1, V2 and V3  are strings. The function returns a new 
                            string resulting from replacing in V1 all the ocurrences 
                            of V2 with V3
             = undefined    otherwise
							

   collection → collectionOperator(parameters)
						

   singleInstance → collectionOperator(parameters)
						

   collection → select( boolean-expression ) 
						

   patient.problemList → select(code = "123")			

This results in a collection that contains all the elements from collection for which the 
boolean-expression evaluates to true. For each element in collection the expression 
boolean-expression evaluates over a property of the elements in the collection. 
						

   collection → select( v | boolean-expression-with-v )

The variable v, called the iterator, is a reference to an object in the collection. v iterates over 
the collection and the boolean-expression-with-v is evaluated for each v. The third form is an 
extension of the latest, where the type of the variable v can be specified. The notation is:

collection → select( v : Type | boolean-expression-with-v)
						

collection(select x BooleanExpression)
collection → select( v | boolean-expression-with-v)
collection →select( v : Type | boolean-expression-with-v)

Type for "select"
   (collection x Boolean Expression) → collection

Definition of evaluation function for Fselect(V,E)
Fselect(V,E)= collection     If V is a collection  and E is a valid GELLO Boolean expression. 
                             The resulting collection contains all the elements from V for which the 
                             Boolean expression E evaluates to true
            = undefined      otherwise

collection → select(v | BooleanExpression-with-v)

Type for "select"
   (collection x Iterator x Boolean Expression) → collection
   
Definition of evaluation function for Fselect(V,I,E)
Fselect(V,I,E)= collection     If V is a collection, I is the iterator referring to the object from 	
                               the collection and E is a valid GELLO Boolean expression. 	
                               The resulting collection contains all the elements from V for which the 
                               Boolean expression E evaluates to true
              = undefined      otherwise

collection → select(v:Type | BooleanExpression-with-v)

Type for "select"
(collection x  Iterator x Type x Boolean Expression)  → collection

Definition of evaluation function for Fselect(V,I,T,E)
Fselect(V,I,E)= collection      If V is a collection, I is the iterator with Type T referring to 	
                                the object from the collection and E is a valid GELLO Boolean 
                                expression. 
                                The resulting collection contains all the elements from V for which 
                                the Boolean expression E evaluates to true
              = undefined       otherwise
					 

   collection→ reject(BooleanExpression)
   collection→ reject( v : Type | boolean-expression-with-v )
   collection→ reject( v | boolean-expression-with-v )

Type for "reject"
 (collection x Boolean Expression)→ collection

Definition of evaluation function for Freject(V,E)
Freject(V,E)= collection      If V is a collection  and E is a valid GELLO Boolean 
                              expression. The resulting collection contains all the elements
                              from V for which the Boolean expression E evaluates to false
            = undefined	      otherwise

collection→ reject(v | BooleanExpression-with-v)

Type for "reject"
 (collection x Iterator x Boolean Expression)→ collection

Definition of evaluation function for Freject(V,I,E)
Freject(V,I,E)= collection      If V is a collection, I is the iterator referring to the object 
                                from the collection and E is a valid GELLO Boolean expression. 	
                                The resulting collection contains all the elements
                                from V for which the Boolean expression E evaluates to false
              = undefined       otherwise

collection → reject(v:Type | BooleanExpression-with-v)

Type for "reject"
  (collection x Iterator x Type(Boolean Expression) → collection

Definition of evaluation function for Freject(V,I,T,E)
Freject(V,I,E)= collection      If V is a collection, I is the iterator with Type T referring to
                                the object from the collection and E is a valid 
                                GELLO Boolean expression. The resulting collection contains all 
                                the elements from V for which the Boolean expression E evaluates 
                                to false                
              = undefined 	otherwise
						

   patient.problemList→ reject(code = "123")
					   

   collection→ collect(Expression)
   collection→ collect( v | expression-with-v )
   collection→ collect( v : Type | expression-with-v )

Type for "collect"
   (set x Expression)→ bag
   (bag x Expression) → bag
   (sequence x Expression)→ sequence

Definition of evaluation function for Fcollect(V,E)
Fcollect(V,E)= collection     If V is a collection  and E is an expression that is 
                              evaluated for each element in to collection.
             = undefined      otherwise

Type for "collect"
   (set x Iterator x Expression) → bag
   (bag x Iterator x Expression) → bag
   (sequence x Iterator x Expression)→ sequence

Definition of evaluation function for Fcollect(V,I,E)
Fcollect(V,I,E)= collection     If V is a collection, I is the iterator referring to the 
                                object from the collection and E is a valid GELLO expression. 
                                The resulting collection contains the results of evaluating E 
                                for each element of V.
               = undefined      otherwise
     
   collection→ collect(v:Type | Expression-with-v)
 
 Type for "collect"
   (set x Iterator x Type x Expression)→ bag
   (bag x Iterator x Type x Expression)→ bag
   (sequence x Iterator x Type x Expression)→ sequence
 
 Definition of evaluation function for Fcollect(V,I,T,E)
 Fcollect(V,I,E)= collection   If V is a collection, I is the iterator with Type T referring 
                               to the object from the collection and E is a valid GELLO 
                               Expression. The resulting collection contains the result of 
                               evaluating E for each element of V.
                = undefined    otherwise
				 

	
   LabResult→ select(code = "CRE")→ collect(value)
					   

   collection→ forAll(Boolean Expression) 
   collection→ forAll( v | boolean-expression-with-v )
   collection→ forAll( v : Type | boolean-expression-with-v )

Type for "forAll"
    (collection x Boolean Expression)→ truth_value

Definition of evaluation function for FforAll(V,E)
FforAll(V,E) = true       If V is a collection  and E is a valid GELLO Boolean expression 
                          containing a property of the elements, and this expression evaluates 
                          to true for all elements in the collection
             = false      If V is a collection and E is a valid GELLO Boolean expression containing
                          a property of the elements, and there is at least one element for which 
                          the expression E evaluates to false. 
             = undefined  otherwise

   collection→ forAll(v | BooleanExpression-with-v) 
 
Type for "forAll"
   (collection x Iterator x Boolean Expression)→ truth_value

Definition of evaluation function for FforAll(V,I,E)
FforAll(V,I,E)= true       If V is a collection, I is the iterator referring to the object from the 
                           collection and E is a valid GELLO Boolean expression containing a 
                           property of the elements, and this expression evaluates to true for all
                           elements in the collection.
              = false      If V is a collection I is the iterator referring to the object from the 
                           collection and E is a valid GELLO Boolean expression containing a property 
                           of the elements, and there is at least one element for which the expression 
                           E evaluates to false. 
              = undefined  otherwise

collection → forAll(v:Type | BooleanExpression-with-v)

Type for "forAll"
   (collection x Iterator x Type(Boolean Expression) → truth_value

Definition of evaluation function for FforAll(V,I,T,E)
FforAll(V,I,E)= true         If V is a collection, I is the iterator with type T referring to the object 
                             from the collection and E is  a valid GELLO Boolean expression containing 
                             a property of the elements, and this expression evaluates to true for all 
                             elements in the collection.
              = false        If V is a collection I is the iterator referring to the object from the 
                             collection and E is a valid GELLO Boolean expression containing a 
                             property of the elements, and there is at least one element for which 
                             the expression E evaluates to false.
              = undefined    otherwise 
						

	
   LabResult → forAll(code = "CRE")
					   

   collection  → iterate(elem: Type; result: Type = expression | 
                         expression-with-elem-and-result)

Type for "iterate"
   (collection x elementName x elementType x resultName x resultType x expression x  
                         expression-with-elem-and-result)  → resultType

Definition of evaluation function for Fiterate(V,S,T1,R,T2,E1,E2)
Fiterate(V,S,T1,R,T2,E1,E2)= DataType      If V is a collection, S is an iterator variable of type T1, 
                                           R is a variable of type T2, E1 is a valid GELLO expression 
                                           defining the initial value of R and E2 is a valid GELLO 
                                           expression that is evaluated for each element S in the 
                                           collection. The evaluated value of E2 is stored in R. 
                                           The final result once the iteration is over is the value of R.
                           = undefined     otherwise
						

	
   LabResult  → iterate(code, acc: Integer = 0 | if code = "CRE" then acc + 1 else acc endif)
					   

   collection → exists(BooleanExpression)
   collection → exists( v | boolean-expression-with-v )
   collection → exists( v : Type | boolean-expression-with-v)
 
 Type for "exists" 
    (collection x BooleanExpression) → truth_value 
 
Definition of evaluation function for Fexists(V,E)
Fexists(V,E)= true        If V is a collection E is a valid GELLO Boolean expression containing 
                          a property of the elements, and there is al least  one element
                          in the collection V that satisfies E.
            = false       If V is a collection E is a valid GELLO Boolean expression containing a 
                          property of the elements, and none of the elements in the collection V 
                          satisfies E.
            = undefined   otherwise

Type for "exists"
 (collection x Iterator x Boolean Expression) →  truth_value

Definition of evaluation function for Fexists(V,I,E)
Fexists(V,I,E) = true          If V is a collection, I is the iterator referring to the object 
                               from the collection and E is a valid GELLO Boolean expression 
                               containing a property of the elements and there is at least one 
                               element in the collection V for which E evaluates to true.
               = false         If V is a collection I is the iterator referring to the object from 
                               the collection and E is a valid GELLO and  there is no element in 
                               the collection V such that E evaluates to true for that element 
               = undefined     otherwise 
 
 collection → existsl(v:Type | BooleanExpression-with-v) 
 
 Type for "exists" 
     (collectionIterator x Type x Boolean Expression) → truth_value 
 
 Definition of evaluation function for Fexists(V,I,T,E) 
 Fexists(V,I,E)= true          If V is a collection, I is the iterator with type T referring 
                              to the object from the collection and E is a valid GELLO Boolean 
                              expression containing a property of the elements and there is 
                              at least one element in the collection V for which E evaluates to true.
               = false          If V is a collection I is the iterator referring to the object 
                               from the collection and E is a valid GELLO Boolean expression 
                               containing a property of the elements, and there is no element 
                               in the collection V such that E evaluates to true for that element
               = undefined     otherwise
						

	
   LabResult → exists(code = "CRE")
					   

   collection → flatten()

Type for "flatten" 
   (collection)  → collection 

Definition of evaluation function for Fflatten(V) 
Fflatten(V) = collection     If V is a collection, the result is a collection containing all the 
                             elements of V.  If V is a set, bag, or sequence, then Fflatten(V) is 
                             a set, bag, or sequence respectively.
            = element        If V is not a collection.
						

						
   {1, 2, {3}, {{4},{5}} → flatten()
						

   collection → size()

Types for "size"
   (collection) → integer

Definition of evaluation function for Fsize(V)
Fsize(V) = integer          If V is a collection 
         = undefined        otherwise
						

						
   patient.problemList → size()
					   

   collection → count(object)

Type for "count"
   (collection x object)  → integer

Definition of evaluation function for Fcount(V,O)
Fcount(V,O) = integer           If V is a collection  and O is a defined object
            = undefined 	otherwise
						

	
   patient.problemList  → collect(code) → count("fever")
					   

   collection → max()

Type for "max"
   (collection)  → number

Definition of evaluation function for Fmax(V)
Fmax(V) = number        If V is a collection of numbers (integers or reals)
        = undefined 	otherwise
						

	
   {2,5,1} → max()        returns 5
   {2,5,1} →  min()       returns 1
					   

   collection → includes(object)

Type for "includes"
   (collection x object) → truth_value 
 
Definition of evaluation function for Fincludes(V,O) 
Fincludes(V,O) = true         If V is a collection  and O is an element in the collection.  
               = false        Else if V is a collection and O is not an element V.  
               = undefined    otherwise 
						 

	
   patient.problemList →  collect(code) → includes("fever")
					   

   collection → includesAll(parameterCollection)

Types for "includesAll"
   (collection x singleInstance) → truth_value
   (collection x collection ) → truth_value
 
Definition of evaluation function for FincludesAll(V,C)
FincludesAll(V,C)= true         If both V and C are collections and all the elements in C 
                                 appear in V. 
                 = false         Else if V is a collection and there is at least one element in C 
                                 that does not appear in V.
                 = undefined     otherwise
						

	
   patient.problemList → collect(code) → includesAll( SET{"fever", "rash"})
					   

   collection → isEmpty()

Type for "isEmpty"
   (collection) → truth_value 

Definition of evaluation function for FisEmpty(V) 
 FisEmpty(V) = true          If V is a collection  with no elements
             = false         Else if V is a collection with one or more elements 
             = undefined     otherwise 
						

	
   patient.problemList → isEmpty()
					   

   collection → notEmpty()

Type for "notEmpty" 
   (collection) → truth_value 
 
Definition of evaluation function for FnotEmpty(V) 
FnotEmpty(V) = true          If V is a collection  with one or more elements 
             = false	     Else if V is a collection with no elements 
             = undefined     otherwise 
						

						
   patient.problemList → notEmpty()
					   

   collection  → sum()
 
Types for "sum"
   (collection_of_integers)  → integer 
   (collection_of_reals)  → real 
 
Definition of evaluation function for Fsum(V) 
Fsum(V) = V1+…+Vn           If V is a non-empty collection of n integer or 
                            real values < V1 , … , Vn > with (1≤ i ≤ n) 
        = 0	            Else if V is an empty collection  
        = undefined 	    otherwise 
						

						
   {1, 2, 3, 4, 5}  → sum()
					   

   sequence → firstN(numberOfElements)

Type for "firstN"
   (sequence x integer)  → sequence

Definition of evaluation function for FfirstN(V,N)
FfirstN(V,N)= sequence        If V is an non-empty sequence and N is an integer 
                              such that 1≤ N ≤ size of V. The resulting sequence
                              is of the same type as V
            = undefined       otherwise
						

	
   {1,2,3,4,5}  → firstN(3)      returns {1,2,3}
					   

    sequence  → lastN(numberOfElements)

Type for "lastN"
    (sequence x integer)  → sequence

Definition of evaluation function for FlastN(V,N)
FlastN(V,N)= sequence      If V is an non-empty sequence and N is an integer 
                           such that 1 ≤ N ≤ size of V.  The resulting sequence 
                           is of the same type as V 
           = undefined     otherwise 
						

	
   {1,2,3,4,5}  → lastN(3)      returns {3,4,5}
					   

    sequence → elemAt(ElementPosition)


Type for "elemAt"
   (sequence x integer) → element

Definition of evaluation function for FelemAt(V,N)
FelemAt(V,N) = element     If V is an non-empty sequence and N is an integer 
                           such that 1 ≤ N ≤ size of V. The result is the  
                           element at the Nth position.
             = undefined   otherwise
						

	
   {a, f, g, k, z} → elemAt(3)      returns g
					   

   sequence → reverse()

Type for "reverse" 
   (sequence) → sequence 

Definition of evaluation function for Freverse(V) 
Freverse(V) = sequence       If V is a single instance or a sequence. 
                             The resulting sequence is of the same 
                             type as V. 
            = undefined      otherwise 
						 

	
   {a, f, g, k, z} → reverse()      returns {z, k, g, f, a}
					   

   collection  → sortBy(orderByExpression)

Types for "sortBy"
    (collection x ListOfProperties)  →sequence

Definition of evaluation function for FsortBy(V,E)
FsortBy(V,E) = sequence          If V is a single instance or a collection  
                                 and E is a GELLO expression specifying the 
                                 properties by which the current collection 
                                 should be ordered by. The result is a 
                                 sequence. 
             = undefined 	 otherwise 
						

	
   Patient.Medication  → sortBy(effectiveTime.high())
					   

   collection → intersection(parameterCollection)

Types for "intersection" 
   (set x set) → set 
   (bag x bag) → set 
   (set x bag) → set 
   (bag x set) → set 

Definition of evaluation function for Fintersection(V1,V2) 
Fintersection(V1,V2) = set         If V1 and V2 are either sets or bags with 
                                   elements < V1,1, … , V1,n >  and 
                                   < V2,1, … ,V2,n >  respectively. The 
                                   resulting set contains all the elements from 
                                   V1 that also are elements of V2  (V1,i = V2,j). 
                                   If there are not common elements in V1 and V2
                                   the intersection returns an empty set. 
                     = undefined   otherwise 
						

   
   TDrug: a variable holding a collection of drugs, each of which has a 
   "compellingIndication" property.  aPatient is a variable referencing a 
   particular patient’s medical record:

   Drug → exists(aDrug: not(aDrug.compellingIndication → 
                            intersection(aPerson.problemList) → isEmpty))
						

   collection union(parameterCollection)

Types for "union"
   (set x bag) → bag 
   (bag x set)  → bag 
   (set x set) → bag 
   (bag x bag) → bag 
   (sequence x sequence) → sequence 

 Definition of evaluation function for Funion(V1,V2) 
 Funion(V1,V2) = set             If V1 and V2 are both sets. The resulting set contains 
                                 the values   that are either in V1 or in V2. Duplicate 
                                 elements are not added. 
               = bag             If V1 and V2 are either sets or bags. The resulting bag 
                                 contains the values <  V1,1, … , V1,n > from V1 
                                 and < V2,1, … , V2,n >  from V2. 
               = sequence        Else if  V1 and V2 are both sequences. The resulting 
                                 sequence contains the values <  V1,1, … , V1,n , 
                                 V2,1, … , V2,n > such that <  V1,1, … , V1,n > are
                                 from V1 and < V2,1, … , V2,n >  are from V2
               = undefined	 otherwise 
						

						
   Patient.problemList → exist(problemList : medication.AllInstances → 
                              exist( medication.effectiveTime → union(effectiveTime))
					   

   collection →  including(element)

Types for "including" 
   (set x element) → set 
   (bag x element) → bag 
   (sequence x element) → set
   (sequence → element) → bag 
 
Definition of evaluation function for Fincluding(V,E)
Fincluding(V,E)= set              If V is a set and E is an element that does not exist in V. 
                                  E must be of the same type as the elements in V. The 
                                  returning result is a set V→union(Set{E}).
Fincluding(V,E)= bag              If V is a bag, the returning type of the collection is a 
                                  bag with E added to V.
Fincluding(V,E)= sequence         If V is a sequence and E is an element that does 
                                  not exist in V.  The resulting sequence has E added to the 
                                  end of V.  E must be of the same type as the elements in V.
Fincluding(V,E)= bag              If V is a sequence and E is an element that does 
                                  exist in V.  E must be of  the same type as the elements in V.
               = undefined        otherwise
						

	
   Set{7, 2, 8, 4}→ including(5)     returns  Set{7, 2, 8, 4, 5}
					   

   collection → excluding(element)

Types for "excluding" 
   (set x element) → set   
   (bag x (element) → bag 
   (sequence x element) → sequence 
 
Definition of evaluation function for Fexcluding(V,E) 
>Fexcluding(V,E)= collection       If V is either a set, bag or sequence and E 
                                   is an element  in V.   
                = undefined        otherwise 
						

	
   Bag{7, 2, 5, 8, 4, 5} → excluding(5)     returns Bag{7, 2, 8, 4}
					   

   currentCollection  → join(namesOfCollections; namesOfProperties; booleanExpression; 
         orderByExpression)

Where:
• namesOfCollections is a list of strings separated by commas, where each  
  string represents the name of a collection from where data is retrieved. 
• The name of the current collection currentCollection must appear in the list. 

Notation for namesOfCollections:
• Collection1, collection2,…collectionn;                
   E.g.   patient, labTest, …, treatment
• Alias1 in collection1, alias2 in collection2, …, aliasn in collectionn;               
   E.g.   p in patient, lt in labTest, …, t in treatment
 
• namesOfProperties is a list of strings separated by commas, where each 
  string is the full description of the properties from the objects in the
  collections we want to get in the result.  

The notation is: object.property.  E.g. [patient.ID, labTest.ID, labTest.result, 
labTest.date, treatment.ID, treatment.description].  
Or using aliases: p.ID, lt.ID, etc. 

 • booleanExpression is a valid GELLO Boolean expression containing the 
   conditions the elements from the collections defined in listOfCollections 
   must satisfy in order to be included in the result. For each pair of 
   collections there must be at least one condition related to these 
   collections in the booleanExpression. In general, the number of conditions 
   must be at least equal to the number of collections in listOfCollections-1.

• orderByExpression is a valid GELLO expression specifying the properties 
  by which the result should be ordered.   E.g. patient.ID, treatmentID or
  using aliases  p.ID, t.ID, will sort the result by patientID and 
  treatment ID. 

Types for "join"
   (collection x  parameterList x parameterList x booleanExpression x 
         OrderExpression) → bag_of_tuples  
                     *: for any type of collection if OrderExpression is 
                         not specified. 
                         
   (collection x parameterList x parameterList x booleanExpression x 
         OrderExpression) → sequence_of_tuples 
                    +: for any type of collection if OrderExpression is 
                        specified. 

 Definition of evaluation function for Fjoin(V,S1,S2,E1,E2) 
 Fjoin(V,S1,S2,E1,E2) = bag of tuples  	       If V is collection, S1 is a parameter list of 
                                               strings with the names of the collections from 
                                               where  data will be retrieved, S2 is a parameter
                                               list of strings with the full names of the properties 
                                               to be included in the result, E1 is a boolean
                                               expression containing the conditions C <C1 booleanOP 
                                               C2 … booleanOP Cn >    the returning elements must 
                                               satisfy. The number of conditions Ci in
                                                E1 ≥ [S1(size()-1].  E2 is an optional 
                                               parameter that specifies the criteria for ordering the
                                               resulting elements. If  E2 is not specified, the 
                                               result is a bag.
 Fjoin(V,S1,S2,E1,E2) = sequence of tuples     If V is collection, S1 is a parameter list of 
                                               strings with the names of the collections from 
                                               where data will be retrieved, S2 is a parameter
                                               list of strings with the full names of the properties 
                                               to be included in the result, E1 is a boolean expression 
                                               containing the conditions Ci < C1 booleanOP 
                                               C2 … booleanOP Cn  > the returning elements 
                                               must satisfy. The number of conditions Ci in 
                                               E1 ≥ [S1(size()-1].  E2 is an optional parameter 
                                               that specifies the criteria for ordering the
                                               resulting elements. If ordering is required, then 
                                               a GELLO expression specifying the  properties 
                                               by which the result should be ordered by
                                               must be defined.  The resulting collection is
                                               a sequence.
                      = undefined              otherwise
						 

	
   LabResults→ join(Medications; Medications.code, Medications.effectiveTime,
                     Medications.value, LabResults.code,  LabResults.effectiveTime, 
                     LabResults.value; Medications.effectiveTime.contains(LabResults.effectiveTime)
						

   collection → average()

Type for "average"
   (collection)  → real

Definition of evaluation function for Faverage(V)
Faverage(V) = real       If V is a collection  and all the elements in the collection 
                         are either real or integer numbers
            = undefined  otherwise
						

	
    recorded_temperatures is a collection containing the recorded temperatures 
    of a patient: {97, 98, 98.5, 99, 99, 97, 97}. 

                     So, recorded_temperatures → average()          returns: 97.92 F
					   

   collection → stdev()

Type for "stdev"
   (collection)  → real

Definition of evaluation function for Fstdev(V)
Fstdev(V) = real        If V is a collection  and all the elements in the collection are 
                        either real or integer numbers
          = undefined 	otherwise
						

	
    recorded_temperatures is a collection containing the recorded temperatures 
    of a patient: {97, 98, 98.5, 99, 99, 97, 97}. 

                     So, recorded_temperatures → stdev()          returns: 0.9322
					   

   collection → variance()

Type for "variance"
   (collection)  → real

Definition of evaluation function for Fvariance(V)
Fvariance(V) = real         If V is a collection  and all the elements in the collection are 
                            either real or integer numbers
             = undefined    otherwise
						

	
    recorded_temperatures is a collection containing the recorded temperatures
    of a patient: {97, 98, 98.5, 99, 99, 97, 97}. 
    
                     So, recorded_temperatures → variance()          returns: 0.8690
					   

   collection → median()

Type for "median"
   (collection)  → real

Definition of evaluation function for Fmedian(V)
Fmedian(V) = integer      If V is a collection and all the elements in the collection are 
                          integer numbers
            = real        Else if V is a collection and all the elements in the collection are 
                          either real or integer numbers
            = undefined   otherwise
						

	
    recorded_temperatures is a collection containing the recorded temperatures
    of a patient: {97, 98, 98.5, 99, 99, 97, 97}. 
    
                     So,   recorded_temperatures → median()          returns: 98
					   

   collection → mode()

Type for "mode"
   (collection)  → real

Definition of evaluation function for Fmode(V)
Fmode(V) = integer      If V is a collection and all the elements in the collection are 
                        integer numbers
         = real         Else if V is a collection and all the elements in the collection are 
                        either real or integer numbers
         = undefined 	otherwise
						

	
    recorded_temperatures is a collection containing the recorded temperatures
    of a patient: {97, 98, 98.5, 99, 99, 97, 97}. 
    
                     So,   recorded_temperatures → mode()          returns: 97
					   

   collection → like(String)

Type for "like"
   (collection x string) → collection 
 
Definition of evaluation function for Flike(V1,V2) 
Flike(V1,V2) = collection     If V1 is a collection  of strings and V2   
                              is string pattern.The result is a collection of all 
                              strings that matched the given pattern. If there 
                              are no matches, the returning collection is empty.
              = undefined     otherwise 
						 

	
   patient.problemList →  collect(code) → like("ast")
					   

   collection → notlike(String)

Type for "notlike"
   (collection x string) → collection 
 
Definition of evaluation function for Fnotlike(V1,V2) 
Fnotlike(V1,V2) = collection   If V1 is a collection  of strings and V2  
                               is string pattern. The result is a collection of all  
                               strings that did not match the given pattern.  
                               If there are no matches, the returning collection is empty.
                = undefined    otherwise 
						 

	
   patient.problemList →  collect(code) → notlike("ast")
					   

   collection → between(String1, String2)

Type for "between"
   (collection x string x string) → collection 
 
Definition of evaluation function for Fbetween(V1,V2,V3) 
Fbetween(V1,V2,V3) = collection   If V1 is a collection of strings 
                                  and V2 and V3 are both stringsdefining a 
                                  range.  The result is a collection of all  strings 
                                  that are between the given range. If there are 
                                  no matches, the returning collection is empty.
                   = undefined    otherwise 
						 

	
   {asthma, copd, diabetes, IRS, meningitis, reflux, UTI} → between(diabetes, reflux) 
   returns: {diabetes, IRS, meningitis, reflux}
					   

   collection → distinct()

Type for "distinct"
   (collection) → set 
 
Definition of evaluation function for Fdistinct(V1) 
Fdistinct(V1) = set         If V1 is a collection  the result is a set 
              = undefined   otherwise 
						 

	
   {asthma, copd, diabetes, copd, UTI, IRS, reflux, UTI} → distinct() 
   returns: {asthma, copd, diabetes, UTI, IRS, reflux}
					   

						
   Tuple.size()

Types for "size" 
   (tuple) → integer 

Definition of evaluation function for Fsize(T) 
Fsize(T)= integer      If T is a tuple   
        = undefined    otherwise 
						

						
   personalData.size()   returns 3 
						

						
   Tuple.getValue(elemName)

Types for "getValue" 
   (tuple(string) → PredefinedDataTypeValue 
   (tuple(string) → ModelDataTypeObject 
 
Definition of evaluation function for FgetValue(T,S)
FgetValue(T,S) = PredefinedDataTypeValue     If T is a tuple  and S is a string with the name of  
                                             an element in T, and the type of the returning  
                                             value is one of the predefined data types: 
                                             integer, real, boolean, string or one of the 
                                             collection types. 
               = ModelDataTypeObject	     Else if T is a tuple  and S is a string with the name 
                                             of an element in T, and the type of the returning 
                                             value is one of the model data types. 
               = undefined                   otherwise
						

   personalData.getValue(nickname)     returns ‘Johnny’ 
   
   this is equivalent to:   personalData.nickname 
					   

   Tuple.getElemName(position) 
 
Type for "getElemName"
   (tuple x integer) → string 

Definition of evaluation function for FgetElemName(T,I) 
 FgetElemName(T,I) = string       If T is a tuple  and I is an integer (1 ≤ T.size()). 
                   = undefined    otherwise 
						 

	
   personalData.getElemName(2)     returns ‘nickname’
						   

   Tuple.getElemType(position)
   Tuple.getElemType(elemName) 
 
Types for "getElemType" 
   (tuple x integer) → string 
   (tuple x string) → string 
 
Definition of evaluation function for FgetElemType(T,I) 
FgetElemType(T,I) = PredefinedDataType     If T is a tuple  and I is an integer (1 ≤ T.size()). 
                                           The returning value is a string referring to a
                                           predefined data type: integer, real, Boolean, 
                                           string or one of the collection types. 
                  = ModelDataType          Else if T is a tuple  and I is an integer (1 ≤ T.size()). 
                                           The returning value is a string referring to a model 
                                           data type. 
                  = undefined              otherwise 
 
 Definition of evaluation function for FgetElemType(T,S)
 FgetElemType(T,S)= PredefinedDataType     If T is a tuple  and S is a string referring to the 
                                           name of an element in the tuple. The returning value 
                                           is a string referring to a basic data type: integer, 
                                           real, Boolean, string, or one of the collection types. 
                  = ModelDataType          Else if T is a tuple and S is a string referring to the 
                                           name of an element in the tuple.  The returning value
                                           is a string referring to a model data type. 
                  = undefined              otherwise 
						 

	
   personalData.getElemType(2)     returns String

   this is equivalent to:    personalData.getElemType(‘nickname’) 
						

Type for "todate" 
• (string) →  PointInTime    (a RIM object)

Definition of evaluation function for Ftodate(V)
Ftodate(V)= PointInTime    If V is a valid string. The result is a PoinInTime object  
          = undefined      otherwise
						 

					
	The following expression creates a PointInTime object 
	with the argument string:
	
	              Let aDate: PointInTime = Factory.PointInTime(String)