yukigo-haskell-parser 0.1.0 → 0.1.2

package/dist/prelude.js

@@ -1,205 +1,281 @@
-export const preludeCode = `data Ordering  = LT | EQ | GT
-data Maybe a = Nothing | Just a
-(,) :: a -> b -> (a, b)
-(,) x y = (x, y)
-($) :: (a -> b) -> a -> b
-($) f x = f x
-(.) :: (b -> c) -> (a -> b) -> a -> c
-(.) f g a = (\\x -> f (g x)) a
-(:) :: a -> [a] -> [a]
-(:) x xs = x : xs
-(++) :: [a] -> [a] -> [a]
-(++) [] ys = ys
-(++) (x:xs) ys = x : (xs ++ ys)
-(&&) :: (Eq a) => a -> a -> Boolean
-(||) :: (Eq a) => a -> a -> Boolean
-(&&) x y = x && y
-(||) x y = x || y
-(==) :: (Ord a) => a -> a -> Boolean
-(/=) :: (Ord a) => a -> a -> Boolean
-(<) :: (Ord a) => a -> a -> Boolean
-(>) :: (Ord a) => a -> a -> Boolean
-(<=) :: (Ord a) => a -> a -> Boolean
-(>=) :: (Ord a) => a -> a -> Boolean
-(==) x y = x == y
-(/=) x y = x /= y
-(<) x y = x < y
-(>) x y = x > y
-(<=) x y = x <= y
-(>=) x y = x >= y
-(+) :: Num a => a -> a -> a
-(-) :: Num a => a -> a -> a
-(+) x y = x + y
-(-) x y = x - y
-(**) :: (Floating a) => a -> a -> a
-(**) x y = x ** y
-(^) :: (Num a, Integral b) => a -> b -> a
-(^) x y = x ^ y
-(^^) :: (Fractional a, Integral b) => a -> b -> a
-(^^) x y = x ^^ y
-(*) :: (Num a) => a -> a -> a
-(*) x y = x * y
-(/) :: Fractional a => a -> a -> a
-(/) _ 0 = error "Prelude./: divide by zero"
-(/) x y = x / y
-(!!) :: [a] -> Int -> a
-(!!) xs n | n < 0 = error "Prelude.!!: negative index"
-(!!) [] _ = error "Prelude.!!: index too large"
-(!!) (x:_) 0 = x
-(!!) (_:xs) n = xs !! (n - 1)
-not :: Bool -> Bool
-not True = False
-not False = True
-quot :: Integral a => a -> a -> a
-quot _ 0 = error "divide by zero"
-quot 0 _ = 0
-quot a b = let { absA = abs a; absB = abs b; result = quotPositive absA absB } in if (a < 0) == (b < 0) then result else -result
-rem :: Integral a => a -> a -> a
-rem _ 0 = error "divide by zero"
-rem 0 _ = 0
-rem a b = let { absA = abs a; absB = abs b; remainder = remPositive absA absB } in if a < 0 then -remainder else remainder
-quotPositive :: Integral a => a -> a -> a
-quotPositive n d | n < d = 0 | otherwise = 1 + quotPositive (n - d) d
-remPositive :: Integral a => a -> a -> a
-remPositive n d | n < d = n | otherwise = remPositive (n - d) d
-div :: Integral a => a -> a -> a
-div _ 0 = error "divide by zero"
-div 0 _ = 0
-div a b = let { q = quot a b; r = rem a b } in if r == 0 || (a < 0) == (b < 0) then q else q - 1
-mod :: Integral a => a -> a -> a
-mod _ 0 = error "divide by zero"
-mod 0 _ = 0
-mod a b = a - (div a b) * b
-signum :: (Num a) => a -> a
-signum x | x == 0 = 0 | x > 0 = 1 | otherwise = -1
-abs :: (Num a) => a -> a
-abs n = if n < 0 then -n else n
-sqrt :: (Num a) => a -> a
-sqrt x = x ** 0.5
-max :: a -> a -> a
-max x y = if x <= y then y else x
-min :: a -> a -> a
-min x y = if x <= y then x else y
-even :: (Integral a) => a -> Bool
-odd :: (Integral a) => a -> Bool
-even n = n \`rem\` 2 == 0
-odd n = (not . even) n
-length :: [a] -> Int
-length [] = 0
-length (_:l) = 1 + length l
-genericLength :: (Integral a) => [b] -> a
-genericLength [] = 0
-genericLength (x:xs) = 1 + genericLength xs
-null :: [a] -> Bool
-null [] = True
-null (_:_) = False
-union :: (Eq a) => [a] -> [a] -> [a]
-union xs ys = unionBy (==) xs ys
-deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
-deleteBy eq x [] = []
-deleteBy eq x (y:ys) = if x \`eq\` y then ys else y : deleteBy eq x ys
-deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-deleteFirstsBy eq xs ys = foldl (flip (deleteBy eq)) xs ys
-nubBy :: (a -> a -> Bool) -> [a] -> [a]
-nubBy eq [] = []
-nubBy eq (x:xs) = x : nubBy eq (filter (\\y -> not (eq x y)) xs)
-unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-unionBy eq xs ys = xs ++ deleteFirstsBy eq (nubBy eq ys) xs
-intersect :: (Eq a) => [a] -> [a] -> [a]
-intersect xs ys = intersectBy (==) xs ys
-intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-intersectBy eq xs ys = [x | x <- xs, any (eq x) ys]
-elem :: (Eq a) => a -> [a] -> Bool
-notElem :: (Eq a) => a -> [a] -> Bool
-elem x xs = any (\\y -> y == x) xs
-notElem x xs = all (\\y -> y /= x) xs
-maximum :: (Ord a) => [a] -> a
-minimum :: (Ord a) => [a] -> a
-maximum [] = error "Prelude.maximum: empty list"
-maximum xs = foldl1 max xs
-minimum [] = error "Prelude.minimum: empty list"
-minimum xs = foldl1 min xs
-sum :: (Num a) => [a] -> a
-product :: (Num a) => [a] -> a
-sum xs = foldl (+) 0 xs
-product xs = foldl (*) 1 xs
-concat :: [[a]] -> [a]
-concat xss = foldr (++) [] xss
-concatMap :: (a -> [b]) -> [a] -> [b]
-concatMap f xs = (concat . map) f xs
-take :: Int -> [a] -> [a]
-take n _ | n <= 0 = []
-take _ [] = []
-take n (x:xs) = x : take (n - 1) xs
-drop :: Int -> [a] -> [a]
-drop n xs | n <= 0 = xs
-drop _ [] = []
-drop n (_:xs) = drop (n - 1) xs
-head :: [a] -> a
-head (x:_) = x
-head [] = error "Prelude.head: empty list"
-tail :: [a] -> [a]
-tail (_:xs) = xs
-tail [] = error "Prelude.tail: empty list"
-last :: [a] -> a
-last [x] = x
-last (_:xs) = last xs
-last [] = error "Prelude.last: empty list"
-init :: [a] -> [a]
-init [x] = []
-init (x:xs) = x : init xs
-init [] = error "Prelude.init: empty list"
-zip :: [a] -> [b] -> [(a, b)]
-zip xs ys = zipWith (,) xs ys
-zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
-zipWith z (a:as) (b:bs) = z a b : zipWith z as bs
-zipWith _ _ _ = []
-reverse :: [a] -> [a]
-reverse xs = foldl (flip (:)) [] xs
-filter :: (a -> Bool) -> [a] -> [a]
-filter p [] = []
-filter p (x:xs) | p x = x : filter p xs | otherwise = filter p xs
-map :: (a -> b) -> [a] -> [b]
-map f [] = []
-map f (x:xs) = f x : map f xs
-any :: (a -> Bool) -> [a] -> Bool
-all :: (a -> Bool) -> [a] -> Bool
-any f (x:xs) = f x || any f xs
-all f (x:xs) = f x && all f xs
-foldl :: (a -> b -> a) -> a -> [b] -> a
-foldl f z [] = z
-foldl f z (x:xs) = foldl f (f z x) xs
-foldl1 :: (a -> a -> a) -> [a] -> a
-foldl1 f (x:xs) = foldl f x xs
-foldl1 _ [] = error "Prelude.foldl1: empty list"
-foldr :: (a -> b -> b) -> b -> [a] -> b
-foldr f z [] = z
-foldr f z (x:xs) = f x (foldr f z xs)
-foldr1 :: (a -> a -> a) -> [a] -> a
-foldr1 f [x] = x
-foldr1 f (x:xs) = f x (foldr1 f xs)
-foldr1 _ [] = error "Prelude.foldr1: empty list"
-find :: Ord a => (a -> Bool) -> [a] -> Maybe a
-find _ [] = Nothing
-find f (x:xs) | f x = Just x | otherwise = find f xs
-sort :: (Ord a) => [a] -> [a]
-sort xs = sortBy compare xs
-sortBy :: (a -> a -> Ordering) -> [a] -> [a]
-sortBy cmp xs = foldr (insertBy cmp) [] xs
-compare :: a -> a -> Ordering
-compare x y | x == y = EQ | x <= y = LT | otherwise = GT
-insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
-insertBy cmp x [] = [x]
-insertBy cmp x ys@(y:ys') = case cmp x y of { GT -> y : insertBy cmp x ys'; _ -> x : ys }
-flip :: (a -> b -> c) -> b -> a -> c
-flip f x y = f y x
-repeat :: a -> [a]
-repeat x = x : (repeat x)
-iterate :: (a -> a) -> a -> [a]
-iterate f x = x : iterate f (f x)
-replicate :: Int -> a -> [a]
-replicate n x = take n (repeat x)
-cycle :: [a] -> [a]
-cycle [] = error "Prelude.cycle: empty list"
-cycle xs = xs ++ (cycle xs)`;
+export const preludeCode = `data Ordering  = LT | EQ | GT
+data Maybe a = Nothing | Just a
+id :: a -> a
+id x = x
+const :: a -> b -> a
+const x _ = x
+(,) :: a -> b -> (a, b)
+(,) x y = (x, y)
+($) :: (a -> b) -> a -> b
+($) f x = f x
+($!) :: (a -> b) -> a -> b
+($!) f x = f x
+(.) :: (b -> c) -> (a -> b) -> a -> c
+(.) f g a = (\\x -> f (g x)) a
+(:) :: a -> [a] -> [a]
+(:) x xs = x : xs
+(++) :: [a] -> [a] -> [a]
+(++) [] ys = ys
+(++) (x:xs) ys = x : (xs ++ ys)
+(&&) :: Bool -> Bool -> Bool
+(||) :: Bool -> Bool -> Bool
+(&&) x y = x && y
+(||) x y = x || y
+(==) :: (Ord a) => a -> a -> Boolean
+(==) x y = x == y
+(/=) :: (Ord a) => a -> a -> Boolean
+(/=) x y = x /= y
+(<) :: (Ord a) => a -> a -> Boolean
+(<) x y = x < y
+(>) :: (Ord a) => a -> a -> Boolean
+(>) x y = x > y
+(<=) :: (Ord a) => a -> a -> Boolean
+(<=) x y = x <= y
+(>=) :: (Ord a) => a -> a -> Boolean
+(>=) x y = x >= y
+(+) :: Num a => a -> a -> a
+(-) :: Num a => a -> a -> a
+(+) x y = x + y
+(-) x y = x - y
+(**) :: (Floating a) => a -> a -> a
+(**) x y = x ** y
+(^) :: (Num a, Integral b) => a -> b -> a
+(^) x y = x ^ y
+(^^) :: (Fractional a, Integral b) => a -> b -> a
+(^^) x y = x ^^ y
+(*) :: (Num a) => a -> a -> a
+(*) x y = x * y
+(/) :: Fractional a => a -> a -> a
+(/) _ 0 = error "Prelude./: divide by zero"
+(/) x y = x / y
+(!!) :: [a] -> Int -> a
+(!!) xs n | n < 0 = error "Prelude.!!: negative index"
+(!!) [] _ = error "Prelude.!!: index too large"
+(!!) (x:_) 0 = x
+(!!) (_:xs) n = xs !! (n - 1)
+not :: Bool -> Bool
+not True = False
+not False = True
+quot :: Integral a => a -> a -> a
+quot _ 0 = error "divide by zero"
+quot 0 _ = 0
+quot a b = let { absA = abs a; absB = abs b; result = quotPositive absA absB } in if (a < 0) == (b < 0) then result else -result
+rem :: Integral a => a -> a -> a
+rem _ 0 = error "divide by zero"
+rem 0 _ = 0
+rem a b = let { absA = abs a; absB = abs b; remainder = remPositive absA absB } in if a < 0 then -remainder else remainder
+quotPositive :: Integral a => a -> a -> a
+quotPositive n d | n < d = 0 | otherwise = 1 + quotPositive (n - d) d
+remPositive :: Integral a => a -> a -> a
+remPositive n d | n < d = n | otherwise = remPositive (n - d) d
+div :: Integral a => a -> a -> a
+div _ 0 = error "divide by zero"
+div 0 _ = 0
+div a b = let { q = quot a b; r = rem a b } in if r == 0 || (a < 0) == (b < 0) then q else q - 1
+mod :: Integral a => a -> a -> a
+mod _ 0 = error "divide by zero"
+mod 0 _ = 0
+mod a b = a - (div a b) * b
+signum :: (Num a) => a -> a
+signum x | x == 0 = 0 | x > 0 = 1 | otherwise = -1
+abs :: (Num a) => a -> a
+abs n = if n < 0 then -n else n
+succ :: (Num a) => a -> a
+succ x = x + 1
+pred :: (Num a) => a -> a
+pred x = x - 1
+sqrt :: (Num a) => a -> a
+sqrt x = x ** 0.5
+max :: Ord a => a -> a -> a
+max x y = if x <= y then y else x
+min :: Ord a => a -> a -> a
+min x y = if x <= y then x else y
+even :: (Integral a) => a -> Bool
+odd :: (Integral a) => a -> Bool
+even n = n \`rem\` 2 == 0
+odd n = (not . even) n
+length :: [a] -> Int
+length [] = 0
+length (_:l) = 1 + length l
+genericLength :: (Integral a) => [b] -> a
+genericLength [] = 0
+genericLength (x:xs) = 1 + genericLength xs
+null :: [a] -> Bool
+null [] = True
+null (_:_) = False
+union :: (Eq a) => [a] -> [a] -> [a]
+union xs ys = unionBy (==) xs ys
+deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
+deleteBy eq x [] = []
+deleteBy eq x (y:ys) = if x \`eq\` y then ys else y : deleteBy eq x ys
+deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
+deleteFirstsBy eq xs ys = foldl (flip (deleteBy eq)) xs ys
+nubBy :: (a -> a -> Bool) -> [a] -> [a]
+nubBy eq [] = []
+nubBy eq (x:xs) = x : nubBy eq (filter (\\y -> not (eq x y)) xs)
+unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
+unionBy eq xs ys = xs ++ deleteFirstsBy eq (nubBy eq ys) xs
+intersect :: (Eq a) => [a] -> [a] -> [a]
+intersect xs ys = intersectBy (==) xs ys
+intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
+intersectBy eq xs ys = [x | x <- xs, any (eq x) ys]
+elem :: (Eq a) => a -> [a] -> Bool
+notElem :: (Eq a) => a -> [a] -> Bool
+elem x xs = any (\\y -> y == x) xs
+notElem x xs = all (\\y -> y /= x) xs
+maximum :: (Ord a) => [a] -> a
+minimum :: (Ord a) => [a] -> a
+maximum [] = error "Prelude.maximum: empty list"
+maximum xs = foldl1 max xs
+minimum [] = error "Prelude.minimum: empty list"
+minimum xs = foldl1 min xs
+sum :: (Num a) => [a] -> a
+product :: (Num a) => [a] -> a
+sum xs = foldl (+) 0 xs
+product xs = foldl (*) 1 xs
+concat :: [[a]] -> [a]
+concat xss = foldr (++) [] xss
+concatMap :: (a -> [b]) -> [a] -> [b]
+concatMap f xs = (concat . map) f xs
+take :: Int -> [a] -> [a]
+take n _ | n <= 0 = []
+take _ [] = []
+take n (x:xs) = x : take (n - 1) xs
+drop :: Int -> [a] -> [a]
+drop n xs | n <= 0 = xs
+drop _ [] = []
+drop n (_:xs) = drop (n - 1) xs
+head :: [a] -> a
+head (x:_) = x
+head [] = error "Prelude.head: empty list"
+tail :: [a] -> [a]
+tail (_:xs) = xs
+tail [] = error "Prelude.tail: empty list"
+last :: [a] -> a
+last [x] = x
+last (_:xs) = last xs
+last [] = error "Prelude.last: empty list"
+init :: [a] -> [a]
+init [x] = []
+init (x:xs) = x : init xs
+init [] = error "Prelude.init: empty list"
+zip :: [a] -> [b] -> [(a, b)]
+zip xs ys = zipWith (,) xs ys
+zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+zipWith z (a:as) (b:bs) = z a b : zipWith z as bs
+zipWith _ _ _ = []
+reverse :: [a] -> [a]
+reverse xs = foldl (flip (:)) [] xs
+filter :: (a -> Bool) -> [a] -> [a]
+filter p [] = []
+filter p (x:xs) | p x = x : filter p xs | otherwise = filter p xs
+map :: (a -> b) -> [a] -> [b]
+map f [] = []
+map f (x:xs) = f x : map f xs
+any :: (a -> Bool) -> [a] -> Bool
+any f [] = False
+any f (x:xs) = f x || any f xs
+all :: (a -> Bool) -> [a] -> Bool
+all f [] = True
+all f (x:xs) = f x && all f xs
+foldl :: (a -> b -> a) -> a -> [b] -> a
+foldl f z [] = z
+foldl f z (x:xs) = foldl f (f z x) xs
+foldl1 :: (a -> a -> a) -> [a] -> a
+foldl1 f (x:xs) = foldl f x xs
+foldl1 _ [] = error "Prelude.foldl1: empty list"
+foldr :: (a -> b -> b) -> b -> [a] -> b
+foldr f z [] = z
+foldr f z (x:xs) = f x (foldr f z xs)
+foldr1 :: (a -> a -> a) -> [a] -> a
+foldr1 f [x] = x
+foldr1 f (x:xs) = f x (foldr1 f xs)
+foldr1 _ [] = error "Prelude.foldr1: empty list"
+find :: Ord a => (a -> Bool) -> [a] -> Maybe a
+find _ [] = Nothing
+find f (x:xs) | f x = Just x | otherwise = find f xs
+sort :: (Ord a) => [a] -> [a]
+sort xs = sortBy compare xs
+sortBy :: (a -> a -> Ordering) -> [a] -> [a]
+sortBy cmp xs = foldr (insertBy cmp) [] xs
+compare :: Ord a => a -> a -> Ordering
+compare x y | x == y = EQ | x <= y = LT | otherwise = GT
+insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
+insertBy cmp x [] = [x]
+insertBy cmp x ys@(y:ys') = case cmp x y of { GT -> y : insertBy cmp x ys'; _ -> x : ys }
+flip :: (a -> b -> c) -> b -> a -> c
+flip f x y = f y x
+repeat :: a -> [a]
+repeat x = x : (repeat x)
+iterate :: (a -> a) -> a -> [a]
+iterate f x = x : iterate f (f x)
+replicate :: Int -> a -> [a]
+replicate n x = take n (repeat x)
+cycle :: [a] -> [a]
+cycle [] = error "Prelude.cycle: empty list"
+cycle xs = xs ++ (cycle xs)
+fst :: (a,b) -> a
+fst (x,_) = x
+snd :: (a,b) -> b
+snd (_,y) = y
+between :: Ord a => a -> a -> a -> Bool
+between m n p | n >= m && n <= p = True | otherwise = False
+truncate :: (Num a, Integral b) => a -> b
+truncate x = quot x 1
+floor :: (Num a, Integral b) => a -> b
+floor x = div x 1
+negate :: Num a => a -> a
+negate n = 0 - n
+ceiling :: (Num a, Integral b) => a -> b
+ceiling x = negate (floor (negate x))
+round :: (Num a, Integral b) => a -> b
+round x | r < 0.5 = n | r > 0.5 = n + 1 | even n = n | otherwise = n + 1 where { n = floor x; r = x - n }
+dropWhile :: (a -> Bool) -> [a] -> [a]
+dropWhile _ [] = []
+dropWhile p xs@(x:xs') | p x = dropWhile p xs' | otherwise = xs
+break :: (a -> Bool) -> [a] -> ([a], [a])
+break _ [] = ([], [])
+break p (x:xs) | p x = ([], x:xs) | otherwise = (x : fst (break p xs), snd (break p xs))
+words :: String -> [String]
+words s = let { sTrim = dropWhile (\\c -> c == ' ') s } in if null sTrim then [] else fst (break (\\c -> c == ' ') sTrim) : words (snd (break (\\c -> c == ' ') sTrim))
+intersperse :: a -> [a] -> [a]
+intersperse _ [] = []
+intersperse _ [x] = [x]
+intersperse sep (x:xs) = x : sep : intersperse sep xs
+intercalate :: [a] -> [[a]] -> [a]
+intercalate xs xss = concat (intersperse xs xss)
+fromIntegral :: (Integral a, Num b) => a -> b
+fromIntegral x = x 
+
+anyException = ""
+evaluate x = x
+
+class Show a where
+  show :: a -> String
+
+instance Show Int where
+  show x = primShow x
+
+instance Show Bool where
+  show True = "True"
+  show False = "False"
+
+instance Show Ordering where
+  show LT = "LT"
+  show EQ = "EQ"
+  show GT = "GT"
+
+instance Show (Maybe a) where
+  show Nothing = "Nothing"
+  show (Just x) = "Just " ++ show x
+
+instance Show Char where
+  show c = '\\'' : c : '\\'' : []
+
+instance Show String where
+  show s = primShowString s
+
+instance Show [a] where
+  show xs = '[' : (intercalate "," (map show xs) ++ "]")
+`;
 //# sourceMappingURL=prelude.js.map

package/dist/prelude.js.map

@@ -1 +1 @@
-{"version":3,"file":"prelude.js","sourceRoot":"","sources":["../src/prelude.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA2MC,CAAA"}
+{"version":3,"file":"prelude.js","sourceRoot":"","sources":["../src/prelude.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuR1B,CAAA"}

package/dist/typechecker/DeclarationCollector.d.ts

@@ -1,4 +1,4 @@
-import { ASTNode, Record, TypeAlias, TypeSignature, Visitor } from "@yukigo/ast";
+import { ASTNode, Record, TypeAlias, TypeSignature, Visitor, TestGroup, Test, Assert, TypeClass, Instance } from "yukigo-ast";
 import { Type, TypeScheme } from "./checker.js";
 import { CoreHM } from "./core.js";
 export declare class DeclarationCollectorVisitor implements Visitor<void> {
@@ -10,6 +10,11 @@ export declare class DeclarationCollectorVisitor implements Visitor<void> {
     constructor(errors: string[], typeAliasMap: Map<string, Type>, recordMap: Map<string, Type>, signatureMap: Map<string, TypeScheme>, coreHM: CoreHM);
     visitTypeAlias(node: TypeAlias): void;
     visitRecord(node: Record): void;
+    visitTypeClass(node: TypeClass): void;
+    visitInstance(node: Instance): void;
     visitTypeSignature(node: TypeSignature): void;
+    visitTestGroup(node: TestGroup): void;
+    visitTest(node: Test): void;
+    visitAssert(node: Assert): void;
     visit(node: ASTNode): void;
 }

package/dist/typechecker/DeclarationCollector.js

@@ -1,6 +1,8 @@
+import { SimpleType, ListType, } from "yukigo-ast";
 import { functionType, } from "./checker.js";
 import { CoreHM } from "./core.js";
 import { TypeBuilder } from "./TypeBuilder.js";
+import { typeMappings } from "../utils/types.js";
 const builder = new TypeBuilder(new CoreHM());
 export class DeclarationCollectorVisitor {
     errors;
@@ -57,6 +59,34 @@ export class DeclarationCollectorVisitor {
             this.signatureMap.set(cons.name.value, scheme);
         }
     }
+    visitTypeClass(node) {
+        const className = node.name.value;
+        if (!this.coreHM.typeClasses.has(className)) {
+            this.coreHM.typeClasses.set(className, []);
+        }
+        // Register method signatures
+        for (const sig of node.signatures) {
+            this.visitTypeSignature(sig);
+        }
+    }
+    visitInstance(node) {
+        const className = node.className.value;
+        let yukigoTypeName = "YuUnknown";
+        if (node.type instanceof SimpleType) {
+            yukigoTypeName = typeMappings[node.type.value] || node.type.value;
+        }
+        else if (node.type instanceof ListType) {
+            yukigoTypeName = "YuList";
+        }
+        let instances = this.coreHM.typeClasses.get(className);
+        if (!instances) {
+            instances = [];
+            this.coreHM.typeClasses.set(className, instances);
+        }
+        if (!instances.includes(yukigoTypeName)) {
+            instances.push(yukigoTypeName);
+        }
+    }
     visitTypeSignature(node) {
         const functionName = node.identifier.value;
         if (this.signatureMap.has(functionName)) {
@@ -73,6 +103,15 @@ export class DeclarationCollectorVisitor {
             constraints,
         });
     }
+    visitTestGroup(node) {
+        node.group.accept(this);
+    }
+    visitTest(node) {
+        node.body.accept(this);
+    }
+    visitAssert(node) {
+        // assertions don't contain declarations
+    }
     visit(node) {
         node.accept(this);
     }

package/dist/typechecker/DeclarationCollector.js.map

@@ -1 +1 @@
-{"version":3,"file":"DeclarationCollector.js","sourceRoot":"","sources":["../../src/typechecker/DeclarationCollector.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"DeclarationCollector.js","sourceRoot":"","sources":["../../src/typechecker/DeclarationCollector.ts"],"names":[],"mappings":"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"}

package/dist/typechecker/TypeBuilder.d.ts

@@ -1,4 +1,4 @@
-import { Type as YukigoType } from "@yukigo/ast";
+import { Type as YukigoType } from "yukigo-ast";
 import { CoreHM } from "./core.js";
 import { Type, TypeVar } from "./checker.js";
 export declare class TypeBuilder {