Give Op0 a mandatory name

Author: herrmanno

app/Main.hs

@@ -7,19 +7,19 @@ import Autotool.Parser.Relation (parseIntRelation)
 import Autotool.Data.Parallel.LazyTree (treesP)
 main = do
         let
-            r = parseIntRelation "{(1,1),(1,2),(2,1)}"
+            r = Op0 "r" $ parseIntRelation "{(1,1),(1,2),(2,1)}"
                 -- s = Set "S" [ V(1 , 3), V(2 , 1), V(2 , 2) ]
-            s = parseIntRelation "{(1,3),(2,1),(2,2)}"
+            s = Op0 "s" $ parseIntRelation "{(1,3),(2,1),(2,2)}"
                 -- t = S[ V(1 , 2) , V(2 , 3) ]
             t = parseIntRelation "{(1,3),(2,3)}"
-            ops = [(+), (&), (-), (*), Op0 r, Op0 s]
+            ops = [(+), (&), (-), (*), r, s]
                 -- result = Node2 Subtr (Node2 Compose (Node0 r) (Node2 Subtr (Node0 s) (Node0 r))) (Node0 s)
             result = Node (-) [
                 Node (*) [
-                    Node (Op0 r) [],
-                    Node (-) [ Node (Op0 s) [], Node (Op0 r) [] ]
+                    Node r [],
+                    Node (-) [ Node s [], Node r [] ]
                 ],
-                Node (Op0 s) []
+                Node s []
                 ]
             ts = treesP ops
             st = let f a
@@ -28,5 +28,5 @@ main = do
                         | otherwise = show a
                 in showTreeFn f
         -- mapM_ (putStrLn . st) ts
-        print $ solve ops t
+        putStrLn $ showTree $ solve ops t
 

src/Autotool/Data/LazyTree.hs

@@ -21,9 +21,9 @@ module Autotool.Data.LazyTree
 import Data.Tree (foldTree, levels, Tree(Node) )
 import Debug.Trace (traceShow, traceShowId)
 
-data Op a = Op0 a | Op1 String (a -> a) | Op2 String (a -> a -> a)
+data Op a = Op0 String a | Op1 String (a -> a) | Op2 String (a -> a -> a)
 
-isOp0 (Op0 _) = True
+isOp0 (Op0 _ _) = True
 isOp0 _ = False
 
 isOp1 (Op1 _ _) = True
@@ -33,20 +33,20 @@ isOp2 (Op2 _ _) = True
 isOp2 _ = False
 
 eval :: Op a -> [a] -> a
-eval (Op0 a) _ = a
+eval (Op0 _ a) _ = a
 eval (Op1 _ f) [a] = f a
 eval (Op2 _ f) [a,b] = f a b
 
 evalTree = foldTree eval
 
 instance (Eq a) => Eq (Op a) where
-    (Op0 a) == (Op0 b) = a == b
+    (Op0 _ a) == (Op0 _ b) = a == b
     (Op1 a _) == (Op1 b _) = a == b
     (Op2 a _) == (Op2 b _) = a == b
     _ == _ = False
 
 instance (Show a) => Show (Op a) where
-    show (Op0 a) = show a
+    show (Op0 s _) = s
     show (Op1 s _) = s
     show (Op2 s _) = s
 
@@ -135,6 +135,6 @@ showTree = showTreeFn show
 showTreeFn :: (Show a) => (a -> String) -> Tree (Op a) -> String
 showTreeFn showValue = foldTree f
     where
-        f (Op0 a) _ = showValue a
+        f (Op0 s _) _ = s
         f (Op1 s _) [a] =  s ++ "(" ++ a ++ ")"
         f (Op2 s _) [a,b] = "(" ++ a ++ ") " ++ s ++ " (" ++ b ++ ")"

src/Autotool/Data/NestedSet.hs

@@ -4,8 +4,10 @@ import Data.Set (Set, empty, fromList, toList, insert)
 import qualified Data.Set as S
 import Data.List (intercalate)
 
+-- | Recursive sum type of 'either a value or a set of Ts'
 data T a = V a | S (Set (T a)) deriving (Eq, Ord, Show)
 
+-- | A Data.Set of type (T a)
 type NSet a = Set (T a)
 
 -- for internal (e. g. parser) use
@@ -17,8 +19,8 @@ set = S
 
 unwrap :: T a -> NSet a
 unwrap (S s) = s
---
 
+ø :: Set a
 ø = empty
 
 øN :: (Ord a) => Int -> NSet a
@@ -39,6 +41,7 @@ a ++. s = insert (S $ fromList $ map V a) s
 (&.) :: (Ord a) => NSet a -> NSet a -> NSet a
 infixr 2 &.
 a &. s = insert (S a) s
+--
 
 powerSet :: (Ord a) => NSet a -> NSet a
 powerSet s = S.map S $ S.powerSet s

test/Autotool/Solver/RelationsSpec.hs

@@ -12,34 +12,34 @@ spec = do
     describe "relations" $ do
         it "finds term w/ a target value from a set of relations and operations on them (1)" $
             let
-                r = parseIntRelation "{(1,1),(1,2),(2,1)}"
-                s = parseIntRelation "{(1,3),(2,1),(2,2)}"
+                r = Op0 "r" $ parseIntRelation "{(1,1),(1,2),(2,1)}"
+                s = Op0 "s" $ parseIntRelation "{(1,3),(2,1),(2,2)}"
                 t = parseIntRelation "{(1,3),(2,3)}"
-                ops = [(+), (&), (-), (*), Op0 r, Op0 s]
+                ops = [(+), (&), (-), (*), r, s]
                 result =
                     Node (-) [
                         Node (*) [
-                            Node (Op0 r) [],
-                            Node (Op0 s) []
+                            Node r [],
+                            Node s []
                         ],
-                        Node (Op0 r) []
+                        Node r []
                     ]
             in solve ops t `shouldBe` result
         it "finds term w/ a target value from a set of relations and operations on them (2)" $
             let
-                r = parseIntRelation "{(1 , 4) , (2 , 4) , (3 , 2) , (4 , 1)}"
-                s = parseIntRelation "{(1 , 4) , (2 , 2) , (2 , 3) , (4 , 4)}"
+                r = Op0 "r" parseIntRelation "{(1 , 4) , (2 , 4) , (3 , 2) , (4 , 1)}"
+                s = Op0 "s" parseIntRelation "{(1 , 4) , (2 , 2) , (2 , 3) , (4 , 4)}"
                 t = parseIntRelation "{(1 , 1) , (1 , 4) , (2 , 1) , (2 , 2) , (2 , 4) , (4 , 1) , (4 , 4)}"
-                ops = [(+), (&), (-), (*), Op0 r, Op0 s]
+                ops = [(+), (&), (-), (*), r, s]
                 result =
                     Node (*) [
-                        Node (Op0 s) [],
+                        Node s [],
                         Node (*) [
                             Node (+) [
-                                Node (Op0 s) [],
-                                Node (Op0 r) []
+                                Node s [],
+                                Node r []
                             ],
-                            Node (Op0 r) []
+                            Node r []
                         ]
                     ]
             in solve ops t `shouldBe` result

test/Autotool/Solver/SetsSpec.hs

@@ -12,17 +12,17 @@ spec = do
     describe "sets" $ do
         it "finds term w/ a target value from a set of sets and operations on them (1)" $
             let 
-                a = parseIntSet "{1, 2}"
-                b = parseIntSet "{{3}}"
+                a = Op0 "a" $ parseIntSet "{1, 2}"
+                b = Op0 "b" $ parseIntSet "{{3}}"
                 r = parseIntSet "{{}, {1, 2, {3}}, {1, {3}}, {2, {3}}, {{3}}}"
-                ops = [(-), (+), (&), pow, Op0 a, Op0 b]
-                result = Node (-) [Node pow [Node (+) [Node (Op0 a) [], Node (Op0 b) []] ], Node (-) [Node pow [Node (Op0 a) []], Node pow [Node (Op0 b) []]] ]
+                ops = [(-), (+), (&), pow, a, b]
+                result = Node (-) [Node pow [Node (+) [Node a [], Node b []] ], Node (-) [Node pow [Node a []], Node pow [Node b []]] ]
             in solve ops r `shouldBe` result
         it "finds term w/ a target value from a set of sets and operations on them (2)" $
             let
-                a = parseIntSet "{{3, {}}}"
-                b = parseIntSet "{3, {1, {}, {2}}}"
+                a = Op0 "a" $ parseIntSet "{{3, {}}}"
+                b = Op0 "b" $ parseIntSet "{3, {1, {}, {2}}}"
                 r = parseIntSet "{{{3, {}}}}"
-                ops = [(-), (+), (&), pow, Op0 a, Op0 b]
-                result = Node (-) [ Node pow [Node (Op0 a) []], Node pow [Node (Op0 b) []] ]
+                ops = [(-), (+), (&), pow, a, b]
+                result = Node (-) [ Node pow [Node a []], Node pow [Node b []] ]
             in solve ops r `shouldBe` result