Base class for exceptions

To install, run:

haxelib install exception 1.0.2 

See using Haxelib in Haxelib documentation for more information.


Exception TravisCI Build Status

haxe.Exception is the base class for your exceptions.


Creating your own exceptions:

class TerribleErrorException extends haxe.Exception {}

throw new TerribleErrorException('OMG!');

Wrapping third-party exceptions:

import haxe.Exception;

try {
	throw 'Terrible error!';
} catch (e:Dynamic) {
	throw Exception.wrap(e);
	//or if you want to keep original exception stack
	throw Exception.wrap(e).setStack(haxe.CallStack.exceptionStack());

Rethrowing exceptions:

import haxe.Exception;

class Test {
	static function fail() throw new Exception('OMG!');

	static function rethrow() {
		try {
		} catch(e:Exception) {
			throw new Exception('Rethrown', e);

	static function doStuff() {

	static public function main() {
		try {
		} catch(e:Exception) {

That second exception will look like this when stringified:

Test.hx:22: Exception: OMG!
Called from Test::fail line 4
Called from Test::rethrow line 8

Next Exception: Rethrown
Called from Test::rethrow line 10
Called from Test::doStuff line 15
Called from Test::main line 20
Called from StringBuf::$statics line 1


Module haxe.Exception:

class Exception {
	/** Message of this exception. */
	public var message(default,null):String;
	/** Call stack of the line where this exception was created. */
	public var stack(default,null):Stack;
	/** Previously caught exception. */
	public var previous(default,null):Null<Exception>;
	 *  Creates an instance of `Exception` using `e` as message.
	 *  If `e` is already an instance of `Exception` then `e` is returned as-is.
	static public inline function wrap (e:Dynamic):Exception;
	 *  String representation of this exception.
	 *  Includes message, stack and the previous exception (if set).
	public function toString():String;

 *  Call stack for exceptions
abstract Stack(Array<StackItem>) from Array<StackItem> to Array<StackItem> {
	 *  Get current call stack.
	public inline function new();
	 *  Returns string representation of this call stack.
	public inline function toString():String;
	 *  Iterator to be able to iterate over items of this stack.
	public inline function iterator():StackIterator<StackItem>;
	 *  Array access for reading arbitrary items of this stack.
	@:arrayAccess inline function get(index:Int):StackItem;
	 *  Returns a range of entries of current stack from the beginning to the the common part of this and `stack`.
	public function subtract(stack:Stack):Stack;

Happy throwing!

4 months ago

All libraries are free

Every month, more than thousand developers use haxelib to find, share, and reuse code — and assemble it in powerful new ways. Enjoy Haxe; It is great!

Explore Haxe

Haxe Manual

Haxe Code Cookbook

Haxe API documentation

You can try Haxe in the browser! try.haxe.org

Join us on Github!

Haxe is being developed on GitHub. Feel free to contribute or report issues to our projects.

Haxe on Github