chore: begin porting modules

Author: mikearnaldi

.changeset/weak-berries-fold.md

@@ -0,0 +1,5 @@
+---
+"@tsplus/stdlib": patch
+---
+
+Port Option, List, ListBuffer, Equivalence, Ord, Utilities, Tuple, Function, Predicate

.gitignore

@@ -11,4 +11,5 @@ yarn-error.log
 .DS_Store
 compiler/
 dist/
-tmp/
+tmp/
+core/

src/collections/List.ts

@@ -1,5 +1,14 @@
 // codegen:start {preset: barrel, include: ./List/*.ts}
+export * from "./List/builder.js"
+export * from "./List/concat.js"
 export * from "./List/definition.js"
+export * from "./List/empty.js"
+export * from "./List/exists.js"
+export * from "./List/filter.js"
+export * from "./List/find.js"
+export * from "./List/flatMap.js"
+export * from "./List/prependAll.js"
 export * from "./List/reduce.js"
+export * from "./List/unsafeHead.js"
 export * from "./List/unsafeTail.js"
 // codegen:end

src/collections/List/builder.ts

@@ -0,0 +1,21 @@
+import { ListBuffer } from "../mutable/ListBuffer.js"
+
+export class ListBuilder<A> {
+  constructor(private buffer: ListBuffer<A>) {}
+
+  append(a: A): ListBuilder<A> {
+    this.buffer.append(a)
+    return this
+  }
+
+  build() {
+    return this.buffer.toList
+  }
+}
+
+/**
+ * @tsplus static ListOps builder
+ */
+export function builder<A>(): ListBuilder<A> {
+  return new ListBuilder(new ListBuffer())
+}

src/collections/List/concat.ts

@@ -0,0 +1,9 @@
+import type { List } from "./definition.js"
+
+/**
+ * @tsplus fluent List concat
+ * @tsplus operator List &
+ */
+export function concat<A, B>(self: List<A>, that: List<B>): List<A | B> {
+  return that.prependAll(self)
+}

src/collections/List/empty.ts

@@ -0,0 +1,10 @@
+import { List } from "./definition.js"
+
+/**
+ * Returns the empty `List`
+ *
+ * @tsplus static ListOps empty
+ */
+export function empty<A>(): List<A> {
+  return List.nil()
+}

src/collections/List/exists.ts

@@ -0,0 +1,16 @@
+import type { Predicate } from "../../data/Predicate.js"
+import type { List } from "./definition.js"
+
+/**
+ * @tsplus fluent List exists
+ */
+export function exists<A>(self: List<A>, p: Predicate<A>): boolean {
+  let these = self
+  while (!these.isNil()) {
+    if (p(these.head)) {
+      return true
+    }
+    these = these.tail
+  }
+  return false
+}

src/collections/List/filter.ts

@@ -0,0 +1,90 @@
+/* eslint-disable no-constant-condition */
+import { unsafeCoerce } from "../../data/Function.js"
+import type { Predicate } from "../../data/Predicate.js"
+import { List } from "./definition.js"
+
+/**
+ * @tsplus fluent List filter
+ */
+export function filter<A>(self: List<A>, p: Predicate<A>): List<A> {
+  return filterCommon_(self, p, false)
+}
+
+function noneIn<A>(l: List<A>, p: Predicate<A>, isFlipped: boolean): List<A> {
+  while (true) {
+    if (l.isNil()) {
+      return List.nil()
+    } else {
+      if (p(l.head) !== isFlipped) {
+        return allIn(l, l.tail, p, isFlipped)
+      } else {
+        l = l.tail
+      }
+    }
+  }
+}
+
+function allIn<A>(
+  start: List<A>,
+  remaining: List<A>,
+  p: Predicate<A>,
+  isFlipped: boolean
+): List<A> {
+  while (true) {
+    if (remaining.isNil()) {
+      return start
+    } else {
+      if (p(remaining.head) !== isFlipped) {
+        remaining = remaining.tail
+      } else {
+        return partialFill(start, remaining, p, isFlipped)
+      }
+    }
+  }
+}
+
+function partialFill<A>(
+  origStart: List<A>,
+  firstMiss: List<A>,
+  p: Predicate<A>,
+  isFlipped: boolean
+): List<A> {
+  const newHead = List.cons<A>(origStart.unsafeHead()!, List.nil())
+  let toProcess = origStart.unsafeTail()! as List.Cons<A>
+  let currentLast = newHead
+
+  while (!(toProcess === firstMiss)) {
+    const newElem = List.cons(toProcess.unsafeHead()!, List.nil())
+    currentLast.tail = newElem
+    currentLast = unsafeCoerce(newElem)
+    toProcess = unsafeCoerce(toProcess.tail)
+  }
+
+  let next = firstMiss.tail
+  let nextToCopy: List.Cons<A> = unsafeCoerce(next)
+  while (!next.isNil()) {
+    const head = next.unsafeHead()!
+    if (p(head) !== isFlipped) {
+      next = next.tail
+    } else {
+      while (!(nextToCopy === next)) {
+        const newElem = List.cons(nextToCopy.unsafeHead()!, List.nil())
+        currentLast.tail = newElem
+        currentLast = newElem
+        nextToCopy = unsafeCoerce(nextToCopy.tail)
+      }
+      nextToCopy = unsafeCoerce(next.tail)
+      next = next.tail
+    }
+  }
+
+  if (!nextToCopy.isNil()) {
+    currentLast.tail = nextToCopy
+  }
+
+  return newHead
+}
+
+function filterCommon_<A>(list: List<A>, p: Predicate<A>, isFlipped: boolean): List<A> {
+  return noneIn(list, p, isFlipped)
+}

src/collections/List/find.ts

@@ -0,0 +1,17 @@
+import { Option } from "../../data/Option.js"
+import type { Predicate } from "../../data/Predicate.js"
+import type { List } from "./definition.js"
+
+/**
+ * @tsplus fluent List find
+ */
+export function find<A>(self: List<A>, p: Predicate<A>): Option<A> {
+  let these = self
+  while (!these.isNil()) {
+    if (p(these.head)) {
+      return Option.some(these.head)
+    }
+    these = these.tail
+  }
+  return Option.none
+}

src/collections/List/flatMap.ts

@@ -0,0 +1,26 @@
+import { List } from "./definition.js"
+
+/**
+ * @tsplus fluent List flatMap
+ */
+export function flatMap<A, B>(self: List<A>, f: (a: A) => List<B>): List<B> {
+  let rest = self
+  let h: List.Cons<B> | undefined = undefined
+  let t: List.Cons<B> | undefined = undefined
+  while (!rest.isNil()) {
+    let bs = f(rest.head)
+    while (!bs.isNil()) {
+      const nx = List.cons(bs.head, List.nil())
+      if (t === undefined) {
+        h = nx
+      } else {
+        t.tail = nx
+      }
+      t = nx
+      bs = bs.tail
+    }
+    rest = rest.tail
+  }
+  if (h === undefined) return List.nil()
+  else return h
+}