{"id":617,"date":"2017-09-13T05:33:05","date_gmt":"2017-09-13T05:33:05","guid":{"rendered":"http:\/\/www.rangakrish.com\/?p=617"},"modified":"2017-09-13T13:02:33","modified_gmt":"2017-09-13T13:02:33","slug":"reuse-of-grammars-through-inheritance","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2017\/09\/13\/reuse-of-grammars-through-inheritance\/","title":{"rendered":"Reuse of Grammars Through Inheritance"},"content":{"rendered":"

We are familiar with the advantages of class inheritance in object-oriented languages such as C++, C#, Java, and Python. The ability to reuse functionality via inheritance allows us to express our software design optimally, without having to write redundant code.<\/p>\n

iLangGen<\/strong><\/em> encourages the reuse of grammars by supporting Grammar Inheritance<\/strong><\/em>, where a grammar can explicitly derive from another (base) grammar. As of now, only single inheritance is supported (i.e. it is not possible derive from more than one base grammar). A derived grammar can make use of the rules (or productions) of the base grammar, and in some cases, can override<\/strong><\/em> base grammar productions. Let us look at the various possibilities.<\/p>\n

Consider the following grammar:<\/p>\n

\"Simple<\/a>
A Simple Grammar<\/strong><\/figcaption><\/figure>\n

When we run this grammar, we get the following output:<\/p>\n

\"Output<\/a>
Output Produced by the Grammar<\/strong><\/figcaption><\/figure>\n

We now derive<\/strong><\/em> another grammar from this grammar:<\/p>\n

\"Derived<\/a>
Derived Grammar<\/strong><\/figcaption><\/figure>\n

As the syntax suggests, DerivedGrammar<\/strong><\/em> derives from BaseGrammar<\/strong><\/em>. What is interesting in this grammar is that it does not have definitions for the Non-terminals A, B<\/strong><\/em> and C<\/strong><\/em>. When you run this grammar, it inherits<\/strong><\/em> the relevant rules from its base grammar. See the output.<\/p>\n

\"Derived<\/a>
Derived Grammar Output<\/strong><\/figcaption><\/figure>\n

Let us now look at a slight variant of the BaseGrammar<\/strong><\/em>.<\/p>\n

\"Grammar<\/a>
Grammar without “start” Rule<\/strong><\/figcaption><\/figure>\n

This grammar does not have a start<\/strong><\/em> production. Because of this, the grammar cannot be used directly. It can only be used in the context of a derived grammar. In this sense, it is like an abstract<\/strong> class<\/strong><\/em> in OO languages.<\/p>\n

The derived grammar defines the start<\/strong><\/em> symbol and uses the rules of the base grammar.<\/p>\n

\"Derived<\/a>
Derived Grammar with “start” Rule<\/strong><\/figcaption><\/figure>\n

Please note that in the earlier example, the base grammar was directly usable, but not in this example. In\u00a0 both the cases, the derived grammar makes use of the rules defined in the base grammar, exhibiting the power of inheritance. Of course, the derived grammar can define additional productions and use them if it chooses to. See this example:<\/p>\n

\"Derived<\/a>
Derived Grammar with Additional Rules<\/strong><\/figcaption><\/figure>\n

Here, D<\/strong><\/em> is an additional rule of the derived grammar. This is the output:<\/p>\n

\"Derived<\/a>
Derived Grammar Output<\/strong><\/figcaption><\/figure>\n

The last variant of inheritance I want to discuss involves overriding<\/strong><\/em> productions. Just as we can declare a funtion to be virtual<\/strong><\/em> in C++, in iLangGen<\/strong><\/em> we can declare grammar productions as virtual<\/strong><\/em>, thus allowing a derived grammar to provide its overriding<\/strong><\/em> productions.<\/p>\n

Take alook at the following grammar:<\/p>\n

\"Grammar<\/a>
Grammar with “virtual” Rule<\/strong><\/figcaption><\/figure>\n

You will notice that production B<\/strong><\/em> has been declared virtual<\/strong><\/em>. It is an empty production, but in general, it could have non-empty RHS. Since this grammar has a start<\/strong><\/em> production, it can be run directly. This is what you get when you run the grammar:<\/p>\n

\"Grammar<\/a>
Grammar Output<\/strong><\/figcaption><\/figure>\n

We get output as expected. Let us now derive a grammar from this grammar and override<\/strong><\/em> rule B<\/strong><\/em>.<\/p>\n

\"Grammar<\/a>
Grammar with Overriding Production<\/strong><\/figcaption><\/figure>\n

When you run this grammar, you get the following output:<\/p>\n

\"Output<\/a>
Output of Grammar<\/strong><\/figcaption><\/figure>\n

You can see that the overridden<\/strong><\/em> production participates in the generated output. You can also notice that the derived class does not have a start<\/strong><\/em> rule. This is an interesting generation pattern<\/strong><\/em> where the base class decides the overall structure of the generated text and the derived class supplies appropriate components of the structure.<\/p>\n

This brings us to the end of today’s discussion on grammar inheritance in iLangGen<\/strong><\/em>. As you can see, this is a very powerful feature and will come in handy when we develop large grammars.<\/p>\n

In the next post, we shall look at Grammar Composition<\/strong><\/em>, yet another technique for building grammars.<\/p>\n","protected":false},"excerpt":{"rendered":"

We are familiar with the advantages of class inheritance in object-oriented languages such as C++, C#, Java, and Python. The ability to reuse functionality via inheritance allows us to express our software design optimally, without having to write redundant code. iLangGen encourages the reuse of grammars by supporting Grammar Inheritance, where a grammar can explicitly […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"advanced_seo_description":"","jetpack_seo_html_title":"","jetpack_seo_noindex":false,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[18,107,17],"tags":[117,109,66,108],"class_list":["post-617","post","type-post","status-publish","format-standard","hentry","category-lisp","category-natural-language-processing","category-programming","tag-grammar","tag-ilanggen","tag-inheritance","tag-text-generation"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-9X","jetpack-related-posts":[{"id":637,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/09\/27\/composition-of-grammars\/","url_meta":{"origin":617,"position":0},"title":"Composition of Grammars","author":"admin","date":"September 27, 2017","format":false,"excerpt":"In the last post, we saw how iLangGen text generation framework supports reuse of grammars through inheritance, akin to object-oriented languages. The good news is that we can achieve reuse through composition as well. The following is a simple grammar, nothing fancy to elaborate. Here is the output when you\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Simple Grammar","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/09\/G1.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":1410,"url":"https:\/\/www.rangakrish.com\/index.php\/2019\/01\/27\/generating-poetry-using-ilanggen\/","url_meta":{"origin":617,"position":1},"title":"Generating Poetry Using iLangGen","author":"admin","date":"January 27, 2019","format":false,"excerpt":"In an earlier article, I wrote about using iLangGen to generate natural language text. iLangGen is a powerful text generation library that I have been working on over the years. Today, I would like to show how we can use that library to generate \"poetry\". Be warned, however, that the\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Sample Output 2","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/01\/Output2.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":575,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/08\/06\/text-generation-using-ilanggen-framework\/","url_meta":{"origin":617,"position":2},"title":"Text Generation Using iLangGen Framework","author":"admin","date":"August 6, 2017","format":false,"excerpt":"The two primary areas in Natural Language processing are Natural Language Understanding and Natural Language Generation. The former is concerned with processing and making sense of natural language text, whereas the latter is concerned with synthesizing text, possibly from some deep representation. Both are fascinating and at the same time,\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"iLangGen Grammar","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/08\/Blog1.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/08\/Blog1.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/08\/Blog1.png?resize=525%2C300 1.5x"},"classes":[]},{"id":884,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/04\/08\/natural-language-generation\/","url_meta":{"origin":617,"position":3},"title":"Natural Language Generation","author":"admin","date":"April 8, 2018","format":false,"excerpt":"I had written a series of posts on my iLangGen framework last year. It aims to provide a flexible and expressive approach for building natural language generation systems. In today's post, I would like to describe a concrete example of how iLangGen can be used for generating natural language text\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Overall Approach","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/04\/overall-1.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":653,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/10\/14\/using-function-calls-in-the-grammar\/","url_meta":{"origin":617,"position":4},"title":"Using Function Calls in the Grammar","author":"admin","date":"October 14, 2017","format":false,"excerpt":"One of the advanced features of iLangGen is the ability to embed arbitrary function calls on the RHS of grammar rules. Such functions impart interesting dynamic behaviour to the generated data. For convenience and flexibility, iLangGen supports two types of function calls - Direct and Indirect. In the case of\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Direct Function Call in Grammar","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/10\/Image1.png?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":585,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/08\/18\/repetition-in-grammar-rules\/","url_meta":{"origin":617,"position":5},"title":"Repetition in Grammar Rules","author":"admin","date":"August 18, 2017","format":false,"excerpt":"Many times, we need to repeatedly generate an element, or in general, have a way to control the number times one or more elements get generated. iLangGen supports all the standard cases: - Zero or once - Zero or more times (unbounded) - Zero or more times (bounded) - One\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Zero or Once","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/08\/Optional.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/08\/Optional.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/08\/Optional.png?resize=525%2C300 1.5x"},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/617","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/comments?post=617"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/617\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=617"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=617"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=617"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}