Add "Safe" (nullable) cast operator `as?`

[wrozwad]

It'll be a little enhancement but so much pleasant one :)

Kotlin and Swift has something like Safe casting with as? operator. It gives an opportunity to casting with null fallback if cast can't be performed:

void someFunction(dynamic arg) {
  // we could has something like
  final classVariable = (arg as? SomeClass)?.someValue;
  
  // in place of
  final classVariable = arg is SomeClass ? arg.someValue : null;
}

[johnpryan]

Thanks for filing an issue - just a head up, this issue tracker is for issues with the website. Language feature requests can be filed at https://github.com/dart-lang/language

[wrozwad]

Ahh, you're right, sorry ;)

[kevmoo]

Moved to the language repo!

[lrhn]

I like this. I was honestly just about to file a request for the exact same thing (thanks to GitHub for listing relevant existing issues!)

Another practical use case would be;

int x = o as? int ?? 0;  // Could perhaps use some parentheses for readability :)

This is the safe cast operator that was originally requested when the current as operator was added, and it is very useful in a number of situations. See C# for prior art.

[kevmoo]

I like it, too! I missed this when I came from C#

[gnawf]

Definitely something I miss from Kotlin. Would be great timing to have this implemented this alongside the upcoming null safety.

[wjling]

Any progress about this issue? I'm from Swift and suffered exceptions when casting from time to time.

[eernstg]

We could also consider this to be a proposal to have a few extensions in a conveniently accessible library:

extension AsExtension on Object? {
  X as<X>() => this as X;
  X? asOrNull<X>() {
    var self = this;
    return self is X ? self : null;
  }
}

extension AsSubtypeExtension<X> on X {
  Y asSubtype<Y extends X>() => this as Y;
}

extension AsNotNullExtension<X> on X? {
  X asNotNull() => this as X;
}

void main() {
  num? n = 1 as dynamic;
  n.as<int>().isEven;
  n.asSubtype<int>().isEven; // `n.asSubtype<String>()` is an error.
  n.asNotNull().floor();
  n.asOrNull<int>()?.isEven; // Corresponds to `(n as? int)?.isEven`.
}