Interactive Chapel¶

Variables¶

The IPE supports variables with types bool, int, real, and c_string. These are declared in the natural way with local type inference e.g.:

1 > var x : int = 20;
2 > var y = 30.3;             // Equivalent to var y : real = 30.3;
3 > var z : int;              // Equivalent to var z : int  =  0;

Assignment¶

The assignment operator is defined for bool, int, and real e.g:

1 > var x : int;              // x is  0
2 > var y = 42;               // y is 42
3 > x = y;                    // x is now 42

The types of the LHS and RHS must match. There is currently no support for Chapel's implicit coercion from int to real during assignment.

Arithmetic operators¶

The IPE implements the unary +, - operators on int and real and the binary operators +, -, *, / on int and real. Once again the IPE does not currently implement implicit coercion from int to real.

Equality operators¶

The IPE implements == and != on pairs of bool, int, and real.

Comparison operators¶

The IPE implements <, >, <=, >= on pairs of int and real.

If statement¶

The IPE implements the IF statement e.g. the code:

var value : int = 0;

writeln('value (expect  0) ', value);

if true then
  value =  6;

writeln('value (expect  6) ', value);

if false then
  value =  2;

writeln('value (expect  6) ', value);

if value > 9 then
  value =  2;
else
  value = 10;

writeln('value (expect 10) ', value);

will produce:

value (expect  0)     0
value (expect  6)     6
value (expect  6)     6
value (expect 10)    10

While statement¶

The IPE implements a restricted form of the while statement; it does not support the break or continue statement e.g. entering the following in to the IPE:

var i   : int =  0;
var n   : int = 10;

var res : int =  1;

while (i < n)
{
  res = res * 2;
  i   = i   + 1;
}

writeln('i:   ', i);
writeln('n:   ', n);
writeln('res: ', res);

will produce:

i:      10
n:      10
res:  1024

User defined procedures¶

The IPE supports user defined procedures with the limitation that any formals must be explicitly typed and cannot be named or take a default value. Additionally the type of the return value, if any, must be specified. If there is no return value, then void must be specified. For example the following implements square() for an integer:

1> proc square(x : int) : int return x * x;

Return statement¶

The IPE implements the return statement within a procedure with the limitation that if it appears, then it must be the final statement of the procedure. This implies that there can be only one return statement in a procedure and that a return cannot appear within an if statement or a while statement.

Output functions¶

There is a small set of output functions. There is a procedure print() which takes one argument of type bool, int, real, or c_string and prints the type and the value e.g.:

1 > var x = 30;
2 > print(x);
    int      30

There is a restricted form of writeln(). The first version takes a single c_string and prints the string and then a newline e.g.:

1> writeln('Hello world');
   Hello world

The remaining versions take two arguments. The first argument must be a c_string, and the second argument must be a bool, int, or real. This prints the c_string followed by a representation of the second argument e.g.:

1 > var x = 42;
2 > writeln('The Answer to the Ultimate Question of Life, the Universe, and Everything is ', x);
    The Answer to the Ultimate Question of Life, the Universe, and Everything is    42