Is FutureOr <T> a type of reided future <T> / <T>?

Question

I have a class in AngularDart as shown below:

abstract class Validator {
  Map validate(AbstractControl c);
}

Having looked carefully, this was earlier (before we added support for the strong mode):

abstract class Validator {
  validate(AbstractControl c);
}

The problem is that it technically supports the return of the Future or the Map.

I would like to reorganize this and print it correctly with FutureOr:

abstract class Validator {
  FutureOr<T> validate(AbstractControl c);
}

Can I use validation isat runtime? (In DDC and dart2js)

void runValidator(Validator v) {
  var result = v.validate(...);
  if (result is Future) {
    // async...
  } else {
    // sync...
  }
}

I think about it right?

EDIT : As mentioned below, I mean

if (result is Future<T>) {

} else if (result is T) {

}

One more question: validatecorresponds to these two typedefs:

Future<Map> AsyncValidate(AbstractControl c);

Map SyncValidate(AbstractControl c);

Answer 1

, result is Future<Map>. , validate, Future, . , FutureOr<Map> , , "FutureOr". Future<Map>, a Map.

, "". , Map, FutureMap:

abstract class Validator {
  FutureOr<Map> validate(abstractControl c);
}
class AsyncValidator extends Validator { 
  Future<Map> validate(AbstractControl c) {...}   
}
class SyncValidator extends Validator { 
  Map validate(AbstractControl c) {...} 
}

, Validator.validate, .

typedef FutureOr<Map> Validate(AbstractControl c);
typedef Future<Map> AsyncValidate(AbstractControl c);
typedef Map SyncValidate(AbstractControl c);
Validator v = ...;
Validate f0 = v.validate;  // Safe.
AsyncValidate f1 = v.validate; // BAD assignment.
SyncValidate f2 = v.validate; // BAD assignment.

Map syncValidate(AbstractControl c) { ... }
Future<Map> asyncValidate(AbstractControl c) { ... }
v = syncValidate;  // Good assignment.
v = asyncValidate;  // Good assignment.    

validate v, , f1 f2, , , .

, FutureOr. a Future Future . FutureOr, , , .