Why does Haskell use lists so much, even when they seem inappropriate, sometimes?

https://www.imn.htwk-leipzig.de/~waldmann/etc/untutorial/list-or-not-list/

How are updates to lists handled with regards to referential transparency?

Under which circumstances are lists slow?

What is a good rule of thumb for picking the right collection type - such as Array, Map, Set, Sequence, finger trees, tuples, or the list type?

Should I decide based on the time complexity of operations I need available?

How can I make other collection types easier to use? Not having literal notation for some of these things sucks! I also don’t like having to do qualified imports.

Is “infinite sequence” the right mathematical term for an infinite lists?

Do lists in Haskell confuse the idea of an iterator (that allows one to traverse data) and its underlying collection (that holds the actual data)?

What is GHCs “list deforestation” compiler optimization? What is GHCs “list fusion” compiler optimization?

https://wiki.haskell.org/GHC_optimisations

Is it possible to add invariants to lists that are known statically (such as the length, whether it is a finite or infinite list, etc)?

What sections did I find most valuable?

Which sections didn’t I get anything out of?

What surprised me in the chapter?

Which sections were straight-forward, and which were not?

Why did Chris decide to discuss the cardinality of the list type in section 9.2? How is it relevant to the learning objectives? What does knowing this allow us to do that we couldn’t before?

How are lists in other languages different from Haskell?

Which sections or points seemed like they were intended for complete beginners, and which points seem to be intended for programmers with experience in other languages?

What is a list?

A list is a structure that is used to arrange elements in a linear order.

Within a list, there can be multiple occurrences of any element.

Every member of a list must have the same type.

Each element is attached to a cons cell within the list. Cons cells are represented as the cons data constructor which has two arguments: the elements value, and a link to the next cons data constructor or end-of-list data constructor.

In order to get to the \({n}th\) element of a list, each cons cell before it must be traversed.

The elements within the cons cells do not have to be evaluated along the way, though.