From a9f13b737ba89f79409f12f0678b07d34b974ab1 Mon Sep 17 00:00:00 2001
From: Akshay Nair <phenax5@gmail.com>
Date: Sat, 8 Jan 2022 19:31:29 +0530
Subject: fix: fixes pattern matching type

---
 src/eval/index.ts | 23 ++++++++++++-----------
 src/utils.ts      |  9 ++++++---
 2 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/eval/index.ts b/src/eval/index.ts
index e88b583..f80c04d 100644
--- a/src/eval/index.ts
+++ b/src/eval/index.ts
@@ -3,21 +3,22 @@ import { Expr, ListExpr } from '../types'
 import {match} from '../utils';
 
 export const find = <T>([startO, exprs, endO]: ListExpr, list: T[]): any => {
-  const check = (e: Expr) => <T>(x: T, _i: number, _l: T[]): boolean => {
+  const check = (expr: Expr) => <T>(x: T, i: number, ls: T[]): boolean => {
     return pipe(
-      e.tag as any,
-      match({
-        AnyItem: () => true,
-        AnyNumber: () => typeof x === 'number',
-        AnyString: () => typeof x === 'string',
-        AnyBool: () => typeof x === 'boolean',
-        Truthy: () => !!x,
-        Falsey: () => !x,
-        _: () => false,
+      expr,
+      match<boolean, Expr>({
+        AnyItem: _ => true,
+        AnyNumber: _ => typeof x === 'number',
+        AnyString: _ => typeof x === 'string',
+        AnyBool: _ => typeof x === 'boolean',
+        Truthy: _ => !!x,
+        Falsey: _ => !x,
+        Group: ({ exprs }) => exprs.every(e => check(e)(x, i, ls)),
+        _: _ => false,
       })
     )
   };
-  
+
   const cs = exprs.map(check)
 
   return list.filter((x, i, ls) => cs.every(c => c(x, i, ls)))
diff --git a/src/utils.ts b/src/utils.ts
index 8e3abb9..15d5fb0 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -3,10 +3,13 @@ export const eq =
   (b: T): boolean =>
     a === b
 
+type TagValue<T, N> = T extends Tag<N, infer V> ? V : never;
+
 export const match =
-  <R, K extends string>(pattern: { [key in K | '_']: () => R }) =>
-  (k: K): R =>
-    (pattern[k] || pattern._)()
+  <R, T extends Tag<string, any>>
+  (pattern: { [key in T['tag'] | '_']?: (v: TagValue<T, key>) => R }) =>
+    (tag: T): R =>
+      (pattern[tag.tag] || pattern._ as any)(tag.value)
 
 type Tag<N, V> = { tag: N; value: V }
 export type Union<T> = { [N in keyof T]: Tag<N, T[N]> }[keyof T]
-- 
cgit v1.3.1