This datatype defines snoc-lists: lists with O(1) append and O(n) prepend. Underneath the hood, it is just a plain list, but understood as containing its elements in reverse order.

| See? It's "List" in reverse? I dunno, I just think RList is an inelegant name, and word-initial t͜s is one of my favorite phonemes.

I initially went with this boring name for reverse-lists. However, I genuinely would rather write (and pronounce) Tsil.

The empty Tsil.

O(1) Append an element.

If you are looking for cons, you should use a plain list, or a finite sequence/queue type.

Create a single-element Tsil.

O(1) Access the last element and initial portion of the list. See also last and init if you only need one component.

If you are looking for uncons, you should use a plain list, or a finite sequence/queue type.

An empty RList, such as nil.

The Tsil consisting of initial and last elements, such as created by snoc.

Test if an Tsil is empty.

O(1) extract the elements of a list other than the last, if they exist. See also unsnoc if you also need last at the same time.

O(1) extract the last element of a list, if it exists. See also unsnoc if you also need init at the same time.

Remove all Nothings from an Tsil of Maybes.

O(n) Convert to a plain list, maintaining order.

This is here so that you can escape back out to normal cons-list land once you're done building your list.

See reverseOut for when order doesn't matter.

O(n) Convert from a plain list, maintaining order.

This is added for completion's sake, as I'm not sure you'll often need this adapter.

See toList for the inverse, or reverseIn for when order doesn't matter.

O(0) Reverse a plain cons list, rerutning an Tsil.

See reverseOut for the inverse, and why you might use these.

O(0) Reverse an Tsil, returning a plain cons list.

This is here so that when the output list is fed to an order-agnostic function, you don't have to pay the cost of reversing the representation.

See toList for when order matters.

Write the contents of the Tsil into an array, assuming you know the length of the array. This is useful in the common case of buffering an unknown-length stream before allocating contiguous space for the elements.

If you sepcify to small a langth, the initial part of the array will be uninitialized. If you specify to large a length, the initial part of the list will not be written.

If you are unaware of the size of the list, `Arr.fromList . fromList` will do the trick, but will obviously be slower.

Convert to a set without an intermediate conversion to a cons-list.