Type Inference with Generics that extend other generics

[matejthetree]

• Dart SDK Version Dart SDK version: 2.12.0 (stable) (Thu Feb 25 19:50:53 2021 +0100) on "macos_x64"
• MacOSX

In this code the compiler/analyzer does not recognize that foo inside Boo is Foo<String>

void main() {
  var boo = Boo(FooStringer((String val) => print(val)));
  // boo.foo.call('5'); // this works
  boo.call('5');
}

class Foo<V> {
  final void Function(V) call;

  Foo(this.call);
}

class FooStringer extends Foo<String> {
  FooStringer(void Function(String val) callback) : super(callback);
}

class Boo<T extends Foo<V>, V> {
  final T foo;

  void call(V val) => foo.call(val);

  Boo(this.foo);
}

throws type '(String) => void' is not a subtype of type '(dynamic) => void'

changing Boo to this throws the same error

void main() {
  var boo = Boo(FooStringer((String val) => print(val)));
  // boo.foo.call('5'); // this works
  boo.call('5');
}

class Foo<V> {
  final void Function(V) call;

  Foo(this.call);
}

class FooStringer extends Foo<String> {
  FooStringer(void Function(String val) callback) : super(callback);
}

class Boo<T extends Foo> {
  final T foo;

  void call(String val) => foo.call(val);

  Boo(this.foo);
}

[mraleph]

This is working as intended AFAIK. Type inference algorithm does not infer type parameters from other type parameters.

The second one throws because bound for T if Foo<dynamic> andfoo.call is compiled as foo.call as void Function(dynamic) to ensure soundness. You could make it work if you write the bound as T extends Foo<String>.

Could you provide more information on what you are trying to achieve (rather than a reduced test case?).

/cc @leafpetersen @eernstg

[matejthetree]

I am trying to use Type Inference for creating a framework that revolves around a Type as a main mapping point.

Here is a use case:

I am trying to create a mapping for internal framework that I am designing. And the idea is that the action method is executed every time by constructing the Runner object (Runner is empty here, but there would be dependency injection, and type handlers that would run before passing the parametar to .action;

void main() {
  // Doesn't work
  // var mapping = SignalActionMapping(
  //     signal: UpdateSignal(), action: (val) => Runner().action(val));

  // this works
  // var mapping = SignalActionMapping(
  //     signal: UpdateSignal(), action: (String val) => Runner().action(val));

  // also works
  var mapping = SignalActionMapping(signal: UpdateSignal(), action: action);
}

void action(String val) => print(val);

class Runner {
  void action(String val) => print(val);
}

class UpdateSignal extends Signal<String> {}

class SignalActionMapping<T extends Signal<Y>, Y> {
  final T signal;

  final void Function(Y) action;
  final SignalSubscription<Y> listener;

  SignalActionMapping({
    required T signal,
    required this.action,
  })   : listener = signal.listen((value) => action(signal.cast(value))),
        signal = signal;

  void dispose(scope) => listener.close();
}

typedef SignalListener<T> = void Function(T);

abstract class Signal<T> {
  T cast(dynamic value) => value as T;

  final List<SignalListener<T>> listeners = [];

  SignalSubscription<T> listen<Y>(SignalListener<T> listener) {
    listeners.add(listener);
    return SignalSubscription<T>(this, listener);
  }

  Future<void> sendAsync(T data) => Future.forEach<SignalListener<T>>(
      listeners, (listener) => listener(data));

  void send(T data) => listeners.forEach((listener) => listener(data));

  bool remove(SignalListener<T> listener) => listeners.remove(listeners);

  void clearListeners() => listeners.clear();

  @override
  String toString() {
    return 'Signal<$T>';
  }
}

class SignalSubscription<T> {
  final Signal<T> signal;
  final SignalListener<T> listener;

  SignalSubscription(this.signal, this.listener);

  void close() => signal.remove(listener);
}

[matejthetree]

Maybe this question should go to the dart-lang/language but what is the reason for not infering supertype generics?

If we have

class Foo<S> {}

class FooStringer extends Foo<String> {}

class Boo<T Foo<S>>{
  Type type = S;
}

Boo declaration seems intuitive. S will become the generic from Foo, since it knows about it.

[leafpetersen]

@matejthetree is the basic idea I describe here what you are looking for?

[matejthetree]

Yeah, something like it.