217 lines
5.0 KiB
Haskell
217 lines
5.0 KiB
Haskell
{-# OPTIONS_GHC -fno-warn-missing-methods #-}
|
|
{-# OPTIONS_GHC -Wno-simplifiable-class-constraints #-}
|
|
{-# LANGUAGE MultiParamTypeClasses #-}
|
|
{-# LANGUAGE FunctionalDependencies #-}
|
|
{-# LANGUAGE FlexibleInstances #-}
|
|
{-# LANGUAGE UndecidableInstances #-}
|
|
|
|
class Solution n r | n -> r
|
|
where solution :: n -> r
|
|
instance (InitList n l, Map BoomOrNum' l r)
|
|
=> Solution n r where solution = nil
|
|
|
|
data BoomOrNum'
|
|
|
|
nil = undefined
|
|
|
|
class EqNine d b | d -> b
|
|
instance (Equal d (S (S (S (S (S (S (S (S (S Z))))))))) r)
|
|
=> EqNine d r
|
|
|
|
class Inc l r | l -> r
|
|
instance (Reverse Nil l nl, Inc' True nl nr, Reverse Nil nr r)
|
|
=> Inc l r
|
|
|
|
class Inc1 b n r | b n -> r
|
|
instance Inc1 True d Z
|
|
instance (Add (S Z) d r)
|
|
=> Inc1 False d r
|
|
|
|
class Inc' c l r | c l -> r
|
|
instance Inc' False l l
|
|
instance Inc' True Nil (Cons (S Z) Nil)
|
|
instance (Inc1 nc x nx, EqNine x nc, Inc' nc xs r)
|
|
=> Inc' True (Cons x xs) (Cons nx r)
|
|
|
|
class InitList' t n l a | t n l -> a
|
|
instance InitList' Z n l (Cons n l)
|
|
instance (Inc n nn, InitList' x nn (Cons n l) a)
|
|
=> InitList' (S x) n l a
|
|
|
|
class InitList t l | t -> l
|
|
instance (InitList' t (Cons Z Nil) Nil a, Reverse Nil a l)
|
|
=> InitList t l
|
|
|
|
data Boom
|
|
|
|
class EqualThree x r | x -> r
|
|
instance (Equal x (S (S (S Z))) a)
|
|
=> EqualThree x a
|
|
|
|
data EqualThree'
|
|
|
|
class Apply f a r | f a -> r
|
|
instance (EqualThree x r)
|
|
=> Apply EqualThree' x r
|
|
instance (BoomOrNum x r)
|
|
=> Apply BoomOrNum' x r
|
|
|
|
class Map f xs ys | f xs -> ys
|
|
instance Map f Nil Nil
|
|
instance (Apply f x y, Map f xs ys)
|
|
=> Map f (Cons x xs) (Cons y ys)
|
|
|
|
class Boom' c n r | c n -> r
|
|
instance Boom' True n Boom
|
|
instance Boom' False n n
|
|
|
|
class BoomOrNum n r | n -> r
|
|
instance (Map EqualThree' n bs, AnyTrue bs a, Boom' a n r)
|
|
=> BoomOrNum n r
|
|
|
|
data Nil
|
|
data Cons x xs
|
|
|
|
class First list x | list -> x
|
|
instance First Nil Nil
|
|
instance First (Cons x more) x
|
|
|
|
class ListConcat a b c | a b -> c
|
|
instance ListConcat Nil x x
|
|
instance (ListConcat as bs cs)
|
|
=> ListConcat (Cons a as) bs (Cons a cs)
|
|
|
|
class ListConcatAll ls l | ls -> l
|
|
instance ListConcatAll Nil Nil
|
|
instance (ListConcat chunk acc result,
|
|
ListConcatAll rest acc)
|
|
=> ListConcatAll (Cons chunk rest) result
|
|
|
|
class AnyTrue list t | list -> t
|
|
instance AnyTrue Nil False
|
|
instance AnyTrue (Cons True more) True
|
|
instance (AnyTrue list t)
|
|
=> AnyTrue (Cons False list) t
|
|
|
|
data True
|
|
data False
|
|
|
|
class Not b1 b | b1 -> b
|
|
instance Not False True
|
|
instance Not True False
|
|
|
|
class Or b1 b2 b | b1 b2 -> b
|
|
instance Or True True True
|
|
instance Or True False True
|
|
instance Or False True True
|
|
instance Or False False False
|
|
|
|
data Z
|
|
data S n
|
|
|
|
class Equal a b t | a b -> t
|
|
instance Equal Z Z True
|
|
instance Equal (S a) Z False
|
|
instance Equal Z (S b) False
|
|
instance (Equal a b t)
|
|
=> Equal (S a) (S b) t
|
|
|
|
class LessThan a b t | a b -> t
|
|
instance LessThan Z Z False
|
|
instance LessThan (S x) Z False
|
|
instance LessThan Z (S x) True
|
|
instance (LessThan a b t)
|
|
=> LessThan (S a) (S b) t
|
|
|
|
class Add x y z | x y -> z
|
|
instance Add x Z x
|
|
instance Add Z y y
|
|
instance (Add (S x) y z)
|
|
=> Add x (S y) z
|
|
|
|
class Multiply x y a z | x y a -> z
|
|
instance Multiply Z y a a
|
|
instance Multiply x Z a a
|
|
instance (Add x a r, Multiply x y r z)
|
|
=> Multiply x (S y) a z
|
|
|
|
class Reverse i l r | i l -> r
|
|
instance Reverse i Nil i
|
|
instance (Reverse (Cons x i) xs r)
|
|
=> Reverse i (Cons x xs) r
|
|
|
|
{-
|
|
|
|
*Main> :t solution (nil :: (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S Z))))))))))))))))))))))))))
|
|
solution (nil :: (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S Z))))))))))))))))))))))))))
|
|
:: Cons
|
|
(Cons Z Nil)
|
|
(Cons
|
|
(Cons (S Z) Nil)
|
|
(Cons
|
|
(Cons (S (S Z)) Nil)
|
|
(Cons
|
|
Boom
|
|
(Cons
|
|
(Cons (S (S (S (S Z)))) Nil)
|
|
(Cons
|
|
(Cons (S (S (S (S (S Z))))) Nil)
|
|
(Cons
|
|
(Cons (S (S (S (S (S (S Z)))))) Nil)
|
|
(Cons
|
|
(Cons (S (S (S (S (S (S (S Z))))))) Nil)
|
|
(Cons
|
|
(Cons (S (S (S (S (S (S (S (S Z)))))))) Nil)
|
|
(Cons
|
|
(Cons (S (S (S (S (S (S (S (S (S Z))))))))) Nil)
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons Z Nil))
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons (S Z) Nil))
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons (S (S Z)) Nil))
|
|
(Cons
|
|
Boom
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons (S (S (S (S Z)))) Nil))
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons (S (S (S (S (S Z))))) Nil))
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons (S (S (S (S (S (S Z)))))) Nil))
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons (S (S (S (S (S (S (S Z))))))) Nil))
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons (S (S (S (S (S (S (S (S Z)))))))) Nil))
|
|
(Cons
|
|
(Cons (S Z)
|
|
(Cons (S (S (S (S (S (S (S (S (S Z))))))))) Nil))
|
|
(Cons
|
|
(Cons (S (S Z))
|
|
(Cons Z Nil))
|
|
(Cons
|
|
(Cons (S (S Z))
|
|
(Cons (S Z) Nil))
|
|
(Cons
|
|
(Cons (S (S Z))
|
|
(Cons (S (S Z)) Nil))
|
|
(Cons
|
|
Boom
|
|
(Cons
|
|
(Cons (S (S Z))
|
|
(Cons (S (S (S (S Z)))) Nil))
|
|
(Cons
|
|
(Cons (S (S Z))
|
|
(Cons (S (S (S (S (S Z))))) Nil))
|
|
Nil)))))))))))))))))))))))))
|
|
*Main>
|
|
|
|
-}
|