Declaratieve Talen/Oplossing formule boom

Oplossing

   form1 = (Of (En (Niet 'a') (Niet 'b')) (En (Wel 'a') (Niet 'c')))
   tree1 = (Node 'a' (Node 'b' (Blad True) (Blad False))
                     (Node 'c' (Blad True) (Blad False)))
   
   tree2 = (Node 'a' (Node 'b' (Blad True) (Blad False))
                     (Node 'c' (Blad False) (Blad False)))
   
   data Boom t = Node t (Boom t) (Boom t)
                   | Blad Bool deriving Show
   
   data Formule t = En (Formule t) (Formule t)
                   | Of (Formule t) (Formule t)
                   | Niet t
                   | Wel t
                   deriving Show
   
   boom_is_formule :: (Eq t) => (Boom t) -> (Formule t) -> Bool
   boom_is_formule boom formule = verdiep boom formule []
   
   berekenFormule :: (Eq t) => (Formule t) -> [(t, Bool)] -> Bool
   berekenFormule (En a b) waarden =
           (berekenFormule a waarden) && (berekenFormule b waarden)
   berekenFormule (Of a b) waarden =
           (berekenFormule a waarden) || (berekenFormule b waarden)
   berekenFormule (Niet a) waarden =
           let waarde = [y | (x,y) <- waarden, x==a]
           in
                   if (length(waarde) == 1) then
                           [y | (x,y) <- waarden, x==a] == [False]
                   else
                           False
   
   berekenFormule (Wel a) waarden =
           let waarde = [y | (x,y) <- waarden, x==a]
           in
                   if (length(waarde) == 1) then
                           [y | (x,y) <- waarden, x==a] == [True]
                   else
                           False
   
   verdiep :: (Eq t) => (Boom t) -> (Formule t) -> [(t, Bool)] -> Bool
   verdiep (Node var l r) formule waarden =
           (verdiep l formule (waarden ++ [(var, False)]))
                   && (verdiep r formule (waarden ++ [(var, True)]))
   verdiep (Blad False) formule waarden =
           berekenFormule formule waarden == False
   verdiep (Blad True) formule waarden =
           berekenFormule formule waarden == True