+ +1/6 (AR) Added the FCFG parser written by Krasimir Angelov. Invoked by +p -fcfg. This parser is as general as MCFG but faster. +It needs more testing and debugging. + +
+ +1/6 (AR) The command r = reload repeats the latest +i = import command. + +
+ 30/5 (AR) It is now possible to use the flags -all, -table, -record in combination with l -multi, and also with tb. diff --git a/doc/tutorial/arithm/Arithm.gf b/doc/tutorial/arithm/Arithm.gf new file mode 100644 index 000000000..00d6b4780 --- /dev/null +++ b/doc/tutorial/arithm/Arithm.gf @@ -0,0 +1,13 @@ +abstract Arithm = { + + cat + Prop ; + Nat ; + + fun + Zero : Nat ; + Succ : Nat -> Nat ; + Even : Nat -> Prop ; + And : Prop -> Prop -> Prop ; + +} diff --git a/doc/tutorial/arithm/ArithmEng.gf b/doc/tutorial/arithm/ArithmEng.gf new file mode 100644 index 000000000..5d2cd966d --- /dev/null +++ b/doc/tutorial/arithm/ArithmEng.gf @@ -0,0 +1,27 @@ +--# -path=.:alltenses:prelude + +concrete ArithmEng of Arithm = ArithmI with + (Lang = LangEng), + (Lex = LexEng) ; + +{- + +concrete ArithmEng of Arithm = open LangEng, ParadigmsEng in { + + lincat + Prop = S ; + Nat = NP ; + + lin + Zero = + UsePN (regPN "zero" nonhuman) ; + Succ n = + DetCN (DetSg (SgQuant DefArt) NoOrd) (ComplN2 (regN2 "successor") n) ; + Even n = + UseCl TPres ASimul PPos + (PredVP n (UseComp (CompAP (PositA (regA "even"))))) ; + And x y = + ConjS and_Conj (BaseS x y) ; + +} +-} diff --git a/doc/tutorial/arithm/ArithmI.gf b/doc/tutorial/arithm/ArithmI.gf new file mode 100644 index 000000000..f41b57fa6 --- /dev/null +++ b/doc/tutorial/arithm/ArithmI.gf @@ -0,0 +1,20 @@ +--# -path=.:alltenses:prelude + +incomplete concrete ArithmI of Arithm = open Lang, Lex in { + + lincat + Prop = S ; + Nat = NP ; + + lin + Zero = + UsePN zero_PN ; + Succ n = + DetCN (DetSg (SgQuant DefArt) NoOrd) (ComplN2 successor_N2 n) ; + Even n = + UseCl TPres ASimul PPos + (PredVP n (UseComp (CompAP (PositA even_A)))) ; + And x y = + ConjS and_Conj (BaseS x y) ; + +} diff --git a/doc/tutorial/arithm/ArithmSwe.gf b/doc/tutorial/arithm/ArithmSwe.gf new file mode 100644 index 000000000..070dcc280 --- /dev/null +++ b/doc/tutorial/arithm/ArithmSwe.gf @@ -0,0 +1,29 @@ +--# -path=.:alltenses:prelude + + +concrete ArithmSwe of Arithm = ArithmI with + (Lang = LangSwe), + (Lex = LexSwe) ; + +{- +concrete ArithmSwe of Arithm = open LangSwe, ParadigmsSwe in { + + lincat + Prop = S ; + Nat = NP ; + + lin + Zero = + UsePN (regPN "noll" neutrum) ; + Succ n = + DetCN (DetSg (SgQuant DefArt) NoOrd) + (ComplN2 (mkN2 (mk2N "efterföljare" "efterföljare") + (mkPreposition "till")) n) ; + Even n = + UseCl TPres ASimul PPos + (PredVP n (UseComp (CompAP (PositA (regA "jämn"))))) ; + And x y = + ConjS and_Conj (BaseS x y) ; + +} +-} \ No newline at end of file diff --git a/doc/tutorial/arithm/Lex.gf b/doc/tutorial/arithm/Lex.gf new file mode 100644 index 000000000..bfc725772 --- /dev/null +++ b/doc/tutorial/arithm/Lex.gf @@ -0,0 +1,6 @@ +abstract Lex = Cat ** { + fun + zero_PN : PN ; + successor_N2 : N2 ; + even_A : A ; +} diff --git a/doc/tutorial/arithm/LexEng.gf b/doc/tutorial/arithm/LexEng.gf new file mode 100644 index 000000000..50a2a99df --- /dev/null +++ b/doc/tutorial/arithm/LexEng.gf @@ -0,0 +1,6 @@ +concrete LexEng of Lex = CatEng ** open ParadigmsEng in { + lin + zero_PN = regPN "zero" nonhuman ; + successor_N2 = regN2 "successor" ; + even_A = regA "even" ; +} diff --git a/doc/tutorial/arithm/LexSwe.gf b/doc/tutorial/arithm/LexSwe.gf new file mode 100644 index 000000000..54d66b6e9 --- /dev/null +++ b/doc/tutorial/arithm/LexSwe.gf @@ -0,0 +1,8 @@ +concrete LexSwe of Lex = CatSwe ** open ParadigmsSwe in { + lin + zero_PN = regPN "noll" neutrum ; + successor_N2 = + mkN2 (mk2N "efterföljare" "efterföljare") (mkPreposition "till") ; + even_A = regA "jämn" ; + +} diff --git a/doc/tutorial/gf-tutorial2.txt b/doc/tutorial/gf-tutorial2.txt index c06fc8190..978d46f36 100644 --- a/doc/tutorial/gf-tutorial2.txt +++ b/doc/tutorial/gf-tutorial2.txt @@ -1967,6 +1967,167 @@ The rest of the modules (black) come from the resource. ===Restricted inheritance and qualified opening=== +==Using the standard resource library== + +The example files of this chapter can be found in +the directory [``arithm`` ./arithm]. + + +===The simplest way=== + +The simplest way is to ``open`` a top-level ``Lang`` module +and a ``Paradigms`` module: +``` + abstract Foo = ... + + concrete FooEng = open LangEng, ParadigmsEng in ... + concrete FooSwe = open LangSwe, ParadigmsSwe in ... +``` +Here is an example. +``` +abstract Arithm = { + cat + Prop ; + Nat ; + fun + Zero : Nat ; + Succ : Nat -> Nat ; + Even : Nat -> Prop ; + And : Prop -> Prop -> Prop ; +} + +--# -path=.:alltenses:prelude + +concrete ArithmEng of Arithm = open LangEng, ParadigmsEng in { + lincat + Prop = S ; + Nat = NP ; + lin + Zero = + UsePN (regPN "zero" nonhuman) ; + Succ n = + DetCN (DetSg (SgQuant DefArt) NoOrd) (ComplN2 (regN2 "successor") n) ; + Even n = + UseCl TPres ASimul PPos + (PredVP n (UseComp (CompAP (PositA (regA "even"))))) ; + And x y = + ConjS and_Conj (BaseS x y) ; + +} + +--# -path=.:alltenses:prelude + +concrete ArithmSwe of Arithm = open LangSwe, ParadigmsSwe in { + lincat + Prop = S ; + Nat = NP ; + lin + Zero = + UsePN (regPN "noll" neutrum) ; + Succ n = + DetCN (DetSg (SgQuant DefArt) NoOrd) + (ComplN2 (mkN2 (mk2N "efterföljare" "efterföljare") + (mkPreposition "till")) n) ; + Even n = + UseCl TPres ASimul PPos + (PredVP n (UseComp (CompAP (PositA (regA "jämn"))))) ; + And x y = + ConjS and_Conj (BaseS x y) ; +} +``` + + +===How to find resource functions=== + +The definitions in this example were found by parsing: +``` + > i LangEng.gf + + -- for Successor: + > p -cat=NP -mcfg -parser=topdown "the mother of Paris" + + -- for Even: + > p -cat=S -mcfg -parser=topdown "Paris is old" + + -- for And: + > p -cat=S -mcfg -parser=topdown "Paris is old and I am old" +``` +The use of parsing can be systematized by **example-based grammar writing**, +to which we will return later. + + +===A functor implementation=== + +The interesting thing now is that the +code in ``ArithmSwe`` is similar to the code in ``ArithmEng``, except for +some lexical items ("noll" vs. "zero", "efterföljare" vs. "successor", +"jämn" vs. "even"). How can we exploit the similarities and +actually share code between the languages? + +The solution is to use a functor: an ``incomplete`` module that opens +an ``abstract`` as an ``interface``, and then instantiate it to different +languages that implement the interface. The structure is as follows: +``` + abstract Foo ... + + incomplete concrete FooI = open Lang, Lex in ... + + concrete FooEng of Foo = FooI with (Lang=LangEng), (Lex=LexEng) ; + concrete FooSwe of Foo = FooI with (Lang=LangSwe), (Lex=LexSwe) ; +``` +where ``Lex`` is an abstract lexicon that includes the vocabulary +specific to this application: +``` + abstract Lex = Cat ** ... + + concrete LexEng of Lex = CatEng ** open ParadigmsEng in ... + concrete LexSwe of Lex = CatSwe ** open ParadigmsSwe in ... +``` +Here, again, a complete example (``abstract Arithm`` is as above): +``` +incomplete concrete ArithmI of Arithm = open Lang, Lex in { + lincat + Prop = S ; + Nat = NP ; + lin + Zero = + UsePN zero_PN ; + Succ n = + DetCN (DetSg (SgQuant DefArt) NoOrd) (ComplN2 successor_N2 n) ; + Even n = + UseCl TPres ASimul PPos + (PredVP n (UseComp (CompAP (PositA even_A)))) ; + And x y = + ConjS and_Conj (BaseS x y) ; +} + +--# -path=.:alltenses:prelude +concrete ArithmEng of Arithm = ArithmI with + (Lang = LangEng), + (Lex = LexEng) ; + +--# -path=.:alltenses:prelude +concrete ArithmSwe of Arithm = ArithmI with + (Lang = LangSwe), + (Lex = LexSwe) ; + +abstract Lex = Cat ** { + fun + zero_PN : PN ; + successor_N2 : N2 ; + even_A : A ; +} + +concrete LexSwe of Lex = CatSwe ** open ParadigmsSwe in { + lin + zero_PN = regPN "noll" neutrum ; + successor_N2 = + mkN2 (mk2N "efterföljare" "efterföljare") (mkPreposition "till") ; + even_A = regA "jämn" ; +} +``` + + ==Transfer modules==