List foo -> List bar
I can use three method
1.List<MyClass> bar = foo.cast<MyClass>()
2.List<MyClass> bar = List.castFrom(foo)
3.List<MyClass> bar = List.from(foo)
What is the difference?
The answer to the additional question ("Any practical differences (not just quoting/sharing docs) as to when one would work and the other fail would be appreciated."):
When you have a giant array, copying it (List.from) will not be a smart idea - you will spend a lot of time copying everything and it will also cost you a lot of memory. Instead, you will want to use List.cast, which will only return a view and will not copy everything from the list. That is a case when List.cast would work and other would fail. Indeed, not fail, but not good.
Since "[List.cast is] typically implemented as List.castFrom<E, R>(this)", the example mentioned above applies to List.castFrom as well.
As for when should we use List.from but not the other two, think about the following case: You have List a, and want to copy it to list b and make some modifications to b. If you only want to modify b but want a to keep the original, you should use List.from to copy (clone) instead of the List.cast.
In short: List.cast almost same as List.castFrom. They both do not copy anything. The List.from copies everything.
Indeed, you can also look at the source code: static List<T> castFrom<S, T>(List<S> source) => CastList<S, T>(source); And CastList is implemented as:
abstract class _CastListBase<S, T> extends _CastIterableBase<S, T>
with ListMixin<T> {
List<S> get _source;
T operator [](int index) => _source[index] as T;
...
}
class CastList<S, T> extends _CastListBase<S, T> {
...
}
So, you can very clearly see that, when you do cast (or castFrom), you do not copy and create a new list, but only make a very thin wrapper. That wrapper will make a type cast whenever you use it.