There are situations where an expression evaluation is stuck, because it is attempting to perform some impossible operation and cannot compute a value. In that case, the expression is silent. An expression is also silent if it depends on the result of a silent subexpression. For example, the following expressions are silent: 10/0, 6 + false, 3 + 1/0, 4 + true = 5.

Cor is a dynamically typed language. A Cor implementation does not statically check the type correctness of an expression; instead, an expression with a type error is simply silent when it is evaluated.

A tuple expression is a comma-separated sequence of at least two expressions, enclosed by parentheses. Each expression is evaluated; the value of the whole tuple expression is a tuple containing each of these values in order. If any of the expressions is silent, then the whole tuple expression is silent.

A list expression is a comma-separated sequence of expressions enclosed by square brackets. It may be of any length, including zero. Each expression is evaluated; the value of the whole list expression is a list containing each of these values in order. If any of the expressions is silent, then the whole list expression is silent.

There is also a concatenation (cons) operation on lists, written F:G, where F and G are expressions. Its result is a new list whose first element is the value of F and whose remaining elements are the list value of G. The : operator is right associative, so F:G:H is F:(G:H).

Functions can be recursive; that is, the name of a function may be used in its own body.

def sumto(n) = if n < 1 then 0 else n + Sumto(n-1)

Mutual recursion is also supported.

def even(n) = 
  if (n > 0) then odd(n-1)
  else if (n < 0) then odd(n+1)
  else true
def odd(n) = 
  if (n > 0) then even(n-1)
  else if (n < 0) then even(n+1)
  else false

Functions are actually values, just like any other value. Defining a function creates a special value called a closure; the name of the function is a variable and its bound value is the closure. Thus, a closure can be put into a data structure, or bound to some other variable, just like any other value.

def a(x) = x-3
def b(y) = y*4
val funs = (a,b)

Like any other value, a closure can be passed as an argument to another function. This means that Cor supports higher-order functions.

def onetwosum(f) = f(1) + f(2)
def triple(x) = x * 3

Since all declarations (including function declarations) in Cor are lexically scoped, these closures are lexical closures. This means that when a closure is created, if the body of the function contains any variables other than the formal parameters, the bindings for those variables are stored in the closure. Then, when the closure is called, the evaluation of the function body uses those stored variable bindings.

Sometimes one would like to create a closure directly, without bothering to give it a name. There is a special keyword lambda for this purpose. By writing a function definition without the keyword def and replacing the function name with the keyword lambda, that definition becomes an expression which evaluates to a closure.

def onetwosum(f) = f(1) + f(2)

onetwosum( lambda(x) = x * 3 )
{- 
  identical to:
  def triple(x) = x * 3
  onetwosum(triple)
-}

Since a function defined using lambda has no name, it is not possible to define a recursive function in this way. Only def can create a recursive function.

The combination of functions and pattern matching offers a powerful capability: clausal definition of functions. We can define expressions which execute different code depending on the structure of their arguments.

Here's an example.

def sum([]) = 0
def sum(h:t) = h + sum(t)

A function may have multiple clauses, each of which has a sequence of patterns to match each argument, and a body expression. Naturally, all clauses of a function must have the same number of arguments. Any contiguous sequence of definitions with the same name and different arguments is interpreted as a clausal definition, where each individual declaration is a clause of the larger function.

When the function is called, the clauses are tried in the order in which they appear until a match is found. If no clause matches, the call remains silent.

We allow a new form of pattern which is very useful in clausal definition of functions: a constant pattern. A constant pattern is a match only for the same constant value. We can use this to define the "base case" of a recursive function in a straightforward way.

{- Fibonacci numbers -}
def fib(0) = 1
def fib(1) = 1
def fib(n) = if (n < 0) then 0 else fib(n-1) + fib(n-2)

{- Alternate definition of the Fibonacci function -}

{- A helper function: find the pair (Fibonacci(n-1), Fibonacci(n)) -}
def H(0) = (1,1)
def H(n) = 
  val (x,y) = H(n-1)
  (y,x+y)

def fib(n) = 
  if (n < 0) then 0 
  else (
    val (x,_) = H(n) 
    x
  )
     
    

As a more complex example of matching, consider the following function which takes a list argument and returns a new list containing only the first n elements of the argument list.

def take(0,_) = []
def take(n,h:t) = if (n > 0) then h:(take(n-1,t)) else []

Mutual recursion and clausal definitions are allowed to occur together. Here are two functions, stutter and mutter, which are each mutually recursive, and each have multiple clauses. stutter(l) returns l with every odd element repeated. mutter(l) returns l with every even element repeated.

def stutter([]) = []
def stutter(h:t) = h:h:mutter(t)
def mutter([]) = []
def mutter(h:t) = h:stutter(t)

Clauses of mutually recursive functions may also be interleaved, to make them easier to read.

def even(0) = true
def odd(0) = false
def even(n) = odd(if n > 0 then n-1 else n+1)
def odd(n) = even(if n > 0 then n-1 else n+1)