"A sequence with exactly one element, which may be null." shared class Singleton<out Element>(Element element) extends Object() satisfies [Element+] { "Returns `0`." shared actual Integer lastIndex => 0; "Returns `1`." shared actual Integer size => 1; "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 `Empty`." shared actual Empty rest => {}; "Returns the contained element, if the specified index is `0`." shared actual Element? get(Integer index) { if (index==0) { return element; } else { return null; } } "Returns a `Singleton` with the same element." shared actual Singleton<Element> clone => this; shared actual default Iterator<Element> iterator() { class SingletonIterator() satisfies Iterator<Element> { variable Boolean done = false; shared actual Element|Finished next() { if (done) { return finished; } else { done=true; return element; } } shared actual String string { return "SingletonIterator"; } } return SingletonIterator(); } shared actual String string => "[`` element?.string else "null" ``]"; "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> segment (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; "Return this singleton." shared actual Singleton<Element> reversed => this; "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 (exists element) { if (is List<Anything> that) { if (that.size==1) { if (exists elem = that.first) { return elem==element; } } } return false; } return false; } shared actual Integer hash => 31 + (element?.hash else 0); "Returns `true` if the specified element is this `Singleton`\'s element." shared actual Boolean contains(Object element) { if (exists e=this.element) { return e==element; } return false; } "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 [Result+] map<Result> (Result selecting(Element e)) => [ selecting(element) ]; shared actual Singleton<Element>|Empty 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? find (Boolean selecting(Element e)) { if (selecting(element)) { return element; } return null; } shared actual default Element? findLast (Boolean selecting(Element elem)) => 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 skipping(Integer skip) => skip<1 then this else {}; shared actual Singleton<Element>|Empty taking(Integer take) => take>0 then this else {}; "Returns the Singleton itself, or empty" shared actual {<Element&Object>*} coalesced { if (is Singleton<Object> self=this) { return self; } return {}; } }