We have added an experimental implementation of exceptions to the Orc language, which allows exceptions to be raised, caught, and handled. Exceptions are currently off by default, and can be enabled by adding the -exceptions flag on the command line. It should also be noted that exception handling in Orc are currently experimental, and may be removed in a future release.

Exceptions introduce three new keywords to the Orc syntax: throw, try, and catch, which are defined as follows:

throw E: for each publication x by expression E, raise an exception with value x.

try E: Defines E to be a block, possibly containing throw expressions.

catch ( P ) E: Given pattern P and expression E, any exception with value x that matches pattern P causes execution of E under the binding of P to x. For each corresponding try expression, one or more catch statements are defined. Catch statements are executed in order, and the first to match is the statement executed.

Examples of throw expressions:

throw 3
throw "error"
throw (3 | 4)    {- throws two exceptions -}
throw stop       {- throws no exceptions -}

{- simple exception expressions -}
try(0 | throw 1 | throw 2) 
catch (1) "one"
catch (x) x               
catch (2) "two"           

{- Output: 0, "one", 2 -}

Exception handlers can also be nested; if the immediately enclosing try/catch block has no handler that matches the thrown exception, the Orc interpreter attempts to match against the next enclosing handler. If no handler matches the exception (or no enclosing handler exists) the exception is dropped (for example, it is treated as a stop) and an error is reported to the interpreter.

{- a contrived nested handler example -}
try(
  try(throw 3)
  catch (1) "one"
)
catch (x) x

When combining exceptions with the combinators, i.e., the pruning or otherwise combinators, exceptions are silent, that is, they do not publish any value. For example, in the following expression, both 0 and 1 are published; throw 0 is silent, not publishing any value, causing the otherwise combinator to also execute its alternate expression:

{- the throw expression is treated as a silent by the combinators -}
try (throw 0; 1) catch(x) x

{- output: 
0
1
-}

Similarly, exceptions thrown within a pruning combinator do not terminate the expression (since the throw is treated as a silent), and throwing a silent expression (i.e., throw stop) results in no exception being thrown; the entire expression functions as a stop. Unlike other languages, an uncaught exception only kills the process that threw it, and the other processes in the system will continue running. In the example below, the entire expression publishes no value (because the expression inside the pruning combinator does not publish). Instead, the exception thrown is uncaught and results in a runtime error:

x <x< throw 2

{- output:
Error: uncaught exception:
Backtrace:
OrcJava/examples/uncaught.orc:1:8-15:  x <x< throw 2
-}

{- catching exceptions thrown by Java sites via pattern matching -}
class FileInputStream = java.io.FileInputStream
class FileNotFoundException = java.io.FileNotFoundException

...

try(
FileInputStream("non/existent/file/path")
) catch (FileNotFoundException(e)) e

...

{- Detecting runtime errors using exceptions -}
class ArgumentTypeMismatchException = orc.error.runtime.ArgumentTypeMismatchException

try(
  if 3 then "foo"
) catch (ArgumentTypeMismatchException(e)) "error"

{- error handling without exceptions: -}
def makeRequest() = 
  let(request() >x> (true, x) | Rtimer(1000) >> (false, "timeout"))

def call() =
  makeRequest() >(success, result)> if success then result else "failed"

{- error handling with exceptions -}
def makeRequest() = 
  request() | Rtimer(1000) >> throw("timeout")

def call() =
  try( makeRequest() ) catch (_) "failed"

class FileNotFoundException = java.io.FileNotFoundException
try
  ...
catch (FileNotFoundException(e))
  ...