Cybersearch2

Information Connects

Expression Pattern Language (eXPL)

Scopes

A scope in eXPL is a context that encapsulates a namespace, a locale and a properties environment. There is a global scope created at the start of a program and it is this scope which has been employed exclusively up till nou. The global scope has the following characteristics:

Name - All scopes have a unique name which as a rule must used when refering to an artifact from outside the scope in which it resides. The global scope is an exception to that rule. It's name is "global", and when scope is omitted from an artifact's name, it is assumed to be this name. .
Locale -The locale for any scope, including the global scope, defaults to the system default. However, the locale can be configured to any of ones supported by the Java runtime and this will be applied when working with number and currency formats.
Properties - A scope can be assigned any number of key-value pairs, plus 2 properties are reserved to set the locale - "language" and "region". If you run the ShowLocale application of tutorial12, you will see what these properties are set to in the global scope of your system. In Australia, you will see: locale_query(language=en, region=AU).

To prove the global scope exists, change the ShowLocale query from:

query<term> locale_query(locale);

query<term> locale_query(global.locale);

and run the application. The query should run to completion as normal. Change "global" to something else, and you will get a "scope not found" error.

Scope Format

A scope declaration has a name, statements enclosed in braces {} and optional properties:

scope name [ ( properties ) ]
{
eXPL-statements
}

The properties are specified as a comma-delimited list of name-value pairs eg. (language="de", region="DE") specifies the Germany locale. A "variant" or "script" property can be added if required. The properties are accessed using a built-in axiom term list named "scope".

A scope may not have any enclosed statements, in which case, it just declares a context for artifacts in the global scope to use. Note that, apart from the global scope, a scope may not be nested inside another scope.

Applying Scope to Global Artifacts

A scope is assigned to a global artifact by referring to it using a 2-part name, the first part being the name of the desired scope. A scope can also be applied to a query at the time it is executed, which has the effect of applying that scope to all global artifacts.

The global scope is not normally declared, but this can be done to override the preset properties or add new ones.

Application CalculateSquareMiles3 of tutorial12 demonstrates declaring the global scope to change the "location" property to an actual name of a country. There is a second scope named "australia" which also sets the "location" property. The application displays the surface areas of both Australia and the USA and the units used, square kilometers or square miles depends on the location property. Note how the calculator named "country_area" is referred to as "australia.country_area" in the Australian query.

Axiom Collections in Scopes

There various ways to place an axiom collection within a scope and access it. An axiom collection can be declared in the global scope using a 2-part name. This is a requirement for context lists, but for other purposes it is appropriate to enclose a collection inside the scope to which it belongs. This approach is explored in using 3 queries, each run by one of the 3 SingleCurrency applications of tutorial13. The 3 queries are all contained in a single eXPL single-currency.xpl file which declares a German and French scope, each containing an axiom collection with a single axiom containing a single Euro amount. Each application runs one query in this file and prints the solution showing "Total" for a German-formatted amount and "le total" for a French one. The program may be a little confusing, because the example also shows it is okay to use the same name for artifacts in different scopes. The axiom collection in both cases is named "item".

SingleCurrency - part 1

The following query is declared in the global scope and uses 2-part names for both the axiom collection and the template. Below it is the solution.

query<term> item_query(german.item : german.charge_plus_gst);
Total + gst: 13.580,24 EUR

This approach is useful in that all queries can be declared together, rather than spit amongst the scopes.

SingleCurrency - part 2

The following query is declared in the German scope and pairs the local axiom collection to a template in the French scope.Below it is the solution.

query<term> french_item_query(item : french.charge_plus_gst);
le total + gst: 16 419,74 EUR

This shows that it is okay to cross scopes when pairing axiom collections to templates. In this case, a higher tax rate is applied as well as changing the word for "Total"

SingleCurrency - part 3

The following query is declared back in the global scope. It directly evaluates global template "french_charge_plus_gst".Below it is the solution.

query<term> french_item_query(french_charge_plus_gst);
le total + gst: AUD665.00R

We see "le total" and a very different amount because it is derived from the French item containing only 500 Euros. The French item is refered to using a 2-part name: french.item->amount. This is similar to using a context list, but because there is just one specific scope, no declaration is required.

Resources in Scopes

External axiom collections are accessed via resources, and these are capable of being slotted into scopes. Application ForeignColors of tutorial13 sequences 2 eXPL programs to firstly create French and German axiom collections which are marshalled to files on disk and then run queries to access these collections as resources.

Reading Resources

The second program declares the "colors" axiom collections as resources using 2-part names:

resource german.colors axiom(aqua, black, blue, white);
resource french.colors axiom(aqua, black, blue, white);

These collections are accessed using context lists ie. refering them as colors@scope.

Context Term Lists

A context term list is a member of a collection of lists with the same name but residing in different scopes. A reference to a context list is interpreted as an access to the list belonging to the current scope. To reference a context list, use an identifier in the artifact format with the address part the reserved word "scope", eg. for a list named "lexicon", use identifier "lexicon@scope". The only list type supported is the axiom list. If the list contains only one item, then it's content can be accessed using an axiom term list. As you will see in the examples, this is the most likely usage of context lists - the selection of terms which are specific to a particular context.

For a context list declaration to be valid, there must exist in at least one scope, an axiom collection to which it refers. It is good practice to declare an axiom collection in the global scope, as this will be used as the default at the start of the program. Without such a default, then the context list is initialized only upon the first change to a scope with a referenced axiom collection.

Word Translation Example

Application ForeignScope of tutorial12 has a German scope configured with a query to print out a Euro amount + 10% tax along with the word "Total" in German. The translation of the word "Total" is done using a context list named "lexican@scope". This list contains a single axiom with a term to translate "Total" to "Gesamtkosten":

axiom german.lexicon

( Total)
{"Gesamtkosten"};

Note how this list is declared in the global scope with a 2-part name. The global scope is the custodian of all context lists.

This is the calculator which formats the text to output:

calc format_total
+ list<term> lexicon@scope;
(

string total_text =
lexicon->Total +
" + gst: " +
total.amount.format

);

The context list is attached to the calculator as an axiom term list, allowing direct access to the Total term.

The solution to the query is:

total_text = Gesamtkosten + gst: 13.580,24 EUR

To show that the context list is working as expected, a second French scope has been included. This time, the scope is empty and 2-part names are used in the "french_item_query" declared in the global scope. Run application ForeignScope2 and you should see the context list should now select "le total" for "Total". Also note the subtle difference between the German and French Euro thousands separator ("." vs. " ").

Axiom Choice

To allow selection based on context-sensitive values, axiom choice can have a context list attached. Application ForeignColors of tutorial12 provides a demonstration using an axiom choice to select a color by both it's German and French names:

choice swatch
+ list<term> lexicon@scope;

( name, red, green, blue)
{lexicon->aqua, 0, 255, 255}
{lexicon->black, 0, 0, 0}
{lexicon->blue, 0 , 0, 255}
{lexicon->white, 255, 255, 255};

Next: Axiom Collections in Scopes ...

Skip to Function/Query Calls ...

Writing Resources

Here is the program to export two axiom collections each in a particular scope:

resource german.colors export;
resource french.colors export;

scope french (language="fr", region="FR"){}
scope german (language="de", region="DE"){}

axiom french.colors (aqua, black, blue, white)

{"bleu vert", "noir", "bleu", "blanc"};

axiom german.colors (aqua, black, blue, white)

{"Wasser", "schwarz", "blau", "weiß"};

query color_query (german.colors:german.colors)

-> (french.colors:french.colors);

Note in the resource declarations, the use of 2-part names and "export" keyword. There is in fact no explicit template declared as the resource export will automatically supply one, if needed.

Stacked Scope Queries

Using 2-part names in a query declaration allows a single query to be repeated, using a different scope each time. Here is an example where the query (item:charge_plus_gst)->(format_total) is stacked 4 times into a single declaration:

query item_query
(item:german.charge_plus_gst)->(german.format_total)->
(item:french.charge_plus_gst)->(french.format_total)->
(item:belgium_fr.charge_plus_gst)->(belgium_fr.format_total)->
(item:belgium_nl.charge_plus_gst)->(belgium_nl.format_total);

Applications ForeignScope and ForeignScope2 of tutorial13 demonstrate this. The first follows on from the same-named application of tutuorial12, but has 4 different scopes and stacks the same query 4 times into a single declaration. The query solution contains the results for all 4 scopes and these are identified using the 2-part names. The second application builds on the first by taking a catalog number to select an item to process.

When queries are stacked then some strategy is required to collect together the solution generated by each scope. Alternatives are:

Use a global template to combine the output of each scope into a single solution
Append each result to a global exported list
Provide a solution handler to create a single solution

The third approach is used for the first two applications, but ForeignScope3 uses a global template and this has the advantage of shortening the query:

query<term> item_query

(catalog_no : german.charge_plus_gst) ->
(catalog_no : french.charge_plus_gst) ->
(catalog_no : belgium_fr.charge_plus_gst) ->
(catalog_no : belgium_nl.charge_plus_gst) ->
(catalog_no : format_total);

For each scope, the global template makes a query call to format the text and uses a 3-part name to reference the total amount. Here is the code to generate the German total:

<- format_text("de_DE") -> (text),
string german_total =

text + " " + german.charge_plus_gst.total.format,

The format_text calculator uses the country code supplied as a parameter to select the translations of "Total" and "tax" from a global list written to by charge_plus_gst.

Next: Function/Query Calls ...