Exceptions

Exceptions
You are encouraged to solve this task according to the task description, using any language you may know.

Control Structures

These are examples of control structures. You may also be interested in:

• Conditional structures
• Exceptions
• Flow-control structures
• Loops

This task is to give an example of an exception handling routine and to "throw" a new exception.

Cf. Exceptions Through Nested Calls

Ada

Define an exception

<lang ada>Foo_Error : exception;</lang>

Raise an exception

<lang ada>procedure Foo is begin

  raise Foo_Error;

end Foo;</lang> Re-raising once caught exception: <lang ada> ... exception

  when Foo_Error =>
     if ... then -- Alas, cannot handle it here,
        raise;   -- continue propagation of
     end if;</lang>

Handle an exception

<lang ada>procedure Call_Foo is begin

  Foo;

exception

  when Foo_Error =>
     ... -- do something
  when others =>
     ... -- this catches all other exceptions

end Call_Foo;</lang>

Ada.Exceptions

The standard package Ada.Exceptions provides a possibility to attach messages to exceptions, to get exception occurrence information and textual description of exceptions. The following example illustrates basic functionality of: <lang ada>with Ada.Exceptions; use Ada.Exceptions; with Ada.Text_IO; use Ada.Text_IO;

procedure Main is begin

  ...
  Raise_Exception (Foo_Error'Identity, "This is the exception message");
  ..

exception

  when Error : others =>
     Put_Line ("Something is wrong here" & Exception_Information (Error));

end Main;</lang>

ALGOL 68

Define an exception

<lang algol68># a user defined object # MODE OBJECTFOO = STRUCT ( PROC (REF OBJECTFOO)BOOL foo event mended, ... );

PROC on foo event = (REF OBJECTFOO foo, PROC (REF OBJECTFOO)BOOL foo event)VOID: (

 foo event mended OF foo := foo event

);</lang>

Raise an exception

<lang algol68>OBJECTFOO foo proxy := foo base; # event routines are specific to an foo #

on foo event(foo proxy, raise foo event);

WHILE TRUE DO

 # now raise example foo event #
 IF NOT (foo event mended OF foo proxy)(foo proxy) THEN undefined # trace back # FI

OD;</lang> Re-raising once caught exception: <lang algol68>... except foo event:

 IF ... THEN # Alas, cannot handle it here continue propagation of #
   IF NOT (foo event mended OF foo base)(foo base) THEN undefined # trace back # FI
 FI</lang>

Handle an exception

<lang algol68>PROC raise foo event(REF OBJECTFOO foo)BOOL:

 IF mend foo(foo) THEN
   TRUE # continue #
 ELSE
   except foo event
   FALSE # OR fall back to default event routine #
 FI</lang>

Standard Prelude "on event" routines

ALGOL 68 uses event routines extensively in the "standard transput" (stdio) to manage the various events that arise when data is read (or written) to a file or external device. The built in "on event" routines are:

• on char error - if the character transput (input or output) in cannot be converted to the standard character set.
• on format error - if the format specified is incompatible to the data being transput (input or output)
• on line end - if an end of line was read while the program was "transputting" data
• on logical file end - if the end of data was encounted during transput
• on page end - if the end of a page was encounted during transput
• on physical file end - if the end of physical media was encounted during transput
• on value error - if the data transput was incompatibly with the variable being transput, eg a letter when a digit was expected.

All of the above allow the programmer to define a user created event routine when a particular event happens to a particular FILE. When such an event routine is called, then the routine can use any of the standard prelude routine to reposition the FILE and rectify the detected event, eg:

• space or back space
• new line, new page, set or reset.

For example: these may notify the operator to mount a new tape (in the case of physical file end).

The handler is permitted to return TRUE depending on whether the event has been handled and the program can can continue. And FALSE is when event remains unhandled, and the standard prelude event routine should be used. The handler is also permitted to exit to a label (without returning anything) if the user defined event routine determines that processing is complete.

AppleScript

try

<lang applescript>try

   set num to 1 / 0
   --do something that might throw an error

end try</lang>

try-on error

<lang applescript>try

   set num to 1 / 0
   --do something that might throw an error

on error errMess number errNum

   --errMess and number errNum are optional
   display alert "Error # " & errNum & return & errMess

end try</lang>

error

<lang applescript>error "Error message." number 2000</lang>

AutoHotkey

<lang AutoHotkey>foo() If ErrorLevel

 Msgbox calling foo failed with:  %ErrorLevel%

foo() {

 If success
   Return
 Else
   ErrorLevel = foo_error
 Return

}</lang>

C

The setjmp()/longjmp() functions in the C standard library header <setjmp.h> are typically used for exception handling.

try-catch

<lang c>#include <setjmp.h>

enum { MY_EXCEPTION = 1 }; /* any non-zero number */

jmp_buf env;

void foo() {

 longjmp(env, MY_EXCEPTION); /* throw MY_EXCEPTION */

}

void call_foo() {

 switch (setjmp(env)) {
 case 0:                     /* try */
   foo();
   break;
 case MY_EXCEPTION:          /* catch MY_EXCEPTION */
   /* handle exceptions of type MY_EXCEPTION */
   break;
 default:
   /* handle any type of exception not handled by above catches */
 }

}</lang>

C++

C++ has no finally construct. Instead you can do this in the destructor of an object on the stack, which will be called if an exception is thrown.

The exception can be of any type, this includes int's, other primitives, as well as objects.

Defining exceptions

<lang cpp>struct MyException {

 // data with info about exception

};</lang>

There's also a class std::exception which you can, but are not required to derive your exception class from. The advantage of doing so is that you can catch unknown exceptions and still get some meaningful information out. There are also more specific classes like std::runtime_error which derive from std::exception.

<lang cpp>#include <exception> struct MyException: std::exception {

 char const* what() const throw() { return "description"; }

}</lang>

Note that in principle you can throw any copyable type as exception, including built-in types.

Throw exceptions

<lang cpp>// this function can throw any type of exception void foo() {

 throw MyException();

}

// this function can only throw the types of exceptions that are listed void foo2() throw(MyException) {

 throw MyException();

}

// this function turns any exceptions other than MyException into std::bad_exception void foo3() throw(MyException, std::bad_exception) {

 throw MyException();

}</lang>

Catching exceptions

<lang cpp>try {

 foo();

} catch (MyException &exc) {

 // handle exceptions of type MyException and derived

} catch (std::exception &exc) {

 // handle exceptions derived from std::exception, which were not handled by above catches
 // e.g.
 std::cerr << exc.what() << std::endl;

} catch (...) {

 // handle any type of exception not handled by above catches

}</lang>

C#

Works with: Visual Studio version 2005

Defining exceptions

<lang csharp>public class MyException : Exception {

 // data with info about exception

};</lang>

Throw exceptions

<lang csharp>void foo() {

 throw MyException();

}</lang>

Catching exceptions

<lang csharp>try {

 foo();

} catch (MyException e) {

 // handle exceptions of type MyException and derived

} catch {

 // handle any type of exception not handled by above catches

}</lang>

ColdFusion

Catch Exceptions

inside <cfscript>:

<lang cfm>try {

 foo();

} catch (Any e) {

 // handle exception e

}</lang>

otherwise: <lang cfm><cftry> <cfcatch type="Database|..."> </cfcatch> </cftry></lang>

Common Lisp

The Common Lisp condition system allows much more control over condition signaling and condition handling than many exception-based systems. The following example, however, simply defines a condition type, unexpected-odd-number, defines a function get-number which generates a random number, returning it if it is even, but signaling an unexpected-odd-number condition if it is odd. The function get-even-number uses handler-case to call get-number returning its result if no condition is signaled, and, in the case that an unexpected-odd-number condition is signaled, returning one plus the odd number.

<lang lisp>(define-condition unexpected-odd-number (error)

 ((number :reader number :initarg :number))
 (:report (lambda (condition stream)
            (format stream "Unexpected odd number: ~w."
                    (number condition)))))

(defun get-number (&aux (n (random 100)))

 (if (not (oddp n)) n
   (error 'unexpected-odd-number :number n)))

(defun get-even-number ()

 (handler-case (get-number)
   (unexpected-odd-number (condition)
     (1+ (number condition)))))</lang>

A good introduction to Lisp's condition system is the chapter Beyond Exception Handling: Conditions and Restarts from Peter Seibel's Practical Common Lisp.

In Common Lisp, there are functions throw and catch, but these are not related to the condition system. Rather, they provide another mechanism for non-local control transfer.

D

Throw Exceptions

<lang d>void test() {

 throw new Exception("Sample Exception");

}</lang>

Catch Exceptions

<lang d>void test2() {

 try test();
 catch (Exception ex) { writefln(ex); throw ex; /* rethrow */ }

}</lang>

In debug mode, stack traces can be generated via an external package, but the standard library does not support it by default.

Ways to implement finally

<lang d>void test3() {

 try test2();
 finally writefln("test3 finally");

}</lang> Or also with scope guards! <lang d>void test4() {

 scope(exit) writefln("Test4 done");
 scope(failure) writefln("Test4 exited by exception");
 scope(success) writefln("Test4 exited by return or function end");
 test2();

}</lang>

E

Exceptions

An exception object describes what the problem is and has nothing to do with control flow.

Due to E's ancestry as a JVM scripting language, E does not yet have any standard mechanism for user-defined exception types.

A string provided in place of an exception will be coerced to a generic exception object.

There are two control flow constructs used with exceptions: throw and eject.

Throw and catch

throw is the built-in function which throws exceptions in the conventional sense: control goes to the catch block of the most recently entered try/catch construct.

<lang e>def nameOf(arg :int) {

   if (arg == 43) {
       return "Bob"
   } else {
       throw("Who?")
   }

}

def catching(arg) {

   try {
       return ["ok", nameOf(arg)]
   } catch exceptionObj {
       return ["notok", exceptionObj]
   }

}</lang>

<lang e>? catching(42)

1. value: ["not ok", problem: Who?]

? catching(43)

1. value: ["ok", "Bob"]

? catching(45.7)

1. value: ["not ok", problem: the float64 45.7 doesn't coerce to an int]</lang>

However, there is a problem here: exceptions accidentally produced or uncaught from inside a given module can lead to the calling program getting information about the internals that it shouldn't have (possibly a security problem). As a result of this, we are planning to move to a 'sealed exception' model where throw and catch have the same control flow, but only debuggers can see any information in a caught exception other than "a throw happened". For situations where the caller should have information about what happened, the ejector mechanism will be used.

Ejectors

Ejectors provide the same sort of "exit to catch block" control flow that throw/catch do, but with an explicit path rather than implicitly "nearest enclosing". Ejectors are also used as a general purpose control construct as well as for exceptions.

The escape ej { body } catch pat { catch block } construct creates an ejector object and binds it to ej, which is valid for as long as body is executing. An ejector object is a function; if it is called, then control immediately passes to the catch block, with its argument bound to pat.

The above code rewritten to use ejectors:

<lang e>def nameOf(arg :int, ejector) {

   if (arg == 43) {
       return "Bob"
   } else {
       ejector("Who?")
   }

}

def catching(arg) {

   escape unnamed {
       return ["ok", nameOf(arg, unnamed)]
   } catch exceptionObj {
       return ["notok", exceptionObj]
   }

}</lang>

<lang e>? catching(42)

1. value: ["not ok", problem: Who?]

? catching(43)

1. value: ["ok", "Bob"]

? catching(45.7)

1. problem: the float64 45.7 doesn't coerce to an int</lang>

Note that the escape-catch block does not catch the coercion error resulting from passing a float64 instead of an int, since that is an (implicit) throw.

(One further refinement: While an ejector is an ordinary function, which does not return, it is generally desirable to protect against being supplied a function which unexpectedly does return. For this purpose we have throw.eject which calls the supplied function and throws if that function returns: throw.eject(ejector, "Who?"))

The benefit of using ejectors to communicate exceptions, besides the information-leak prevention described above, is that only exceptions intended to be handled by that catch block will be passed to it; unexpected internal errors will be handled by general try/catch handlers.

For example, suppose we have nameOf written as follows:

<lang e>var nameTable := null def nameOf(arg :int, ejector) {

   if (nameTable == null) {
       nameTable := <import:nameTableParser>.parseFile(<file:nameTable.txt>)
   }
   if (nameTable.maps(arg)) {
       return nameTable[arg]
   } else {
       ejector(makeNotFoundException("Who?"))
   }

}</lang>

Suppose that loading the parser, or reading the file, throws a NotFoundException (note this exception type was made up for this example). Even though it is of the same type as the "Who?" exception, it will not be caught by the caller's escape/catch block since it was not passed via the ejector, whereas a traditional "try { ... } catch ex :NotFoundException { ... }" as in other languages would, leading to incorrect handling of the error.

Factor

Throw Exceptions

<lang factor>"Install Linux, Problem Solved" throw

TUPLE: velociraptor ; \ velociraptor new throw</lang>

Or a shorthand for this: <lang factor>ERROR: velociraptor ; velociraptor</lang>

Catch Exceptions

<lang factor>! Preferred exception handling

try-foo

   [ foo ] [ foo-failed ] recover ;

try-bar

   [ bar ] [ bar-errored ] [ bar-always ] cleanup ;

! Used rarely [ "Fail" throw ] try  ! throws a "Fail" [ "Fail" throw ] catch ! returns "Fail" [ "Hi" print ] catch  ! returns f (looks the same as throwing f; don't throw f) [ f throw ] catch  ! returns f, bad! use recover or cleanup instead</lang>

Forth

Forth's exception mechanism is, like most things in Forth, very simple but powerful. CATCH captures the data and return stack pointers, then executes an execution token. THROW conditionally throws a value up to the most recent CATCH, restoring the stack pointers.

Throw Exceptions

<lang forth>: f ( -- ) 1 throw ." f " ; \ will throw a "1"

g ( -- ) 0 throw ." g " ; \ does not throw</lang>

Catch Exceptions

<lang forth>: report ( n -- ) ?dup if ." caught " . else ." no throw" then ;

test ( -- )

 ['] f catch report
 ['] g catch report ;</lang>

test example. (Output shown in bold) <lang forth>cr test caught 1 g no throw ok</lang>

Note that CATCH only restores the stack pointers, not the stack values, so any values that were changed during the execution of the token will have undefined values. In practice, this means writing code to clean up the stack, like this: <lang forth>10 ['] myfun catch if drop then</lang>

Haskell

Exceptions can be implemented using monads; no special syntax is necessary.[1] In GHC, specialized functionality for exceptions are provided by the Control.Exception module.

Defining exceptions

The type "Exception", which contains pre-defined exceptions, cannot be extended. You can however use "dynamic exceptions", which can be of any type that is of "Typeable" class.

Throw exceptions

In the context of the IO monad, use "throwIO" to throw exceptions; the expression will return any type: <lang haskell>do {- ... -}

  throwIO SomeException</lang>

In purely functional context, use "throw" to throw exceptions; the expression will match any type: <lang haskell>if condition then 3 else throw SomeException</lang>

To throw a user-defined exception, use "throwDyn": <lang haskell>if condition then 3 else throwDyn myException</lang>

Catching exceptions

The "catch" function performs the whole try-catch stuff. It is usually used in infix style: pattern-matches on the exception type and argument: <lang haskell>do

 {- do IO computations here -}

`catch` \ex -> do

 {- handle exception "ex" here -}</lang>

Note: Control.Exception's "catch" is different than Prelude's "catch".

To catch a user-defined exception, use "catchDyn": <lang haskell>do

 {- do IO computations here -}

`catchDyn` \ex -> do

 {- handle exception "ex" here -}</lang>

J

Tacit

Program u :: v executes u and provides its result as output unless an error occurs. In case of error, the result of v is provided instead.

Explicit

An exception in an explicit definition can be detected with try. and catcht. and can be thrown with throw. as seen below.

<lang j> pickyPicky =: verb define

    if. y-:'bad argument' do.
       throw.
    else.
       'thanks!'
    end.
  )
  
  tryThis  =: verb define
    try.
       pickyPicky y
    catcht.
       'Uh oh!'
    end.
  )

  tryThis 'bad argument'

Uh oh!</lang>

Java

An exception needs to extend the Exception type.

Defining exceptions

<lang java>//Checked exception public class MyException extends Exception {

  //Put specific info in here

}

//Unchecked exception public class MyRuntimeException extends RuntimeException {}</lang>

Throw exceptions

<lang java>public void fooChecked() throws MyException {

  throw new MyException();

}

public void fooUnchecked() {

  throw new MyRuntimeException();

}</lang>

Catching exceptions

<lang java>try {

  fooChecked();

} catch(MyException exc) {

  //Catch only your specified type of exception

} catch(Exception exc) {

  //Catch any non-system error exception

} catch(Throwable exc) {

  //Catch everything including system errors (not recommended)

} finally {

  //This code is always executed after exiting the try block

}</lang>

JavaScript

Throwing exceptions

<lang javascript>function doStuff() {

 throw new Error('Not implemented!');

}</lang>

Catching exceptions

<lang javascript>try {

 element.attachEvent('onclick', doStuff);

} catch(e if e instanceof TypeError) {

 element.addEventListener('click', doStuff, false);

} finally {

 eventSetup = true;

}</lang>

Logo

Works with: UCB Logo

<lang logo>to div.checked :a :b

 if :b = 0 [(throw "divzero 0)]
 output :a / :b

end to div.safely :a :b

 output catch "divzero [div.checked :a :b]

end</lang> There are also some predefined exceptions:

• throw "toplevel returns to the interactive prompt if uncaught (like control-C)
• (throw "error [message]) prints a message like a primitive, bypassing normal catch output
• throw "system immediately exits Logo to the shell
• catch "error will catch any thrown error instead of printing an error message

Make

In make, an exception is caused when a rule returns a non-zero status i.e the below will fail as false returns 1, (thus raising exception)

fail.mk

<lang make>all:

    false</lang>

Using -@ to ignore the exception.

catch.mk

<lang make>all:

   -@make -f fail.mk</lang>

Using explicit exit 0 to ignore the exception.

catch.mk

<lang make>all:

   make -f fail.mk; exit 0</lang>

Modula-3

Defining exceptions

Exceptions can only be declared at the "top-level" of a module or interface. Arguments are optional. <lang modula3>EXCEPTION EndOfFile; EXCEPTION Error(TEXT);</lang>

Throw exceptions

Exceptions can be bound to procedures using RAISES: <lang modula3>PROCEDURE Foo() RAISES { EndOfFile } =

 ...
 RAISE EndOfFile;
 ...</lang>

Catching exceptions

<lang modula3>TRY

 Foo();

EXCEPT | EndOfFile => HandleFoo(); END;</lang>

Modula-3 also has a FINALLY keyword: <lang modula3>TRY

 Foo();

FINALLY

 CleanupFoo(); (* always executed *)

END;</lang>

MOO

Throw exceptions

Values can be raised to exceptions using raise(): <lang moo>raise(E_PERM);</lang>

Catching exceptions

<lang moo>try

 this:foo();

except e (ANY)

 this:bar(e);

endtry</lang>

MOO also has a finally statement: <lang moo>try

 this:foo();

finally

 this:bar();

endtry</lang>

Shorthand

<lang moo>`this:foo()!ANY=>this:bar()';</lang>

Objective-C

Defining exceptions

Exceptions can be any Objective-C object, though they are usually instances of NSException. You can create a subclass of NSException if necessary: <lang objc>@interface MyException : NSException {

 //Put specific info in here

} @end</lang>

Throw exceptions

<lang objc>- (void)foo {

 @throw [NSException exceptionWithName:@"TerribleException"
                                reason:@"OMGWTFBBQ111!1"  userInfo:nil];

}</lang>

Catching exceptions

<lang objc>@try {

 [self foo];

} @catch (MyException *exc) {

 //Catch only your specified type of exception

} @catch (NSException *exc) {

 //Catch any NSException or subclass
 NSLog(@"caught exception named %@, with reason: %@", [exc name], [exc reason]);  

} @catch (id exc) {

 //Catch any kind of object

} @finally {

 //This code is always executed after exiting the try block

}</lang>

OCaml

Defining exceptions

Like constructors, exceptions may or may not have an argument: <lang ocaml>exception My_Exception;; exception Another_Exception of string;;</lang>

Throw exceptions

Throw exceptions with the "raise" function; the expression will match any type: <lang ocaml>let foo x =

 match x with
   1 -> raise My_Exception
 | 2 -> raise (Another_Exception "hi mom")
 | _ -> 5

</lang>

Catching exceptions

The "with" syntax pattern-matches on the exception type and argument: <lang ocaml>try

 string_of_int (foo 2)

with

 My_Exception        -> "got my exception"

| Another_Exception s -> s | _ -> "unknown exception"</lang>

Oz

Throw exceptions

Any value can be thrown as an exception. Typically record values are used. <lang oz>raise sillyError end raise slightlyLessSilly(data:42 reason:outOfMemory) end</lang>

Catching exceptions

Exception are caught with pattern matching. Ellipsis indicating additional optional fields are often useful here. <lang oz>try

  {Foo}

catch sillyError then

  {Bar}

[] slightlyLessSilly(data:D ...) then

  {Quux D}

[] _ then %% an unknown type of exception was thrown

  {Baz}

finally

  {Fin}

end</lang>

Perl

<lang perl># throw an exception die "Danger, danger, Will Robinson!";

1. catch an exception and show it

eval {

   die "this could go wrong mightily";

}; print $@ if $@;

1. rethrow

die $@;</lang>

See http://perldoc.perl.org/perlvar.html#%24EVAL_ERROR for the meaning of the special variable $@. See http://search.cpan.org/dist/Error for advanced object based-exception handling.

PHP

Works with: PHP version 5.0+

Exceptions were not available prior to PHP 5.0

Define exceptions

<lang php>class MyException extends Exception {

   //  Custom exception attributes & methods

}</lang>

Throwing exceptions

<lang php>function throwsException() {

   throw new Exception('Exception message');

}</lang>

Catching Exceptions

<lang php>try {

   throwsException();

} catch (Exception $e) {

   echo 'Caught exception: ' . $e->getMessage();

}</lang>

Pop11

Throwing exceptions

<lang pop11>define throw_exception();

  throw([my_exception my_data]);

enddefine;</lang>

Catching exceptions

<lang pop11>define main();

  vars cargo;
  define catcher();
     ;;; print exception data
     cargo =>
  enddefine;
  catch(throw_exception, catcher, [my_exception ?cargo]);

enddefine;

main();</lang>

Python

Defining an exception

<lang python>import exceptions class SillyError(exceptions.Exception):

   def __init__(self,args=None):
        self.args=args</lang>

Note: In most cases new exceptions are defined simply using the pass statement. For example:

<lang python>class MyInvalidArgument(ValueError):

  pass</lang>

This example makes "MyInvalidArgument" an type of ValueError (one of the built-in exceptions). It's simply declared as a subclass of the existing exception and no over-riding is necessary. (An except clause for ValueError would catch MyInvalidArgument exceptions ... but one's code could insert a more specific exception handler for the more specific type of exception).

Throwing an exception

Works with: Python version 2.x and 3.x

Creating an exception using the default constructor of an exception class: <lang python>def spam():

   raise SillyError # equivalent to raise SillyError()</lang>

Works with: Python version 2.5

Passing an argument to the constructor of an exception class: <lang python>def spam():

   raise SillyError, 'egg' # equivalent to raise SillyError('egg')</lang>

The above syntax is removed in Python 3.0; but the following syntax works in Python 2.x and 3.x, so should be preferred.

Works with: Python version 2.x and 3.x

<lang python>def spam():

   raise SillyError('egg')</lang>

Handling an exception

Works with: Python version 2.5

try-except-else-finally

<lang python>try:

  foo()

except SillyError, se:

  print se.args
  bar()

else:

  # no exception occurred
  quux()

finally:

  baz()</lang>

Before Python 2.5 it was not possible to use finally and except together. (It was necessary to nest a separate try...except block inside of your try...finally block).

Works with: Python version 3.0

Note: Python3 will change the syntax of except slightly, but in a way that is not backwards compatible. In Python 2.x and earlier the except statement could list a single exception or a tuple/list of exceptions and optionally a name to which the exception object will be bound. In the old versions the exception's name followed a comma (as in the foregoing example). In Python3 the syntax will become: except Exception1 [,Exception2 ...] as ExceptionName <lang python>try:

  foo()

except SillyError as se:

  print(se.args)
  bar()

else:

  # no exception occurred
  quux()

finally:

  baz()</lang>

Raven

<lang raven>42 as custom_error

define foo

   custom_error throw

try

   foo

catch

   custom_error =
   if  'oops' print</lang>

Ruby

Defining an exception

<lang ruby>class SillyError < Exception

   def initialize(args = nil)
        @args = args
   end

end</lang>

Note: Often new exceptions are defined simply with no body. For example:

<lang ruby>class MyInvalidArgument < ArgumentError end</lang>

This example makes "MyInvalidArgument" an type of ArgumentError (one of the built-in exceptions). It's simply declared as a subclass of the existing exception and no over-riding is necessary. (A rescue clause for ArgumentError would catch MyInvalidArgument exceptions ... but one's code could insert a more specific exception handler for the more specific type of exception).

Throwing an exception

<lang ruby>def spam

   raise SillyError, 'egg'

end</lang>

Handling an exception

rescue/else/ensure

<lang ruby>begin

   foo

rescue SillyError, se

   print se.args
   bar()

else

   # no exception occurred
   quux

ensure

   baz

end</lang>

The "rescue" clause is like the "catch" clause in other languages. The "ensure" clause is like the "finally" clause in other languages.

Catch/Throw

Ruby has a separate exception-like system that is meant to be used to exit out of deep executions that are not errors.

<lang ruby>def foo

   throw :done

end

catch :done do

   foo

end</lang>

You can only "throw" and "catch" symbols. Like exceptions, the throw can be made from a function defined elsewhere from the catch block.

Slate

Handling Exceptions

<lang slate>se@(SceneElement traits) doWithRestart: block [

 block handlingCases: {Abort -> [| :_ | ^ Nil]}

].</lang>

Define Exceptions

<lang slate>conditions define: #Abort &parents: {Restart}. "An Abort is a Restart which exits the computation, unwinding the stack."

_@lobby abort [

 Abort signal

]. _@(Abort traits) describeOn: console [

 console ; 'Abort evaluation of expression\n'

].

"This will call:" c@(Condition traits) signal "Signalling a Condition." [

 c tryHandlers

].</lang>

Throwing Exceptions

Some lines in this example are too long (more than 80 characters). Please fix the code if it's possible and remove this message.

<lang slate>(fileName endsWith: '.image') ifTrue: [error: 'Image filename specified where Slate source expected. Make sure you run slate with the -i flag to specify an image.'].</lang>

Standard ML

Define Exceptions

<lang sml>exception MyException; exception MyDataException of int; (* can be any first-class type, not just int *)</lang>

Throw Exceptions

<lang sml>fun f() = raise MyException; fun g() = raise MyDataException 22;</lang>

Catch Exceptions

<lang sml>val x = f() handle MyException => 22; val y = f() handle MyDataException x => x;</lang>

Tcl

<lang tcl>package require Tcl 8.5

1. Throw

proc e {args} {

   error "error message" "error message for stack trace" {errorCode list}

}

1. Catch and rethrow

proc f {} {

   if {[catch {e 1 2 3 4} errMsg options] != 0} {
       return -options $options $errMsg 
   }

}

f</lang> This creates the stack trace

error message for stack trace
    (procedure "e" line 1)
    invoked from within
"e 1 2 3 4"
    (procedure "f" line 2)
    invoked from within
"f"

Ursala

In this program fragment, a function named thrower returns the string 'success' if its argument is non-empty, but otherwise raises an exception with the diagnostic message 'epic fail'. (The diagnostic message can also be made to depend on the input.) <lang Ursala>#import std

thrower = ~&?/'success'! -[epic fail]-!%

catcher = guard(thrower,---[someone failed]-)</lang>

If the exception is not caught, the program terminates immediately and the diagnostic is written to stderr. Alternatively, a calling function or any caller thereof can be defined to catch an exception as shown. The exception handler may inspect and arbitrarily modify the diagnostic message, but normal execution may not be resumed. In this example, the exception handler appends some additional verbiage to the message.

V

throwing exceptions <lang v>[myproc

 ['new error' 1 2 3] throw
 'should not come here' puts

].</lang>

catching them

<lang v>[myproc] [puts] catch =[new error 1 2 3]</lang>

Visual Basic .NET

Defining exceptions

<lang vbnet>Class MyException

 Inherits Exception
 'data with info about exception

End Class</lang>

Throw exceptions

<lang vbnet>Sub foo()

   Throw New MyException

End Sub</lang>

Catching exceptions

<lang vbnet>Sub bar()

   Try
       foo()
   Catch e As MyException When e.Data.Contains("Foo")
       ' handle exceptions of type MyException when the exception contains specific data
   Catch e As MyException
       ' handle exceptions of type MyException and derived exceptions
   Catch e As Exception
       ' handle any type of exception not handled by above catches
   Finally
       'code here occurs whether or not there was an exception
   End Try

End Sub</lang>