now in the command shell the primary type in the pipe is Expr not Tree. This makes the pt -compute and pt -typecheck more interesting

5 files changed, 47 insertions, 42 deletions

diff --git a/src/GF/Command/Abstract.hs b/src/GF/Command/Abstract.hs
index dff404194..1f7c4014e 100644
--- a/src/GF/Command/Abstract.hs
+++ b/src/GF/Command/Abstract.hs
@@ -25,7 +25,7 @@ data Value
   deriving (Eq,Ord,Show)
 
 data Argument
-  = ATree Tree
+  = AExpr Expr
   | ANoArg
   | AMacro Ident
   deriving (Eq,Ord,Show)
diff --git a/src/GF/Command/Commands.hs b/src/GF/Command/Commands.hs
index 1c0a3c2f9..2c30b89d0 100644
--- a/src/GF/Command/Commands.hs
+++ b/src/GF/Command/Commands.hs
@@ -39,10 +39,10 @@ import Text.PrettyPrint
 
 import Debug.Trace
 
-type CommandOutput = ([Tree],String) ---- errors, etc
+type CommandOutput = ([Expr],String) ---- errors, etc
 
 data CommandInfo = CommandInfo {
-  exec     :: [Option] -> [Tree] -> IO CommandOutput,
+  exec     :: [Option] -> [Expr] -> IO CommandOutput,
   synopsis :: String,
   syntax   :: String,
   explanation :: String,
@@ -117,8 +117,9 @@ allCommands cod env@(pgf, mos) = Map.fromList [
        "by the flag. The target format is postscript, unless overridden by the",
        "flag -format."
        ],
-     exec = \opts ts -> do
-         let grph = if null ts then [] else alignLinearize pgf (head ts)
+     exec = \opts es -> do
+         let ts = toTrees es
+             grph = if null ts then [] else alignLinearize pgf (head ts)
          if isFlag "view" opts || isFlag "format" opts then do
            let file s = "_grph." ++ s
            let view = optViewGraph opts ++ " "
@@ -261,7 +262,7 @@ allCommands cod env@(pgf, mos) = Map.fromList [
           _ | isOpt "changes" opts -> changesMsg
           _ | isOpt "coding" opts -> codingMsg
           _ | isOpt "license" opts -> licenseMsg
-          [t] -> let co = getCommandOp (showTree t) in 
+          [t] -> let co = getCommandOp (showExpr t) in 
                  case lookCommand co (allCommands cod env) of   ---- new map ??!!
                    Just info -> commandHelp True (co,info)
                    _ -> "command not found"
@@ -306,7 +307,7 @@ allCommands cod env@(pgf, mos) = Map.fromList [
        "gr -lang=LangHin -cat=Cl | l -table -to_devanagari -to_utf8 -- hindi table",
        "l -unlexer=\"LangSwe=to_utf8 LangHin=to_devanagari,to_utf8\" -- different lexers"
        ],
-     exec = \opts -> return . fromStrings . map (optLin opts),
+     exec = \opts -> return . fromStrings . map (optLin opts) . toTrees,
      options = [
        ("all","show all forms and variants"),
        ("bracket","show tree structure with brackets and paths to nodes"),
@@ -443,7 +444,7 @@ allCommands cod env@(pgf, mos) = Map.fromList [
        "pt -compute (plus one two)   -- compute value",
        "p \"foo\" | pt -typecheck      -- type check parse results"
        ],
-     exec = \opts -> returnFromTrees . treeOps (map prOpt opts),
+     exec = \opts -> returnFromExprs . treeOps (map prOpt opts),
      options = treeOpOptions pgf
      }),
   ("q",  emptyCommandInfo {
@@ -464,7 +465,7 @@ allCommands cod env@(pgf, mos) = Map.fromList [
        ("lines","return the list of lines, instead of the singleton of all contents"),
        ("tree","convert strings into trees")
        ],
-     exec = \opts arg -> do 
+     exec = \opts _ -> do 
        let file = valStrOpts "file" "_gftmp" opts
        s <- readFile file
        return $ case opts of
@@ -524,7 +525,7 @@ allCommands cod env@(pgf, mos) = Map.fromList [
   ("ut", emptyCommandInfo {
      longname = "unicode_table",
      synopsis = "show a transliteration table for a unicode character set",
-     exec = \opts arg -> do
+     exec = \opts _ -> do
          let t = concatMap prOpt (take 1 opts)
          let out = maybe "no such transliteration" characterTable $ transliteration t
          return $ fromString out,
@@ -548,8 +549,9 @@ allCommands cod env@(pgf, mos) = Map.fromList [
        "by the flag. The target format is postscript, unless overridden by the",
        "flag -format."
        ],
-     exec = \opts ts -> do
-         let funs = not (isOpt "nofun" opts)
+     exec = \opts es -> do
+         let ts = toTrees es
+             funs = not (isOpt "nofun" opts)
          let cats = not (isOpt "nocat" opts)
          let grph = visualizeTrees pgf (funs,cats) ts -- True=digraph
          if isFlag "view" opts || isFlag "format" opts then do
@@ -599,13 +601,13 @@ allCommands cod env@(pgf, mos) = Map.fromList [
        ],
      exec = \opts arg -> do
        case arg of
-         [Fun id []] -> case Map.lookup id (funs (abstract pgf)) of
-                          Just (ty,_,eqs) -> return $ fromString $
+         [EVar id] -> case Map.lookup id (funs (abstract pgf)) of
+                        Just (ty,_,eqs) -> return $ fromString $
                                               render (text "fun" <+> text (prCId id) <+> colon <+> ppType 0 ty $$
                                                       if null eqs
                                                         then empty
                                                         else text "def" <+> vcat [text (prCId id) <+> hsep (map (ppPatt 9) patts) <+> char '=' <+> ppExpr 0 res | Equ patts res <- eqs])
-                          Nothing       -> case Map.lookup id (cats (abstract pgf)) of
+                        Nothing         -> case Map.lookup id (cats (abstract pgf)) of
                                              Just hyps -> do return $ fromString $
                                                                 render (text "cat" <+> text (prCId id) <+> hsep (map ppHypo hyps) $$
                                                                         space $$
@@ -679,16 +681,21 @@ allCommands cod env@(pgf, mos) = Map.fromList [
    optNum opts = valIntOpts "number" 1 opts
    optNumInf opts = valIntOpts "number" 1000000000 opts ---- 10^9
 
-   fromTrees ts = (ts,unlines (map showTree ts))
-   fromStrings ss = (map (Lit . LStr) ss, unlines ss)
-   fromString  s  = ([Lit (LStr s)], s)
+   fromTrees ts = (map tree2expr ts,unlines (map showTree ts))
+   fromStrings ss = (map (ELit . LStr) ss, unlines ss)
+   fromString  s  = ([ELit (LStr s)], s)
+   toTrees = map expr2tree
    toStrings = map showAsString 
    toString = unwords . toStrings
 
    returnFromTrees ts = return $ case ts of
-     [] -> (ts, "no trees found")
+     [] -> ([], "no trees found")
      _ -> fromTrees ts
 
+   returnFromExprs es = return $ case es of
+     [] -> ([], "no trees found")
+     _  -> (es,unlines (map showExpr es))
+
    prGrammar opts
      | isOpt "cats"     opts = return $ fromString $ unwords $ map showType $ categories pgf
      | isOpt "fullform" opts = return $ fromString $ concatMap (prFullFormLexicon . morpho) $ optLangs opts
@@ -715,8 +722,8 @@ allCommands cod env@(pgf, mos) = Map.fromList [
      app f = maybe id id (treeOp pgf f) 
 
    showAsString t = case t of
-     Lit (LStr s) -> s
-     _ -> "\n" ++ showTree t  --- newline needed in other cases than the first
+     ELit (LStr s) -> s
+     _ -> "\n" ++ showExpr t  --- newline needed in other cases than the first
 
 stringOpOptions = [
        ("bind","bind tokens separated by Prelude.BIND, i.e. &+"),
diff --git a/src/GF/Command/Interpreter.hs b/src/GF/Command/Interpreter.hs
index 7c962b375..23b928ed6 100644
--- a/src/GF/Command/Interpreter.hs
+++ b/src/GF/Command/Interpreter.hs
@@ -27,7 +27,7 @@ data CommandEnv = CommandEnv {
   morphos       :: Map.Map Language Morpho,
   commands      :: Map.Map String CommandInfo,
   commandmacros :: Map.Map String CommandLine,
-  expmacros     :: Map.Map String Tree
+  expmacros     :: Map.Map String Expr
   }
 
 mkCommandEnv :: Encoding -> PGF -> CommandEnv
@@ -72,18 +72,20 @@ interpretPipe enc env cs = do
    appLine es = map (map (appCommand es))
 
 -- macro definition applications: replace ?i by (exps !! i)
-appCommand :: [Tree] -> Command -> Command
+appCommand :: [Expr] -> Command -> Command
 appCommand xs c@(Command i os arg) = case arg of
-  ATree e -> Command i os (ATree (app e))
+  AExpr e -> Command i os (AExpr (app e))
   _       -> c
  where
   app e = case e of
-    Meta i   -> xs !! i
-    Fun f as -> Fun f (map app as)
-    Abs x b  -> Abs x (app b)
+    EAbs x e   -> EAbs x (app e)
+    EApp e1 e2 -> EApp (app e1) (app e2)
+    ELit l     -> ELit l
+    EMeta i    -> xs !! i
+    EVar x     -> EVar x
 
 -- return the trees to be sent in pipe, and the output possibly printed
-interpret :: (String -> String) -> CommandEnv -> [Tree] -> Command -> IO CommandOutput
+interpret :: (String -> String) -> CommandEnv -> [Expr] -> Command -> IO CommandOutput
 interpret enc env trees0 comm = case lookCommand co comms of
     Just info -> do
       checkOpts info
@@ -108,15 +110,15 @@ interpret enc env trees0 comm = case lookCommand co comms of
 
 -- analyse command parse tree to a uniform datastructure, normalizing comm name
 --- the env is needed for macro lookup
-getCommand :: CommandEnv -> Command -> [Tree] -> (String,[Option],[Tree])
+getCommand :: CommandEnv -> Command -> [Expr] -> (String,[Option],[Expr])
 getCommand env co@(Command c opts arg) ts = 
   (getCommandOp c,opts,getCommandArg env arg ts) 
 
-getCommandArg :: CommandEnv -> Argument -> [Tree] -> [Tree]
+getCommandArg :: CommandEnv -> Argument -> [Expr] -> [Expr]
 getCommandArg env a ts = case a of
   AMacro m -> case Map.lookup m (expmacros env) of
     Just t -> [t]
     _ -> [] 
-  ATree t -> [t] -- ignore piped
+  AExpr t -> [t] -- ignore piped
   ANoArg  -> ts  -- use piped
 
diff --git a/src/GF/Command/Parse.hs b/src/GF/Command/Parse.hs
index 3417baff9..35abf1b7b 100644
--- a/src/GF/Command/Parse.hs
+++ b/src/GF/Command/Parse.hs
@@ -51,7 +51,7 @@ pFilename = liftM2 (:) (RP.satisfy isFileFirst) (RP.munch (not . isSpace)) where
 
 pArgument =          
   RP.option ANoArg 
-    (fmap ATree (pTree False)
+    (fmap AExpr pExpr
               RP.<++ 
     (RP.munch isSpace >> RP.char '%' >> fmap AMacro pIdent))
 
diff --git a/src/GF/Command/TreeOperations.hs b/src/GF/Command/TreeOperations.hs
index ff87de563..262ce35b5 100644
--- a/src/GF/Command/TreeOperations.hs
+++ b/src/GF/Command/TreeOperations.hs
@@ -6,13 +6,9 @@ module GF.Command.TreeOperations (
 import GF.Compile.TypeCheck
 import PGF
 
---import GF.Compile.GrammarToGFCC (mkType,mkExp)
-import qualified GF.Grammar.Grammar as G
-import qualified GF.Grammar.Macros as M
-
 import Data.List
 
-type TreeOp = [Tree] -> [Tree]
+type TreeOp = [Expr] -> [Expr]
 
 treeOp :: PGF -> String -> Maybe TreeOp
 treeOp pgf f = fmap snd $ lookup f $ allTreeOps pgf
@@ -20,20 +16,20 @@ treeOp pgf f = fmap snd $ lookup f $ allTreeOps pgf
 allTreeOps :: PGF -> [(String,(String,TreeOp))]
 allTreeOps pgf = [
    ("compute",("compute by using semantic definitions (def)",
-      map (expr2tree pgf . tree2expr))),
+      map (compute pgf))),
    ("paraphrase",("paraphrase by using semantic definitions (def)",
-      nub . concatMap (paraphrase pgf))),
+      map tree2expr . nub . concatMap (paraphrase pgf . expr2tree))),
    ("smallest",("sort trees from smallest to largest, in number of nodes",
       smallest)),
    ("typecheck",("type check and solve metavariables; reject if incorrect",
       concatMap (typecheck pgf)))
   ]
 
-smallest :: [Tree] -> [Tree]
+smallest :: [Expr] -> [Expr]
 smallest = sortBy (\t u -> compare (size t) (size u)) where
   size t = case t of
-    Abs _ b -> size b + 1
-    Fun f ts -> sum (map size ts) + 1
+    EAbs _ e -> size e + 1
+    EApp e1 e2 -> size e1 + size e2 + 1
     _ -> 1
 
 {-