chore: sniper kill tuple

Author: mikearnaldi

.changeset/light-turkeys-taste.md

@@ -0,0 +1,5 @@
+---
+"@tsplus/stdlib": patch
+---
+
+Kill Tuple

packages/stdlib/_examples/associative.ts

@@ -2,10 +2,10 @@ main()
 
 function main() {
   /* one namespace per module with "aliased" constructor! */
-  const map0 = VoteMap(HashMap(Tuple("TsPlus", Votes(1)), Tuple("Effect", Votes(2))))
+  const map0 = VoteMap(HashMap(["TsPlus", Votes(1)], ["Effect", Votes(2)]))
 
   /* configure global imports that are still tree-shakeable */
-  const map1 = VoteMap(HashMap(Tuple("TsPlus", Votes(4)), Tuple("Effect-2", Votes(2))))
+  const map1 = VoteMap(HashMap(["TsPlus", Votes(4)], ["Effect-2", Votes(2)]))
 
   /* custom binary operators */
   console.assert(map0.sum(map1) == (map0 + map1))

packages/stdlib/_examples/recursive.ts

@@ -26,22 +26,22 @@ function main() {
 // use the string's length to lookup neighboring cells and the answer pops out at the head
 function editDistance(s: string, t: string) {
   return pipe(
-    Tuple(s, t),
+    [s, t],
     Recursive.unfold(Functor, substrings(s)),
     Recursive.$.foldAnnotated(Functor, editDistanceAnnotatedAlgebra(s.length))
   )
 }
 function substrings(s0: string): Unfolder.Fn<ListF, Carrier> {
-  return ({ tuple: [s, t] }) => {
+  return ([s, t]) => {
     const [, ...ss] = s
     const [, ...ts] = t
     switch (s.length) {
       case 0:
         return t.length == 0 ?
-          new Leaf(Tuple("", "")) :
-          new Node(Tuple("", t), Tuple(s0, ts.join("")))
+          new Leaf(["", ""]) :
+          new Node(["", t], [s0, ts.join("")])
       default:
-        return new Node(Tuple(s, t), Tuple(ss.join(""), t))
+        return new Node([s, t], [ss.join(""), t])
     }
   }
 }
@@ -54,7 +54,7 @@ function editDistanceAnnotatedAlgebra(len: number): Annotated.Fn<ListF, number>
       "cons": minDistance
     })
 
-  function minDistance({ head: { tuple: [[a], [b]] }, tail }: AnnotatedNode): number {
+  function minDistance({ head: [[a], [b]], tail }: AnnotatedNode): number {
     return Math.min(
       lookup(0, tail) + 1, // insert
       lookup(len, tail) + 1, // delete
@@ -72,7 +72,7 @@ function editDistanceAnnotatedAlgebra(len: number): Annotated.Fn<ListF, number>
 }
 // Type definitions
 type MyNonEmptyList<A> = Leaf<A> | Node<A>
-type Carrier = Tuple<[string, string]>
+type Carrier = readonly [string, string]
 interface ListF extends HKT {
   readonly type: MyNonEmptyList<this["A"]>
 }

packages/stdlib/_src/collections.ts

@@ -6,7 +6,6 @@ export * as immutableArray from "@tsplus/stdlib/collections/ImmutableArray"
 export * as immutableMap from "@tsplus/stdlib/collections/ImmutableMap"
 export * as immutableQueue from "@tsplus/stdlib/collections/ImmutableQueue"
 export * as list from "@tsplus/stdlib/collections/List"
-export * as map from "@tsplus/stdlib/collections/Map"
 export * as mutable from "@tsplus/stdlib/collections/mutable"
 export * as nonEmptyImmutableArray from "@tsplus/stdlib/collections/NonEmptyImmutableArray"
 export * as parSeq from "@tsplus/stdlib/collections/ParSeq"

packages/stdlib/_src/collections/Chunk/operations/forEachWithIndexF.ts

@@ -10,7 +10,7 @@ export const forEachWithIndexF = ForEachWithIndex.implementForEachWithIndexF<num
           let base = succeed<Chunk<typeof _.B>, typeof _.R, typeof _.E>(Chunk.empty())
           for (let i = 0; i < fa.length; i = i + 1) {
             base = G.map(
-              ({ tuple: [bs, b] }: Tuple<[Chunk<typeof _.B>, typeof _.B]>) => bs.append(b)
+              ([bs, b]: readonly [Chunk<typeof _.B>, typeof _.B]) => bs.append(b)
             )(G.both(f(i, fa.unsafeGet(i)!))(base))
           }
           return base

packages/stdlib/_src/collections/Chunk/operations/mapAccum.ts

@@ -6,8 +6,8 @@ import { concreteChunkId } from "@tsplus/stdlib/collections/Chunk/definition"
  * @tsplus static Chunk.Aspects mapAccum
  * @tsplus pipeable Chunk mapAccum
  */
-export function mapAccum<A, B, S>(s: S, f: (s: S, a: A) => Tuple<[S, B]>) {
-  return (self: Chunk<A>): Tuple<[S, Chunk<B>]> => {
+export function mapAccum<A, B, S>(s: S, f: (s: S, a: A) => readonly [S, B]) {
+  return (self: Chunk<A>): readonly [S, Chunk<B>] => {
     const iterator = concreteChunkId(self)._arrayLikeIterator()
     let next
     let s1 = s
@@ -20,12 +20,12 @@ export function mapAccum<A, B, S>(s: S, f: (s: S, a: A) => Tuple<[S, B]>) {
       while (i < len) {
         const a = array[i]!
         const x = f(s1, a)
-        s1 = x.get(0)
-        builder = builder.append(x.get(1))
+        s1 = x[0]
+        builder = builder.append(x[1])
         i++
       }
     }
 
-    return Tuple(s1, builder)
+    return [s1, builder]
   }
 }

packages/stdlib/_src/collections/Chunk/operations/partition.ts

@@ -5,5 +5,6 @@
  * @tsplus pipeable Chunk partition
  */
 export function partition<A>(f: Predicate<A>) {
-  return (self: Chunk<A>): Tuple<[Chunk<A>, Chunk<A>]> => self.partitionWithIndex((_, a: A) => f(a))
+  return (self: Chunk<A>): readonly [Chunk<A>, Chunk<A>] =>
+    self.partitionWithIndex((_, a: A) => f(a))
 }

packages/stdlib/_src/collections/Chunk/operations/partitionMap.ts

@@ -6,5 +6,6 @@
  * @tsplus pipeable Chunk partitionMap
  */
 export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
-  return (self: Chunk<A>): Tuple<[Chunk<B>, Chunk<C>]> => self.partitionMapWithIndex((_, a) => f(a))
+  return (self: Chunk<A>): readonly [Chunk<B>, Chunk<C>] =>
+    self.partitionMapWithIndex((_, a) => f(a))
 }

packages/stdlib/_src/collections/Chunk/operations/partitionMapWithIndex.ts

@@ -6,7 +6,7 @@
  * @tsplus pipeable Chunk partitionMapWithIndex
  */
 export function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>) {
-  return (self: Chunk<A>): Tuple<[Chunk<B>, Chunk<C>]> => {
+  return (self: Chunk<A>): readonly [Chunk<B>, Chunk<C>] => {
     const left: Array<B> = []
     const right: Array<C> = []
     for (let i = 0; i < self.length; i++) {
@@ -17,6 +17,6 @@ export function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B,
         right.push(e.right)
       }
     }
-    return Tuple(Chunk.from(left), Chunk.from(right))
+    return [Chunk.from(left), Chunk.from(right)]
   }
 }

packages/stdlib/_src/collections/Chunk/operations/partitionWithIndex.ts

@@ -6,7 +6,7 @@
  * @tsplus pipeable Chunk partitionWithIndex
  */
 export function partitionWithIndex<A>(f: PredicateWithIndex<number, A>) {
-  return (self: Chunk<A>): Tuple<[Chunk<A>, Chunk<A>]> => {
+  return (self: Chunk<A>): readonly [Chunk<A>, Chunk<A>] => {
     const left: Array<A> = []
     const right: Array<A> = []
     for (let i = 0; i < self.length; i++) {
@@ -17,6 +17,6 @@ export function partitionWithIndex<A>(f: PredicateWithIndex<number, A>) {
         left.push(a)
       }
     }
-    return Tuple(Chunk.from(left), Chunk.from(right))
+    return [Chunk.from(left), Chunk.from(right)]
   }
 }