From a0fc2f28e8fc2036e4f33eab48bbf1958d71054e Mon Sep 17 00:00:00 2001
From: Krasimir Angelov <kr.angelov@gmail.com>
Date: Mon, 28 Aug 2017 14:23:47 +0200
Subject: more in the runtime documentation

---
 doc/runtime-api.html | 180 ++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 142 insertions(+), 38 deletions(-)

(limited to 'doc/runtime-api.html')
diff --git a/doc/runtime-api.html b/doc/runtime-api.html
index 9bc167217..da5b21a9e 100644
--- a/doc/runtime-api.html
+++ b/doc/runtime-api.html
@@ -1,6 +1,5 @@
 <html>
 	<head>
-		<link rel="stylesheet" type="text/css" href="cloud.css" title="Cloud">
 		<style>
 			body { background: #eee; }
 
@@ -268,7 +267,7 @@ red theatre
 </pre>
 This method produces only a single linearization. If you use variants
 in the grammar then you might want to see all possible linearizations.
-For that purpouse you should use linearizeAll:
+For that purpouse you should use <tt>linearizeAll</tt>:
 <pre class="python">
 >>> for s in eng.linearizeAll(e):
        print(s)
@@ -294,8 +293,8 @@ then the right method to use is <tt>tabularLinearize</tt>:
 {'s Sg Nom': 'red theatre', 's Pl Nom': 'red theatres', 's Pl Gen': "red theatres'", 's Sg Gen': "red theatre's"}
 </pre>
 <pre class="haskell">
-Prelude PGF2> tabularLinearize eng e
-{'s Sg Nom': 'red theatre', 's Pl Nom': 'red theatres', 's Pl Gen': "red theatres'", 's Sg Gen': "red theatre's"}
+Prelude PGF2> tabularLinearize eng e   ---- TODO
+fromList [("s Sg Nom", "red theatre"), ("s Pl Nom", "red theatres"), ("s Pl Gen", "red theatres'"), ("s Sg Gen", "red theatre's")]
 </pre>
 <pre class="java">
 for (Map.Entry&lt;String,String&gt; entry : eng.tabularLinearize(e)) {
@@ -316,20 +315,53 @@ a list of phrases:
 (CN:4 (AP:1 (A:0 red)) (CN:3 (N:2 theatre)))
 </pre>
 <pre class="haskell">
-Prelude PGF2> let [b] = bracketedLinearize eng e
+Prelude PGF2> let [b] = bracketedLinearize eng e   ---- TODO
 Prelude PGF2> print b
 (CN:4 (AP:1 (A:0 red)) (CN:3 (N:2 theatre)))
 </pre>
 <pre class="java">
 Object[] bs = eng.bracketedLinearize(e)
 </pre>
-Each bracket is actually an object of type pgf.Bracket. The property
-<tt>cat</tt> of the object gives you the name of the category and 
-the property children gives you a list of nested brackets.
-If a phrase is discontinuous then it is represented as more than
-one brackets with the same category name. In that case, the index
-that you see in the example above will have the same value for all
-brackets of the same phrase.
+<span class="python">
+Each element in the sequence above is either a string or an object
+of type <tt>pgf.Bracket</tt>. When it is actually a bracket then
+the object has the following properties:
+<ul>
+	<li><tt>cat</tt> - the syntactic category for this bracket</li>
+	<li><tt>fid</tt> - an id which identifies this bracket in the bracketed string. If there are discontinuous phrases this id will be shared for all brackets belonging to the same phrase.</li>
+	<li><tt>lindex</tt> - the constituent index</li>
+	<li><tt>fun</tt> - the abstract function for this bracket</li>
+	<li><tt>children</tt> - a list with the children of this bracket</li>
+</ul>
+</span>
+<span class="haskell">
+The list above contains elements of type <tt>BracketedString</tt>.
+This type has two constructors:
+<ul>
+	<li><tt>Leaf</tt> with only one argument of type <tt>String</tt> that contains the current word</li>
+	<li><tt>Bracket</tt> with the following arguments:
+		<ul>
+			<li><tt>cat :: String</tt> - the syntactic category for this bracket</li>
+			<li><tt>fid :: Int</tt> - an id which identifies this bracket in the bracketed string. If there are discontinuous phrases this id will be shared for all brackets belonging to the same phrase.</li>
+			<li><tt>lindex :: Int</tt> - the constituent index</li>
+			<li><tt>fun :: String</tt> - the abstract function for this bracket</li>
+			<li><tt>children :: [BracketedString]</tt> - a list with the children of this bracket</li>
+		</ul>
+	</li>
+</ul>
+</span>
+<span class="java">
+Each element in the sequence above is either a string or an object
+of type <tt>Bracket</tt>. When it is actually a bracket then
+the object has the following public final variables:
+<ul>
+	<li><tt>String cat</tt> - the syntactic category for this bracket</li>
+	<li><tt>int fid</tt> - an id which identifies this bracket in the bracketed string. If there are discontinuous phrases this id will be shared for all brackets belonging to the same phrase.</li>
+	<li><tt>int lindex</tt> - the constituent index</li>
+	<li><tt>String fun</tt> - the abstract function for this bracket</li>
+	<li><tt>Object[] children</tt> - a list with the children of this bracket</li>
+</ul>
+</span>
 </p>
 
 The linearization works even if there are functions in the tree 
@@ -357,20 +389,45 @@ a tree into a function name and a list of arguments:
 >>> e.unpack()
 ('AdjCN', [&lt;pgf.Expr object at 0x7f7df6db78c8&gt;, &lt;pgf.Expr object at 0x7f7df6db7878&gt;])
 </pre>
-
+<pre class="haskell">
+Prelude PGF2> unApp e
+Just ("AdjCN", [..., ...])
+</pre>
+</p>
+<p>
+<span class="python">
 The result from unpack can be different depending on the form of the
 tree. If the tree is a function application then you always get
-a tuple of function name and a list of arguments. If instead the
+a tuple of a function name and a list of arguments. If instead the
 tree is just a literal string then the return value is the actual
 literal. For example the result from:
+</span>
 <pre class="python">
 >>> pgf.readExpr('"literal"').unpack()
 'literal'
 </pre>
-is just the string 'literal'. Situations like this can be detected
+<span class="haskell">
+The result from <tt>unApp</tt> is <tt>Just</tt> if the expression
+is an application and <tt>Nothing</tt> in all other cases.
+Similarly, if the tree is a literal string then the return value 
+from <tt>unStr</tt> will be <tt>Just</tt> with the actual literal. 
+For example the result from:
+</span>
+<pre class="haskell">
+Prelude PGF2> unStr (readExpr "\"literal\"")
+"literal"
+</pre>
+is just the string "literal". 
+<span class="python">Situations like this can be detected
 in Python by checking the type of the result from <tt>unpack</tt>.
+It is also possible to get an integer or a floating point number
+for the other possible literal types in GF.</span>
+<span class="haskell">
+There are also the functions <tt>unAbs</tt>, <tt>unInt</tt>, <tt>unFloat</tt> and <tt>unMeta</tt> for all other possible cases.
+</span>
 </p>
 
+<span class="python">
 <p>
 For more complex analyses you can use the visitor pattern.
 In object oriented languages this is just a clumpsy way to do
@@ -406,10 +463,12 @@ the current tree is <tt>DetCN</tt> or <tt>AdjCN</tt>
 correspondingly. In this example we just print a message and
 we call <tt>visit</tt> recursively to go deeper into the tree.
 </p>
+</span>
 
 Constructing new trees is also easy. You can either use 
 <tt>readExpr</tt> to read trees from strings, or you can
 construct new trees from existing pieces. This is possible by
+<span class="python">
 using the constructor for <tt>pgf.Expr</tt>:
 <pre class="python">
 >>> quant = pgf.readExpr("DetQuant IndefArt NumSg")
@@ -417,7 +476,18 @@ using the constructor for <tt>pgf.Expr</tt>:
 >>> print(e2)
 DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA red_A) (UseN theatre_N))
 </pre>
+</span>
+<span class="haskell">
+using the functions <tt>mkApp</tt>, <tt>mkStr</tt>, <tt>mkInt</tt>, <tt>mkFloat</tt> and <tt>mkMeta</tt>:
+<pre class="haskell">
+Prelude PGF2> let Just quant = readExpr "DetQuant IndefArt NumSg"
+Prelude PGF2> let e2 = mkApp "DetCN" [quant, e]
+Prelude PGF2> print e2
+DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA red_A) (UseN theatre_N))
+</pre>
+</span>
 
+<span class="python">
 <h2>Embedded GF Grammars</h2>
 
 The GF compiler allows for easy integration of grammars in Haskell
@@ -439,6 +509,7 @@ functions:
 >>> print(App.DetCN(quant,e))
 DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA red_A) (UseN house_N))
 </pre>
+</span>
 
 <h2>Access the Morphological Lexicon</h2>
 
@@ -447,18 +518,27 @@ lexicon. The first makes it possible to dump the full form lexicon.
 The following code just iterates over the lexicon and prints each
 word form with its possible analyses:
 <pre class="python">
-for entry in eng.fullFormLexicon():
-	print(entry)
+>>> for entry in eng.fullFormLexicon():
+>>>    print(entry)
+</pre>
+<pre class="haskell">
+Prelude PGF2> mapM_ print [(form,lemma,analysis,prob) | (form,analyses) &lt;- fullFormLexicon eng, (lemma,analysis,prob) &lt- analyses]
 </pre>
 <pre class="java">
-for (entry in eng.fullFormLexicon()) {
-    System.out.println(entry);
+for (FullFormEntry entry in eng.fullFormLexicon()) {
+	for (MorphoAnalysis analysis : entry.getAnalyses()) {
+		System.out.println(entry.getForm()+" "+analysis.getProb()+" "+analysis.getLemma()+" "+analysis.getField());
+	}
 }
 </pre>
 The second one implements a simple lookup. The argument is a word
 form and the result is a list of analyses:
 <pre class="python">
-print(eng.lookupMorpho("letter"))
+>>> print(eng.lookupMorpho("letter"))
+[('letter_1_N', 's Sg Nom', inf), ('letter_2_N', 's Sg Nom', inf)]
+</pre>
+<pre class="python">
+Prelude PGF2> print (lookupMorpho eng "letter")
 [('letter_1_N', 's Sg Nom', inf), ('letter_2_N', 's Sg Nom', inf)]
 </pre>
 <pre class="java">
@@ -588,6 +668,7 @@ Expr e = gr.checkExpr(e,Type.readType("A"))
 pgf.TypeError: The expected type of the expression AdjCN (PositA red_A) (UseN theatre_N) is A but CN is infered
 </pre></p>
 
+<span class="python">
 <h2>Partial Grammar Loading</h2>
 
 <p>By default the whole grammar is compiled into a single file
@@ -600,12 +681,6 @@ This is done by using the option <tt>-split-pgf</tt> in the compiler:
 <pre class="python">
 $ gf -make -split-pgf App12.pgf
 </pre>
-<pre class="haskell">
-$ gf -make -split-pgf App12.pgf
-</pre>
-<pre class="java">
-$ gf -make -split-pgf App12.pgf
-</pre>
 </p>
 
 Now you can load the grammar as usual but this time only the
@@ -616,10 +691,6 @@ concrete syntax objects:
 >>> gr = pgf.readPGF("App.pgf")
 >>> eng = gr.languages["AppEng"]
 </pre>
-<pre class="java">
-PGF gr = PGF.readPGF("App.pgf")
-Concr eng = gr.getLanguages().get("AppEng")
-</pre>
 However, if you now try to use the concrete syntax then you will
 get an exception:
 <pre class="python">
@@ -628,6 +699,46 @@ Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 pgf.PGFError: The concrete syntax is not loaded
 </pre>
+
+Before using the concrete syntax, you need to explicitly load it: 
+<pre class="python">
+>>> eng.load("AppEng.pgf_c")
+>>> print(eng.lookupMorpho("letter"))
+[('letter_1_N', 's Sg Nom', inf), ('letter_2_N', 's Sg Nom', inf)]
+</pre>
+
+When you don't need the language anymore then you can simply
+unload it:
+<pre class="python">
+>>> eng.unload()
+</pre>
+</span>
+
+<span class="java">
+<h2>Partial Grammar Loading</h2>
+
+<p>By default the whole grammar is compiled into a single file
+which consists of an abstract syntax together will all concrete
+languages. For large grammars with many languages this might be
+inconvinient because loading becomes slower and the grammar takes
+more memory. For that purpose you could split the grammar into
+one file for the abstract syntax and one file for every concrete syntax.
+This is done by using the option <tt>-split-pgf</tt> in the compiler:
+<pre class="java">
+$ gf -make -split-pgf App12.pgf
+</pre>
+</p>
+
+Now you can load the grammar as usual but this time only the
+abstract syntax will be loaded. You can still use the <tt>languages</tt>
+property to get the list of languages and the corresponding
+concrete syntax objects:
+<pre class="java">
+PGF gr = PGF.readPGF("App.pgf")
+Concr eng = gr.getLanguages().get("AppEng")
+</pre>
+However, if you now try to use the concrete syntax then you will
+get an exception:
 <pre class="java">
 eng.lookupMorpho("letter")
 Traceback (most recent call last):
@@ -636,11 +747,6 @@ pgf.PGFError: The concrete syntax is not loaded
 </pre>
 
 Before using the concrete syntax, you need to explicitly load it: 
-<pre class="python">
->>> eng.load("AppEng.pgf_c")
->>> print(eng.lookupMorpho("letter"))
-[('letter_1_N', 's Sg Nom', inf), ('letter_2_N', 's Sg Nom', inf)]
-</pre>
 <pre class="java">
 eng.load("AppEng.pgf_c")
 for (MorphoAnalysis an : eng.lookupMorpho("letter")) {
@@ -652,12 +758,10 @@ letter_2_N, s Sg Nom, inf
 
 When you don't need the language anymore then you can simply
 unload it:
-<pre class="python">
->>> eng.unload()
-</pre>
 <pre class="java">
 eng.unload()
 </pre>
+</span>
 
 <h2>GraphViz</h2>
 
-- 
cgit v1.2.3


From 78768483759866227b9bf7e7ad292f18a466fce4 Mon Sep 17 00:00:00 2001
From: Krasimir Angelov <kr.angelov@gmail.com>
Date: Tue, 29 Aug 2017 12:00:00 +0200
Subject: remove the TODOs from the runtime documentation

---
 doc/runtime-api.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'doc/runtime-api.html')

diff --git a/doc/runtime-api.html b/doc/runtime-api.html
index da5b21a9e..23b86b1da 100644
--- a/doc/runtime-api.html
+++ b/doc/runtime-api.html
@@ -293,7 +293,7 @@ then the right method to use is <tt>tabularLinearize</tt>:
 {'s Sg Nom': 'red theatre', 's Pl Nom': 'red theatres', 's Pl Gen': "red theatres'", 's Sg Gen': "red theatre's"}
 </pre>
 <pre class="haskell">
-Prelude PGF2> tabularLinearize eng e   ---- TODO
+Prelude PGF2> tabularLinearize eng e
 fromList [("s Sg Nom", "red theatre"), ("s Pl Nom", "red theatres"), ("s Pl Gen", "red theatres'"), ("s Sg Gen", "red theatre's")]
 </pre>
 <pre class="java">
@@ -315,7 +315,7 @@ a list of phrases:
 (CN:4 (AP:1 (A:0 red)) (CN:3 (N:2 theatre)))
 </pre>
 <pre class="haskell">
-Prelude PGF2> let [b] = bracketedLinearize eng e   ---- TODO
+Prelude PGF2> let [b] = bracketedLinearize eng e
 Prelude PGF2> print b
 (CN:4 (AP:1 (A:0 red)) (CN:3 (N:2 theatre)))
 </pre>
-- 
cgit v1.2.3


From b524a5a9086b8779c91ce7c2dd00a980b5336247 Mon Sep 17 00:00:00 2001
From: Krasimir Angelov <kr.angelov@gmail.com>
Date: Tue, 29 Aug 2017 13:59:30 +0200
Subject: final fixes for the Haskell documentation

---
 doc/runtime-api.html | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

(limited to 'doc/runtime-api.html')

diff --git a/doc/runtime-api.html b/doc/runtime-api.html
index 23b86b1da..d6a46149e 100644
--- a/doc/runtime-api.html
+++ b/doc/runtime-api.html
@@ -134,7 +134,7 @@ If the result is <tt>Left</tt> then the parser has failed and you will
 get the token where the parser got stuck. If the parsing was successful
 then you get a potentially infinite list of parse results:
 <pre class="haskell">
-Prelude PGF2> let Right ((p,e):rest) = res
+Prelude PGF2> let Right ((e,p):rest) = res
 </pre>
 </span>
 <span class="java">
@@ -294,7 +294,7 @@ then the right method to use is <tt>tabularLinearize</tt>:
 </pre>
 <pre class="haskell">
 Prelude PGF2> tabularLinearize eng e
-fromList [("s Sg Nom", "red theatre"), ("s Pl Nom", "red theatres"), ("s Pl Gen", "red theatres'"), ("s Sg Gen", "red theatre's")]
+fromList [("s Pl Gen","red theatres'"),("s Pl Nom","red theatres"),("s Sg Gen","red theatre's"),("s Sg Nom","red theatre")]
 </pre>
 <pre class="java">
 for (Map.Entry&lt;String,String&gt; entry : eng.tabularLinearize(e)) {
@@ -316,7 +316,7 @@ a list of phrases:
 </pre>
 <pre class="haskell">
 Prelude PGF2> let [b] = bracketedLinearize eng e
-Prelude PGF2> print b
+Prelude PGF2> putStrLn (showBracketedString b)
 (CN:4 (AP:1 (A:0 red)) (CN:3 (N:2 theatre)))
 </pre>
 <pre class="java">
@@ -371,12 +371,15 @@ It is sometimes helpful to be able to see whether a function
 is linearizable or not. This can be done in this way:
 <pre class="python">
 >>> print(eng.hasLinearization("apple_N"))
+True
 </pre>
 <pre class="haskell">
 Prelude PGF2> print (hasLinearization eng "apple_N")
+True
 </pre>
 <pre class="java">
 System.out.println(eng.hasLinearization("apple_N"))
+true
 </pre>
 
 <h2>Analysing and Constructing Expressions</h2>
@@ -414,7 +417,7 @@ from <tt>unStr</tt> will be <tt>Just</tt> with the actual literal.
 For example the result from:
 </span>
 <pre class="haskell">
-Prelude PGF2> unStr (readExpr "\"literal\"")
+Prelude PGF2> readExpr "\"literal\"" >>= unStr
 "literal"
 </pre>
 is just the string "literal". 
@@ -537,7 +540,7 @@ form and the result is a list of analyses:
 >>> print(eng.lookupMorpho("letter"))
 [('letter_1_N', 's Sg Nom', inf), ('letter_2_N', 's Sg Nom', inf)]
 </pre>
-<pre class="python">
+<pre class="haskell">
 Prelude PGF2> print (lookupMorpho eng "letter")
 [('letter_1_N', 's Sg Nom', inf), ('letter_2_N', 's Sg Nom', inf)]
 </pre>
@@ -596,7 +599,7 @@ The full type of a function can be retrieved as:
 Det -> CN -> NP
 </pre>
 <pre class="haskell">
-Prelude PGF2> print (gr.functionType "DetCN")
+Prelude PGF2> print (functionType gr "DetCN")
 Det -> CN -> NP
 </pre>
 <pre class="java">
@@ -617,8 +620,8 @@ AdjCN (PositA red_A) (UseN theatre_N)
 CN
 </pre>
 <pre class="haskell">
-Prelude PGF2> let Right (e,ty) = inferExpr gr e
-Prelude PGF2> print e
+Prelude PGF2> let Right (e',ty) = inferExpr gr e
+Prelude PGF2> print e'
 AdjCN (PositA red_A) (UseN theatre_N)
 Prelude PGF2> print ty
 CN
@@ -644,8 +647,8 @@ AdjCN (PositA red_A) (UseN theatre_N)
 </pre>
 <pre class="haskell">
 Prelude PGF2> let Just ty = readType "CN"
-Prelude PGF2> let Just e = checkExpr gr e ty
-Prelude PGF2> print e
+Prelude PGF2> let Right e' = checkExpr gr e ty
+Prelude PGF2> print e'
 AdjCN (PositA red_A) (UseN theatre_N)
 </pre>
 <pre class="java">
@@ -653,15 +656,15 @@ Expr e = gr.checkExpr(e,Type.readType("CN"))
 >>> System.out.println(e)
 AdjCN (PositA red_A) (UseN theatre_N)
 </pre>
-<p>In case of type error you will get an exception:
+<p>In case of type error you will get an error:
 <pre class="python">
 >>> e = gr.checkExpr(e,pgf.readType("A"))
 pgf.TypeError: The expected type of the expression AdjCN (PositA red_A) (UseN theatre_N) is A but CN is infered
 </pre>
 <pre class="haskell">
 Prelude PGF2> let Just ty = readType "A"
-Prelude PGF2> let Just e = checkExpr gr e ty
-pgf.TypeError: The expected type of the expression AdjCN (PositA red_A) (UseN theatre_N) is A but CN is infered
+Prelude PGF2> let Left msg = checkExpr gr e ty
+Prelude PGF2> putStrLn msg
 </pre>
 <pre class="java">
 Expr e = gr.checkExpr(e,Type.readType("A"))
-- 
cgit v1.2.3


From 09d5d9b0912907210a14acd4a051ec9248b11bc7 Mon Sep 17 00:00:00 2001
From: Krasimir Angelov <kr.angelov@gmail.com>
Date: Tue, 29 Aug 2017 14:17:28 +0200
Subject: some missing pieces of documentation for Java

---
 doc/runtime-api.html | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 79 insertions(+), 3 deletions(-)

(limited to 'doc/runtime-api.html')

diff --git a/doc/runtime-api.html b/doc/runtime-api.html
index d6a46149e..374060403 100644
--- a/doc/runtime-api.html
+++ b/doc/runtime-api.html
@@ -396,6 +396,13 @@ a tree into a function name and a list of arguments:
 Prelude PGF2> unApp e
 Just ("AdjCN", [..., ...])
 </pre>
+<pre class="java">
+ExprApplication app = e.unApp();
+System.out.println(app.getFunction());
+for (Expr arg : app.getArguments()) {
+   System.out.println(arg);
+}
+</pre>
 </p>
 <p>
 <span class="python">
@@ -420,6 +427,17 @@ For example the result from:
 Prelude PGF2> readExpr "\"literal\"" >>= unStr
 "literal"
 </pre>
+<span class="java">
+The result from <tt>unApp</tt> is not <tt>null</tt> if the expression
+is an application, and <tt>null</tt> in all other cases.
+Similarly, if the tree is a literal string then the return value 
+from <tt>unStr</tt> will not be <tt>null</tt> with the actual literal. 
+For example the output from:
+</span>
+<pre class="java">
+Expr e = Expr.readExpr("\"literal\"")
+System.out.println(e.unStr())
+</pre>
 is just the string "literal". 
 <span class="python">Situations like this can be detected
 in Python by checking the type of the result from <tt>unpack</tt>.
@@ -489,6 +507,14 @@ Prelude PGF2> print e2
 DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA red_A) (UseN theatre_N))
 </pre>
 </span>
+<span class="java">
+using the constructor for <tt>Expr</tt>:
+<pre class="java">
+Expr quant = Expr.readExpr("DetQuant IndefArt NumSg");
+Expr e2 = new Expr("DetCN", new Expr[] {quant, e});
+System.out.println(e2);
+</pre>
+</span>
 
 <span class="python">
 <h2>Embedded GF Grammars</h2>
@@ -653,8 +679,7 @@ AdjCN (PositA red_A) (UseN theatre_N)
 </pre>
 <pre class="java">
 Expr e = gr.checkExpr(e,Type.readType("CN"))
->>> System.out.println(e)
-AdjCN (PositA red_A) (UseN theatre_N)
+System.out.println(e)
 </pre>
 <p>In case of type error you will get an error:
 <pre class="python">
@@ -668,7 +693,7 @@ Prelude PGF2> putStrLn msg
 </pre>
 <pre class="java">
 Expr e = gr.checkExpr(e,Type.readType("A"))
-pgf.TypeError: The expected type of the expression AdjCN (PositA red_A) (UseN theatre_N) is A but CN is infered
+TypeError: The expected type of the expression AdjCN (PositA red_A) (UseN theatre_N) is A but CN is infered
 </pre></p>
 
 <span class="python">
@@ -800,6 +825,20 @@ n3 -- n4 [style = "solid"]
 n0 -- n3 [style = "solid"]
 }
 </pre>
+<pre class="java">
+System.out.println(gr.graphvizAbstractTree(e))
+graph {
+n0[label = "AdjCN", style = "solid", shape = "plaintext"]
+n1[label = "PositA", style = "solid", shape = "plaintext"]
+n2[label = "red_A", style = "solid", shape = "plaintext"]
+n1 -- n2 [style = "solid"]
+n0 -- n1 [style = "solid"]
+n3[label = "UseN", style = "solid", shape = "plaintext"]
+n4[label = "theatre_N", style = "solid", shape = "plaintext"]
+n3 -- n4 [style = "solid"]
+n0 -- n3 [style = "solid"]
+}
+</pre>
 
 <pre class="python">
 >>> print(eng.graphvizParseTree(e))
@@ -874,6 +913,43 @@ graph {
   n0 -- n100000
   n2 -- n100001
 }
+</pre>
+<pre class="java">
+System.out.println(eng.graphvizParseTree(e))
+graph {
+  node[shape=plaintext]
+
+  subgraph {rank=same;
+    n4[label="CN"]
+  }
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n1[label="AP"]
+    n3[label="CN"]
+    n1 -- n3
+  }
+  n4 -- n1
+  n4 -- n3
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n0[label="A"]
+    n2[label="N"]
+    n0 -- n2
+  }
+  n1 -- n0
+  n3 -- n2
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n100000[label="red"]
+    n100001[label="theatre"]
+    n100000 -- n100001
+  }
+  n0 -- n100000
+  n2 -- n100001
+}
 </pre>
 
 	</body>
-- 
cgit v1.2.3


From 634ec20b38085e791668a335a3db682624e309bf Mon Sep 17 00:00:00 2001
From: Krasimir Angelov <kr.angelov@gmail.com>
Date: Tue, 29 Aug 2017 14:42:52 +0200
Subject: corrected and tested documentation for Java

---
 doc/runtime-api.html | 57 ++++++++++++++++++++++++++--------------------------
 1 file changed, 29 insertions(+), 28 deletions(-)

(limited to 'doc/runtime-api.html')

diff --git a/doc/runtime-api.html b/doc/runtime-api.html
index 374060403..e63899ded 100644
--- a/doc/runtime-api.html
+++ b/doc/runtime-api.html
@@ -81,7 +81,7 @@ A grammar is loaded by calling <span class="python">the method pgf.readPGF</span
 Prelude PGF2> gr &lt;- readPGF "App12.pgf"
 </pre>
 <pre class="java">
-PGF gr = PGF.readPGF("App12.pgf")
+PGF gr = PGF.readPGF("App12.pgf");
 </pre>
 
 From the grammar you can query the set of available languages.
@@ -100,7 +100,7 @@ Prelude PGF2> :t eng
 eng :: Concr
 </pre>
 <pre class="java">
-Concr eng = gr.getLanguages().get("AppEng")
+Concr eng = gr.getLanguages().get("AppEng");
 </pre>
 
 <h2>Parsing</h2>
@@ -115,7 +115,7 @@ For example to invoke the parser, you can call:
 Prelude PGF2> let res = parse eng (startCat gr) "this is a small theatre"
 </pre>
 <pre class="java">
-Iterable&lt;ExprProb&gt; iterable = eng.parse(gr.startCat(), "this is a small theatre")
+Iterable&lt;ExprProb&gt; iterable = eng.parse(gr.getStartCat(), "this is a small theatre");
 </pre>
 <span class="python">
 This gives you an iterator which can enumerate all possible
@@ -141,8 +141,8 @@ Prelude PGF2> let Right ((e,p):rest) = res
 This gives you an iterable which can enumerate all possible
 abstract trees. You can get the next tree by calling <tt>next</tt>:
 <pre class="java">
-Iterator&lt;ExprProb&gt; iter = iterable.iterator()
-ExprProb ep = iter.next()
+Iterator&lt;ExprProb&gt; iter = iterable.iterator();
+ExprProb ep = iter.next();
 </pre>
 </span>
 
@@ -161,7 +161,7 @@ Prelude PGF2> print p
 35.9166526794
 </pre>
 <pre class="java">
-System.out.println(ep.getProb())
+System.out.println(ep.getProb());
 35.9166526794
 </pre>
 and this is the corresponding abstract tree:
@@ -174,7 +174,7 @@ Prelude PGF2> print e
 PhrUtt NoPConj (UttS (UseCl (TTAnt TPres ASimul) PPos (PredVP (DetNP (DetQuant this_Quant NumSg)) (UseComp (CompNP (DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA small_A) (UseN theatre_N)))))))) NoVoc
 </pre>
 <pre class="java">
-System.out.println(ep.getExpr())
+System.out.println(ep.getExpr());
 PhrUtt NoPConj (UttS (UseCl (TTAnt TPres ASimul) PPos (PredVP (DetNP (DetQuant this_Quant NumSg)) (UseComp (CompNP (DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA small_A) (UseN theatre_N)))))))) NoVoc
 </pre>
 
@@ -216,7 +216,7 @@ There is also the method <tt>parseWithHeuristics</tt> which
 takes two more paramaters which let you to have a better control 
 over the parser's behaviour:
 <pre class="java">
-Iterable&lt;ExprProb&gt; iterable = eng.parseWithHeuristics(gr.startCat(), heuristic_factor, callbacks)
+Iterable&lt;ExprProb&gt; iterable = eng.parseWithHeuristics(gr.startCat(), heuristic_factor, callbacks);
 </pre>
 </span>
 
@@ -250,7 +250,7 @@ a new expression like this:
 Prelude PGF2> let Just e = readExpr "AdjCN (PositA red_A) (UseN theatre_N)"
 </pre>
 <pre class="java">
-Expr e = Expr.readExpr("AdjCN (PositA red_A) (UseN theatre_N)")
+Expr e = Expr.readExpr("AdjCN (PositA red_A) (UseN theatre_N)");
 </pre>
 and then we can linearize it:
 <pre class="python">
@@ -262,7 +262,7 @@ Prelude PGF2> putStrLn (linearize eng e)
 red theatre
 </pre>
 <pre class="java">
-System.out.println(eng.linearize(e))
+System.out.println(eng.linearize(e));
 red theatre
 </pre>
 This method produces only a single linearization. If you use variants
@@ -281,7 +281,7 @@ red theater
 </pre>
 <pre class="java">
 for (String s : eng.linearizeAll(e)) {
-    System.out.println(s)
+    System.out.println(s);
 }
 red theatre
 red theater
@@ -297,7 +297,7 @@ Prelude PGF2> tabularLinearize eng e
 fromList [("s Pl Gen","red theatres'"),("s Pl Nom","red theatres"),("s Sg Gen","red theatre's"),("s Sg Nom","red theatre")]
 </pre>
 <pre class="java">
-for (Map.Entry&lt;String,String&gt; entry : eng.tabularLinearize(e)) {
+for (Map.Entry&lt;String,String&gt; entry : eng.tabularLinearize(e).entrySet()) {
     System.out.println(entry.getKey() + ": " + entry.getValue());
 }
 s Sg Nom: red theatre
@@ -320,7 +320,7 @@ Prelude PGF2> putStrLn (showBracketedString b)
 (CN:4 (AP:1 (A:0 red)) (CN:3 (N:2 theatre)))
 </pre>
 <pre class="java">
-Object[] bs = eng.bracketedLinearize(e)
+Object[] bs = eng.bracketedLinearize(e);
 </pre>
 <span class="python">
 Each element in the sequence above is either a string or an object
@@ -378,7 +378,7 @@ Prelude PGF2> print (hasLinearization eng "apple_N")
 True
 </pre>
 <pre class="java">
-System.out.println(eng.hasLinearization("apple_N"))
+System.out.println(eng.hasLinearization("apple_N"));
 true
 </pre>
 
@@ -435,8 +435,8 @@ from <tt>unStr</tt> will not be <tt>null</tt> with the actual literal.
 For example the output from:
 </span>
 <pre class="java">
-Expr e = Expr.readExpr("\"literal\"")
-System.out.println(e.unStr())
+Expr elit = Expr.readExpr("\"literal\"");
+System.out.println(elit.unStr());
 </pre>
 is just the string "literal". 
 <span class="python">Situations like this can be detected
@@ -446,6 +446,9 @@ for the other possible literal types in GF.</span>
 <span class="haskell">
 There are also the functions <tt>unAbs</tt>, <tt>unInt</tt>, <tt>unFloat</tt> and <tt>unMeta</tt> for all other possible cases.
 </span>
+<span class="java">
+There are also the methods <tt>unAbs</tt>, <tt>unInt</tt>, <tt>unFloat</tt> and <tt>unMeta</tt> for all other possible cases.
+</span>
 </p>
 
 <span class="python">
@@ -554,7 +557,7 @@ word form with its possible analyses:
 Prelude PGF2> mapM_ print [(form,lemma,analysis,prob) | (form,analyses) &lt;- fullFormLexicon eng, (lemma,analysis,prob) &lt- analyses]
 </pre>
 <pre class="java">
-for (FullFormEntry entry in eng.fullFormLexicon()) {
+for (FullFormEntry entry in eng.fullFormLexicon()) { ///// TODO
 	for (MorphoAnalysis analysis : entry.getAnalyses()) {
 		System.out.println(entry.getForm()+" "+analysis.getProb()+" "+analysis.getLemma()+" "+analysis.getField());
 	}
@@ -603,7 +606,7 @@ Prelude PGF2> categories gr
 ....
 </pre>
 <pre class="java">
-List&lt;String&gt; cats = gr.getCategories()
+List&lt;String&gt; cats = gr.getCategories();
 ....
 </pre>
 You can also access all functions with the same result category:
@@ -616,7 +619,7 @@ Prelude PGF2> functionsByCat gr "Weekday"
 ['friday_Weekday', 'monday_Weekday', 'saturday_Weekday', 'sunday_Weekday', 'thursday_Weekday', 'tuesday_Weekday', 'wednesday_Weekday']
 </pre>
 <pre class="java">
-List&lt;String&gt; cats = gr.getFunctionsByCat("Weekday")
+List&lt;String&gt; funsByCat = gr.getFunctionsByCat("Weekday");
 ....
 </pre>
 The full type of a function can be retrieved as:
@@ -629,7 +632,7 @@ Prelude PGF2> print (functionType gr "DetCN")
 Det -> CN -> NP
 </pre>
 <pre class="java">
-System.out.println(gr.getFunctionType("DetCN"))
+System.out.println(gr.getFunctionType("DetCN"));
 Det -> CN -> NP
 </pre>
 
@@ -653,11 +656,9 @@ Prelude PGF2> print ty
 CN
 </pre>
 <pre class="java">
-TypedExpr te = gr.inferExpr(e)
-System.out.println(te.getExpr())
-AdjCN (PositA red_A) (UseN theatre_N)
-System.out.println(te.getType())
-CN
+TypedExpr te = gr.inferExpr(e);
+System.out.println(te.getExpr()+" : "+te.getType());
+AdjCN (PositA red_A) (UseN theatre_N) : CN
 </pre>
 The result is a potentially updated expression and its type. In this
 case we always deal with simple types, which means that the new
@@ -678,7 +679,7 @@ Prelude PGF2> print e'
 AdjCN (PositA red_A) (UseN theatre_N)
 </pre>
 <pre class="java">
-Expr e = gr.checkExpr(e,Type.readType("CN"))
+Expr new_e = gr.checkExpr(e,Type.readType("CN")); //// TODO
 System.out.println(e)
 </pre>
 <p>In case of type error you will get an error:
@@ -826,7 +827,7 @@ n0 -- n3 [style = "solid"]
 }
 </pre>
 <pre class="java">
-System.out.println(gr.graphvizAbstractTree(e))
+System.out.println(gr.graphvizAbstractTree(e));   //// TODO
 graph {
 n0[label = "AdjCN", style = "solid", shape = "plaintext"]
 n1[label = "PositA", style = "solid", shape = "plaintext"]
@@ -915,7 +916,7 @@ graph {
 }
 </pre>
 <pre class="java">
-System.out.println(eng.graphvizParseTree(e))
+System.out.println(eng.graphvizParseTree(e));   //// TODO
 graph {
   node[shape=plaintext]
 
-- 
cgit v1.2.3


From adcc6a53fef7e56b93c8574c4822f9c7b4d1ea82 Mon Sep 17 00:00:00 2001
From: Krasimir Angelov <kr.angelov@gmail.com>
Date: Tue, 29 Aug 2017 15:28:37 +0200
Subject: a preliminary version of the C# documentation

---
 doc/runtime-api.html | 202 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 198 insertions(+), 4 deletions(-)

(limited to 'doc/runtime-api.html')

diff --git a/doc/runtime-api.html b/doc/runtime-api.html
index e63899ded..bdff41a06 100644
--- a/doc/runtime-api.html
+++ b/doc/runtime-api.html
@@ -47,7 +47,7 @@
 		
 <h2>Loading the Grammar</h2>
 
-Before you use the <span class="python">Python</span> binding you need to import the <span class="haskell">PGF2 module</span><span class="python">pgf module</span><span class="java">pgf package</span>.
+Before you use the <span class="python">Python</span> binding you need to import the <span class="haskell">PGF2 module</span><span class="python">pgf module</span><span class="java">pgf package</span><span class="csharp">PGFSharp package</span>:
 <pre class="python">
 >>> import pgf
 </pre>
@@ -57,6 +57,9 @@ Prelude> import PGF2
 <pre class="java">
 import org.grammaticalframework.pgf.*;
 </pre>
+<pre class="csharp">
+using PGFSharp;
+</pre>
 
 <span class="python">Once you have the module imported, you can use the <tt>dir</tt> and
 <tt>help</tt> functions to see what kind of functionality is available.
@@ -83,10 +86,13 @@ Prelude PGF2> gr &lt;- readPGF "App12.pgf"
 <pre class="java">
 PGF gr = PGF.readPGF("App12.pgf");
 </pre>
+<pre class="csharp">
+PGF gr = PGF.ReadPGF("App12.pgf");
+</pre>
 
 From the grammar you can query the set of available languages.
 It is accessible through the property <tt>languages</tt> which
-is a map from language name to an object of <span class="python">class <tt>pgf.Concr</tt></span><span class="haskell">type <tt>Concr</tt></span><span class="java">class <tt>Concr</tt></span>
+is a map from language name to an object of <span class="python">class <tt>pgf.Concr</tt></span><span class="haskell">type <tt>Concr</tt></span><span class="java">class <tt>Concr</tt></span><span class="csharp">class <tt>Concr</tt></span>
 which respresents the language.
 For example the following will extract the English language:
 <pre class="python">
@@ -102,11 +108,14 @@ eng :: Concr
 <pre class="java">
 Concr eng = gr.getLanguages().get("AppEng");
 </pre>
+<pre class="csharp">
+Concr eng = gr.Languages["AppEng"];
+</pre>
 
 <h2>Parsing</h2>
 
 All language specific services are available as 
-<span class="python">methods of the class <tt>pgf.Concr</tt></span><span class="haskell">functions that take as an argument an object of type <tt>Concr</tt></span><span class="java">methods of the class <tt>Concr</tt></span>.
+<span class="python">methods of the class <tt>pgf.Concr</tt></span><span class="haskell">functions that take as an argument an object of type <tt>Concr</tt></span><span class="java">methods of the class <tt>Concr</tt></span><span class="csharp">methods of the class <tt>Concr</tt></span>.
 For example to invoke the parser, you can call:
 <pre class="python">
 >>> i = eng.parse("this is a small theatre")
@@ -117,6 +126,9 @@ Prelude PGF2> let res = parse eng (startCat gr) "this is a small theatre"
 <pre class="java">
 Iterable&lt;ExprProb&gt; iterable = eng.parse(gr.getStartCat(), "this is a small theatre");
 </pre>
+<pre class="csharp">
+IEnumerable&lt;Tuple&lt;Expr, float&gt;&gt; enumerable = eng.Parse(gr.StartCat, "this is a small theatre");
+</pre>
 <span class="python">
 This gives you an iterator which can enumerate all possible
 abstract trees. You can get the next tree by calling <tt>next</tt>:
@@ -145,6 +157,14 @@ Iterator&lt;ExprProb&gt; iter = iterable.iterator();
 ExprProb ep = iter.next();
 </pre>
 </span>
+<span class="csharp">
+This gives you an enumerable which can enumerate all possible
+abstract trees. You can get the next tree by calling <tt>MoveNext</tt>:
+<pre class="csharp">
+enumerable.MoveNext();
+Tuple&lt;Expr, float&gt; ep = enumerable.Current;
+</pre>
+</span>
 
 <p>The results are pairs of probability and tree. The probabilities
 are negated logarithmic probabilities and this means that the lowest
@@ -164,6 +184,10 @@ Prelude PGF2> print p
 System.out.println(ep.getProb());
 35.9166526794
 </pre>
+<pre class="csharp">
+Console.WriteLine(ep.Item2);
+35.9166526794
+</pre>
 and this is the corresponding abstract tree:
 <pre class="python">
 >>> print(e)
@@ -177,6 +201,10 @@ PhrUtt NoPConj (UttS (UseCl (TTAnt TPres ASimul) PPos (PredVP (DetNP (DetQuant t
 System.out.println(ep.getExpr());
 PhrUtt NoPConj (UttS (UseCl (TTAnt TPres ASimul) PPos (PredVP (DetNP (DetQuant this_Quant NumSg)) (UseComp (CompNP (DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA small_A) (UseN theatre_N)))))))) NoVoc
 </pre>
+<pre class="csharp">
+Console.WriteLine(ep.Item1);
+PhrUtt NoPConj (UttS (UseCl (TTAnt TPres ASimul) PPos (PredVP (DetNP (DetQuant this_Quant NumSg)) (UseComp (CompNP (DetCN (DetQuant IndefArt NumSg) (AdjCN (PositA small_A) (UseN theatre_N)))))))) NoVoc
+</pre>
 
 <p>Note that depending on the grammar it is absolutely possible that for 
 a single sentence you might get infinitely many trees. 
@@ -219,6 +247,14 @@ over the parser's behaviour:
 Iterable&lt;ExprProb&gt; iterable = eng.parseWithHeuristics(gr.startCat(), heuristic_factor, callbacks);
 </pre>
 </span>
+<span class="csharp">
+There is also the method <tt>ParseWithHeuristics</tt> which 
+takes two more paramaters which let you to have a better control 
+over the parser's behaviour:
+<pre class="csharp">
+IEnumerable&lt;Tuple&lt;Expr, float&gt;&gt; enumerable = eng.ParseWithHeuristics(gr.StartCat, heuristic_factor, callbacks);
+</pre>
+</span>
 
 <p>The heuristics factor can be used to trade parsing speed for quality.
 By default the list of trees is sorted by probability and this corresponds
@@ -252,6 +288,9 @@ Prelude PGF2> let Just e = readExpr "AdjCN (PositA red_A) (UseN theatre_N)"
 <pre class="java">
 Expr e = Expr.readExpr("AdjCN (PositA red_A) (UseN theatre_N)");
 </pre>
+<pre class="csharp">
+Expr e = Expr.ReadExpr("AdjCN (PositA red_A) (UseN theatre_N)");
+</pre>
 and then we can linearize it:
 <pre class="python">
 >>> print(eng.linearize(e))
@@ -265,6 +304,10 @@ red theatre
 System.out.println(eng.linearize(e));
 red theatre
 </pre>
+<pre class="csharp">
+Console.WriteLine(eng.Linearize(e));
+red theatre
+</pre>
 This method produces only a single linearization. If you use variants
 in the grammar then you might want to see all possible linearizations.
 For that purpouse you should use <tt>linearizeAll</tt>:
@@ -286,6 +329,13 @@ for (String s : eng.linearizeAll(e)) {
 red theatre
 red theater
 </pre>
+<pre class="csharp">
+for (String s : eng.LinearizeAll(e)) {
+    Console.WriteLine(s);
+}
+red theatre
+red theater
+</pre>
 If, instead, you need an inflection table with all possible forms
 then the right method to use is <tt>tabularLinearize</tt>:
 <pre class="python">
@@ -305,6 +355,15 @@ s Pl Nom: red theatres
 s Pl Gen: red theatres'
 s Sg Gen: red theatre's
 </pre>
+<pre class="csharp">
+for (Map.Entry&lt;String,String&gt; entry : eng.TabularLinearize(e).EntrySet()) {
+    Console.WriteLine(entry.Key + ": " + entry.Value);
+}
+s Sg Nom: red theatre
+s Pl Nom: red theatres
+s Pl Gen: red theatres'
+s Sg Gen: red theatre's
+</pre>
 
 <p>
 Finally, you could also get a linearization which is bracketed into
@@ -322,6 +381,9 @@ Prelude PGF2> putStrLn (showBracketedString b)
 <pre class="java">
 Object[] bs = eng.bracketedLinearize(e);
 </pre>
+<pre class="csharp">
+Object[] bs = eng.BracketedLinearize(e);
+</pre>
 <span class="python">
 Each element in the sequence above is either a string or an object
 of type <tt>pgf.Bracket</tt>. When it is actually a bracket then
@@ -362,6 +424,18 @@ the object has the following public final variables:
 	<li><tt>Object[] children</tt> - a list with the children of this bracket</li>
 </ul>
 </span>
+<span class="csharp">
+Each element in the sequence above is either a string or an object
+of type <tt>Bracket</tt>. When it is actually a bracket then
+the object has the following public final variables:
+<ul>
+	<li><tt>String cat</tt> - the syntactic category for this bracket</li>
+	<li><tt>int fid</tt> - an id which identifies this bracket in the bracketed string. If there are discontinuous phrases this id will be shared for all brackets belonging to the same phrase.</li>
+	<li><tt>int lindex</tt> - the constituent index</li>
+	<li><tt>String fun</tt> - the abstract function for this bracket</li>
+	<li><tt>Object[] children</tt> - a list with the children of this bracket</li>
+</ul>
+</span>
 </p>
 
 The linearization works even if there are functions in the tree 
@@ -381,6 +455,10 @@ True
 System.out.println(eng.hasLinearization("apple_N"));
 true
 </pre>
+<pre class="csharp">
+Console.WriteLine(eng.HasLinearization("apple_N"));
+true
+</pre>
 
 <h2>Analysing and Constructing Expressions</h2>
 
@@ -403,6 +481,13 @@ for (Expr arg : app.getArguments()) {
    System.out.println(arg);
 }
 </pre>
+<pre class="csharp">
+ExprApplication app = e.UnApp();
+System.out.println(app.Function);
+for (Expr arg : app.Arguments) {
+   Console.WriteLine(arg);
+}
+</pre>
 </p>
 <p>
 <span class="python">
@@ -438,6 +523,17 @@ For example the output from:
 Expr elit = Expr.readExpr("\"literal\"");
 System.out.println(elit.unStr());
 </pre>
+<span class="csharp">
+The result from <tt>UnApp</tt> is not <tt>null</tt> if the expression
+is an application, and <tt>null</tt> in all other cases.
+Similarly, if the tree is a literal string then the return value 
+from <tt>UnStr</tt> will not be <tt>null</tt> with the actual literal. 
+For example the output from:
+</span>
+<pre class="csharp">
+Expr elit = Expr.ReadExpr("\"literal\"");
+Console.WriteLine(elit.UnStr());
+</pre>
 is just the string "literal". 
 <span class="python">Situations like this can be detected
 in Python by checking the type of the result from <tt>unpack</tt>.
@@ -449,6 +545,9 @@ There are also the functions <tt>unAbs</tt>, <tt>unInt</tt>, <tt>unFloat</tt> an
 <span class="java">
 There are also the methods <tt>unAbs</tt>, <tt>unInt</tt>, <tt>unFloat</tt> and <tt>unMeta</tt> for all other possible cases.
 </span>
+<span class="csharp">
+There are also the methods <tt>UnAbs</tt>, <tt>UnInt</tt>, <tt>UnFloat</tt> and <tt>UnMeta</tt> for all other possible cases.
+</span>
 </p>
 
 <span class="python">
@@ -518,6 +617,14 @@ Expr e2 = new Expr("DetCN", new Expr[] {quant, e});
 System.out.println(e2);
 </pre>
 </span>
+<span class="csharp">
+using the constructor for <tt>Expr</tt>:
+<pre class="csharp">
+Expr quant = Expr.ReadExpr("DetQuant IndefArt NumSg");
+Expr e2 = new Expr("DetCN", new Expr[] {quant, e});
+Console.WriteLine(e2);
+</pre>
+</span>
 
 <span class="python">
 <h2>Embedded GF Grammars</h2>
@@ -563,6 +670,13 @@ for (FullFormEntry entry in eng.fullFormLexicon()) { ///// TODO
 	}
 }
 </pre>
+<pre class="csharp">
+for (FullFormEntry entry in eng.FullFormLexicon) {
+	for (MorphoAnalysis analysis : entry.Analyses) {
+		Console.WriteLine(entry.Form+" "+analysis.Prob+" "+analysis.Lemma+" "+analysis.Field);
+	}
+}
+</pre>
 The second one implements a simple lookup. The argument is a word
 form and the result is a list of analyses:
 <pre class="python">
@@ -580,6 +694,13 @@ for (MorphoAnalysis an : eng.lookupMorpho("letter")) {
 letter_1_N, s Sg Nom, inf
 letter_2_N, s Sg Nom, inf
 </pre>
+<pre class="csharp">
+for (MorphoAnalysis an : eng.LookupMorpho("letter")) {
+    Console.WriteLine(an.Lemma+", "+an.Field+", "+an.Prob);
+}
+letter_1_N, s Sg Nom, inf
+letter_2_N, s Sg Nom, inf
+</pre>
 
 <h2>Access the Abstract Syntax</h2>
 
@@ -593,7 +714,12 @@ you can get a list of abstract functions:
 Prelude PGF2> functions gr
 ....
 </pre>
-gr.getFunctions()
+<pre class="java">
+List&lt;String&gt; funs = gr.getFunctions()
+....
+</pre>
+<pre class="csharp">
+IList&lt;String&gt; funs = gr.Functions;
 ....
 </pre>
 or a list of categories:
@@ -609,6 +735,10 @@ Prelude PGF2> categories gr
 List&lt;String&gt; cats = gr.getCategories();
 ....
 </pre>
+<pre class="csharp">
+IList&lt;String&gt; cats = gr.Categories;
+....
+</pre>
 You can also access all functions with the same result category:
 <pre class="python">
 >>> gr.functionsByCat("Weekday")
@@ -622,6 +752,10 @@ Prelude PGF2> functionsByCat gr "Weekday"
 List&lt;String&gt; funsByCat = gr.getFunctionsByCat("Weekday");
 ....
 </pre>
+<pre class="csharp">
+IList&lt;String&gt; funsByCat = gr.FunctionsByCat("Weekday");
+....
+</pre>
 The full type of a function can be retrieved as:
 <pre class="python">
 >>> print(gr.functionType("DetCN"))
@@ -660,6 +794,11 @@ TypedExpr te = gr.inferExpr(e);
 System.out.println(te.getExpr()+" : "+te.getType());
 AdjCN (PositA red_A) (UseN theatre_N) : CN
 </pre>
+<pre class="csharp">
+TypedExpr te = gr.InferExpr(e);
+Console.WriteLine(te.Expr+" : "+te.Type);
+AdjCN (PositA red_A) (UseN theatre_N) : CN
+</pre>
 The result is a potentially updated expression and its type. In this
 case we always deal with simple types, which means that the new
 expression will be always equal to the original expression. However, this
@@ -682,6 +821,10 @@ AdjCN (PositA red_A) (UseN theatre_N)
 Expr new_e = gr.checkExpr(e,Type.readType("CN")); //// TODO
 System.out.println(e)
 </pre>
+<pre class="csharp">
+Expr new_e = gr.CheckExpr(e,Type.ReadType("CN"));
+Console.WriteLine(e)
+</pre>
 <p>In case of type error you will get an error:
 <pre class="python">
 >>> e = gr.checkExpr(e,pgf.readType("A"))
@@ -840,6 +983,20 @@ n3 -- n4 [style = "solid"]
 n0 -- n3 [style = "solid"]
 }
 </pre>
+<pre class="csharp">
+Console.WriteLine(gr.GraphvizAbstractTree(e));
+graph {
+n0[label = "AdjCN", style = "solid", shape = "plaintext"]
+n1[label = "PositA", style = "solid", shape = "plaintext"]
+n2[label = "red_A", style = "solid", shape = "plaintext"]
+n1 -- n2 [style = "solid"]
+n0 -- n1 [style = "solid"]
+n3[label = "UseN", style = "solid", shape = "plaintext"]
+n4[label = "theatre_N", style = "solid", shape = "plaintext"]
+n3 -- n4 [style = "solid"]
+n0 -- n3 [style = "solid"]
+}
+</pre>
 
 <pre class="python">
 >>> print(eng.graphvizParseTree(e))
@@ -951,6 +1108,43 @@ graph {
   n0 -- n100000
   n2 -- n100001
 }
+</pre>
+<pre class="csharp">
+Console.WriteLine(eng.GraphvizParseTree(e));
+graph {
+  node[shape=plaintext]
+
+  subgraph {rank=same;
+    n4[label="CN"]
+  }
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n1[label="AP"]
+    n3[label="CN"]
+    n1 -- n3
+  }
+  n4 -- n1
+  n4 -- n3
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n0[label="A"]
+    n2[label="N"]
+    n0 -- n2
+  }
+  n1 -- n0
+  n3 -- n2
+
+  subgraph {rank=same;
+    edge[style=invis]
+    n100000[label="red"]
+    n100001[label="theatre"]
+    n100000 -- n100001
+  }
+  n0 -- n100000
+  n2 -- n100001
+}
 </pre>
 
 	</body>
-- 
cgit v1.2.3

