    "A [[Sequence]] with exactly one [[element]], which may be
     null."
    tagged("Sequences")
    shared final serializable class Singleton<out Element>
            (Element element)
            extends Object()
            satisfies [Element+] {

        "Returns the element contained in this `Singleton`."
        shared actual Element first => element;

        "Returns the element contained in this `Singleton`."
        shared actual Element last => element;

        "Returns `0`."
        shared actual Integer lastIndex => 0;

        "Returns `1`."
        shared actual Integer size => 1;

        "Returns `Empty`."
        shared actual Empty rest => [];

        "Returns the contained element, if the specified
         index is `0`."
        shared actual Element? getFromFirst(Integer index)
                => if (index == 0) then element else null;

        "Return this singleton."
        shared actual Singleton<Element> reversed => this;

        "Returns a `Singleton` with the same element."
        shared actual
        Singleton<Element> clone() => this;

        "Returns `true` if the specified element is this
         `Singleton`\'s element."
        shared actual Boolean contains(Object element)
                => if (exists e = this.element)
                then e == element
                else false;

        string => "[``stringify(element)``]";

        shared actual Iterator<Element> iterator()
                => object
                satisfies Iterator<Element> {
            variable Boolean done = false;
            shared actual Element|Finished next() {
                if (done) {
                    return finished;
                }
                else {
                    done = true;
                    return element;
                }
            }
            string => "``outer.string``.iterator()";
        };

        "A `Singleton` can be equal to another `List` if
         that `List` has only one element which is equal to
         this `Singleton`\'s element."
        shared actual Boolean equals(Object that) {
            if (is List<Anything> that, that.size == 1) {
                value elem = that.first;
                return if (exists element, exists elem)
                then elem == element
                else !element exists && !elem exists;
            }
            else {
                return false;
            }
        }

        shared actual Integer hash
                => 31 + (element?.hash else 0);

        "Returns a `Singleton` if the given starting index
         is `0` and the given `length` is greater than `0`.
         Otherwise, returns an instance of `Empty`."
        shared actual
        Empty|Singleton<Element> measure
                (Integer from, Integer length)
                => from <= 0 && from + length > 0
                then this else [];

        "Returns a `Singleton` if the given starting index
         is `0`. Otherwise, returns an instance of `Empty`."
        shared actual
        Empty|Singleton<Element> span
                (Integer from, Integer to)
                => from <= 0 && to >= 0 ||
                   from >= 0 && to <= 0
                then this else [];

        shared actual
        Empty|Singleton<Element> spanTo(Integer to)
                => to < 0 then [] else this;

        shared actual
        Empty|Singleton<Element> spanFrom(Integer from)
                => from > 0 then [] else this;

        "Returns `1` if this `Singleton`\'s element
         satisfies the predicate, or `0` otherwise."
        shared actual
        Integer count(Boolean selecting(Element element))
                => selecting(element) then 1 else 0;

        shared actual
        Singleton<Result> map<Result>
                (Result collecting(Element e))
                => Singleton(collecting(element));

        shared actual
        Singleton<Element>|[] filter
                (Boolean selecting(Element e))
                => selecting(element) then this else [];

        shared actual
        Result fold<Result>(Result initial)
                (Result accumulating(Result partial,
                                     Element e))
                => accumulating(initial, element);

        shared actual
        Element reduce<Result>
                (Result accumulating(Result|Element partial,
                                     Element e))
                => element;

        shared actual
        Singleton<Result> collect<Result>
                (Result collecting(Element element))
                => Singleton(collecting(element));

        shared actual
        Singleton<Element>|[] select
                (Boolean selecting(Element element))
                => selecting(element) then this else [];

        shared actual
        Element? find(Boolean selecting(Element&Object e))
                => if (exists element, selecting(element))
                        then element else null;

        shared actual
        Element? findLast(Boolean selecting(Element&Object e))
                => find(selecting);

        shared actual
        Singleton<Element> sort
                (Comparison comparing(Element a, Element b))
                => this;

        shared actual
        Boolean any(Boolean selecting(Element e))
                => selecting(element);

        shared actual
        Boolean every(Boolean selecting(Element e))
                => selecting(element);

        shared actual
        Singleton<Element>|Empty skip(Integer skipping)
                => skipping < 1 then this else [];

        shared actual
        Singleton<Element>|Empty take(Integer taking)
                => taking > 0 then this else [];

        shared actual
        Singleton<Element&Object>|Empty coalesced
                => if (exists element)
                        then Singleton(element) else [];

        shared actual
        {Element|Other+} chain<Other,OtherAbsent>
                (Iterable<Other,OtherAbsent> other)
                given OtherAbsent satisfies Null
                => other.follow(element);

        each(void step(Element element)) => step(element);

        indexed => { 0->element };

        "A stream with given [[head]], followed by the [[element]]
         of this singleton.

         For example, the expression

             Singleton(1).follow(2)

         evaluates to the stream `{ 2, 1 }`."
        shared actual {Other|Element+} follow<Other>(Other head)
                => { head, element };

        "An infinite stream that produces the [[element]] of
         this singleton, repeatedly.

         For example, the expression

             Singleton(null).cycled.take(4)

         evaluates to the stream `{ null, null, null, null }`."
        see (`function repeat`)
        shared actual
        {Element+} cycled
                => object satisfies {Element+} {
            string => outer.string + ".cycled";
            shared actual Integer size {
                "stream is infinite"
                assert (false);
            }
            iterator()
                    => object satisfies Iterator<Element> {
                next() => element;
                string => outer.string + ".iterator()";
            };
        };

        "This singleton."
        shared actual
        Singleton<Element> interpose<Other>(
            Other element,
            Integer step) {
            "step must be strictly positive"
            assert (step>=1);
            return this;
        }

        "This singleton."
        shared actual Singleton<Element> distinct => this;

        "An empty stream."
        shared actual [] paired => [];

    }