Some bug fixes mostly in editor commands.

src/GF/UseGrammar/Custom.hs

@@ -184,7 +184,8 @@ customTermCommand =
   ,(strCI "compute",    \g t -> let gr = grammar g in
                                   err (const [t]) return 
                                     (exp2termCommand gr (computeAbsTerm gr) t))
-----  ,(strCI "paraphrase", \g t -> mkParaphrases g t)
+  ,(strCI "paraphrase", \g t -> let gr = grammar g in
+                                  exp2termlistCommand gr (mkParaphrases gr) t)
 ----  ,(strCI "typecheck",  \g t -> err (const []) return (checkIfValidExp g t))
   ,(strCI "solve",      \g t -> err (const [t]) (return . loc2tree)
                                    (uniqueRefinements (grammar g) (tree2loc t)))

src/GF/UseGrammar/Paraphrases.hs

@@ -1,41 +1,40 @@
 module Paraphrases (mkParaphrases) where
 
-import Operations
-import AbsGFC
-import GFC
-import Look
-import CMacros ---- (mkApp, eqStrIdent)
+import Abstract
+import PrGrammar
+import LookAbs
 import AbsCompute
+
+import Operations
+
 import List (nub)
 
 -- paraphrases of GF terms. AR 6/10/1998 -- 24/9/1999 -- 5/7/2000 -- 5/6/2002
 -- Copyright (c) Aarne Ranta 1998--99, under GNU General Public License (see GPL)
 -- thus inherited from the old GF. Incomplete and inefficient...
 
-mkParaphrases :: CanonGrammar -> Exp -> [Exp]
-mkParaphrases st t = [t]
----- mkParaphrases st = nub . map (beta []) . paraphrases (allDefs st)
+mkParaphrases :: GFCGrammar -> Term -> [Term]
+mkParaphrases st = nub . map (beta []) . paraphrases (allDefs st)
 
-{- ----
-type Definition = (Fun,Trm)
+type Definition = (Fun,Term)
 
-paraphrases :: [Definition] -> Trm -> [Trm]
+paraphrases :: [Definition] -> Term -> [Term]
 paraphrases th t =
-  t :
   paraImmed th t ++
 ---  paraMatch th t ++
   case t of
     App c a -> [App d b | d <- paraphrases th c, b <- paraphrases th a]
     Abs x b -> [Abs x d | d <- paraphrases th b]
     c       -> []
+  ++ [t]
 
-paraImmed :: [Definition] -> Trm -> [Trm]
+paraImmed :: [Definition] -> Term -> [Term]
 paraImmed defs t = 
-  [Cn f | (f, u) <- defs, t == u] ++ --- eqTerm
+  [Q m f | ((m,f), u) <- defs, t == u] ++ --- eqTerm
   case t of
-    Cn c -> [u | (f, u) <- defs, eqStrIdent f c]
+  ----  Cn c -> [u | (f, u) <- defs, eqStrIdent f c]
     _    -> []
--}
+
 {- ---
 paraMatch :: [Definition] -> Trm -> [Trm]
 paraMatch th@defs t =