# OCL
Abstract Syntax Models

## Overview

This section defines the classes that make up the Object Command Language (the core part of XOCL). They are defined in the package OCL. The syntax classes are grouped roughly in terms of their basic properties and usage.The figure below shows classes for atomic expressions. These are simple expressions that do not contain sub-expressions:

Patterns are used in OCL expressions in many places that bindings can opccur. The model of patterns is defined below:

Consp is a pair pattern, Varp is a simple variable, Includingp is a set pattern, Objectp is a pattern corresponding to a constructor, Addp is a sequence concatenation or set union pattern, Constp is a constant (where the constant is the result of evaluating an expression), Condp is a guard and Keywordp is a pattern matching objects where the slots are given as keys.

The following example shows how each of the pattern instances occur for a (somewhat unrealistic) example operation:

[1] XMF> [|

@Operation(x:Integer, // Just bind x (optionally check the type).

10, // Fails if 2nd arg is not 10.

Seq{x,y:Boolean}, // Expect a 2-element sequence.

Seq{a | 8}, // Expect a pair.

XCore::Class(name), // Expect an instance of XCore::Class and bind name.

XCore::Class[name=n], // Expect an instance of XCore::Class and bind n.

z when z->size = 10, // Expect a collection of size 10.

S->including(10), // Expect a collection containing 10. Remove 10 and bind S.

S1 + S2) // Expect a collection, bind S1 and S2 to two distinct halves.

x

end |].parameters;

Seq{

Varp(x,[| Integer |]),

Constp([| 10 |]),

Consp(Varp(x,[| XCore::Element |]),Consp(Varp(y,[| Boolean |]),Constp([| Seq{} |]))),

Consp(Varp(a,[| XCore::Element |]),Constp([| 8 |])),

Objectp[

names = Seq{Class},

class = XCore,

slots = Seq{Varp(name,[| XCore::Element |])}],

Keywordp(XCore,Seq{Class},Seq{Keyp(name,Varp(n,[| XCore::Element |]))}),

Condp(Varp(z,[| XCore::Element |]),[| z->size = 10 |]),

Includingp[

set = Varp(S,[| XCore::Element |]),

element = Constp([| 10 |])],

Addp[

left = Varp(S1,[| XCore::Element |]),

right = Varp(S2,[| XCore::Element |])]}

[1] XMF>

The following figure shows the abstract syntax of iteration expressions. Both set and sequence expressions are represented as instances of SetExp with the collType set to Set or Seq respectively. A CollExp supports all concrete expressions of the form S->x(a,b,c) and S->x where the arguments to the latter default to the empty sequence. IterExp represents all concrete expressions of the form S->n(x | e) where n is exists, forAll, select, collect or reject.

The following figure shows the abstract syntax of operation expressions and the related application of operations: