AbsPerson.hx

abstract AbsPerson<X>(Person<X>) {
	public function new(x) {
		this       = x;
	}

	@:from public static function fromAlice(a : Alice) : AbsPerson<Alice> {
		return new AbsPerson(A(a));
	}

	@:from public static function fromBob(b : Bob) : AbsPerson<Bob> {
		return new AbsPerson(B(b));
	}

	@:from public static function fromPerson<T>(x : Person<T>) : AbsPerson<T> {
		return new AbsPerson(x);
	}

	@:to public function toX() : X {
		return switch(this) {
			case A(a): a;
			case B(b): b;
		}
	}

	@:to public function toAbsPerson() : AbsPerson<X> {
		return this;
	}
}

Alice.hx

enum Alice {
	AliceConst;
}

AliceFactory.hx

class AliceFactory implements PersonInterface<Alice> {
	public function new() { }

	public function make() : Alice {
		return AAliceConst;
	}
}

Bob.hx

enum Bob {
	BobConst;
}

BobFactory.hx

class BobFactory implements PersonInterface<Bob> {
	public function new() { }

	public function make() : Bob {
		return BobConst;
	}
}

Person.hx

enum Person<X> {
	A(x : Alice) : Person<Alice>;
	B(x : Bob)   : Person<Bob>;
}

PersonInterface.hx

interface PersonInterface<X> {
	public function make() : AbsPerson<X>;
}

Test.hx

class Test {
	static function test<T>(m : PersonInterface<T>) : T {
		return m.make();
	}

	static function main() {
		var x = test(new AliceFactory());
		
		$type(x);
		trace(x);
	}
}