#
3. How To Use Objects

##
3.1. Objects and Sorts

In CCalc code we often refer to finite sets, for instance, sets of integers.
A set can serve as the set of values of a fluent, or as the domain of a
variable, or for other purposes.
The language of CCalc allows us to introduce names for finite sets. These
names are called *sorts*, and the elements of a set are called
*objects* of the corresponding sort. Sorts can be used in variable and
constant declarations.
For example, the fragment

:- constants
c :: inertialFluent(0..n);
a :: exogenousAction.
:- variables
I :: 0..n-1.

of file `coins` can be rewritten as follows:
:- sorts
number; smallnumber.
:- objects
0..n :: number;
0..n-1 :: smallnumber.
:- constants
c :: inertialFluent(number);
a :: exogenousAction.
:- variables
I :: smallnumber.

The sort declaration in the first two lines says that the symbols
`number` and `smallnumber` are names of sets. The object
declaration that follows tells us what the elements of those sets are. The
names are used then in the declarations of the constant `c` and the
variable `I`.
After declaring a sort in a CCalc file, we "populate" it
by listing the objects of that sort. If this is not done, CCalc will treat
this sort as empty.

The sort and object declarations

:- sorts
number; smallnumber.
:- objects
0..n :: number;
0..n-1 :: smallnumber.

can be also written as
:- sorts
number >> smallnumber.
:- objects
0..n-1 :: smallnumber;
n :: number.

The symbol `>>` in the sort declaration expresses that the
sort `number` is a "supersort" of
sort `smallnumber`, so that every element of the
latter is automatically counted as an element of the former. Accordingly,
when we declare objects of sort `number` later, there is no need
to include all integers in the interval `0..n`; it is enough to mention
`n`.
Sort and object declarations allow us to talk about sets that are more
complex than intervals. For instance, we can declare:

:- sorts
number.
:- objects
1..10, 20, 50, 100 :: number.

A sort can be populated not only with numbers, but also with identifiers.
Consider,
for instance, the blocks world with the blocks called `a`, `b`,
`c`, in which a block can be located on top of another block or on the
table. The description of this system can include the declarations
:- sorts
location >> block.
:- objects
a, b, c :: block;
table :: location.

**Exercise 3.1.**
Consider the following modification of the domain from
Exercise 1.4 (Section 1.3). Instead of 11
people around the table,
there are just two, John and Mary. The value of the fluent `owner`
tells us which of them has the coin. When the action `give` is
executed, the current owner of the coin gives it to the other person. This
action was executed twice, and now the coin belongs to John. Use CCalc to
find out who was the owner of the coin originally.

Forward
to Section 3.2: Families of Fluents, Actions and Objects
Back
to Section 2.3: Counting Bullets
Up to the Table of Contents