fix eslint errors and warnings

7 files changed, 68 insertions, 61 deletions

diff --git a/pbt/ts/.eslintrc.json b/pbt/ts/.eslintrc.json
index f95bb33..9dc9a54 100644
--- a/pbt/ts/.eslintrc.json
+++ b/pbt/ts/.eslintrc.json
@@ -1,3 +1,17 @@
 {
-  "extends": "./node_modules/gts/"
+  "extends": "./node_modules/gts/",
+  "rules": {
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        "args": "all",
+        "argsIgnorePattern": "^_",
+        "caughtErrors": "all",
+        "caughtErrorsIgnorePattern": "^_",
+        "destructuredArrayIgnorePattern": "^_",
+        "varsIgnorePattern": "^_",
+        "ignoreRestSiblings": true
+      }
+    ]
+  }
 }
diff --git a/pbt/ts/src/bank.test.ts b/pbt/ts/src/bank.test.ts
index bbb6fcf..d503faf 100644
--- a/pbt/ts/src/bank.test.ts
+++ b/pbt/ts/src/bank.test.ts
@@ -113,7 +113,7 @@ describe('Bank Simulator', () => {
       const api = new SimpleBank(accounts);
       return property(keyValueOf(accounts), ([accountNr, bal]) => {
         const retrieved = toNullable(api.balance(accountNr));
-        return retrieved == bal;
+        return retrieved === bal;
       });
     });
 
diff --git a/pbt/ts/src/bank.ts b/pbt/ts/src/bank.ts
index e388354..1f47739 100644
--- a/pbt/ts/src/bank.ts
+++ b/pbt/ts/src/bank.ts
@@ -1,4 +1,4 @@
-import {Option, fromNullable, isSome, matchW} from 'fp-ts/lib/Option';
+import {Option, fromNullable, matchW} from 'fp-ts/lib/Option';
 
 // keep it simple
 export type Account = string;
diff --git a/pbt/ts/src/index.test.ts b/pbt/ts/src/index.test.ts
index 1ad1cb0..b0d5cdc 100644
--- a/pbt/ts/src/index.test.ts
+++ b/pbt/ts/src/index.test.ts
@@ -3,7 +3,7 @@ import {Property} from './property';
 
 describe('testing lists reversal', () => {
   test('reverse of two appended lists is append of each list reversed', () => {
-    let reverse_append_result = Property.run(prop_reverse_with_two_lists);
+    const reverse_append_result = Property.run(prop_reverse_with_two_lists);
     expect(reverse_append_result.result).toBe('OK');
   });
 });
diff --git a/pbt/ts/src/index.ts b/pbt/ts/src/index.ts
index 7f67d77..38049b2 100644
--- a/pbt/ts/src/index.ts
+++ b/pbt/ts/src/index.ts
@@ -1,6 +1,6 @@
 import 'dotenv/config';
 import Prando from 'prando';
-import {Gen, Property, listOf, property, shrinklist, someInt} from './property';
+import {Gen, listOf, property, shrinklist, someInt} from './property';
 
 function arrayEquals<A>(a: A[], b: A[]): boolean {
   return (
@@ -12,7 +12,7 @@ function arrayEquals<A>(a: A[], b: A[]): boolean {
 }
 
 function reverse<A>(arr: A[]): A[] {
-  let result = [];
+  const result = [];
   for (let i = arr.length - 1; i >= 0; i--) {
     result.push(arr[i]);
   }
@@ -25,7 +25,7 @@ function reverse_is_self_inverse(arr: number[]): boolean {
 
 function gen2lists<A>(gen: Gen<A>): Gen<[A[], A[]]> {
   return (rng: Prando) => {
-    let gl = listOf(gen)(rng);
+    const gl = listOf(gen)(rng);
     return (size: number) => {
       return [gl(size), gl(size)];
     };
@@ -40,36 +40,25 @@ function reverse_with_two_lists<A>(arrs: [A[], A[]]): boolean {
 }
 
 function shrink2lists<A>([l1, l2]: [A[], A[]]): [A[], A[]][] {
-  let result: [A[], A[]][] = [];
-  let s1 = shrinklist(l1);
-  let s2 = shrinklist(l2);
+  const result: [A[], A[]][] = [];
+  const s1 = shrinklist(l1);
+  const s2 = shrinklist(l2);
   for (let i = 0; i < s1.length; i++) {
-    let j = s2.length - i - 1;
-    let news2 = j >= 0 ? s2[j] : [];
+    const j = s2.length - i - 1;
+    const news2 = j >= 0 ? s2[j] : [];
     result.push([s1[i], news2]);
   }
   return result;
 }
 
-export let prop_reverse_with_two_lists = property<[number[], number[]]>(
+export const prop_reverse_with_two_lists = property<[number[], number[]]>(
   gen2lists(someInt),
   reverse_with_two_lists,
   shrink2lists,
 );
 
-let prop_reverse_is_self_inverse = property(
+export const prop_reverse_is_self_inverse = property(
   listOf(someInt),
   reverse_is_self_inverse,
   shrinklist,
 );
-
-async function main(): Promise<void> {
-  let reverse_append_result = Property.run(prop_reverse_with_two_lists);
-  let reverse_reverse_result = Property.run(prop_reverse_is_self_inverse);
-  console.log(
-    'reverse_append_result: ' + JSON.stringify(reverse_append_result),
-  );
-  console.log(
-    'reverse_reverse_result: ' + JSON.stringify(reverse_reverse_result),
-  );
-}
diff --git a/pbt/ts/src/property.test.ts b/pbt/ts/src/property.test.ts
index c4e089d..920457a 100644
--- a/pbt/ts/src/property.test.ts
+++ b/pbt/ts/src/property.test.ts
@@ -4,12 +4,11 @@ import {
   property,
   shrinkPair,
   shrinkPositive,
-  someInt,
 } from './property';
 
 // from https://github.com/jlink/shrinking-challenge/blob/main/challenges/difference.md
 const predicate1: (pair: [number, number]) => boolean = ([x, y]) =>
-  x < 10 || x != y;
+  x < 10 || x !== y;
 
 describe('Find minimal counterexample', () => {
   test('do not shrink example if no shrinker given', () => {
diff --git a/pbt/ts/src/property.ts b/pbt/ts/src/property.ts
index da05328..2b69109 100644
--- a/pbt/ts/src/property.ts
+++ b/pbt/ts/src/property.ts
@@ -26,14 +26,19 @@ export function findMinimalCounterExample<A>(
   x: A,
   predicate: Predicate<A>,
   shrinker: Shrinker<A>,
-  depth: number = 0,
+  depth = 0,
 ): ShrinkResult<A> {
-  let xs = shrinker(x);
+  const xs = shrinker(x);
   let counterexample = x;
   let shrinks = depth;
-  for (let y of xs) {
+  for (const y of xs) {
     if (!predicate(y)) {
-      let shrink = findMinimalCounterExample(y, predicate, shrinker, depth + 1);
+      const shrink = findMinimalCounterExample(
+        y,
+        predicate,
+        shrinker,
+        depth + 1,
+      );
       if (shrink.shrinks > depth) {
         counterexample = shrink.counterexample;
         shrinks = shrink.shrinks;
@@ -44,7 +49,7 @@ export function findMinimalCounterExample<A>(
 }
 
 export function generate<A>(gen: Gen<A>): A {
-  let rng = new Prando(Math.random() * 1000);
+  const rng = new Prando(Math.random() * 1000);
   return gen(rng)(100);
 }
 
@@ -54,11 +59,11 @@ export function property<A>(
   shrinker?: Shrinker<A>,
 ): Property<A> {
   return (seed: number, size: number) => {
-    let rng = new Prando(seed);
-    let gen = generator(rng);
+    const rng = new Prando(seed);
+    const gen = generator(rng);
     let i = 0;
     for (; i < MAX_SUCCESS; i++) {
-      let x = gen(size);
+      const x = gen(size);
       if (!predicate(x)) {
         let counterexample = {counterexample: x, shrinks: 0};
         if (shrinker !== undefined) {
@@ -76,9 +81,9 @@ export function property<A>(
 
 export function listOf<A>(gen: Gen<A>): Gen<A[]> {
   return (rng: Prando) => {
-    let g = gen(rng);
+    const g = gen(rng);
     return (size: number) => {
-      let result = [];
+      const result = [];
       for (let i = 0; i < size; i++) {
         result.push(g(size));
       }
@@ -90,10 +95,10 @@ export function listOf<A>(gen: Gen<A>): Gen<A[]> {
 /// generates a map with exactly size elements
 export function mapOf<K, V>(genK: Gen<K>, genV: Gen<V>): Gen<Map<K, V>> {
   return (rng: Prando) => {
-    let gk = genK(rng);
-    let gv = genV(rng);
+    const gk = genK(rng);
+    const gv = genV(rng);
     return (size: number) => {
-      let result = new Map<K, V>();
+      const result = new Map<K, V>();
       for (let i = 0; i < size; i++) {
         result.set(gk(size), gv(size));
       }
@@ -107,10 +112,10 @@ export function mapOf<K, V>(genK: Gen<K>, genV: Gen<V>): Gen<Map<K, V>> {
 /// the name
 export function mapOf1<K, V>(genK: Gen<K>, genV: Gen<V>): Gen<Map<K, V>> {
   return (rng: Prando) => {
-    let gk = genK(rng);
-    let gv = genV(rng);
+    const gk = genK(rng);
+    const gv = genV(rng);
     return (size: number) => {
-      let result = new Map<K, V>();
+      const result = new Map<K, V>();
       for (let i = 0; i <= size; i++) {
         result.set(gk(size), gv(size));
       }
@@ -122,7 +127,7 @@ export function mapOf1<K, V>(genK: Gen<K>, genV: Gen<V>): Gen<Map<K, V>> {
 /// Select randomly one element from given list
 export function elements<A>(arr: A[]): Gen<A> {
   return (rng: Prando) => (_size: number) => {
-    let index = rng.nextInt(0, arr.length - 1);
+    const index = rng.nextInt(0, arr.length - 1);
     return arr[index];
   };
 }
@@ -159,12 +164,12 @@ export function frequency<A>(distribution: [number, Gen<A>][]): Gen<A> {
 
 /// Select one key-value pair from given map
 export function keyValueOf<K, V>(map: Map<K, V>): Gen<[K, V]> {
-  let keys = Array.from(map.keys());
+  const keys = Array.from(map.keys());
   return (rng: Prando) => {
-    let gkey = elements(keys)(rng);
+    const gkey = elements(keys)(rng);
     return (size: number) => {
-      let key = gkey(size);
-      let value = map.get(key)!;
+      const key = gkey(size);
+      const value = map.get(key)!;
       return [key, value];
     };
   };
@@ -172,17 +177,17 @@ export function keyValueOf<K, V>(map: Map<K, V>): Gen<[K, V]> {
 
 /// Choose number between some bounds.
 export function choose(min: number, max: number): Gen<number> {
-  return (rng: Prando) => (size: number) => rng.nextInt(min, max);
+  return (rng: Prando) => (_size: number) => rng.nextInt(min, max);
 }
 
 /// Choose some random integer.
-export let someInt: Gen<number> = (rng: Prando) => (size: number) => {
+export const someInt: Gen<number> = (rng: Prando) => (size: number) => {
   const bound = Math.pow(2, size);
   return rng.nextInt(-bound, bound);
 };
 
 /// Choose some random positive integer.
-export let positiveInt: Gen<number> = (rng: Prando) => (size: number) => {
+export const positiveInt: Gen<number> = (rng: Prando) => (size: number) => {
   const bound = Math.pow(2, Math.round(Math.sqrt(size)));
   return rng.nextInt(0, bound);
 };
@@ -194,17 +199,17 @@ export function pairOf<A>(gen: Gen<A>): Gen<[A, A]> {
 
 // basic shrinkers
 export function shrinklist<A>(arr: A[]): A[][] {
-  let result = [];
+  const result = [];
 
-  let tail = arr.slice(1);
-  let keep1 = arr.slice();
+  const tail = arr.slice(1);
+  const keep1 = arr.slice();
   keep1.splice(1, 1);
   result.push(tail, keep1);
 
   if (arr.length > 3) {
-    let half = Math.floor(arr.length / 2);
-    let copy = arr.slice();
-    let secondHalf = copy.slice(half);
+    const half = Math.floor(arr.length / 2);
+    const copy = arr.slice();
+    const secondHalf = copy.slice(half);
     result.push(secondHalf);
   }
 
@@ -212,7 +217,7 @@ export function shrinklist<A>(arr: A[]): A[][] {
 }
 
 export function shrinkPositive(i: number): number[] {
-  if (i == 0) return [];
+  if (i === 0) return [];
 
   return [i - 1, Math.round(Math.sqrt(i))];
 }
@@ -235,7 +240,7 @@ export function shrinkPair<A, B>(
 
 export const Property = {
   run<A>(prop: Property<A>): TestResult<A> {
-    let seed = Math.floor(Math.random() * 1000000);
+    const seed = Math.floor(Math.random() * 1000000);
     return prop(seed, 0);
   },
 };
@@ -247,8 +252,8 @@ export function forall<A, B>(
   k: (a: A) => Property<B>,
 ): Property<B> {
   return (seed: number, size: number) => {
-    let rng = new Prando(seed);
-    let a = gen(rng)(size);
+    const rng = new Prando(seed);
+    const a = gen(rng)(size);
     return k(a)(seed, size);
   };
 }