Language basics

In this page we will explain some basic syntactic features such as comments and continuations, and some basic semantic concepts: commands, functions, constants, and variables.

Comments and continuations

These are illustrated by the example file examples/com_con.ch, given in full below.

def

// This is a comment.

// And below, the two types of continuation.

x = "hello " + ..
 .. "world"

y = 1, 2, 3,
 .. 4, 5, 6

Comments are very much what you’re used to from other languages. Continuations must be marked by a .. at the end of the continued line and a corresponding .. at the beginning. The allowed exception is that the continued line may end in a comma where this is syntactic, in which case the continuation must begin with .. just the same. The continuations can be placed wherever is most readable: they are exempt from whitespace rules.

Commands and functions

Let's look again at our first example script.

cmd

greet :
    get name from Input("What's your name? ")
    post "Hello " + name + "!" to Output()

def

factorial (n) :
    n == 0 :
        1
    n > 0 :
        n * factorial n - 1
    else :
        error "can't take the factorial of a negative number"

It has a command, introduced by the heading cmd, and a function, introduced by the heading def. These are two very different things.

A command does things: it moves data in and out of the service: in this case getting data from the keyboard and posting it to the terminal. You would also use commands to interact with the file system, the database, the system clock, etc. Commands don't return values: they succeed or fail.

A function computes things. It returns a result and this is all. It has no effect on the outside world, and indeed doesn't know that there is an outside world.

Commands can call functions: functions can't call commands.

Headwords

We have met two "headwords" so far: def and cmd. The meaning of a headword is "everything after this until the next headword or the end of file is a declaration of type ". So after cmd, Charm expects you to be declaring commands. After def you can define functions, constants, and types. After var you can define variables, as discussed in the next section.

Constants and variables

Constants can be defined, like functions, under the heading def. The Charm style guide recommends that you use SCREAMING_SNAKE_CASE to name them.

Variables can be declared under the headword var.

An examples is given in examples/variables.ch

var

h = "Hello world!"
x = 2 + 2

def

MONTHS_IN_A_YEAR = 12

You can change the values of variables via the REPL, but unlike for example Python, you can't create variables in the REPL: they must be declared in the script.

In order to interact with variables in a command, you must bring them into the scope of the command using the global keyword. E.g if we add this to the script above, it will do what you think it would do.

cmd

addToXAndShow(n) : 
    global x
    x = x + n
    post x to Output()

In Charm, variables by default take on the type of the thing assigned to them on declaration. So x is of type int, and h is of type string, and trying to put anything else in them causes an error.

This is only the default behavior — Charm is after all a dynamic language. But before we discuss how to widen the type of a variable, we should take a look at Charm's type system.