forked from GitHub/gf-core
fc1b51aa95
This output format converts a GF grammar to a "canonical" GF grammar. A canonical GF grammar consists of - one self-contained module for the abstract syntax - one self-contained module per concrete syntax The concrete syntax modules contain param, lincat and lin definitions, everything else has been eliminated by the partial evaluator, including references to resource library modules and functors. Record types and tables are retained. The -output-format canonical_gf option writes canonical GF grammars to a subdirectory "canonical/". The canonical GF grammars are written as normal GF ".gf" source files, which can be compiled with GF in the normal way. The translation to canonical form goes via an AST for canonical GF grammars, defined in GF.Grammar.Canonical. This is a simple, self-contained format that doesn't cover everyting in GF (e.g. omitting dependent types and HOAS), but it is complete enough to translate the Foods and Phrasebook grammars found in gf-contrib. The AST is based on the GF grammar "GFCanonical" presented here: https://github.com/GrammaticalFramework/gf-core/issues/30#issuecomment-453556553 The translation of concrete syntax to canonical form is based on the previously existing translation of concrete syntax to Haskell, implemented in module GF.Compile.ConcreteToHaskell. This module could now be reimplemented and simplified significantly by going via the canonical format. Perhaps exports to other output formats could benefit by going via the canonical format too. There is also the possibility of completing the GFCanonical grammar mentioned above and using GF itself to convert canonical GF grammars to other formats...
49 lines
1.4 KiB
Haskell
49 lines
1.4 KiB
Haskell
-- | Pretty printing with class
|
|
module GF.Text.Pretty(module GF.Text.Pretty,module PP) where
|
|
import qualified Text.PrettyPrint as PP
|
|
import Text.PrettyPrint as PP(Doc,Style(..),Mode(..),style,empty,isEmpty)
|
|
|
|
class Pretty a where
|
|
pp :: a -> Doc
|
|
ppList :: [a] -> Doc
|
|
ppList = fsep . map pp -- hmm
|
|
|
|
instance Pretty Doc where pp = id
|
|
instance Pretty Int where pp = PP.int
|
|
instance Pretty Integer where pp = PP.integer
|
|
instance Pretty Float where pp = PP.float
|
|
instance Pretty Double where pp = PP.double
|
|
instance Pretty Char where pp = PP.char; ppList = PP.text
|
|
|
|
instance Pretty a => Pretty [a] where
|
|
pp = ppList
|
|
ppList = fsep . map pp -- hmm
|
|
|
|
render x = PP.render (pp x)
|
|
render80 x = renderStyle style{lineLength=80,ribbonsPerLine=1} x
|
|
renderStyle s x = PP.renderStyle s (pp x)
|
|
|
|
infixl 5 $$,$+$
|
|
infixl 6 <>,<+>
|
|
|
|
x $$ y = pp x PP.$$ pp y
|
|
x $+$ y = pp x PP.$+$ pp y
|
|
x <+> y = pp x PP.<+> pp y
|
|
x <> y = pp x PP.<> pp y
|
|
|
|
braces x = PP.braces (pp x)
|
|
brackets x = PP.brackets (pp x)
|
|
cat xs = PP.cat (map pp xs)
|
|
doubleQuotes x = PP.doubleQuotes (pp x)
|
|
fcat xs = PP.fcat (map pp xs)
|
|
fsep xs = PP.fsep (map pp xs)
|
|
hang x d y = PP.hang (pp x) d (pp y)
|
|
hcat xs = PP.hcat (map pp xs)
|
|
hsep xs = PP.hsep (map pp xs)
|
|
nest d x = PP.nest d (pp x)
|
|
parens x = PP.parens (pp x)
|
|
punctuate x ys = PP.punctuate (pp x) (map pp ys)
|
|
quotes x = PP.quotes (pp x)
|
|
sep xs = PP.sep (map pp xs)
|
|
vcat xs = PP.vcat (map pp xs)
|