From c061b8bfd0e08027954631238b6bccbcdc2d8d20 Mon Sep 17 00:00:00 2001
From: Dustin Kane <dustinpkane@gmail.com>
Date: Fri, 2 Jun 2023 10:50:15 -0700
Subject: [PATCH] Fixing ordering and adding tests

---
 test/swap.test.ts | 30 +++++++++++++++++++++++
 types/swap.d.ts   | 61 ++++++++++++++++++++++++++++++-----------------
 2 files changed, 69 insertions(+), 22 deletions(-)
 create mode 100644 test/swap.test.ts

diff --git a/test/swap.test.ts b/test/swap.test.ts
new file mode 100644
index 0000000..4437491
--- /dev/null
+++ b/test/swap.test.ts
@@ -0,0 +1,30 @@
+import { expectType } from "tsd";
+import { __, pipe, compose, swap } from "../es";
+
+const indexA = 0;
+const indexB = 1;
+const list: number[] = [];
+
+expectType<number[]>(swap(indexA, indexB, list));
+
+expectType<number[]>(swap(__, indexB, list)(indexA));
+
+expectType<number[]>(swap(indexA, __, list)(indexB));
+
+expectType<number[]>(swap(__, __, list)(indexA, indexB));
+expectType<number[]>(swap(__, __, list)(__, indexB)(indexA));
+expectType<number[]>(swap(__, __, list)(indexA)(indexB));
+
+expectType<number[]>(swap(indexA, indexB)(list));
+
+expectType<number[]>(swap(__, indexB)(indexA, list));
+expectType<number[]>(swap(__, indexB)(__, list)(indexA));
+expectType<number[]>(swap(__, indexB)(indexA)(list));
+
+expectType<number[]>(swap(indexA)(indexB, list));
+expectType<number[]>(swap(indexA)(__, list)(indexB));
+expectType<number[]>(swap(indexA)(indexB)(list));
+
+// sanity checks for compose and pipe
+expectType<(list: readonly number[]) => number[]>(pipe(swap(indexA, indexB)));
+expectType<(list: readonly number[]) => number[]>(compose(swap(indexA, indexB)));
diff --git a/types/swap.d.ts b/types/swap.d.ts
index a781158..bed2b8f 100644
--- a/types/swap.d.ts
+++ b/types/swap.d.ts
@@ -1,41 +1,58 @@
-import { Placeholder } from './util/tools';
+import { Placeholder } from "./util/tools";
 
-// swap(indexA, indexB, list)
-export function swap<T>(indexA: number, indexB: number, list: readonly T[]): T[];
-// swap(indexA, indexB)(list)
-export function swap<T>(indexA: number, indexB: number): (list: readonly T[]) => T[];
 // swap(indexA)
 export function swap(indexA: number): {
-  // swap(indexA)(indexB, list)
-  <T>(indexB: number, list: readonly T[]): T[];
+  // swap(indexA)(indexB)(list)
+  (indexB: number): <T>(list: readonly T[]) => T[];
   // swap(indexA)(__, list)(indexB)
   <T>(__: Placeholder, list: readonly T[]): (indexB: number) => T[];
-  // swap(indexA)(indexB)(list)
-  <T>(indexB: number): (list: readonly T[]) => T[];
+  // swap(indexA)(indexB, list)
+  <T>(indexB: number, list: readonly T[]): T[];
 };
 
-// swap(__, indexB, list)(indexA)
+// swap(__, indexB)
+export function swap(
+  __: Placeholder,
+  indexB: number
+): {
+  // swap(__, indexB)(indexA)(list)
+  (indexA: number): <T>(list: readonly T[]) => T[];
+  // swap(__, indexB)(__, list)(indexA)
+  <T>(__2: Placeholder, list: readonly T[]): (indexA: number) => T[];
+  // swap(__, indexB)(indexA, list)
+  <T>(indexA: number, list: readonly T[]): T[];
+};
+
+// swap(indexA, indexB)(list)
+export function swap(indexA: number, indexB: number): <T>(list: readonly T[]) => T[];
+
+// swap(__, __, list)
 export function swap<T>(
   __: Placeholder,
-  indexB: number,
+  __2: Placeholder,
   list: readonly T[]
-): (indexA: number) => T[];
+): {
+  // swap(__, __, list)(indexA)(indexB)
+  (indexA: number): (indexB: number) => T[];
+  // swap(__, __, list)(__, indexB)(indexA)
+  (__3: Placeholder, indexB: number): (indexA: number) => T[];
+  // swap(__, __, list)(indexA, indexB)
+  (indexA: number, indexB: number): T[];
+};
+
 // swap(indexA, __, list)(indexB)
 export function swap<T>(
   indexA: number,
   __: Placeholder,
   list: readonly T[]
 ): (indexB: number) => T[];
-// swap(__, __, list)
+
+// swap(__, indexB, list)(indexA)
 export function swap<T>(
   __: Placeholder,
-  __2: Placeholder,
+  indexB: number,
   list: readonly T[]
-): {
-  // swap(__, __, list)(indexA, indexB)
-  (indexA: number, indexB: number): T[];
-  // swap(__, __, list)(__, indexB)(indexA)
-  (__3: Placeholder, indexB: number): (indexA: number) => T[];
-  // swap(__, __, list)(indexA)(indexB)
-  (indexA: number): (indexB: number) => T[];
-};
+): (indexA: number) => T[];
+
+// swap(indexA, indexB, list)
+export function swap<T>(indexA: number, indexB: number, list: readonly T[]): T[];