New: swap

CONTRIBUTING.md

@@ -13,14 +13,14 @@
 
 1.  Run `npm install` to install needed local dependencies.
 
-1.  Run `npm run build` first, then `npm run test` and address any errors.  Preferably, fix commits in place
+1.  Run `npm run build` first, then `npm run test` and `npm run lint` and address any errors. Preferably, fix commits in place
     using `git rebase` or `git commit --amend` to make the changes easier to
     review and to keep the history tidy.
 
 1.  Push to your fork:
 
         $ git push origin <branch>
 
-2.  Open a pull request.
+1.  Open a pull request.
 
 TODO: Explain the convention for creating types for ramda

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)));

types/swap.d.ts

@@ -0,0 +1,58 @@
+import { Placeholder } from './util/tools';
+
+// swap(indexA)
+export function swap(indexA: number): {
+  // 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(__, 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,
+  __2: Placeholder,
+  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[];
+};
+
+// swap(indexA, __, list)(indexB)
+export function swap<T>(
+  indexA: number,
+  __: Placeholder,
+  list: readonly T[]
+): (indexB: number) => T[];
+
+// swap(__, indexB, list)(indexA)
+export function swap<T>(
+  __: Placeholder,
+  indexB: number,
+  list: readonly T[]
+): (indexA: number) => T[];
+
+// swap(indexA, indexB, list)
+export function swap<T>(indexA: number, indexB: number, list: readonly T[]): T[];