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

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

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

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

  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

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 {