In many object-oriented programming languages, one calls a method or accesses a field of an object using the dot operator; for example, obj.m() calls the method m of the object obj.

There is a special kind of site call in Orc which serves a similar purpose. One may write x.msg, for any identifiers x and msg. This treats the value bound to x as a site, and calls it with a special message value msg. If the site understands the message msg (for example, if x is bound to a Java object with a field called msg), the site interprets the message and responds with some appropriate value. If the site does not understand the message sent to it, it does not respond, and no publication occurs. If x cannot be interpreted as a site, no call is made.

Typically this capability is used so that sites may be syntactically treated like objects, with multiple methods and fields. For example, a channel c might understand the messages get and put, to get values from and put values on that channel, respectively. Such calls would be written c.get(), or c.put(6).

A call such as c.put(6) actually occurs in two steps. First c.put sends the message put to the site c; this publishes a site whose only purpose is to put values on the channel. Next, that site is called on the argument 6, sending 6 on the channel. Readers familiar with functional programming will recognize this technique as currying.

It is sometimes useful to stage the arguments to a function; that is, rather than writing a function on two arguments, one instead writes a function on one argument which returns a function taking the second argument and performing the remainder of the evaluation.

This technique is known as currying and it is common in functional programming languages. We can write curried functions using closures. Suppose we want to define a curried addition function on two arguments, and later apply that function to the arguments 3 and 4. We could write such a program in the following way:

def Sum(a) = ( lambda(b) = a+b )  
val f = Sum(3)
f(4)

When defining a curried function, we have abstracted it in two steps, and when applying it we have written two separate calls. However, this is verbose and not very clear. Orc has a special syntax for curried function definitions and curried applications that will simplify both of these steps. Function definitions may have multiple argument sequences; they are enclosed in parentheses and concatenated. Curried function calls chain together multiple applications in a similar way. Here is the previous program, written in this simplified syntax:

def Sum(a)(b) = a+b
Sum(3)(4)

def Sum(a) = ( lambda(b) = a+b )  
Sum(3)(4)

def Sum(a)(b) = a+b  
val f = Sum(3)
f(4)

def sum(x)(0) = x
def sum(x)(y) = x + y
sum(2)(3)

def sum(x) = ( lambda(0) = x )
def sum(x) = ( lambda(y) = x + y )
sum(2)(3)

In taking apart a value with a pattern, it is often useful to capture intermediate results.

val (a,b) = ((1,2),(3,4))
val (ax,ay) = a
val (bx,by) = b

val ((ax,ay) as a, (bx,by) as b) = ((1,2),(3,4))

When a variable occurs in a pattern, it is bound to the value being matched against that pattern. What if instead we would like to use the value of a bound variable as a test pattern, in a way similar to a literal value like 0?

We can use an equality pattern to do this. An equality pattern is a variable name preceded by =. Consider the following definition, which compares its argument to the value bound to variable x, returning true if they are equal and false otherwise.

def isx(=x) = true
def isx(_) = false

The equality pattern becomes much more useful when it is embedded within other patterns. For example, consider this definition withz. If one of the arguments passed to it is equal to z, then the function returns its other argument. Otherwise it remains silent.

def withz(=z,y) = y
def withz(x,=z) = x

When Orc is run on top of an object-oriented programming language, classes from that language may be used as sites in Orc itself, via the class declaration.

{- Use the String class from Java's standard library as a site -}
class String = java.lang.String
val s = String("foo")
s.concat("bar")

This program binds the variable String to Java's String class. When it is called as a site, it constructs a new instance of String, passing the given arguments to the constructor.

This instance of String is a Java object; its methods are called and its fields are accessed using the dot (.) notation, just as one would expect in Java. For complete details of how Orc interacts with Java, see Java Integration.

It is often convenient to group related declarations into units that can be shared between programs. The include declaration offers a simple way to do this. It names a source file containing a sequence of Orc declarations; those declarations are incorporated into the program as if they had textually replaced the include declaration. An included file may itself contain include declarations.

{- Contents of fold.inc -}
def foldl(f,[],s) = s
def foldl(f,h:t,s) = foldl(f,t,f(h,s))

def foldr(f,l,s) = foldl(f,rev(l),s)

{- This is the same as inserting the contents of fold.inc here -}
include "fold.inc"

def sum(L) = foldl(lambda(a,b) = a+b, L, 0)

sum([1,2,3])

Note that these declarations still obey the rules of lexical scope. Also, Orc does not detect shared declarations; if the same file is included twice, its declarations occur twice.