fix eslint errors and warnings

1 files changed, 39 insertions, 34 deletions

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