Exceptions: Difference between revisions

=={{header|Ada}}==

===Define an exception===

Foo_Error : exception;

===Raise an exception===

procedure Foo is

begin

raise Foo_Error;

end Foo;

Re-raising once caught exception:

...

exception

raise; -- continue propagation of

end if;

===Handle an exception===

procedure Call_Foo is

begin

... -- this catches all other exceptions

end Call_Foo;

===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:

with Ada.Exceptions; use Ada.Exceptions;

with Ada.Text_IO; use Ada.Text_IO;

Put_Line ("Something is wrong here" & Exception_Information (Error));

end Main;

=={{header|ALGOL 68}}==

===Define an exception===

===Defining exceptions===

struct MyException

{

// data with info about exception

};

#include <exception>

struct MyException: std::exception

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

}

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

===Throw exceptions===

// this function can throw any type of exception

void foo()

throw MyException();

}

===Catching exceptions===

try {

foo();

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

}

=={{header|C sharp|C #}}==

=={{header|Haskell}}==

===Defining exceptions===

=={{header|J}}==

pickyPicky =: verb define

===Defining an exception===

class SillyError(exceptions.Exception):

def __init__(self,args=None):

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

class MyInvalidArgument(ValueError):

pass

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===

===Handling an exception===

try-except-finally-else

foo()

except SillyError, se:

else:

# no exception occurred

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).

===Defining an exception===

def initialize(args = nil)

@args = args

end

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

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===

raise SillyError, 'egg'

===Handling an exception===

rescue/else/ensure

foo

rescue SillyError, se

ensure

baz

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

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

throw :done

end

catch :done do

foo

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