In Dart, what's the difference between List.from and .of, and between Map.from and .of? : <p>In Dart, what's the difference between <code>List.from</code> and <code>List.of</code>, and between <code>Map.from</code> and <code>Map.of</code>? Their documentation is not totally clear:</p>

<pre><code>/**
* Creates a [LinkedHashMap] instance that contains all key/value pairs of
* [other].
*
* The keys must all be instances of [K] and the values of [V].
* The [other] map itself can have any type.
*
* A `LinkedHashMap` requires the keys to implement compatible
* `operator==` and `hashCode`, and it allows `null` as a key.
* It iterates in key insertion order.
*/
factory Map.from(Map other) = LinkedHashMap&lt;K, V&gt;.from;

/**
* Creates a [LinkedHashMap] with the same keys and values as [other].
*
* A `LinkedHashMap` requires the keys to implement compatible
* `operator==` and `hashCode`, and it allows `null` as a key.
* It iterates in key insertion order.
*/
factory Map.of(Map&lt;K, V&gt; other) = LinkedHashMap&lt;K, V&gt;.of;

/**
* Creates a list containing all [elements].
*
* The [Iterator] of [elements] provides the order of the elements.
*
* All the [elements] should be instances of [E].
* The `elements` iterable itself may have any element type, so this
* constructor can be used to down-cast a `List`, for example as:
* ```dart
* List&lt;SuperType&gt; superList = ...;
* List&lt;SubType&gt; subList =
*     new List&lt;SubType&gt;.from(superList.whereType&lt;SubType&gt;());
* ```
*
* This constructor creates a growable list when [growable] is true;
* otherwise, it returns a fixed-length list.
*/
external factory List.from(Iterable elements, {bool growable: true});

/**
* Creates a list from [elements].
*
* The [Iterator] of [elements] provides the order of the elements.
*
* This constructor creates a growable list when [growable] is true;
* otherwise, it returns a fixed-length list.
*/
factory List.of(Iterable&lt;E&gt; elements, {bool growable: true}) =&gt;
  new List&lt;E&gt;.from(elements, growable: growable);
</code></pre>

<p>Is the difference related to generics? Maybe the <code>.from</code> factories let you change the type of the list, while the <code>.of</code> ones do not? I come from a Java background, which works with type erasure, and maybe types are reified in Dart and you cannot use casts or raw types to change list/map types?</p>
