frabbit

public static function getFirstPath (from:ClassType, to:ClassType):Option<Path> 
  {

    function loop(from:ClassType, to:ClassType, path:Path) 
    {
      trace(loop);

      return if (ClassTypes.eq(from, to)) {
        Some(path);
      } else {

frabbit

  public static function getFirstPath (from:ClassType, to:ClassType):Option<Path> 
  {
    
    function loop(from:ClassType, to:ClassType, path:Path) 
    {
      trace(loop); // boom, loop is null in my case
      
      function findInSuperOrInterface () 
      {
        function findInSuper () 

frabbit

// two special types to fake type constructor ploymorphism.
@:native('Dynamic')
class Of<M,A> {}

class In {}
interface Functor<F>
{
  public function map<A,B>(val:Of<F,A>, f:A->B):Of<F,B>;
}
class ArrayFunctor implements Functor<Array<In>>

frabbit

// - Implicit and explicit PA (via partial function)
// - Short alternative for partial => part, foo.part(_)
// - Implicit as default usage (short and concise), explicit for corner cases, where implicit usage is not possible/ambigous
// - Explicit PA can handle all cases that implicit PA can handle + corner cases
// - Implicit PA is only applied if one of the arguments is an underscore


function foo(x:Array<Int>, ?a:Int, ?b:Int):Void;

// Implicit         Explicit               Type

frabbit

abstract FunctionReturning<T>(Dynamic) {
  inline function new (x:Dynamic) this = x;
  @:from static inline function from0 <T>(x:Void->T):FunctionReturning<T> return new FunctionReturning(x);
  @:from static inline function from1 <T>(x:Dynamic->T):FunctionReturning<T> return new FunctionReturning(x);
  @:from static inline function from2 <T>(x:Dynamic->Dynamic->T):FunctionReturning<T> return new FunctionReturning(x);
  @:from static inline function from3 <T>(x:Dynamic->Dynamic->Dynamic->T):FunctionReturning<T> return new FunctionReturning(x);
  /* ... */
}

class Test {

frabbit

abstract Choice<A,B>(Dynamic) {
  	inline function new (x:Dynamic) this = x;
	@:from static inline function fromA <A,B>(x:A):Choice<A,B> return new Choice(x);
	@:from static inline function fromB <A,B>(x:B):Choice<A,B> return new Choice(x);
}

class Test {

	public static function expectStringOrInt (x:Choice<String, Int>) {
		

frabbit

package ;

using TestX.Eqs;

// consider the following interfaces

interface Compare<T> {
   public function compare(b:T):Int;
}
interface Eq<T> {

frabbit

using Main.PosBuilders;

typedef Pos = { x: Int, y:Int};

private extern class ISSET {}
private extern class UNSET {}

@:allow(Main.PosBuilders) class PosBuilder<X,Y> { 
	public function new (x,y) {
		this.x = x;

frabbit

interface Category<M> 
{
  // identity value in this category
  public function id <A>():OfOf<M, A, A>;
  /**
   * Category composition Operator.
   * 
  **/
  public function dot <A,B,C>(g:OfOf<M, B, C>, f:OfOf<M, A, B>):OfOf<M, A, C>;

frabbit

interface Filterable<M, A> {
   public function filter (f:A->Bool):Of<M,A>;
}

class MyArray<A> implements Filterable<MyArray<In>, A> {
   var a:Array<A>;
   public function new (?a:Array<A>) {
     this.a = a == null ? [] else a;
   }
   public function filter(f:A->Bool):MyArray<A> {