Example.hx

class Future<T> {
  var t:T;
  public function new () {}
  
  public function setValue (t:T) { this.t = t; }
}

class Futures {
  public static function create<T>():Future<T> return new Future<T>()
}

class FuturesInt {
  public static function withFuture(f:Future<Int>, i:Int):Int return i
}

class FuturesString {
  public static function withFuture(f:Future<String>, s:String):String return s
}

using Example.FuturesInt; // takes precedence over FuturesString when type is Unknown
using Example.FuturesString;

class Example {
  public static function main() 
  {
    // works as expected when used with constructor
    new Future<String>().withFuture("hi"); 
    
    // this is the suggested feature, but it is currently not allowed
    Futures.asFuture<String>().withFuture("hi"); // Unexpected )
    
    // this cannot work, because T is unknown and because of that the compiler uses the first version of withFuture which expects an Int
     Futures.create().withFuture("hi"); // String should be Int
    
    // dirty workaround with a temp variable
    var f:Future<String> = Futures.create();
    f.withFuture("hi");
  }
}