@calcit/procs 0.5.0-a6 → 0.5.0

package/ts-src/custom-formatter.ts

@@ -3,8 +3,8 @@ import { CalcitRef, CalcitSymbol, CalcitKeyword } from "./calcit-data";
 import { toPairs } from "@calcit/ternary-tree";
 
 import { CalcitRecord } from "./js-record";
-import { CalcitMap } from "./js-map";
-import { CalcitList } from "./js-list";
+import { CalcitMap, CalcitSliceMap } from "./js-map";
+import { CalcitList, CalcitSliceList } from "./js-list";
 import { CalcitSet } from "./js-set";
 import { CalcitTuple } from "./js-tuple";
 
@@ -41,7 +41,7 @@ export let load_console_formatter_$x_ = () => {
           if (obj instanceof CalcitSymbol) {
             return ["div", { style: "color: hsl(340, 80%, 60%)" }, obj.toString()];
           }
-          if (obj instanceof CalcitList) {
+          if (obj instanceof CalcitList || obj instanceof CalcitSliceList) {
             return [
               "div",
               { style: "color: hsl(280, 80%, 60%, 0.4)" },
@@ -49,7 +49,7 @@ export let load_console_formatter_$x_ = () => {
               ["span", { style: "font-size: 80%; vertical-align: 0.7em; color: hsl(280, 80%, 60%, 0.8)" }, `${obj.len()}`],
             ];
           }
-          if (obj instanceof CalcitMap) {
+          if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
             return ["div", { style: "color: hsl(280, 80%, 60%, 0.4)" }, obj.toString(true)];
           }
           if (obj instanceof CalcitSet) {
@@ -78,10 +78,10 @@ export let load_console_formatter_$x_ = () => {
           return null;
         },
         hasBody: (obj) => {
-          if (obj instanceof CalcitList) {
+          if (obj instanceof CalcitList || obj instanceof CalcitSliceList) {
             return obj.len() > 0;
           }
-          if (obj instanceof CalcitMap) {
+          if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
             return obj.len() > 0;
           }
           if (obj instanceof CalcitSet) {
@@ -90,7 +90,7 @@ export let load_console_formatter_$x_ = () => {
           return false;
         },
         body: (obj, config) => {
-          if (obj instanceof CalcitList) {
+          if (obj instanceof CalcitList || obj instanceof CalcitSliceList) {
             return ["div", { style: "color: hsl(280, 80%, 60%)" }].concat(
               obj.toArray().map((x, idx) => {
                 return [
@@ -117,10 +117,10 @@ export let load_console_formatter_$x_ = () => {
             ret.push(["div", { style: "margin-left: 8px; display: inline-block;" }, embedObject(obj.snd)]);
             return ret;
           }
-          if (obj instanceof CalcitMap) {
+          if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
             let ret: any[] = ["div", { style: "color: hsl(280, 80%, 60%)" }];
-            obj.turnMap();
-            for (let [k, v] of toPairs(obj.value)) {
+            let pairs = obj.pairs();
+            for (let [k, v] of pairs) {
               ret.push([
                 "div",
                 { style: "margin-left: 8px; display: flex;" },

package/ts-src/js-cirru.ts

@@ -2,9 +2,9 @@ import { overwriteComparator, initTernaryTreeMap } from "@calcit/ternary-tree";
 import { CirruWriterNode, writeCirruCode } from "@cirru/writer.ts";
 
 import { CalcitValue } from "./js-primes";
-import { CalcitList } from "./js-list";
+import { CalcitList, CalcitSliceList } from "./js-list";
 import { CalcitRecord } from "./js-record";
-import { CalcitMap } from "./js-map";
+import { CalcitMap, CalcitSliceMap } from "./js-map";
 import { CalcitSet } from "./js-set";
 import { CalcitKeyword, CalcitSymbol, CalcitRecur, CalcitRef, kwd } from "./calcit-data";
 import { CalcitTuple } from "./js-tuple";
@@ -44,11 +44,11 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
   if (x instanceof CalcitSymbol) {
     return x.toString();
   }
-  if (x instanceof CalcitList) {
+  if (x instanceof CalcitList || x instanceof CalcitSliceList) {
     // TODO can be faster
     return (["[]"] as CirruEdnFormat[]).concat(x.toArray().map(to_cirru_edn));
   }
-  if (x instanceof CalcitMap) {
+  if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
     let buffer: CirruEdnFormat = ["{}"];
     for (let [k, v] of x.pairs()) {
       buffer.push([to_cirru_edn(k), to_cirru_edn(v)]);
@@ -105,7 +105,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
     if (x === "false") {
       return false;
     }
-    if (x == "") {
+    if (x === "") {
       throw new Error("cannot be empty");
     }
     if (x[0] === "|" || x[0] === '"') {
@@ -129,18 +129,18 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
       throw new Error("Cannot be empty");
     }
     if (x[0] === "{}") {
-      let result: Array<[CalcitValue, CalcitValue]> = [];
+      let result: Array<CalcitValue> = [];
       x.forEach((pair, idx) => {
-        if (idx == 0) {
+        if (idx === 0) {
           return; // skip first `{}` symbol
         }
-        if (pair instanceof Array && pair.length == 2) {
-          result.push([extract_cirru_edn(pair[0]), extract_cirru_edn(pair[1])]);
+        if (pair instanceof Array && pair.length === 2) {
+          result.push(extract_cirru_edn(pair[0]), extract_cirru_edn(pair[1]));
         } else {
           throw new Error("Expected pairs for map");
         }
       });
-      return new CalcitMap(initTernaryTreeMap(result));
+      return new CalcitSliceMap(result);
     }
     if (x[0] === "%{}") {
       let name = x[1];
@@ -154,7 +154,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
           return; // skip %{} name
         }
 
-        if (pair instanceof Array && pair.length == 2) {
+        if (pair instanceof Array && pair.length === 2) {
           if (typeof pair[0] === "string") {
             entries.push([extractFieldKwd(pair[0]), extract_cirru_edn(pair[1])]);
           } else {
@@ -177,7 +177,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
       return new CalcitRecord(extractFieldKwd(name), fields, values);
     }
     if (x[0] === "[]") {
-      return new CalcitList(x.slice(1).map(extract_cirru_edn));
+      return new CalcitSliceList(x.slice(1).map(extract_cirru_edn));
     }
     if (x[0] === "#{}") {
       return new CalcitSet(x.slice(1).map(extract_cirru_edn));
@@ -209,10 +209,10 @@ export let format_cirru_edn = (data: CalcitValue, useInline: boolean = true): st
   if (typeof data === "string") {
     return "\ndo " + to_cirru_edn(data) + "\n";
   }
-  if (typeof data == "boolean") {
+  if (typeof data === "boolean") {
     return "\ndo " + to_cirru_edn(data) + "\n";
   }
-  if (typeof data == "string") {
+  if (typeof data === "string") {
     return "\ndo " + to_cirru_edn(data) + "\n";
   }
   if (data instanceof CalcitSymbol) {
@@ -244,7 +244,7 @@ export let to_calcit_data = (x: any, noKeyword: boolean = false): CalcitValue =>
     x.forEach((v) => {
       result.push(to_calcit_data(v, noKeyword));
     });
-    return new CalcitList(result);
+    return new CalcitSliceList(result);
   }
   if (x instanceof Set) {
     let result: Array<CalcitValue> = [];
@@ -254,8 +254,8 @@ export let to_calcit_data = (x: any, noKeyword: boolean = false): CalcitValue =>
     return new CalcitSet(result);
   }
 
-  if (x instanceof CalcitList) return x;
-  if (x instanceof CalcitMap) return x;
+  if (x instanceof CalcitList || x instanceof CalcitSliceList) return x;
+  if (x instanceof CalcitMap || x instanceof CalcitSliceMap) return x;
   if (x instanceof CalcitSet) return x;
   if (x instanceof CalcitRecord) return x;
   if (x instanceof CalcitRecur) return x;
@@ -266,22 +266,22 @@ export let to_calcit_data = (x: any, noKeyword: boolean = false): CalcitValue =>
 
   // detects object
   if (x === Object(x)) {
-    let result: Array<[CalcitValue, CalcitValue]> = [];
+    let result: Array<CalcitValue> = [];
     Object.keys(x).forEach((k) => {
-      result.push([to_calcit_data(k, noKeyword), to_calcit_data(x[k], noKeyword)]);
+      result.push(to_calcit_data(k, noKeyword), to_calcit_data(x[k], noKeyword));
     });
-    return new CalcitMap(initTernaryTreeMap(result));
+    return new CalcitSliceMap(result);
   }
 
   console.error(x);
   throw new Error("Unexpected data for converting");
 };
 
-let toWriterNode = (xs: CalcitList): CirruWriterNode => {
+let toWriterNode = (xs: CalcitList | CalcitSliceList): CirruWriterNode => {
   if (typeof xs === "string") {
     return xs;
   }
-  if (xs instanceof CalcitList) {
+  if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
     return xs.toArray().map(toWriterNode);
   } else {
     throw new Error("Unexpected type for CirruWriteNode");

package/ts-src/js-list.ts

@@ -5,6 +5,7 @@ import { CalcitValue } from "./js-primes";
 import {
   TernaryTreeList,
   initTernaryTreeList,
+  initTernaryTreeListFromRange,
   listLen,
   listGet,
   assocList,
@@ -15,97 +16,157 @@ import {
   assocAfter,
 } from "@calcit/ternary-tree";
 
-import { CalcitMap } from "./js-map";
+import { CalcitMap, CalcitSliceMap } from "./js-map";
 import { CalcitSet } from "./js-set";
 import { CalcitTuple } from "./js-tuple";
-import { CalcitFn } from "./calcit.procs";
 
-import { isNestedCalcitData, tipNestedCalcitData, toString } from "./calcit-data";
+import { isNestedCalcitData, tipNestedCalcitData, toString, CalcitFn } from "./calcit-data";
 
+// two list implementations, should offer same interface
 export class CalcitList {
   value: TernaryTreeList<CalcitValue>;
-  // array mode store bare array for performance
-  arrayValue: Array<CalcitValue>;
-  arrayMode: boolean;
-  arrayStart: number;
-  arrayEnd: number;
   cachedHash: Hash;
-  constructor(value: Array<CalcitValue> | TernaryTreeList<CalcitValue>) {
-    if (value == null) {
-      value = []; // dirty, better handled from outside
-    }
+  constructor(value: TernaryTreeList<CalcitValue>) {
     this.cachedHash = null;
-    if (Array.isArray(value)) {
-      this.arrayMode = true;
-      this.arrayValue = value;
-      this.arrayStart = 0;
-      this.arrayEnd = value.length;
-      this.value = null;
+    if (value == null) {
+      this.value = initTernaryTreeList([]);
     } else {
-      this.arrayMode = false;
       this.value = value;
-      this.arrayValue = [];
-      this.arrayStart = null;
-      this.arrayEnd = null;
-    }
-  }
-  turnListMode() {
-    if (this.arrayMode) {
-      this.value = initTernaryTreeList(this.arrayValue.slice(this.arrayStart, this.arrayEnd));
-      this.arrayValue = null;
-      this.arrayStart = null;
-      this.arrayEnd = null;
-      this.arrayMode = false;
     }
   }
   len() {
-    if (this.arrayMode) {
-      return this.arrayEnd - this.arrayStart;
-    } else {
-      return listLen(this.value);
-    }
+    return listLen(this.value);
   }
   get(idx: number) {
-    if (this.arrayMode) {
-      return this.arrayValue[this.arrayStart + idx];
-    } else {
-      return listGet(this.value, idx);
-    }
+    return listGet(this.value, idx);
   }
   assoc(idx: number, v: CalcitValue) {
-    this.turnListMode();
     return new CalcitList(assocList(this.value, idx, v));
   }
   assocBefore(idx: number, v: CalcitValue) {
-    this.turnListMode();
     return new CalcitList(assocBefore(this.value, idx, v));
   }
   assocAfter(idx: number, v: CalcitValue) {
-    this.turnListMode();
     return new CalcitList(assocAfter(this.value, idx, v));
   }
   dissoc(idx: number) {
-    this.turnListMode();
     return new CalcitList(dissocList(this.value, idx));
   }
   slice(from: number, to: number) {
-    if (this.arrayMode) {
-      if (from < 0) {
-        throw new Error(`from index too small: ${from}`);
-      }
-      if (to > this.len()) {
-        throw new Error(`end index too large: ${to}`);
-      }
-      if (to < from) {
-        throw new Error("end index too small");
+    return new CalcitList(ternaryTree.slice(this.value, from, to));
+  }
+  toString(shorter = false): string {
+    let result = "";
+    for (let item of this.items()) {
+      if (shorter && isNestedCalcitData(item)) {
+        result = `${result} ${tipNestedCalcitData(item)}`;
+      } else {
+        result = `${result} ${toString(item, true)}`;
       }
-      let result = new CalcitList(this.arrayValue);
-      result.arrayStart = this.arrayStart + from;
-      result.arrayEnd = this.arrayStart + to;
-      return result;
+    }
+    return `([]${result})`;
+  }
+  isEmpty() {
+    return this.len() === 0;
+  }
+  /** usage: `for of` */
+  items(): Generator<CalcitValue> {
+    return listToItems(this.value);
+  }
+  append(v: CalcitValue) {
+    return new CalcitList(ternaryTree.append(this.value, v));
+  }
+  prepend(v: CalcitValue) {
+    return new CalcitList(ternaryTree.prepend(this.value, v));
+  }
+  first() {
+    return ternaryTree.first(this.value);
+  }
+  rest() {
+    return new CalcitList(ternaryTree.rest(this.value));
+  }
+  concat(ys: CalcitList | CalcitSliceList) {
+    if (ys instanceof CalcitSliceList) {
+      return new CalcitList(ternaryTree.concat(this.value, ys.turnListMode().value));
+    } else if (ys instanceof CalcitList) {
+      return new CalcitList(ternaryTree.concat(this.value, ys.value));
+    } else {
+      throw new Error(`Unknown data to concat: ${ys}`);
+    }
+  }
+  map(f: (v: CalcitValue) => CalcitValue): CalcitList {
+    return new CalcitList(ternaryTree.listMapValues(this.value, f));
+  }
+  toArray(): CalcitValue[] {
+    return [...ternaryTree.listToItems(this.value)];
+  }
+  reverse() {
+    return new CalcitList(ternaryTree.reverse(this.value));
+  }
+}
+
+// represent append-only immutable list in Array slices
+export class CalcitSliceList {
+  // array mode store bare array for performance
+  value: Array<CalcitValue>;
+  start: number;
+  end: number;
+  cachedHash: Hash;
+  constructor(value: Array<CalcitValue>) {
+    if (value == null) {
+      value = []; // dirty, better handled from outside
+    }
+    this.cachedHash = null;
+
+    this.value = value;
+    this.start = 0;
+    this.end = value.length;
+  }
+  turnListMode(): CalcitList {
+    return new CalcitList(initTernaryTreeListFromRange(this.value, this.start, this.end));
+  }
+  len() {
+    return this.end - this.start;
+  }
+  get(idx: number) {
+    return this.value[this.start + idx];
+  }
+  assoc(idx: number, v: CalcitValue) {
+    return this.turnListMode().assoc(idx, v);
+  }
+  assocBefore(idx: number, v: CalcitValue) {
+    return this.turnListMode().assocBefore(idx, v);
+  }
+  assocAfter(idx: number, v: CalcitValue) {
+    if (idx === this.len() - 1) {
+      return this.append(v);
     } else {
-      return new CalcitList(ternaryTree.slice(this.value, from, to));
+      return this.turnListMode().assocAfter(idx, v);
+    }
+  }
+  dissoc(idx: number) {
+    if (idx === 0) {
+      return this.rest();
+    } else if (idx === this.len() - 1) {
+      return this.slice(0, idx);
+    } else {
+      return this.turnListMode().dissoc(idx);
+    }
+  }
+  slice(from: number, to: number) {
+    if (from < 0) {
+      throw new Error(`from index too small: ${from}`);
+    }
+    if (to > this.len()) {
+      throw new Error(`end index too large: ${to}`);
+    }
+    if (to < from) {
+      throw new Error("end index too small");
     }
+    let result = new CalcitSliceList(this.value);
+    result.start = this.start + from;
+    result.end = this.start + to;
+    return result;
   }
   toString(shorter = false): string {
     let result = "";
@@ -123,54 +184,38 @@ export class CalcitList {
   }
   /** usage: `for of` */
   items(): Generator<CalcitValue> {
-    if (this.arrayMode) {
-      return sliceGenerator(this.arrayValue, this.arrayStart, this.arrayEnd);
-    } else {
-      return listToItems(this.value);
-    }
+    return sliceGenerator(this.value, this.start, this.end);
   }
-  append(v: CalcitValue) {
-    if (this.arrayMode && this.arrayEnd === this.arrayValue.length && this.arrayStart < 32) {
+  append(v: CalcitValue): CalcitSliceList | CalcitList {
+    if (this.end === this.value.length && this.start < 32) {
       // dirty trick to reuse list memory, data storage actually appended at existing array
-      this.arrayValue.push(v);
-      let newList = new CalcitList(this.arrayValue);
-      newList.arrayStart = this.arrayStart;
-      newList.arrayEnd = this.arrayEnd + 1;
+      this.value.push(v);
+      let newList = new CalcitSliceList(this.value);
+      newList.start = this.start;
+      newList.end = this.end + 1;
       return newList;
     } else {
-      this.turnListMode();
-      return new CalcitList(ternaryTree.append(this.value, v));
+      return this.turnListMode().append(v);
     }
   }
   prepend(v: CalcitValue) {
-    this.turnListMode();
-    return new CalcitList(ternaryTree.prepend(this.value, v));
+    return this.turnListMode().prepend(v);
   }
   first() {
-    if (this.arrayMode) {
-      if (this.arrayValue.length > this.arrayStart) {
-        return this.arrayValue[this.arrayStart];
-      } else {
-        return null;
-      }
+    if (this.value.length > this.start) {
+      return this.value[this.start];
     } else {
-      return ternaryTree.first(this.value);
+      return null;
     }
   }
   rest() {
-    if (this.arrayMode) {
-      return this.slice(1, this.arrayEnd - this.arrayStart);
-    } else {
-      return new CalcitList(ternaryTree.rest(this.value));
-    }
+    return this.slice(1, this.end - this.start);
   }
-  concat(ys: CalcitList) {
-    if (!(ys instanceof CalcitList)) {
-      throw new Error("Expected list");
-    }
-    if (this.arrayMode && ys.arrayMode) {
-      let size = this.arrayEnd - this.arrayStart;
-      let otherSize = ys.arrayEnd - ys.arrayStart;
+  // TODO
+  concat(ys: CalcitSliceList | CalcitList) {
+    if (ys instanceof CalcitSliceList) {
+      let size = this.end - this.start;
+      let otherSize = ys.end - ys.start;
       let combined = new Array(size + otherSize);
       for (let i = 0; i < size; i++) {
         combined[i] = this.get(i);
@@ -178,36 +223,38 @@ export class CalcitList {
       for (let i = 0; i < otherSize; i++) {
         combined[i + size] = ys.get(i);
       }
-      return new CalcitList(combined);
+      return new CalcitSliceList(combined);
+    } else if (ys instanceof CalcitList) {
+      return this.turnListMode().concat(ys);
     } else {
-      this.turnListMode();
-      ys.turnListMode();
-      return new CalcitList(ternaryTree.concat(this.value, ys.value));
+      throw new Error("Expected list");
     }
   }
-  map(f: (v: CalcitValue) => CalcitValue): CalcitList {
-    if (this.arrayMode) {
-      return new CalcitList(this.arrayValue.slice(this.arrayStart, this.arrayEnd).map(f));
-    } else {
-      return new CalcitList(ternaryTree.listMapValues(this.value, f));
+  map(f: (v: CalcitValue) => CalcitValue): CalcitSliceList {
+    let ys: CalcitValue[] = [];
+    for (let x in sliceGenerator(this.value, this.start, this.end)) {
+      ys.push(f(x));
     }
+
+    return new CalcitSliceList(ys);
   }
   toArray(): CalcitValue[] {
-    if (this.arrayMode) {
-      return this.arrayValue.slice(this.arrayStart, this.arrayEnd);
-    } else {
-      return [...ternaryTree.listToItems(this.value)];
-    }
+    return this.value.slice(this.start, this.end);
   }
   reverse() {
-    this.turnListMode();
-    return new CalcitList(ternaryTree.reverse(this.value));
+    return this.turnListMode().reverse();
   }
 }
 
 function* sliceGenerator(xs: Array<CalcitValue>, start: number, end: number): Generator<CalcitValue> {
-  for (let idx = start; idx < end; idx++) {
-    yield xs[idx];
+  if (xs == null) {
+    if (end <= start) {
+      throw new Error("invalid list to slice");
+    }
+  } else {
+    for (let idx = start; idx < end; idx++) {
+      yield xs[idx];
+    }
   }
 }
 
@@ -217,10 +264,9 @@ export let foldl = function (xs: CalcitValue, acc: CalcitValue, f: CalcitFn): Ca
   }
 
   if (f == null) {
-    debugger;
     throw new Error("Expected function for folding");
   }
-  if (xs instanceof CalcitList) {
+  if (xs instanceof CalcitSliceList || xs instanceof CalcitList) {
     var result = acc;
     for (let idx = 0; idx < xs.len(); idx++) {
       let item = xs.get(idx);
@@ -235,10 +281,20 @@ export let foldl = function (xs: CalcitValue, acc: CalcitValue, f: CalcitFn): Ca
     });
     return result;
   }
+  if (xs instanceof CalcitSliceMap) {
+    let result = acc;
+    // low-level code for performance
+    let size = xs.chunk.length >> 1;
+    for (let i = 0; i < size; i++) {
+      let pos = i << 1;
+      result = f(result, new CalcitSliceList([xs.chunk[pos], xs.chunk[pos + 1]]));
+    }
+    return result;
+  }
   if (xs instanceof CalcitMap) {
     let result = acc;
-    xs.pairs().forEach(([k, item]) => {
-      result = f(result, new CalcitList([k, item]));
+    xs.pairs().forEach((pair) => {
+      result = f(result, new CalcitSliceList(pair));
     });
     return result;
   }
@@ -251,10 +307,9 @@ export let foldl_shortcut = function (xs: CalcitValue, acc: CalcitValue, v0: Cal
   }
 
   if (f == null) {
-    debugger;
     throw new Error("Expected function for folding");
   }
-  if (xs instanceof CalcitList) {
+  if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
     var state = acc;
     for (let idx = 0; idx < xs.len(); idx++) {
       let item = xs.get(idx);
@@ -291,11 +346,31 @@ export let foldl_shortcut = function (xs: CalcitValue, acc: CalcitValue, v0: Cal
     }
     return v0;
   }
-
+  if (xs instanceof CalcitSliceMap) {
+    let state = acc;
+    // low-level code for performance
+    let size = xs.chunk.length >> 1;
+    for (let i = 0; i < size; i++) {
+      let pos = i << 1;
+      let pair = f(state, new CalcitSliceList([xs.chunk[pos], xs.chunk[pos + 1]]));
+      if (pair instanceof CalcitTuple) {
+        if (typeof pair.fst === "boolean") {
+          if (pair.fst) {
+            return pair.snd;
+          } else {
+            state = pair.snd;
+          }
+        }
+      } else {
+        throw new Error("Expected return value in `:: bool acc` structure");
+      }
+    }
+    return v0;
+  }
   if (xs instanceof CalcitMap) {
     let state = acc;
     for (let item of xs.pairs()) {
-      let pair = f(state, new CalcitList(item));
+      let pair = f(state, new CalcitSliceList(item));
       if (pair instanceof CalcitTuple) {
         if (typeof pair.fst === "boolean") {
           if (pair.fst) {
@@ -318,10 +393,9 @@ export let foldr_shortcut = function (xs: CalcitValue, acc: CalcitValue, v0: Cal
   }
 
   if (f == null) {
-    debugger;
     throw new Error("Expected function for folding");
   }
-  if (xs instanceof CalcitList) {
+  if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
     var state = acc;
     // iterate from right
     for (let idx = xs.len() - 1; idx >= 0; idx--) {