What is the difference among .cast() and List.from() and List.castFrom()

Question

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?

Solution 1

1. cast<MyClass>: Returns the view (Immutable List, altering order of the list won't be reflected in original list) of the List containing instances of MyClass type. Please follow.
2. castFrom(foo): Adapts source (foo) to be a List. Please follow
3. from(foo): Creates a List from Iterable (foo) objects provided in the Argument. Please follow

Solution 2

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.

Comments

[iDecode]

Thanks, I was looking for something like this. I'll give it a read later on

[ch271828n]

@iDecode You are welcome! Don't forget to award the bounty if you find it useful ;)