Merge pull request #4039 from RichardTaylorHPCC/B8549

HPCC-8549 Document all the DICTIONARY syntax changes.

Reviewed-by: Gavin Halliday <ghalliday@hpccsystems.com>

docs/ECLLanguageReference/ECLR_mods/Basics-ActionsandAttrib.xml

@@ -2,45 +2,47 @@
 <!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
 "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
 <sect1 id="Actions_and_Attributes">
-  <title>Actions and Attributes</title>
+  <title>Actions and Definitions</title>
 
-  <para>There are several built-in Actions in ECL (such as OUTPUT), but there
-  are many more actions that you can execute as queries to the
-  supercomputer.</para>
+  <para>While Definitions define expressions that may be evaluated, Actions
+  trigger execution of a workunit that produces results that may be viewed. An
+  Action may evaluate Definitions to produce its result. There are a number of
+  built-in Actions in ECL (such as OUTPUT), and any expression (without a
+  Definition name) is implicitly treated as an Action to produce the result of
+  the expression.</para>
 
   <sect2 id="Functions_as_ActionsFunctions_as_Actions">
-    <title>Functions as Actions<indexterm>
-        <primary>Functions as Actions</primary>
+    <title>Expressions as Actions<indexterm>
+        <primary>Expressions as Actions</primary>
       </indexterm></title>
 
-    <para>Fundamentally, all the built-in functions that return single values
-    (such as COUNT) can be executed as Actions. For example,</para>
+    <para>Fundamentally, any expression in can be treated as an Action. For
+    example,</para>
 
-    <programlisting>Attr1 := COUNT(Trades);
+    <programlisting>Attr1 := COUNT(Trades);     
 Attr2 := MAX(Trades,trd_bal);
 Attr3 := IF (1 = 0, 'A', 'B');</programlisting>
 
-    <para>are all attribute definitions, but</para>
+    <para>are all definitions, but without a definition name, they are simply
+    expressions</para>
 
-    <programlisting>COUNT(Trades); //execute these Function calls as Actions
+    <programlisting>COUNT(Trades);       //execute these expressions as Actions
 MAX(Trades,trd_bal);
 IF (1 = 0, 'A', 'B');</programlisting>
 
-    <para>are also all valid actions, and as such, can directly generate
+    <para>that are treated as actions, and as such, can directly generate
     result values by simply submitting them as queries to the supercomputer.
-    Basically, any ECL expression that results in a scalar value can be used
-    as an Action to instigate a workunit.</para>
+    Basically, any ECL expression can be used as an Action to instigate a
+    workunit.</para>
   </sect2>
 
   <sect2 id="Attributes_as_ActionsAttributes_as_Actions">
-    <title>Attributes as Actions<indexterm>
-        <primary>Attributes as Actions</primary>
+    <title>Definitions as Actions<indexterm>
+        <primary>Definitions as Actions</primary>
       </indexterm></title>
 
-    <para>Any Attribute that defines a single value of some sort (that is, it
-    does not define a record set) can be executed as an Action. These same
-    actions can be executed by submitting the names of the Attributes as
-    queries, like this:</para>
+    <para>These same expression definitions can be executed by submitting the
+    names of the Definitions as queries, like this:</para>
 
     <programlisting>Attr1; //These all generate the same result values
 Attr2; // as the previous examples
@@ -48,13 +50,13 @@ Attr3;</programlisting>
   </sect2>
 
   <sect2 id="Actions_as_Attributes">
-    <title>Actions as Attributes<indexterm>
-        <primary>Actions as Attributes</primary>
+    <title>Actions as Definitions<indexterm>
+        <primary>Actions as Definitions</primary>
       </indexterm></title>
 
-    <para>Conversely, by simply giving any Action an Attribute name you turn
-    it into an Attribute definition, therefore no longer a directly executable
-    action. For example,</para>
+    <para>Conversely, by simply giving any Action a Definition name it becomes
+    a definition, therefore no longer a directly executable action. For
+    example,</para>
 
     <programlisting>OUTPUT(Person);</programlisting>
 
@@ -62,19 +64,19 @@ Attr3;</programlisting>
 
     <programlisting>Attr4 := OUTPUT(Person);</programlisting>
 
-    <para>is an attribute definition and does not immediately execute when
-    submitted as part of a query. To execute the action inherent in the
-    attribute, you must execute the Attribute name you've given to the Action,
-    like this:</para>
+    <para>is a definition and does not immediately execute when submitted as
+    part of a query. To execute the action inherent in the definition, you
+    must execute the Definition name you've given to the Action, like
+    this:</para>
 
-    <programlisting>Attr4; // run the OUTPUT(Person) action</programlisting>
+    <programlisting>Attr4;    // run the previously defined OUTPUT(Person) action </programlisting>
   </sect2>
 
   <sect2 id="Debugging_Uses">
     <title>Debugging Uses</title>
 
-    <para>This technique of directly executing an attribute as an Action is
-    useful when debugging complex ECL code. You can send the attribute as a
+    <para>This technique of directly executing a Definition as an Action is
+    useful when debugging complex ECL code. You can send the Definition as a
     query to determine if intermediate values are correctly calculated before
     continuing on with more complex code.</para>
   </sect2>

docs/ECLLanguageReference/ECLR_mods/Basics-AttributeDef.xml

@@ -2,20 +2,18 @@
 <!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
 "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
 <sect1 id="Attribute_Definition">
-  <title>Attribute Definition</title>
+  <title>Definitions</title>
 
   <para>Each ECL definition<indexterm>
       <primary>ECL definition</primary>
-    </indexterm> creates an Attribute<indexterm>
-      <primary>Attribute</primary>
-    </indexterm>—the basic building block of ECL. An Attribute definition
-  asserts that something is true; it defines <emphasis>what </emphasis>is done
-  but not <emphasis>how</emphasis> it is to be done. Attributes can be thought
-  of as a highly developed form of macro-substitution, making each succeeding
-  Attribute definition more and more highly leveraged upon the work that has
-  gone before. This results in extremely efficient query construction.</para>
+    </indexterm> is the basic building block of ECL. A definition specifies
+  <emphasis>what </emphasis>is done but not <emphasis>how</emphasis> it is to
+  be done. Definitions can be thought of as a highly developed form of
+  macro-substitution, making each succeeding definition more and more highly
+  leveraged upon the work that has gone before. This results in extremely
+  efficient query construction.</para>
 
-  <para>All Attribute definitions take the form:</para>
+  <para>All definitions take the form:</para>
 
   <para><emphasis role="bold">[</emphasis><emphasis>Scope</emphasis><emphasis
   role="bold">] [</emphasis><emphasis>ValueType</emphasis><emphasis
@@ -27,10 +25,10 @@
     </indexterm> [ </emphasis><emphasis>:WorkflowService</emphasis><emphasis
   role="bold">] ;</emphasis></para>
 
-  <para>The Attribute Definition Operator<indexterm>
-      <primary>Attribute Definition Operator</primary>
-    </indexterm> (<emphasis role="bold">:=</emphasis> read as “is defined as”)
-  defines an Attribute. On the left side of the operator is an optional
+  <para>The Definition Operator<indexterm>
+      <primary>Definition Operator</primary>
+    </indexterm> (<emphasis role="bold"> :=</emphasis> read as “is defined
+  as”) defines an expression. On the left side of the operator is an optional
   <emphasis>Scope<indexterm>
       <primary>Scope</primary>
     </indexterm></emphasis> (see <emphasis role="bold">Attribute
@@ -41,27 +39,27 @@
       <primary>parameters</primary>
     </indexterm> (<emphasis>parms</emphasis>) it may take (see <emphasis
   role="bold">Functions (Parameter Passing)</emphasis>). On the right side is
-  the Expression that produces the result and optionally a colon (:) and a
+  the expression that produces the result and optionally a colon (:) and a
   comma-delimited list of <emphasis>WorkflowServices</emphasis> (see <emphasis
-  role="bold">Workflow Services</emphasis>). An Attribute definition must be
-  explicitly terminated with a semi-colon (;). The Attribute name can be used
-  in subsequent Attribute definitions:</para>
+  role="bold">Workflow Services</emphasis>). A definition must be explicitly
+  terminated with a semi-colon (;). The Definition name can be used in
+  subsequent definitions:</para>
 
-  <programlisting>MyFirstAttribute := 5; //defined as 5
-MySecondAttribute := MyFirstAttribute + 5; //this is 10</programlisting>
+  <programlisting>MyFirstDefinition := 5; //defined as 5
+MySecondDefinition := MyFirstDefinition + 5; //this is 10</programlisting>
 
   <sect2 id="Attribute_Name_Rules">
-    <title>Attribute Name Rules</title>
+    <title>Definition Name Rules</title>
 
-    <para>Attribute name<indexterm>
-        <primary>Attribute Name</primary>
+    <para>Definition name<indexterm>
+        <primary>Definition Name</primary>
       </indexterm>s begin with a letter and may contain only letters, numbers,
     or underscores (_).</para>
 
-    <programlisting>My_First_Attribute1 := 5; // valid name
-My First Attribute := 5;  // INVALID name, spaces not allowed</programlisting>
+    <programlisting>My_First_Definition1 := 5; // valid name
+My First Definition := 5;  // INVALID name, spaces not allowed</programlisting>
 
-    <para>You may name an attribute with the name of a previously created
+    <para>You may name a Definition with the name of a previously created
     module in the ECL Repository, if the attribute is defined with an explicit
     <emphasis>ValueType</emphasis>.</para>
   </sect2>
@@ -87,14 +85,14 @@ My First Attribute := 5;  // INVALID name, spaces not allowed</programlisting>
   </sect2>
 
   <sect2 id="Attribute_Naming">
-    <title>Attribute Naming</title>
+    <title>Definition Naming</title>
 
-    <para>Use descriptive names for all EXPORTed and SHARED Attributes. This
+    <para>Use descriptive names for all EXPORTed and SHARED Definitions. This
     will make your code more readable. The naming convention adopted
     throughout the ECL documentation and training courses is as
     follows:</para>
 
-    <programlisting><emphasis role="bold">Attribute Type</emphasis>     <emphasis
+    <programlisting><emphasis role="bold">Definition Type</emphasis>     <emphasis
         role="bold">Are Named
 </emphasis>Boolean              Is...
 Set Definition       Set...
@@ -102,8 +100,8 @@ Record Set           ...DatasetName</programlisting>
 
     <para>For example:</para>
 
-    <programlisting>IsTrue := TRUE;                         // a BOOLEAN Attribute
-SetNumbers := [1,2,3,4,5];              // a Set Attribute
-R_People := People(firstname[1] = 'R'); // a Record Set Attribute</programlisting>
+    <programlisting>IsTrue := TRUE;                         // a BOOLEAN Definition
+SetNumbers := [1,2,3,4,5];              // a Set Definition
+R_People := People(firstname[1] = 'R'); // a Record Set Definition</programlisting>
   </sect2>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/Basics-AttributeTypes.xml

@@ -2,12 +2,12 @@
 <!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
 "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
 <sect1 id="Basic_Attribute_Types">
-  <title>Basic Attribute Types<indexterm>
-      <primary>Attribute Types</primary>
+  <title>Basic Definition Types<indexterm>
+      <primary>Definition Types</primary>
     </indexterm></title>
 
-  <para>The basic types of Attributes used most commonly throughout ECL coding
-  are: <emphasis role="bold">Boolean</emphasis><indexterm>
+  <para>The basic types of Definitions used most commonly throughout ECL
+  coding are: <emphasis role="bold">Boolean</emphasis><indexterm>
       <primary>Boolean</primary>
     </indexterm>, <emphasis role="bold">Value<indexterm>
       <primary>Value</primary>
@@ -20,13 +20,13 @@
     </indexterm></emphasis>.</para>
 
   <sect2 id="Boolean_Attributes">
-    <title>Boolean Attribute<indexterm>
-        <primary>Boolean Attribute</primary>
+    <title>Boolean Definition<indexterm>
+        <primary>Boolean Definition</primary>
       </indexterm>s</title>
 
-    <para>A Boolean Attribute is defined as any Attribute whose definition is
-    a logical expression resulting in a TRUE/FALSE result. For example, the
-    following are all Boolean Attributes:</para>
+    <para>A Boolean Definition is defined as any Definition whose definition
+    is a logical expression resulting in a TRUE/FALSE result. For example, the
+    following are all Boolean Definitions:</para>
 
     <programlisting>IsBoolTrue  := TRUE;
 IsFloridian := Person.per_st = 'FL';
@@ -34,13 +34,13 @@ IsOldPerson := Person.Age &gt;= 65;</programlisting>
   </sect2>
 
   <sect2 id="Value_Attributes">
-    <title>Value Attribute<indexterm>
-        <primary>Value Attribute</primary>
+    <title>Value Definition<indexterm>
+        <primary>Value Definition</primary>
       </indexterm>s</title>
 
-    <para>A Value Attribute is defined as any Attribute whose expression is an
-    arithmetic or string expression with a single-valued result. For example,
-    the following are all Value Attributes:</para>
+    <para>A Value Definition is defined as any Definition whose expression is
+    an arithmetic or string expression with a single-valued result. For
+    example, the following are all Value Definitions:</para>
 
     <programlisting>ValueTrue      := 1;
 FloridianCount := COUNT(Person(Person.per_st = 'FL'));
@@ -48,11 +48,11 @@ OldAgeSum     := SUM(Person(Person.Age &gt;= 65),Person.Age);</programlisting>
   </sect2>
 
   <sect2 id="Set_Attributes">
-    <title>Set Attributes</title>
+    <title>Set Definitions</title>
 
-    <para>A Set Attribute<indexterm>
-        <primary>Set Attribute</primary>
-      </indexterm> is defined as any Attribute whose expression is a set of
+    <para>A Set Definition<indexterm>
+        <primary>Set Definition</primary>
+      </indexterm> is defined as any Definition whose expression is a set of
     values, defined within square brackets<indexterm>
         <primary>square brackets</primary>
       </indexterm>. Constant set<indexterm>
@@ -61,7 +61,7 @@ OldAgeSum     := SUM(Person(Person.Age &gt;= 65),Person.Age);</programlisting>
     values<indexterm>
         <primary>constant values</primary>
       </indexterm> that must be declared within square brackets, whether that
-    set is defined as a separate attribute or simply included in-line in
+    set is defined as a separate definition or simply included in-line in
     another expression. All the constants must be of the same type.</para>
 
     <programlisting>SetInts  := [1,2,3,4,5]; // an INTEGER set with 5 elements
@@ -74,11 +74,11 @@ SetStatusCodes := ['A','B','C','D','E'];
     arbitrary expressions. All the expressions must result in the same type
     and must be constant expressions.</para>
 
-    <programlisting>SetExp := [1,2+3,45,SomeIntegerAttribute,7*3];
+    <programlisting>SetExp := [1,2+3,45,SomeIntegerDefinition,7*3];
                         // an INTEGER set with 5 elements</programlisting>
 
-    <para>Declared Sets can contain attributes and expressions<indexterm>
-        <primary>Sets can contain attributes and expressions</primary>
+    <para>Declared Sets can contain definitions and expressions<indexterm>
+        <primary>Sets can contain definitions and expressions</primary>
       </indexterm> as well as constants as long as all the elements are of the
     same result type. For example:</para>
 
@@ -87,8 +87,8 @@ SetStatusCodes := ['A','B','C','D','E'];
 SetFloridaCities := ['Orlando', StateCapitol('FL'), 'Boca '+'Raton',
           person[1].per_full_city];</programlisting>
 
-    <para>Set Attribute<indexterm>
-        <primary>Set Attribute</primary>
+    <para>Set Definition<indexterm>
+        <primary>Set Definition</primary>
       </indexterm>s can also be defined using the SET function<indexterm>
         <primary>SET function</primary>
       </indexterm> (which see). Sets defined this way may be used like any
@@ -148,7 +148,7 @@ MySubString3 := MyString[2.. ]; // MySubString3 is 'BCDE'</programlisting>
   </sect2>
 
   <sect2 id="Record_Set_Attributes">
-    <title>Record Set Attributes</title>
+    <title>Record Set Definitions</title>
 
     <para>The term “Dataset”<indexterm>
         <primary>Dataset</primary>
@@ -162,11 +162,11 @@ MySubString3 := MyString[2.. ]; // MySubString3 is 'BCDE'</programlisting>
     return result from one of the built-in functions that return result
     sets.</para>
 
-    <para>A Record Set Attribute<indexterm>
-        <primary>Record Set Attribute</primary>
-      </indexterm> is defined as any Attribute whose expression is a filtered
+    <para>A Record Set Definition<indexterm>
+        <primary>Record Set Definition</primary>
+      </indexterm> is defined as any Definition whose expression is a filtered
     dataset or record set, or any function that returns a record set. For
-    example, the following are all Record Set Attributes:</para>
+    example, the following are all Record Set Definitions:</para>
 
     <programlisting>FloridaPersons    := Person(Person.per_st = 'FL');
 OldFloridaPersons := FloridaPersons(Person.Age &gt;= 65);</programlisting>
@@ -216,13 +216,13 @@ MyRec4 := Person[2..];   // all recs except the first</programlisting>
   </sect2>
 
   <sect2 id="TypeDef_Attributes">
-    <title>TypeDef Attributes</title>
+    <title>TypeDef Definitions</title>
 
-    <para>A TypeDef Attribute<indexterm>
-        <primary>TypeDef Attribute</primary>
-      </indexterm> is defined as any Attribute whose definition is a value
+    <para>A TypeDef Definition<indexterm>
+        <primary>TypeDef Definition</primary>
+      </indexterm> is defined as any Definition whose definition is a value
     type, whether built-in or user-defined. For example, the following are all
-    TypeDef Attributes (except GetXLen):</para>
+    TypeDef Definitions (except GetXLen):</para>
 
     <programlisting>GetXLen(DATA x,UNSIGNED len) := TRANSFER(((DATA4)(x[1..len])),UNSIGNED4);
 
@@ -242,6 +242,6 @@ namesRecord := RECORD
   pppStr addr;
   
 END;
-//A RECORD structure is also a typedef attribute (user-defined)</programlisting>
+//A RECORD structure is also a typedef definition (user-defined)</programlisting>
   </sect2>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/Basics-AttributeVisibility.xml

@@ -2,27 +2,27 @@
 <!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
 "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
 <sect1 id="Attribute_Visibility">
-  <title>Attribute Visibility<indexterm>
-      <primary>Attribute Visibility</primary>
+  <title>Definition Visibility<indexterm>
+      <primary>Definition Visibility</primary>
     </indexterm></title>
 
-  <para>ECL Attributes are organized into modules. Within a module, you may
-  define as many Attributes as needed. An IMPORT statement (see the <emphasis
-  role="bold">IMPORT </emphasis>keyword) identifies any other modules whose
-  visible Attributes will be available for use in the current attribute
-  definition.</para>
+  <para>ECL definitions are organized into modules (directories or folders on
+  disk). Within a module, you may define as many Definitions as needed. An
+  IMPORT statement (see the <emphasis role="bold">IMPORT </emphasis>keyword)
+  identifies any other modules whose visible Definitions will be available for
+  use in the current definition.</para>
 
-  <programlisting>IMPORT AnotherModule; //imports attributes from AnotherModule
-Attribute1 := 5;     //as many definitions as needed</programlisting>
+  <programlisting>IMPORT AnotherModule; //imports definitions from AnotherModule
+Definition1 := 5;     //as many definitions as needed</programlisting>
 
-  <para>The following fundamental attribute visibility scopes are available in
-  ECL: <emphasis role="bold">"Global," Module</emphasis>, and <emphasis
+  <para>The following fundamental definition visibility scopes are available
+  in ECL: <emphasis role="bold">"Global," Module</emphasis>, and <emphasis
   role="bold">Local</emphasis>.</para>
 
   <sect2 id="Global_attribute_visibility">
     <title>"Global"</title>
 
-    <para>Attributes defined as <emphasis
+    <para>Definitions defined as <emphasis
     role="bold">EXPORT</emphasis><indexterm>
         <primary>EXPORT</primary>
       </indexterm> (see the <emphasis role="bold">EXPORT</emphasis> keyword)
@@ -30,49 +30,49 @@ Attribute1 := 5;     //as many definitions as needed</programlisting>
     throughout any other module that IMPORTs the module (see the <emphasis
     role="bold">IMPORT</emphasis> keyword).</para>
 
-    <programlisting>EXPORT Attribute1 := 5;
-//make Attribute1 available to other modules and
+    <programlisting>EXPORT Definition1 := 5;
+//make Definition1 available to other modules and
 //also available throughout its own module</programlisting>
   </sect2>
 
   <sect2 id="Module">
     <title>Module</title>
 
-    <para>The scope of the Attributes defined as <emphasis
+    <para>The scope of the Definitions defined as <emphasis
     role="bold">SHARED<indexterm>
         <primary>SHARED</primary>
       </indexterm></emphasis> (see the <emphasis role="bold">SHARED</emphasis>
     keyword) is limited to that one module, and are available throughout the
-    module (unlike local Attributes). This allows you to keep private any
+    module (unlike local Definitions). This allows you to keep private any
     definitions that are only needed to implement internal
     functionality.</para>
 
-    <programlisting>SHARED Attribute1 := 5;
-//Attribute1 available throughout its own module, only
-EXPORT Attribute2 := Attribute1 + 5;
-//make Attribute2 available to other modules and
+    <programlisting>SHARED Definition1 := 5;
+//Definition1 available throughout its own module, only
+EXPORT Definition2 := Definition1 + 5;
+//make Definition2 available to other modules and
 //also available throughout its own module</programlisting>
   </sect2>
 
   <sect2 id="Local">
     <title>Local</title>
 
-    <para>An Attribute defined without either EXPORT or SHARED (see the
+    <para>A Definition defined without either EXPORT or SHARED (see the
     <emphasis role="bold">EXPORT </emphasis>and <emphasis
     role="bold">SHARED</emphasis> keywords) is available only to the
-    subsequent Attributes until the next Attribute definition with EXPORT or
-    SHARED. This makes them private Attributes used only within the scope of
-    that EXPORT or SHARED Attribute. This allows you to keep private any
+    subsequent Definitions until the next Definition definition with EXPORT or
+    SHARED. This makes them private Definitions used only within the scope of
+    that EXPORT or SHARED Definition. This allows you to keep private any
     definitions that are only needed to implement internal functionality.
-    Local Attributes are referenced by the Attribute name alone; no
+    Local Definitions are referenced by the Definition name alone; no
     qualification is needed.</para>
 
     <programlisting>MODULE abc;
 LocalAttr := 5;
-//local -- available through the end of Attribute1's definition, only
-SHARED Attribute1 := LocalAttr;
+//local -- available through the end of Definition1's definition, only
+SHARED Definition1 := LocalAttr;
 //SHARED terminates scope for LocalAttr
-Attribute2 := Attribute1 + LocalAttr;
+Definition2 := Definition1 + LocalAttr;
 //INVALID SYNTAX -- LocalAttr is out of scope here</programlisting>
   </sect2>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/Basics-FieldandAttribute.xml

@@ -2,28 +2,28 @@
 <!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
 "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
 <sect1 id="Field_and_Attribute_Qualification">
-  <title>Field and Attribute Qualification</title>
+  <title>Field and Definition Qualification</title>
 
   <sect2 id="Imported_Attributes">
-    <title>Imported Attributes</title>
+    <title>Imported Definitions</title>
 
-    <para><emphasis role="bold">EXPORTed<indexterm>
+    <para>EXPORTed<indexterm>
         <primary>EXPORTed</primary>
-      </indexterm> Attributes<indexterm>
-        <primary>EXPORTed Attributes</primary>
+      </indexterm> definitions<indexterm>
+        <primary>EXPORTed Definitions</primary>
       </indexterm> defined within another module and IMPORTed<indexterm>
         <primary>IMPORTed</primary>
-      </indexterm> (see the </emphasis><emphasis role="bold">EXPORT
-    </emphasis>and <emphasis role="bold">IMPORT</emphasis> keywords) are
-    available for use in the attribute definition that contains the IMPORT.
-    Imported Attributes must be fully qualified by their Module name and
-    Attribute name, using dot syntax<indexterm>
+      </indexterm> (see the <link linkend="EXPORT">EXPORT</link> and <link linkend="IMPORT">IMPORT</link>
+     keywords) are available for use in
+    the definition that contains the IMPORT. Imported Definitions must be
+    fully qualified by their Module name and Definition name, using dot
+    syntax<indexterm>
         <primary>dot syntax</primary>
-      </indexterm> (module.attribute).</para>
+      </indexterm> (module.definition).</para>
 
-    <programlisting>IMPORT abc;                //make all exported attributes in the abc module available
-EXPORT Attribute1 := 5;    //make Attribute1 available to other modules
-Attribute2 := abc.Attribute2 + Attribute1;  // object qualification needed for Attributes from abc module</programlisting>
+    <programlisting>IMPORT abc;                //make all exported definitions in the abc module available
+EXPORT Definition1 := 5;    //make Definition1 available to other modules
+Definition2 := abc.Definition2 + Definition1;  // object qualification needed for Definitions from abc module</programlisting>
   </sect2>
 
   <sect2 id="Fields_in_Datasets">
@@ -41,12 +41,12 @@ Attribute2 := abc.Attribute2 + Attribute1;  // object qualification needed for A
     <programlisting>Young := YearOf(Person.per_dbrth) &lt; 1950;
 MySet := Person(Young);</programlisting>
 
-    <para>When naming a Dataset as part of an Attribute definition, the fields
-    of that Attribute (or record set) come into scope. If Parameterized
-    Attributes (functions) are nested, only the innermost scope is available.
-    That is, all the fields of a Dataset (or derived record set) are in scope
-    in the filter expression. This is also true for expressions parameters of
-    any built-in function that names a Dataset or derived record set as a
+    <para>When naming a Dataset as part of a definition, the fields of that
+    Definition (or record set) come into scope. If Parameterized Definitions
+    (functions) are nested, only the innermost scope is available. That is,
+    all the fields of a Dataset (or derived record set) are in scope in the
+    filter expression. This is also true for expressions parameters of any
+    built-in function that names a Dataset or derived record set as a
     parameter.</para>
 
     <programlisting>MySet1 := Person(YearOf(dbrth) &lt; 1950);
@@ -88,17 +88,17 @@ trades.trd_drpt</programlisting>
 
     <para>1. The currently active dataset, if any</para>
 
-    <para>2. The current attribute being defined, and any parameters it is
+    <para>2. The current definition being defined, and any parameters it is
     based on</para>
 
-    <para>3. Any attributes or parameters of any MODULE or FUNCTION structure
-    that contains the current attribute</para>
+    <para>3. Any definitions or parameters of any MODULE or FUNCTION structure
+    that contains the current definition</para>
 
-    <para>This might mean that the attribute or parameter you want to access
-    isn't picked because it is hidden as in a parameter or private attribute
+    <para>This might mean that the definition or parameter you want to access
+    isn't picked because it is hidden as in a parameter or private definition
     name clashing with the name of a dataset field.</para>
 
-    <para>It would be better to rename the parameter or private attribute so
+    <para>It would be better to rename the parameter or private definition so
     the name clash cannot occur, but sometimes this is not possible.</para>
 
     <para>You may direct access to a different match by qualifying the field
@@ -107,7 +107,7 @@ trades.trd_drpt</programlisting>
     skip.</para>
 
     <para>This example shows the qualification order necessary to reach a
-    specific attribute/parameter:</para>
+    specific definition/parameter:</para>
 
     <para><programlisting>ds := DATASET([1], { INTEGER SomeValue });
 
@@ -119,7 +119,7 @@ myModule(INTEGER SomeValue) := MODULE
     tbl := TABLE(ds,{SUM(GROUP, someValue), // 1 - DATASET field
                      SUM(GROUP, ^.someValue), // 84 - FUNCTION parameter
                      SUM(GROUP, ^^.someValue), // 42 - MODULE parameter
-                     SUM(GROUP, ^^^.someValue), // 10 - local attribute
+                     SUM(GROUP, ^^^.someValue), // 10 - local definition
                  0});
      RETURN<indexterm>
           <primary>RETURN</primary>
@@ -136,7 +136,7 @@ OUTPUT(myModule(42).result);</programlisting></para>
 
     <para>a field in a DATASET.</para>
 
-    <para>a local attribute</para>
+    <para>a local definition</para>
 
     <para>a parameter to a MODULE structure</para>
 
@@ -147,6 +147,6 @@ OUTPUT(myModule(42).result);</programlisting></para>
       </indexterm> shows how to reference each separate instance.</para>
 
     <para>While this syntax allows exceptions where you need it, creating
-    another attribute with a different name is the preferred solution.</para>
+    another definition with a different name is the preferred solution.</para>
   </sect2>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/Basics-FunctionAttributes.xml

@@ -90,16 +90,16 @@
     that the passed value will always be treated as a constant (typically used
     only in ECL prototypes of external functions).</para>
 
-    <programlisting>ValueAttribute := 15;
+    <programlisting>ValueDefinition := 15;
 FirstFunction(INTEGER x=5) := x + 5;
           //takes an integer parameter named "x" and "x" is used in the
           //arithmetic expression to indicate the usage of the parameter
           
-SecondAttribute := FirstFunction(ValueAttribute);
-          // The value of SecondAttribute is 20
+SecondDefinition := FirstFunction(ValueDefinition);
+          // The value of SecondDefinition is 20
           
-ThirdAttribute := FirstFunction();
-          // The value of ThirdAttribute is 10, omitting the parameter</programlisting>
+ThirdDefinition := FirstFunction();
+          // The value of ThirdDefinition is 10, omitting the parameter</programlisting>
   </sect2>
 
   <sect2 id="SET_Parameters">
@@ -134,23 +134,75 @@ OUTPUT(IsInSetFunction(,5)); // true</programlisting>
     role="bold">;</emphasis></para>
 
     <para>The required<emphasis> recstruct</emphasis> names the RECORD
-    structure attribute that defines the layout of fields in the passed
-    DATASET parameter. The <emphasis>recstruct</emphasis> may alternatively
-    use the RECORDOF function. The required<emphasis> AliasName</emphasis>
-    names the dataset for use in the function and is used in the Definition's
+    structure that defines the layout of fields in the passed DATASET
+    parameter. The <emphasis>recstruct</emphasis> may alternatively use the
+    RECORDOF function. The required<emphasis> AliasName</emphasis> names the
+    dataset for use in the function and is used in the Definition's
     <emphasis>expression</emphasis> to indicate where in the operation the
     passed parameter is to be used. See the <emphasis role="bold">DATASET as a
     Value Type</emphasis> discussion in the DATASET documentation for further
     examples.</para>
 
-    <programlisting>    MyRec := {STRING1 Letter};
+    <programlisting>MyRec := {STRING1 Letter};
     
-    SomeFile := DATASET([{'A'},{'B'},{'C'},{'D'},{'E'}],MyRec);
+SomeFile := DATASET([{'A'},{'B'},{'C'},{'D'},{'E'}],MyRec);
 
-    FilteredDS(DATASET(MyRec) ds) := ds(Letter NOT IN ['A','C','E']);
-            //passed dataset referenced as “ds” in expression
+FilteredDS(DATASET(MyRec) ds) := ds(Letter NOT IN ['A','C','E']);
+           //passed dataset referenced as “ds” in expression
 
-    OUTPUT(FilteredDS(SomeFile));</programlisting>
+OUTPUT(FilteredDS(SomeFile));</programlisting>
+  </sect2>
+
+  <sect2 id="Passing_DICTIONARY_Parameters">
+    <title>Passing DICTIONARY Parameters</title>
+
+    <para>Passing a DICTIONARY as a parameter may be accomplished using the
+    following syntax:</para>
+
+    <para><emphasis>DefinitionName</emphasis><emphasis role="bold">(
+    DICTIONARY<indexterm>
+        <primary>DICTIONARY parameter</primary>
+      </indexterm>(</emphasis><emphasis> structure </emphasis><emphasis
+    role="bold">) </emphasis><emphasis>AliasName</emphasis><emphasis
+    role="bold"> ) := </emphasis><emphasis>expression</emphasis><emphasis
+    role="bold">;</emphasis></para>
+
+    <para>The required <emphasis>structure</emphasis> parameter is the RECORD
+    structure that defines the layout of fields in the passed DICTIONARY
+    parameter (usually defined inline). The required<emphasis>
+    AliasName</emphasis> names the DICTIONARY for use in the function and is
+    used in the Definition's <emphasis>expression</emphasis> to indicate where
+    in the operation the passed parameter is to be used. See the <emphasis
+    role="bold">DICTIONARY as a Value Type</emphasis> discussion in the
+    DICTIONARY documentation.</para>
+
+    <programlisting>rec := RECORD
+  STRING10  color;
+  UNSIGNED1 code; 
+  STRING10  name;
+END;
+Ds := DATASET([{'Black' ,0 , 'Fred'},
+               {'Brown' ,1 , 'Seth'},
+               {'Red'   ,2 , 'Sue'},
+               {'White' ,3 , 'Jo'}], rec);
+
+DsDCT := DICTIONARY(DS,{color =&gt; DS});
+
+DCTrec := RECORD 
+  STRING10 color =&gt; 
+  UNSIGNED1 code,
+  STRING10 name,
+END;
+InlineDCT := DICTIONARY([{'Black' =&gt; 0 , 'Fred'},
+                         {'Brown' =&gt; 1 , 'Sam'},
+                         {'Red'   =&gt; 2 , 'Sue'},
+                         {'White' =&gt; 3 , 'Jo'} ], 
+                        DCTrec);
+
+MyDCTfunc(DICTIONARY(DCTrec) DCT,STRING10 key) := DCT[key].name;
+
+MyDCTfunc(InlineDCT,'White');  //Jo
+MyDCTfunc(DsDCT,'Brown');      //Seth</programlisting>
   </sect2>
 
   <sect2 id="Passing_Typeless_Parameters">
@@ -269,7 +321,7 @@ OUTPUT(doApplyValue(2, multiValues));             // 24
 
 
           
-//An attribute taking function parameters which themselves
+//A definition taking function parameters which themselves
 //have parameters that are functions...
 
 STRING doMany(INTEGER v1,
@@ -324,7 +376,7 @@ OUTPUT(doMany(2, applyValue4, applyValue2,multiValues));
           <row>
             <entry><emphasis>AliasName</emphasis></entry>
 
-            <entry>The names of the parameter in the attribute's function
+            <entry>The names of the parameter in the definition's function
             definition.</entry>
           </row>
 

docs/ECLLanguageReference/ECLR_mods/Basics-Overview.xml

@@ -14,10 +14,9 @@
     </indexterm>. ECL’s extreme scalability comes from a design that allows
   you to leverage every query you create for re-use in subsequent queries as
   needed. To do this, ECL takes a Dictionary approach to building queries
-  wherein each ECL definition defines an Attribute expression. Each previously
-  defined Attribute can then be used in succeeding ECL
-  definitions—<emphasis>the language extends itself as you use
-  it</emphasis>.</para>
+  wherein each ECL definition defines an expression. Each previous Definition
+  can then be used in succeeding ECL definitions—<emphasis>the language
+  extends itself as you use it</emphasis>.</para>
 
   <sect2 id="Attributes_versus_Actions">
     <title>Definitions versus Actions</title>
@@ -25,29 +24,29 @@
     <para>Functionally, there are two types of ECL code: Definitions (AKA
     Attribute definitions) and executable Actions. Actions are not valid for
     use in expressions because they do not return values. Most ECL code is
-    composed of Attribute definitions.</para>
+    composed of definitions.</para>
 
-    <para>Attribute definitions only define <emphasis>what</emphasis> is to be
-    done, they do not actually execute. This means that the ECL programmer
-    should think in terms of writing code that specifies
-    <emphasis>what</emphasis> to do rather than <emphasis>how</emphasis> to do
-    it. This is an important concept in that, the programmer is telling the
-    supercomputer <emphasis>what</emphasis> needs to happen and not directing
-    <emphasis>how </emphasis>it must be accomplished. This frees the
-    super-computer to optimize the actual execution in any way it needs to
-    produce the desired result.</para>
+    <para>Definitions only define <emphasis>what</emphasis> is to be done,
+    they do not actually execute. This means that the ECL programmer should
+    think in terms of writing code that specifies <emphasis>what</emphasis> to
+    do rather than <emphasis>how</emphasis> to do it. This is an important
+    concept in that, the programmer is telling the supercomputer
+    <emphasis>what</emphasis> needs to happen and not directing <emphasis>how
+    </emphasis>it must be accomplished. This frees the super-computer to
+    optimize the actual execution in any way it needs to produce the desired
+    result.</para>
 
-    <para>A second consideration is: the order that Attributes are defined in
+    <para>A second consideration is: the order that Definitions appear in
     source code does not define their execution order—ECL is a non-procedural
     language<indexterm>
         <primary>non-procedural language</primary>
       </indexterm>. When an Action (such as OUTPUT) executes, all the
-    Attributes it needs to use (drilling down to the lowest level Attributes
+    Definitions it needs to use (drilling down to the lowest level Definitions
     upon which others are built) are compiled and optimized—in other words,
     unlike other programming languages, there is no inherent execution order
-    implicit in the order that Attribute definitions appear in source code
-    (although there is a necessary order for compilation to occur without
-    error—forward reference<indexterm>
+    implicit in the order that definitions appear in source code (although
+    there is a necessary order for compilation to occur without error—forward
+    reference<indexterm>
         <primary>forward reference</primary>
       </indexterm>s are not allowed). This concept of “orderless execution”
     requires a different mindset from standard, order-dependent programming
@@ -73,10 +72,10 @@ or any succeeding line – everything in between is ignored */</programlisting>
 
     <para>ECL uses the standard <emphasis>object.property</emphasis> syntax
     used by many other programming languages (however, ECL is not an
-    object-oriented language) to qualify Attribute scope and disambiguate
+    object-oriented language) to qualify Definition scope and disambiguate
     field references within tables:</para>
 
-    <programlisting>ModuleName.Attribute //reference an attribute from another module</programlisting>
+    <programlisting>ModuleName.Definition //reference an definition from another module/folder</programlisting>
 
     <programlisting>Dataset.Field       //reference a field in a dataset or recordset</programlisting>
   </sect2>

docs/ECLLanguageReference/ECLR_mods/Basics-RecordSetFiltring.xml

@@ -13,7 +13,7 @@
   separating each filter expression with a comma (,). All filter conditions
   separated by commas must be TRUE for a record to be included, which makes
   the comma an implicit AND operator (see <emphasis role="bold">Logical
-  Operators</emphasis>).</para>
+  Operators</emphasis>) in this context only.</para>
 
   <programlisting>MyRecordSet := Person(per_last_name &gt;= 'T', per_last_name &lt; 'U');
      // MyRecordSet contains people whose last name begins with “T”
@@ -29,8 +29,8 @@ RateGE7trds := Trades(trd_rate &gt;= '7');
 ValidTrades := Trades(NOT rmsTrade.Mortgage AND
                       NOT rmsTrade.HasNarrative(rmsTrade.snClosed));</programlisting>
 
-  <para>Boolean Attribute<indexterm>
-      <primary>Boolean Attribute</primary>
+  <para>Boolean <indexterm>
+      <primary>Boolean Definition</primary>
     </indexterm> definitions should be used as recordset filters for maximum
   flexibility, readability and re-usability instead of hard-coding in a Record
   Set definition. For example, use:</para>
@@ -62,7 +62,7 @@ BankCardTrades := trades(isBankCard AND WithinDate(6));</programlisting>
   role="underline">and</emphasis> a set of parentheses around the individual
   filters being separated. This results in a tighter binding than if AND is
   used instead of a comma without parentheses. For example, the filter
-  expression in this Attribute definition::</para>
+  expression in this definition::</para>
 
   <programlisting>BankMortTrades := trades(isBankCard OR isMortgage, isOpen);</programlisting>
 

docs/ECLLanguageReference/ECLR_mods/BltInFunc-CASE.xml

@@ -44,8 +44,8 @@
           <row>
             <entry><emphasis>value</emphasis></entry>
 
-            <entry>The value to return. This may be a single value, a set of
-            values, a record set, or an action.</entry>
+            <entry>The value to return. This may be any expression or
+            action.</entry>
           </row>
 
           <row>
@@ -97,5 +97,8 @@ MyAction := CASE(MyExp, 1 =&gt; FAIL('Failed for reason 1'),
     4 =&gt; FAIL('Failed for reason 4'),    FAIL('Failed for unknown reason'));
   // for the caseval of 3, Fails for reason 3</programlisting>
 
-  <para>See Also: <link linkend="MAP">MAP</link>, <link linkend="CHOOSE">CHOOSE</link>, <link linkend="IF">IF</link>, <link linkend="REJECTED">REJECTED</link>, <link linkend="WHICH">WHICH</link></para>
+  <para>See Also: <link linkend="MAP">MAP</link>, <link
+  linkend="CHOOSE">CHOOSE</link>, <link linkend="IF">IF</link>, <link
+  linkend="REJECTED">REJECTED</link>, <link
+  linkend="WHICH">WHICH</link></para>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/BltInFunc-CHOOSE.xml

@@ -30,7 +30,7 @@
 
             <entry>The values to return. There may be as many value parameters
             as necessary to specify all the expected values of the expression.
-            This may not be a record set.</entry>
+            This may be any expression or action.</entry>
           </row>
 
           <row>
@@ -38,8 +38,7 @@
 
             <entry>The value to return when the expression returns an
             out-of-range value. The last parameter is always the
-            <emphasis>elsevalue</emphasis>. This may not be a record
-            set.</entry>
+            <emphasis>elsevalue</emphasis>. </entry>
           </row>
 
           <row>
@@ -68,5 +67,6 @@ WorstRate := CHOOSE(IntRate,1,2,3,4,5,6,6,6,6,0);
  // WorstRate receives 6 if the IntRate is 7, 8, or 9
 </programlisting>
 
-  <para>See Also: <link linkend="CASE">CASE</link>, <link linkend="IF">IF</link>, <link linkend="MAP">MAP</link></para>
+  <para>See Also: <link linkend="CASE">CASE</link>, <link
+  linkend="IF">IF</link>, <link linkend="MAP">MAP</link></para>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/BltInFunc-COUNT.xml

@@ -28,11 +28,11 @@
             <entry><emphasis>recordset</emphasis></entry>
 
             <entry>The set of records to process. This may be the name of a
-            dataset or a record set derived from some filter condition, or any
-            expression that results in a derived record set. This also may be
-            the GROUP keyword to indicate counting the number of elements in a
-            group, when used in a RECORD structure to generate crosstab
-            statistics.</entry>
+            DATASET or a record set derived from some filter condition, or any
+            expression that results in a derived record set, or a the name of
+            a DICTIONARY declaration. This also may be the GROUP keyword to
+            indicate counting the number of elements in a group, when used in
+            a RECORD structure to generate crosstab statistics.</entry>
           </row>
 
           <row>
@@ -93,5 +93,8 @@ SetVals := [4,8,16,2,1];
 Cnt2    := COUNT(SetVals); //returns 5
 </programlisting>
 
-  <para>See Also: <link linkend="SUM">SUM</link>, <link linkend="AVE">AVE</link>, <link linkend="MIN">MIN</link>, <link linkend="MAX">MAX</link>, <link linkend="GROUP">GROUP</link>, <link linkend="TABLE">TABLE</link></para>
+  <para>See Also: <link linkend="SUM">SUM</link>, <link
+  linkend="AVE">AVE</link>, <link linkend="MIN">MIN</link>, <link
+  linkend="MAX">MAX</link>, <link linkend="GROUP">GROUP</link>, <link
+  linkend="TABLE">TABLE</link></para>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/BltInFunc-FAIL.xml

@@ -59,8 +59,8 @@
           <row>
             <entry><emphasis>datatype</emphasis></entry>
 
-            <entry>The value type or name of a RECORD structure to
-            emulate.</entry>
+            <entry>The value type, name of a RECORD structure, DATASET, or
+            DICTIONARY to emulate.</entry>
           </row>
         </tbody>
       </tgroup>
@@ -89,5 +89,6 @@ MyRecSet  := IF(EXISTS(Person),Person,
              FAIL(Person,99,’Person does not exist!!’));
 </programlisting>
 
-  <para>See Also: <link linkend="FAILURE">FAILURE</link>, <link linkend="ERROR">ERROR</link></para>
+  <para>See Also: <link linkend="FAILURE">FAILURE</link>, <link
+  linkend="ERROR">ERROR</link></para>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/BltInFunc-IF.xml

@@ -37,17 +37,15 @@
             <entry><emphasis>trueresult</emphasis></entry>
 
             <entry>The result to return when the expression is true. This may
-            be a single value, a SET of values, a recordset, or an action to
-            perform.</entry>
+            be any expression or action.</entry>
           </row>
 
           <row>
             <entry><emphasis>falseresult</emphasis></entry>
 
             <entry>The result to return when the expression is false. This may
-            be a single value, a SET of values, a recordset, or an action to
-            perform. This may be omitted only if the result is an
-            action.</entry>
+            be any expression or action. This may be omitted only if the
+            result is an action.</entry>
           </row>
 
           <row>
@@ -66,18 +64,17 @@
   <emphasis>falseresult</emphasis> based on the evaluation of the
   <emphasis>expression</emphasis>. Both the <emphasis>trueresult</emphasis>
   and <emphasis>falseresult</emphasis> must be the same type (i.e. both
-  strings, or both recordsets, or ...). If the
-  <emphasis>trueresult</emphasis> and <emphasis>falseresult</emphasis> are
-  strings, then the size of the returned string will be the size of the
-  resultant value. If subsequent code relies on the size of the two being the
-  same, then a type cast to the required size may be required (typically to
-  cast an empty string to the proper size so subsequent string indexing will
-  not fail).</para>
-  
-  <para>The <emphasis role="bold">IFF</emphasis> function performs the same 
-  functionality as IF, but ensures that an <emphasis>expression</emphasis> 
+  strings, or both recordsets, or ...). If the <emphasis>trueresult</emphasis>
+  and <emphasis>falseresult</emphasis> are strings, then the size of the
+  returned string will be the size of the resultant value. If subsequent code
+  relies on the size of the two being the same, then a type cast to the
+  required size may be required (typically to cast an empty string to the
+  proper size so subsequent string indexing will not fail).</para>
+
+  <para>The <emphasis role="bold">IFF</emphasis> function performs the same
+  functionality as IF, but ensures that an <emphasis>expression</emphasis>
   containing complex boolean logic is evaluated exactly as it appears.</para>
-  
+
   <para>Example:</para>
 
   <programlisting>MyDate := IF(ValidDate(Trades.trd_dopn),Trades.trd_dopn,0);
@@ -98,5 +95,7 @@ MyAddress := IF(person.gender = 'M',
   // STRING182 ensures a proper-length string return
 </programlisting>
 
-  <para>See Also: <link linkend="MAP">MAP</link>, <link linkend="EVALUATE">EVALUATE</link>, <link linkend="CASE">CASE</link>, <link linkend="CHOOSE">CHOOSE</link>, <link linkend="SET">SET</link></para>
+  <para>See Also: <link linkend="MAP">MAP</link>, <link
+  linkend="EVALUATE">EVALUATE</link>, <link linkend="CASE">CASE</link>, <link
+  linkend="CHOOSE">CHOOSE</link>, <link linkend="SET">SET</link></para>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/BltInFunc-MAP.xml

@@ -39,8 +39,8 @@
           <entry><emphasis>value</emphasis></entry>
 
           <entry>The value to return if the expression is true. This may be a
-          single value expression, a set of values, a record set, or an
-          action.</entry>
+          single value expression, a set of values, a DATASET, a DICTIONARY, a
+          record set, or an action.</entry>
         </row>
 
         <row>

docs/ECLLanguageReference/ECLR_mods/Expr-InOps.xml

@@ -21,23 +21,26 @@
         <row>
           <entry><emphasis>value</emphasis></entry>
 
-          <entry>The value to find in the
-          <emphasis>value_set</emphasis>.</entry>
+          <entry>The value to find in the <emphasis>value_set</emphasis>. This
+          is usually a single value, but if the <emphasis>value_set</emphasis>
+          is a DICTIONARY with a multiple-component key, this may also be a
+          ROW.</entry>
         </row>
 
         <row>
           <entry><emphasis>value_set</emphasis></entry>
 
-          <entry>The low value in the inclusive range.</entry>
+          <entry>A set of values. This may be a set expression or a
+          DICTIONARY.</entry>
         </row>
       </tbody>
     </tgroup>
   </informaltable>
 
   <para>The <emphasis role="bold">IN</emphasis> operator is shorthand for a
-  collection of OR conditions. It is an operator that will search an ordered
-  set to find an inclusion, resulting in a Boolean return. Using IN is much
-  more efficient than the equivalent OR expression.</para>
+  collection of OR conditions. It is an operator that will search a set to
+  find an inclusion, resulting in a Boolean return. Using IN is much more
+  efficient than the equivalent OR expression.</para>
 
   <para>Example:</para>
 
@@ -45,17 +48,33 @@
 IsABCStatus := Person.Status IN ABCset;
     //This code is directly equivalent to:
     // IsABCStatus := Person.Status = 'A' OR
-    // Person.Status = 'B' OR
-    // Person.Status = 'C';
+    //                Person.Status = 'B' OR
+    //                Person.Status = 'C';
        
-IsABCRate := Trades.trd_rate IN ABCset;
-Trades_ABCstat := Trades(IsABCRate);
+IsABC(STRING1 char) := char IN ABCset;
+Trades_ABCstat := Trades(IsABC(rate));
     // Trades_ABCstat is a record set definition of all those
-    // trades with a trade status of A, B, or C</programlisting>
+    // trades with a trade status of A, B, or C
 
-  <para>See Also: <link linkend="Basic_Attribute_Types">Basic Attribute
-  Types</link>, <link linkend="Basic_Attribute_Types">Attribute Types</link>
-  (<link linkend="Set_Attributes">Set Attributes</link>), <link
+//DICTIONARY examples:
+rec := {STRING color,UNSIGNED1 code};
+ColorCodes := DATASET([{'Black' ,0 },
+                       {'Brown' ,1 },
+                       {'Red'   ,2 },
+                       {'White' ,3 }], rec);
+
+CodeColorDCT  := DICTIONARY(ColorCodes,{Code =&gt; Color});
+OUTPUT(6 IN CodeColorDCT);     //true
+
+ColorCodesDCT := DICTIONARY(ColorCodes,{Color,Code});
+OUTPUT(ROW({'Red',2},rec) IN ColorCodesDCT);
+</programlisting>
+
+  <para>See Also: <link linkend="Basic_Attribute_Types">Basic Definition
+  Types</link>, <link linkend="Basic_Attribute_Types">Definition Types</link>
+  (<link linkend="Set_Attributes">Set Definitions</link>), <link
   linkend="Logical_Operators">Logical Operators</link>, <link
-  linkend="PARSE_Pattern_Value_Types">PATTERN</link></para>
+  linkend="PARSE_Pattern_Value_Types">PATTERN</link>, <link
+  linkend="DICTIONARY">DICTIONARY</link>, <link
+  linkend="ROW">ROW</link></para>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/Expr-RecordSetOps.xml

@@ -8,11 +8,10 @@
       <primary>Record Set Operators</primary>
     </indexterm></title>
 
-  <para><emphasis>The following record set Append operators are supported
-  (both require that the files were created using identical RECORD
-  structure<indexterm>
+  <para>The following record set Append operators are supported (both require
+  that the files were created using identical RECORD structures<indexterm>
       <primary>RECORD structure</primary>
-    </indexterm>s):</emphasis></para>
+    </indexterm>):</para>
 
   <informaltable colsep="0" frame="none" rowsep="0">
     <tgroup align="left" cols="2">

docs/ECLLanguageReference/ECLR_mods/RecordStructure.xml

@@ -19,22 +19,22 @@
       <primary>PACKED</primary>
     </indexterm> ]</emphasis></para>
 
-  <para><emphasis role="bold"></emphasis><emphasis role="bold">
-  </emphasis><emphasis>fields ;</emphasis></para>
+  <para><emphasis role="bold"> </emphasis><emphasis>fields ;</emphasis></para>
 
-  <para><emphasis></emphasis><emphasis> </emphasis><emphasis role="bold"> [
-  IFBLOCK<indexterm>
+  <para><emphasis role="bold"> [ IFBLOCK<indexterm>
       <primary>IFBLOCK</primary>
     </indexterm>( </emphasis><emphasis>condition</emphasis><emphasis
-  role="bold"> )</emphasis><emphasis role="bold"> </emphasis><emphasis>
-  </emphasis></para>
+  role="bold"> )</emphasis></para>
 
-  <para><emphasis> fields ;</emphasis><emphasis> </emphasis><emphasis
-  role="bold"> </emphasis></para>
+  <para><emphasis> fields ;</emphasis></para>
 
   <para><emphasis role="bold"> END; ]</emphasis></para>
 
-  <para><emphasis role="bold"></emphasis><emphasis role="bold">END;<indexterm>
+  <para><emphasis role="bold"> [ =&gt;
+  </emphasis><emphasis>payload</emphasis><emphasis role="bold">
+  ]</emphasis></para>
+
+  <para><emphasis role="bold">END;<indexterm>
       <primary>RECORD structure</primary>
     </indexterm></emphasis></para>
 
@@ -49,7 +49,7 @@
           <entry><emphasis>attr</emphasis></entry>
 
           <entry>The name of the RECORD structure for later use in other
-          attributes.</entry>
+          definitions.</entry>
         </row>
 
         <row>
@@ -141,15 +141,32 @@
           receive their declared default values. If there's no default value,
           the <emphasis>fields</emphasis> receive blanks or zeros.</entry>
         </row>
+
+        <row>
+          <entry><emphasis role="bold">=&gt;</emphasis></entry>
+
+          <entry>Optional. The delimiter between the list of key
+          <emphasis>fields</emphasis> and the <emphasis>payload</emphasis>
+          when the RECORD structure is used by the DICTIONARY declaration.
+          Typically, this is an inline structure using curly braces ( { } )
+          instead of RECORD and END.</entry>
+        </row>
+
+        <row>
+          <entry><emphasis>payload</emphasis></entry>
+
+          <entry>The list of non-keyed <emphasis>fields</emphasis> in the
+          DICTIONARY.</entry>
+        </row>
       </tbody>
     </tgroup>
   </informaltable>
 
-  <para>Record layouts are Attribute definitions whose expression is a RECORD
-  structure terminated by the END keyword. The <emphasis>attr</emphasis> name
-  creates a user-defined value type that can be used in built-in functions and
-  TRANSFORM function definitions. The delimiter between field definitions in a
-  RECORD structure can be either the semi-colon (;) or a comma (,).</para>
+  <para>Record layouts are definitions whose expression is a RECORD structure
+  terminated by the END keyword. The <emphasis>attr</emphasis> name creates a
+  user-defined value type that can be used in built-in functions and TRANSFORM
+  function definitions. The delimiter between field definitions in a RECORD
+  structure can be either the semi-colon (;) or a comma (,).</para>
 
   <sect2 id="In-line_Record_Definitions">
     <title>In-line Record Definitions</title>
@@ -159,7 +176,7 @@
     (RECORD/END or {}) can be used to create “on-the-fly” record formats
     within those functions that require record structures (OUTPUT, TABLE,
     DATASET etc.), instead of defining the record as a separate
-    attribute.</para>
+    definition.</para>
   </sect2>
 
   <sect2 id="Field_Definitions">
@@ -224,8 +241,8 @@
 
             <entry>Optional. An expression defining the source of the data
             (for operations that require a data source, such as TABLE and
-            PARSE). This may be a constant, expression, or Attribute providing
-            the value.</entry>
+            PARSE). This may be a constant, expression, or definition
+            providing the value.</entry>
           </row>
 
           <row>
@@ -256,19 +273,19 @@
             <entry><emphasis>sourcedataset</emphasis></entry>
 
             <entry>A previously defined DATASET or derived recordset
-            attribute. See the <emphasis role="bold">Field
+            definition. See the <emphasis role="bold">Field
             Inheritance</emphasis>section below.</entry>
           </row>
 
           <row>
             <entry><emphasis>childdataset</emphasis></entry>
 
-            <entry>A child DATASET declaration (see DATASET discussion), which
-            implicitly defines all the fields of the child at their already
-            defined <emphasis>datatype</emphasis>,
+            <entry>A child dataset declaration (see DATASET and DICTIONARY
+            discussions), which implicitly defines all the fields of the child
+            at their already defined <emphasis>datatype</emphasis>,
             <emphasis>identifier</emphasis>, and
             <emphasis>defaultvalue</emphasis> (if present in the child
-            DATASET's RECORD structure).</entry>
+            dataset's RECORD structure).</entry>
           </row>
         </tbody>
       </tgroup>
@@ -295,7 +312,7 @@
     are implicitly defined using the <emphasis>datatype</emphasis> and
     <emphasis>identifier</emphasis> of all the existing field definitions in
     the <emphasis>recstruct</emphasis>. When a <emphasis>sourcedataset
-    </emphasis>(a previously defined DATASET or recordset attribute) is
+    </emphasis>(a previously defined DATASET or recordset definition) is
     specified to inherit the fields, the new fields are implicitly defined
     using the <emphasis>datatype</emphasis>, <emphasis>identifier</emphasis>,
     and <emphasis>defaultvalue</emphasis> of all the fields (making it usable
@@ -429,9 +446,14 @@ END;</programlisting>
 
     <para><emphasis role="bold"> { XMLDEFAULT<indexterm>
         <primary>XMLDEFAULT</primary>
-      </indexterm>(</emphasis><emphasis role="bold"> </emphasis><emphasis
-    role="bold">'</emphasis><emphasis>value</emphasis><emphasis role="bold">' )
-    }</emphasis><emphasis role="bold"> </emphasis></para>
+      </indexterm>(</emphasis> <emphasis
+    role="bold">'</emphasis><emphasis>value</emphasis><emphasis role="bold">'
+    ) }</emphasis></para>
+
+    <para><emphasis role="bold"> { DEFAULT<indexterm>
+        <primary>DEFAULT</primary>
+      </indexterm>(</emphasis> <emphasis>value</emphasis><emphasis
+    role="bold"> ) }</emphasis></para>
 
     <para><emphasis role="bold"> { VIRTUAL<indexterm>
         <primary>Virtual</primary>
@@ -486,11 +508,27 @@ END;</programlisting>
 
           <row>
             <entry><emphasis role="bold">{
-            XMLDEFAULT(</emphasis>'<emphasis>value</emphasis>'<emphasis role="bold">)
-            }</emphasis></entry>
+            XMLDEFAULT(</emphasis>'<emphasis>value</emphasis>'<emphasis
+            role="bold">) }</emphasis></entry>
+
+            <entry>Specifies a default XML <emphasis>value</emphasis> for the
+            field. The <emphasis>value</emphasis> must be constant.</entry>
+          </row>
 
-            <entry>Specifies a default XML <emphasis>value</emphasis> for the field. 
-            The <emphasis>value</emphasis> must be constant. </entry>
+          <row>
+            <entry><emphasis role="bold">{ DEFAULT(</emphasis><emphasis>
+            value</emphasis> <emphasis role="bold">) }</emphasis></entry>
+
+            <entry>Specifies a default <emphasis>value</emphasis> for the
+            field. The <emphasis>value</emphasis> must be constant. This
+            <emphasis>value</emphasis> will be used: <para>1. When a
+            DICTIONARY lookup returns no match.</para><para>2. When an
+            out-of-range record is fetched using ds[n] (as in ds[5] when ds
+            contains only 4 records). </para><para>3. In the default record
+            passed to TRANSFORM functions in LEFT ONLY or RIGHT ONLY JOINs
+            where there is no corresponding row. </para><para>4. When
+            defaulting field values in a TRANSFORM using SELF = [
+            ].</para></entry>
           </row>
 
           <row>
@@ -576,7 +614,7 @@ END;</programlisting>
 
     <programlisting>R := RECORD
 STRING blah{xpath('a/b&lt;&gt;')};
-//contains all of b, including any child attributes and values
+//contains all of b, including any child definitions and values
 END;</programlisting>
 
     <para>For XML DATASET reading and processing results of the
@@ -719,7 +757,7 @@ Form1 := RECORD
     BOOLEAN HasBogey := FALSE; 
                         //HasBogey defaults to false
     REAL4    Valu8024;
-          //value from the Valu8024 attribute
+          //value from the Valu8024 definition
 END;
 Form2 := RECORD
      Trades; //include all fields from the Trades dataset at their
@@ -838,6 +876,7 @@ OUTPUT(ds,,'~RTTEST::XMLtest2',
  */</programlisting>
 
     <para>See Also: <link linkend="DATASET">DATASET</link>, <link
+    linkend="DICTIONARY">DICTIONARY</link>, <link
     linkend="INDEX_record_structure">INDEX</link>, <link
     linkend="OUTPUT">OUTPUT</link>, <link linkend="TABLE">TABLE</link>, <link
     linkend="TRANSFORM_Structure">TRANSFORM Structure</link>, <link

docs/ECLLanguageReference/ECLR_mods/Recrd-DATASET.xml

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
 "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
 <sect1 id="DATASET">
@@ -51,6 +51,9 @@
     </indexterm>(</emphasis><emphasis> struct </emphasis><emphasis
   role="bold">)</emphasis></para>
 
+  <para><emphasis role="bold">DATASET(</emphasis><emphasis> dict
+  </emphasis><emphasis role="bold">)</emphasis></para>
+
   <informaltable colsep="0" frame="none" rowsep="0">
     <tgroup cols="2">
       <colspec align="left" colwidth="122.40pt" />
@@ -123,7 +126,7 @@
           <entry><emphasis>recordset</emphasis></entry>
 
           <entry><para>A set of in-line data records. This can simply name a
-          previously-defined set attribute or explicitly use square brackets
+          previously-defined set definition or explicitly use square brackets
           to indicate an inline set definition. Within the square brackets
           records are separated by commas. The records are specified by
           either:</para><para>1) Using curly braces ({}) to surround the field
@@ -221,9 +224,9 @@
         </row>
 
         <row>
-          <entry><emphasis>DATASET</emphasis></entry>
+          <entry><emphasis>dict</emphasis></entry>
 
-          <entry>declares a new data table in the supercomputer.</entry>
+          <entry>The name of a DICTIONARY definition.</entry>
         </row>
       </tbody>
     </tgroup>
@@ -266,6 +269,9 @@
     </indexterm> (see <emphasis role="bold">DATASET as a Parameter Type
   </emphasis>below).</para>
 
+  <para>The eighth form is used to define a DICTIONARY as a DATASET (see
+  <emphasis role="bold">DATASET from DICTIONARY </emphasis>below).</para>
+
   <sect2 id="THOR-FLAT_Files">
     <title>THOR/FLAT Files</title>
 
@@ -726,7 +732,7 @@ file3 := DATASET('MyFile.CSV',
 rform := RECORD
   STRING author; //data from author tag -- tag name is lowercase and matches field name
   STRING name {XPATH('title')}; //data from title tag, renaming the field
-  STRING isbn {XPATH('@isbn')}; //isbn attribute data from book tag
+  STRING isbn {XPATH('@isbn')}; //isbn definition data from book tag
 tag
 END;
 books := DATASET('MyFile',rform,XML('library/book'));</programlisting>
@@ -868,7 +874,7 @@ OUTPUT(ds);</programlisting>
       </indexterm> and have it treated as a file. This is useful in situations
     where file operations are needed on dynamically generated data (such as
     the runtime values of a set of pre-defined expressions). It is also useful
-    to test any boundary conditions for attributes by creating a small
+    to test any boundary conditions for definitions by creating a small
     well-defined set of records with constant values<indexterm>
         <primary>constant values</primary>
       </indexterm> that specifically exercise those boundaries. This form may
@@ -883,7 +889,7 @@ OUTPUT(ds);</programlisting>
 
     <para>Example:</para>
 
-    <programlisting>//Inline DATASET using attribute values
+    <programlisting>//Inline DATASET using definition values
 myrec := {REAL diff, INTEGER1 reason};
 rms5008 := 10.0;
 rms5009 := 11.0;
@@ -1300,7 +1306,37 @@ OUTPUT(s_Name1);
 OUTPUT(s_Name2);
 OUTPUT(a_Name);
 OUTPUT(b_Name);</programlisting>
+  </sect2>
+
+  <sect2 id="DATASET_from_DICTIONARY">
+    <title>DATASET from DICTIONARY</title>
+
+    <para><emphasis role="bold">DATASET(</emphasis><emphasis> dict
+    </emphasis><emphasis role="bold">)</emphasis></para>
+
+    <para>This form re-defines the<emphasis> dict </emphasis> as a
+    DATASET<indexterm>
+        <primary>Treating DICTIONARY as a DATASET</primary>
+      </indexterm>.</para>
+
+    <para>Example:</para>
+
+    <programlisting>rec := {STRING color,UNSIGNED1 code, STRING name};
+ColorCodes := DATASET([{'Black' ,0 , 'Fred'},
+                       {'Brown' ,1 , 'Sam'},
+                       {'Red'   ,2 , 'Sue'},
+                       {'White' ,3 , 'Jo'}], rec);
+
+ColorCodesDCT := DICTIONARY(ColorCodes,{Color,Code});
+
+ds := DATASET(ColorCodesDCT);
+OUTPUT(ds);         </programlisting>
 
-    <para>See Also: <link linkend="OUTPUT">OUTPUT</link>, <link linkend="RECORD_Structure">RECORD Structure</link>, <link linkend="TABLE">TABLE</link>, <link linkend="ROW">ROW</link>, <link linkend="RECORDOF">RECORDOF</link>, <link linkend="TRANSFORM_Structure">TRANSFORM Structure</link></para>
+    <para>See Also: <link linkend="OUTPUT">OUTPUT</link>, <link
+    linkend="RECORD_Structure">RECORD Structure</link>, <link
+    linkend="TABLE">TABLE</link>, <link linkend="ROW">ROW</link>, <link
+    linkend="RECORDOF">RECORDOF</link>, <link
+    linkend="TRANSFORM_Structure">TRANSFORM Structure</link>, <link
+    linkend="DICTIONARY">DICTIONARY</link></para>
   </sect2>
 </sect1>

docs/ECLLanguageReference/ECLR_mods/Recrd-DICTIONARY.xml

@@ -0,0 +1,166 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+"http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+<sect1 id="DICTIONARY">
+  <title>DICTIONARY<indexterm>
+      <primary>DICTIONARY</primary>
+    </indexterm></title>
+
+  <para>
+    <emphasis>attr</emphasis>
+
+    <emphasis role="bold">:= DICTIONARY(</emphasis>
+
+    <emphasis>dataset, structure</emphasis>
+
+    <emphasis role="bold">);</emphasis>
+  </para>
+
+  <para>
+    <emphasis role="bold">DICTIONARY(</emphasis>
+
+    <emphasis>structure</emphasis>
+
+    <emphasis role="bold">)</emphasis>
+  </para>
+
+  <informaltable colsep="0" frame="none" rowsep="0">
+    <tgroup cols="2">
+      <colspec align="left" colwidth="122.40pt" />
+
+      <colspec />
+
+      <tbody>
+        <row>
+          <entry>
+            <emphasis>attr</emphasis>
+          </entry>
+
+          <entry>The name of the DICTIONARY for later use in other
+          definitions.</entry>
+        </row>
+
+        <row>
+          <entry>
+            <emphasis>dataset</emphasis>
+          </entry>
+
+          <entry>The name of a DATASET or recordset from which to derive the
+          DICTIONARY. This may be defined inline (similar to an inline
+          DATASET).</entry>
+        </row>
+
+        <row>
+          <entry>
+            <emphasis>structure</emphasis>
+          </entry>
+
+          <entry>The RECORD structure (often defined inline) specifying the
+          layout of the fields. The first field(s) are key fields, optionally
+          followed the "results in" operator (=&gt;) and additional payload
+          fields. This is similar to the payload version of an INDEX. The
+          payload may specify individual fields or may use the name of the
+          <emphasis>dataset </emphasis> to payload all the non-key
+          fields.</entry>
+        </row>
+      </tbody>
+    </tgroup>
+  </informaltable>
+
+  <para>A <emphasis role="bold">DICTIONARY</emphasis> allows you to
+  efficiently check whether a particular data value is in a list (using the IN
+  operator), or to simply map data. It is similar to a LOOKUP JOIN that can be
+  used in any context.</para>
+
+  <sect2 id="DICTIONARY_Definition">
+    <title>DICTIONARY Definition</title>
+
+    <para>The DICTIONARY declaration defines a set of unique records derived
+    from the <emphasis>dataset</emphasis> parameter and indexed by the first
+    field(s) named in the <emphasis>structure</emphasis> parameter. The
+    DICTIONARY will contain one record for each unique value(s) in the key
+    field(s). You can access an individual record by appending square brackets
+    ( [ ] ) to the <emphasis>attr</emphasis> name of the DICTIONARY, which
+    contain the key field value(s) that identify the specific record to
+    access.</para>
+  </sect2>
+
+  <sect2 id="Child_DICTIONARY">
+    <title>DICTIONARY as a Value Type</title>
+
+    <para>The second form of DICTIONARY is a value type with the
+    <emphasis>structure</emphasis> parameter specifying the RECORD structure
+    of the data. This data type usage allows you to specify a DICTIONARY as a
+    child dataset, similar to the way DATASET may be used to define a child
+    dataset. This may also be used to pass a DICTIONARY as a parameter.</para>
+  </sect2>
+
+  <para>Example:</para>
+
+  <programlisting>ColorCodes := DATASET([{'Black' ,0 },
+                       {'Brown' ,1 },
+                       {'Red'   ,2 },
+                       {'Orange',3 },
+                       {'Yellow',4 },
+                       {'Green' ,5 },
+                       {'Blue'  ,6 },
+                       {'Violet',7 },
+                       {'Grey'  ,8 },
+                       {'White' ,9 }], {STRING color,UNSIGNED1 code});
+
+ColorCodesDCT := DICTIONARY(ColorCodes,{Color,Code});    //multi-field key
+ColorCodeDCT  := DICTIONARY(ColorCodes,{Color =&gt; Code}); //payload field
+CodeColorDCT  := DICTIONARY(ColorCodes,{Code =&gt; Color});
+
+//mapping examples
+MapCode2Color(UNSIGNED1 code) := CodeColorDCT[code].color;
+MapColor2Code(STRING color)   := ColorCodeDCT[color].code;
+
+OUTPUT(MapColor2Code('Red'));     //true
+OUTPUT(MapCode2Color(4));         //true
+
+//Search term examples
+OUTPUT('Green' IN ColorCodeDCT);  //true
+OUTPUT(6 IN CodeColorDCT);        //true
+OUTPUT(ROW({'Red',2},RECORDOF(ColorCodes)) IN ColorCodesDCT); //multi-field key, true 
+
+//multi-field payload examples
+rec := RECORD
+  STRING10  color;
+  UNSIGNED1 code; 
+  STRING10  name;
+END;
+Ds := DATASET([{'Black' ,0 , 'Fred'},
+               {'Brown' ,1 , 'Seth'},
+               {'Red'   ,2 , 'Sue'},
+               {'White' ,3 , 'Jo'}], rec);
+
+DsDCT := DICTIONARY(DS,{color =&gt; DS});
+
+OUTPUT('Red' IN DsDCT); //true
+DsDCT['Red'].code;      //2
+DsDCT['Red'].name;      //Sue
+
+//inline DCT examples
+InlineDCT := DICTIONARY([{'Black' =&gt; 0 , 'Fred'},
+                         {'Brown' =&gt; 1 , 'Sam'},
+                         {'Red'   =&gt; 2 , 'Sue'},
+                         {'White' =&gt; 3 , 'Jo'} ], 
+                        {STRING10 color =&gt; UNSIGNED1 code,STRING10 name});
+
+OUTPUT('Red' IN InlineDCT); //true
+InlineDCT['Red'].code;      //2
+InlineDCT['Red'].name;      //Sue
+InlineDCT['Red'];           //Red   2   Sue
+
+//Form 2 examples -- parameter passing
+MyDCTfunc(DICTIONARY({STRING10 color =&gt; UNSIGNED1 code,STRING10 name}) DCT,
+          STRING10 key) := DCT[key].name;
+MyDCTfunc(InlineDCT,'White');  //Jo
+MyDCTfunc(DsDCT,'Brown');      //Seth
+</programlisting>
+
+  <para>See Also: <link linkend="DATASET">DATASET</link>, <link
+  linkend="RECORD_Structure">RECORD Structure</link>, <link
+  linkend="INDEX">INDEX</link>, <link linkend="IN_Operator">IN Operator</link></para>
+</sect1>