Apertium-recursive/Formalism - Revision history

Popcorndude: give the proper syntax for matching unknowns

2023-09-06T13:27:52Z

give the proper syntax for matching unknowns

Unhammer: /* Matching unknowns */

2023-09-06T08:44:21Z

Matching unknowns

Unhammer: unknowns

2023-09-06T08:43:26Z

unknowns

Trondtr: /* Attribute Categories */

2023-06-01T08:13:49Z

Attribute Categories

Trondtr at 06:12, 1 June 2023

2023-06-01T06:12:18Z

Unhammer: _1 → _ ( no longer needs pos attribute)

2022-06-20T13:33:33Z

_1 → _ (<b/> no longer needs pos attribute)

← Older revision Revision as of 13:33, 20 June 2022
Line 537: Line 537:

For passing nodes up and down a tree, an alternative to multi-output rules and interpolation is global chunk variables. Global chunk variables are referred to with double dollar signs and are set in the attribute literal section of a rule.

For passing nodes up and down a tree, an alternative to multi-output rules and interpolation is global chunk variables. Global chunk variables are referred to with double dollar signs and are set in the attribute literal section of a rule.

VP -> %vblex DP.$itg [$$wh_word=(if (2.itg = itg) 2)] { 1 (if (2.itg not = itg) [ _1 2 ]) } ;

VP -> %vblex DP.$itg [$$wh_word=(if (2.itg = itg) 2)] { 1 (if (2.itg not = itg) [ _ 2 ]) } ;

The value of this variable can then be included in the output step of any rule.

The value of this variable can then be included in the output step of any rule.

S -> DP.nom VP { (if (2.itg = itg) [ $$wh_word _ ] ) 1 _1 2 } ;

S -> DP.nom VP { (if (2.itg = itg) [ $$wh_word _ ] ) 1 _ 2 } ;

If a rule attempts to output an unset variable, the result will be no output. All variables are reset at the end of the output step.

If a rule attempts to output an unset variable, the result will be no output. All variables are reset at the end of the output step.

Popcorndude: document SIDE_SOURCES

2022-06-01T18:55:39Z

document SIDE_SOURCES

← Older revision Revision as of 18:55, 1 June 2022
Line 53: Line 53:

| <code>pos_tag</code>

| <code>pos_tag</code>

| The first tag or an LU or chunk

| The first tag or an LU or chunk

|-

| <code>SIDE_SOURCES</code>

| Conflicts with [[#File_Directives|file directives]]

|-

|-

| <code>whole</code>, <code>chname</code>, <code>chcontent</code>, and <code>content</code>

| <code>whole</code>, <code>chname</code>, <code>chcontent</code>, and <code>content</code>

Line 554: Line 557:

=== Clips ===

=== Clips ===

When clipping a tag or lemma from a lexical unit in the input stream, <code>/sl</code> refers to source language, <code>/tl</code> refers to target language, and <code>/ref</code> refers to the output of apertium-anaphora. Chunks, meanwhile, have only 1 side, which is <code>/tl</code>. If the side is left unspecified, then <code>/tl</code> will be clipped. However, if an LU is being clipped from and the value for <code>/tl</code> is empty or is the unspecified value for that attribute category, it will try again with <code>/ref</code> and then with <code>/sl</code>.

When clipping a tag or lemma from a lexical unit in the input stream, <code>/sl</code> refers to source language, <code>/tl</code> refers to target language, and <code>/ref</code> refers to the output of apertium-anaphora. Chunks, meanwhile, have only 1 side, which is <code>/tl</code>. If the side is left unspecified, then <code>/tl</code> will be clipped. However, if an LU is being clipped from and the value for <code>/tl</code> is empty or is the unspecified value for that attribute category, it will try again with <code>/ref</code> and then with <code>/sl</code>. The order in which sides are checked in the case of unspecified values can be modified by a <code>SIDE_SOURCES</code> directive (see [[#File_Directives|below]]).

Almost anywhere that a clip or a literal value is used as a value, it can be replaced with an if statement using the same syntax as output conditionals and macros.

Almost anywhere that a clip or a literal value is used as a value, it can be replaced with an if statement using the same syntax as output conditionals and macros.

Line 562: Line 565:

The one exception is embedding an if statement inside a conditional: <code>(x in (if ...))</code>.

The one exception is embedding an if statement inside a conditional: <code>(x in (if ...))</code>.

=== File Directives ===

File directives control the behavior of compilation. They are set using the same syntax as attribute categories. For example:

SIDE_SOURCES = tl ref ;

{| class="wikitable"

|-

! Directive

! Values

! Default

! Description

|-

| <code>SIDE_SOURCES</code>

| 1 or more of <code>sl</code>, <code>tl</code>, and <code>ref</code>

| <code>tl ref sl</code>

| specifies the order in which unlabeled clips check the sides of an LU

|}

=== Brackets ===

=== Brackets ===

Popcorndude: /* Matched Elements */ add example of magic output %

2022-05-31T15:08:41Z

Matched Elements: add example of magic output %

← Older revision Revision as of 15:08, 31 May 2022
Line 292: Line 292:

These elements can also be prefixed with <code>%</code> to specify that as many tags as possible should be placeholders for tags of the parent chunk.

These elements can also be prefixed with <code>%</code> to specify that as many tags as possible should be placeholders for tags of the parent chunk.

%1[gender=f]

! the first input element with gender tag <f> and all other tags copied from the parent node

These elements can be conjoined using +:

These elements can be conjoined using +:

Unhammer: /* Literal Lexical Units */

2021-10-06T13:28:02Z

Literal Lexical Units

← Older revision Revision as of 13:28, 6 October 2021
Line 311: Line 311:

V -> vblex.inf {1(vbinf)};

V -> vblex.inf {1(vbinf)};

! result: ^whatever<vblex><inf>$

! result: ^whatever<vblex><inf>$

==== Titlecase/capitalisation ====

You can set the lemma case with the lemcase attribute, e.g.

N -> %n { 1[lemcase=$lemcase] } ; ! % will not copy lemcase, have to manually set it

A -> %adj { 1[lemcase=$lemcase] } ;

NP -> A %N { 2[lemcase=1.lemcase] _ 1[lemcase=2.lemcase] } ; ! switch around adj/n lemma case since we switched the words

You can also set it to a literal value, e.g. lemcase=aa for lowercase or lemcase=Aa for titlecase

==== Literal Lexical Units ====

==== Literal Lexical Units ====

Unhammer: /* Blanks */

2021-10-04T22:06:55Z

Blanks

← Older revision Revision as of 22:06, 4 October 2021
Line 270: Line 270:

==== Blanks ====

==== Blanks ====

An underscore represents a single space.

⚫
~~An underscore represents a single space.~~ An underscore followed by a number represents the superblank after that position, so <code>1 _ 2</code> is elements 1 and 2 separated by a space while <code>1 _1 2</code> is elements 1 and 2 separated by whatever separated them in the input.

<small>(It used to be that you needed to specify the position of the blank – this is no longer necessary, but the syntax will still be accepted for backwards-compatibility:

⚫
An underscore followed by a number represents the superblank after that position, so <code>1 _ 2</code> is elements 1 and 2 separated by a space while <code>1 _1 2</code> is elements 1 and 2 separated by whatever separated them in the input.)</small>

==== Matched Elements ====

==== Matched Elements ====

@@ Line 269: / Line 269: @@
 === Matching unknowns ===
-Unknowns get the special tag <code><nowiki><UNKNOWN:INTERNAL></nowiki></code>. The colon must be escaped in the rtx file, e.g.
+Unknowns get the special tag <code><nowiki><UNKNOWN:INTERNAL></nowiki></code>. They can be referred to in patterns using <code>*</code>.
-       S -> %UNKNOWN\:INTERNAL   { %1 }
+       S -> *   { 1 }
 will give a tree like

@@ Line 275: / Line 275: @@
 will give a tree like
+<pre>
-    ^someword<S>{
+^someword<S>{
-            ^someword<UNKNOWN:INTERNAL>{
+        ^someword<UNKNOWN:INTERNAL>{
-                    ^*someword/*someword$
+                ^*someword/*someword$
-            }$
+        }$
-    }$
+}$
+</pre>
 === Outputs ===

@@ Line 266: / Line 266: @@
 | 0 or more arbitrary tags. Note: this contrasts with other places in the pipeline where <code>*</code> must match at least 1 tag. A final <code>.*</code> is automatically appended to every pattern
 |}
+=== Matching unknowns ===
+Unknowns get the special tag <code><nowiki><UNKNOWN:INTERNAL></nowiki></code>. The colon must be escaped in the rtx file, e.g.
+       S -> %UNKNOWN\:INTERNAL   { %1 }
+will give a tree like
+    ^someword<S>{
+            ^someword<UNKNOWN:INTERNAL>{
+                    ^*someword/*someword$
+            }$
+    }$
 === Outputs ===

@@ Line 18: / Line 18: @@
 This defines the <code>gender</code> category as before, but with the addition that if any rule tries to read the gender of a node that doesn't have a gender tag, the result will be <code><GD></code> rather than the empty string. It also states that any remaining <code><GD></code> tags will be replaced with <code><m></code> tags in the output step.
-An attribute category can also specify certain values as non-overwritable.
+An attribute category can also specify certain values as non-overwritable, marked with ''@''.
  gender = m f @mf;

← Older revision		Revision as of 06:12, 1 June 2023
Line 907:		Line 907:

	Technically this would compile to a rule which outputs an <code>NP</code> chunk containing the input unchanged and also a separate postchunk rule that would do the actual rearranging so that the conditionals can depend on changed values of the chunk tags.		Technically this would compile to a rule which outputs an <code>NP</code> chunk containing the input unchanged and also a separate postchunk rule that would do the actual rearranging so that the conditionals can depend on changed values of the chunk tags.

			[[Category:Recursive transfer]]

@@ Line 537: / Line 537: @@
 For passing nodes up and down a tree, an alternative to multi-output rules and interpolation is global chunk variables. Global chunk variables are referred to with double dollar signs and are set in the attribute literal section of a rule.
- VP -> %vblex DP.$itg [$$wh_word=(if (2.itg = itg) 2)] { 1 (if (2.itg not = itg) [ _1 2 ]) } ;
+ VP -> %vblex DP.$itg [$$wh_word=(if (2.itg = itg) 2)] { 1 (if (2.itg not = itg) [ _ 2 ]) } ;
 The value of this variable can then be included in the output step of any rule.
- S -> DP.nom VP { (if (2.itg = itg) [ $$wh_word _ ] ) 1 _1 2 } ;
+ S -> DP.nom VP { (if (2.itg = itg) [ $$wh_word _ ] ) 1 _ 2 } ;
 If a rule attempts to output an unset variable, the result will be no output. All variables are reset at the end of the output step.

@@ Line 53: / Line 53: @@
 | <code>pos_tag</code>
 | The first tag or an LU or chunk
+|-
+| <code>SIDE_SOURCES</code>
+| Conflicts with [[#File_Directives|file directives]]
 |-
 | <code>whole</code>, <code>chname</code>, <code>chcontent</code>, and <code>content</code>
@@ Line 554: / Line 557: @@
 === Clips ===
-When clipping a tag or lemma from a lexical unit in the input stream, <code>/sl</code> refers to source language, <code>/tl</code> refers to target language, and <code>/ref</code> refers to the output of apertium-anaphora. Chunks, meanwhile, have only 1 side, which is <code>/tl</code>. If the side is left unspecified, then <code>/tl</code> will be clipped. However, if an LU is being clipped from and the value for <code>/tl</code> is empty or is the unspecified value for that attribute category, it will try again with <code>/ref</code> and then with <code>/sl</code>.
+When clipping a tag or lemma from a lexical unit in the input stream, <code>/sl</code> refers to source language, <code>/tl</code> refers to target language, and <code>/ref</code> refers to the output of apertium-anaphora. Chunks, meanwhile, have only 1 side, which is <code>/tl</code>. If the side is left unspecified, then <code>/tl</code> will be clipped. However, if an LU is being clipped from and the value for <code>/tl</code> is empty or is the unspecified value for that attribute category, it will try again with <code>/ref</code> and then with <code>/sl</code>. The order in which sides are checked in the case of unspecified values can be modified by a <code>SIDE_SOURCES</code> directive (see [[#File_Directives|below]]).
 Almost anywhere that a clip or a literal value is used as a value, it can be replaced with an if statement using the same syntax as output conditionals and macros.
@@ Line 562: / Line 565: @@
 The one exception is embedding an if statement inside a conditional: <code>(x in (if ...))</code>.
+=== File Directives ===
+File directives control the behavior of compilation. They are set using the same syntax as attribute categories. For example:
+ SIDE_SOURCES = tl ref ;
+{| class="wikitable"
+|-
+! Directive
+! Values
+! Default
+! Description
+|-
+| <code>SIDE_SOURCES</code>
+| 1 or more of <code>sl</code>, <code>tl</code>, and <code>ref</code>
+| <code>tl ref sl</code>
+| specifies the order in which unlabeled clips check the sides of an LU
+|}
 === Brackets ===

@@ Line 292: / Line 292: @@
 These elements can also be prefixed with <code>%</code> to specify that as many tags as possible should be placeholders for tags of the parent chunk.
+ %1[gender=f]
+ ! the first input element with gender tag <f> and all other tags copied from the parent node
 These elements can be conjoined using +:

@@ Line 311: / Line 311: @@
  V -> vblex.inf {1(vbinf)};
    ! result: ^whatever<vblex><inf>$
+==== Titlecase/capitalisation ====
+You can set the lemma case with the lemcase attribute, e.g.
+ N -> %n { 1[lemcase=$lemcase] } ;    ! % will not copy lemcase, have to manually set it
+ A -> %adj { 1[lemcase=$lemcase] } ;
+ NP -> A %N { 2[lemcase=1.lemcase] _ 1[lemcase=2.lemcase] } ; ! switch around adj/n lemma case since we switched the words
+You can also set it to a literal value, e.g. lemcase=aa for lowercase or lemcase=Aa for titlecase
 ==== Literal Lexical Units ====

@@ Line 270: / Line 270: @@
 ==== Blanks ====
+An underscore represents a single space.
-An underscore represents a single space. An underscore followed by a number represents the superblank after that position, so <code>1 _ 2</code> is elements 1 and 2 separated by a space while <code>1 _1 2</code> is elements 1 and 2 separated by whatever separated them in the input.
+<small>(It used to be that you needed to specify the position of the blank – this is no longer necessary, but the syntax will still be accepted for backwards-compatibility:
+An underscore followed by a number represents the superblank after that position, so <code>1 _ 2</code> is elements 1 and 2 separated by a space while <code>1 _1 2</code> is elements 1 and 2 separated by whatever separated them in the input.)</small>
 ==== Matched Elements ====