Skip to content

Simn-haxe2/hxop

 
 

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Haxe operator overloading

OBSOLETE: This library is no longer maintained

This library enables overloading of unary and binary haxe operators. It can be used to allow mathematical operations on complex data structures, or give a whole new meaning to the array access operator [] or the new operator.

Usage

Working with this library consists of two steps:

  1. Create a class YourOperatorClass defining the operators and
  2. add implements hxop.Overload<YourOperatorClass> where you want to use it

Bundled with this library are a few operator-defining classes, which include

  • Int32 and Int64: use haxe.Int32 and haxe.Int64 as if they were normal Ints
  • Point: support for nme's Point data structure
  • Complex: use concise infix notation on complex numbers
  • Quaternion: if you want to rotate things in funny ways, this math is for you
  • Reflection: translate o["field"] to matching Reflect calls

Defining and using operators

You create your own operators by defining a class with static fields annotated by @op("operator"). As a non-mathematical example, assume that you have a class Signal that dispatches events to registered listeners. You like C#'s += operator, so you want to mimic this in haxe:

  • SignalMath.hx

class SignalMath
{
	@op("+=") static public function add(lhs:Signal, rhs:Void->Void)
	{
		lhs.add(rhs);
		return lhs;
	}
}

With just that you can start using your += operator like so:

  • Main.hx

class Main implements hxop.Overload<SignalMath>
{
	static public function main()
	{
		var signal = new Signal();
		s1 += function()
		{
			trace("I was called today.");
		}
		s1.dispatch();
	}
}

Remarks

  • @op accepts a second argument of type Bool, which defaults to false and defines if an operator is commutative. For example, if you define an operator + that adds Float and Point, you likely want to allow this on both (Float + Point) and (Point + Float), so you would set this argument to true. Note that this only makes sense if your operands are of different types.
  • If you have a situation where you want to disable overloading for a specific function of a class implementing hxop.Overload, you can annotate it with @noOverload.
  • Usually, assignment operators such as += and *= generate an assignment of their return value to the left hand side argument. If you wish to disable it for certain operators, you can add the @noAssign metadata.
  • Supported operators are all unary and binary haxe operators. Also, array access [] is treated as a binary operator lhs[rhs] and new is supported as a pseudo-operator.

About

Operator overloading for haxe.

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages

  • Haxe 100.0%