pareto 0.73.0 → 0.75.0

package/auto.pareto/auto.dependencies/pareto-pure/$.data.ts

@@ -1,7 +1,7 @@
 import * as pd from 'pareto-core-data'
 import * as pt from 'pareto-core-types'
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
 
@@ -68,29 +68,99 @@ export const $: g_project.D.Library = {
     'module sets': {
         'public': {
             'glossaries': d({
-                "alan light": dataglossary([], d_alan_light),
-                "astn": dataglossary([], d_astn),
-                "boekhouding constrained": dataglossary([], d_boekhouding_constrained),
-                "boekhouding unconstrained": dataglossary([], d_boekhouding_unconstrained),
-                "fountain pen directory": dataglossary([], d_fountain_pen_directory),
-                "fountain pen indented file with escaped strings": dataglossary([], d_fountain_pen_indented_file_with_escaped_strings),
-                "fountain pen indented file": dataglossary([], d_fountain_pen_indented_file),
-                "grammar": dataglossary([], d_grammar),
-                "graphviz": dataglossary([], d_graphviz),
-                "html": dataglossary([], d_html),
-                "liana project": dataglossary([], d_liana_project),
-                "liana schema unconstrained without annotations": dataglossary([], d_liana_schema_in_between),
-                "lines": dataglossary([], d_lines),
-                "pareto 3gl high": dataglossary([], d_pareto_3gl_high),
-                "pareto 4gl type system": dataglossary([], d_pareto_4gl_type_system),
-                "pareto 4gl typescript": dataglossary([], d_pareto_4gl_typescript),
-                "semantic versioning": dataglossary([], d_semantic_versioning),
-                "testresult": dataglossary([], d_testresult),
-                "text": dataglossary([], d_text),
-                "typescript intermediate": dataglossary([], d_typescript_intermediate),
-                "xml": dataglossary([], d_xml),
-                // "tendril possibly constrained": dataglossary([], d_liana_schema_unconstrained_without_annotations),
-                // "tendril unconstrained": dataglossary([], d_liana_schema_unconstrained),
+                "alan light": dataglossary([
+                    `Alan Light is a language containing a subset of the Alan language developed by Kjerner (https://www.kjerner.com).`,
+                    `the subset is chosen to be able to generate a Alan model from a liana schema.`,
+                ], d_alan_light),
+                "astn": dataglossary([
+                    `ASTN is a notation language, like JSON. In fact, it is very similar to JSON. It is used to describe ASTs.`,
+                    `ASTN is to JSON what TypeScript is to JavaScript.`,
+                    ``,
+                    `it extends JSON with a couple of crucial concepts;`,
+                    `-separation between instance and meta data, not only do you have {} and [] for instance data, but you have () and <> for meta data`,
+                    `-tagged unions (state groups) as first class citizens`,
+                    `-schema specification,`,
+                    ``,
+                    `furthermore it adds some conveniences, like:`,
+                    `-comments`,
+                    `-optional (trailing) commas`,
+                    `-multiple delimiters text formats; besides quotes, apostrophes and backticks are also supported, each with their own intended use`,
+                    `--apostrophes: meta data (property and state names, as defined in the schema)`,
+                    `--quotes: short text instance data`,
+                    `--backticks: multiline instance data`,
+                    `-bare text (no delimiters at all) is also supported (it is up to the application to determine what to do with it)`,
+                    ``,
+                    `you might claim that ASTN is not a proper superset of JSON, as it does not contain the JSON concepts of a number, 'null', 'true' and 'false'`,
+                    `however, because ASTN contains the concept of an bare text string, which these are , JSON files can still be processed as ASTN files`,
+                ], d_astn),
+                "boekhouding constrained": dataglossary([
+                    `Boekhouding is a language to describe financial data. This is the constrained version`,
+                ], d_boekhouding_constrained),
+                "boekhouding unconstrained": dataglossary([
+                    `Boekhouding is a language to describe financial data. This is the unconstrained version`,
+                ], d_boekhouding_unconstrained),
+                "fountain pen directory": dataglossary([
+                    `a glossary containing types to write out a directory`,
+                ], d_fountain_pen_directory),
+                "fountain pen indented file with escaped strings": dataglossary([
+                    `a glossary containing types to write out an indented file with escaped strings`,
+                ], d_fountain_pen_indented_file_with_escaped_strings),
+                "fountain pen indented file": dataglossary([
+                    `a glossary containing types to write out an indented file`,
+                ], d_fountain_pen_indented_file),
+                "grammar": dataglossary([
+                    `for defining a grammar on top of a liana schema`,
+                ], d_grammar),
+                "graphviz": dataglossary([
+                    `a glossary containing types to write out a graphviz file (https://www.graphviz.org/)`,
+                ], d_graphviz),
+                "html": dataglossary([
+                    `a port of HTML to a liana schema`,
+                ], d_html),
+                "liana project": dataglossary([
+                    `for defining a project of multiple liana schemas and resolvers`,
+                ], d_liana_project),
+                "liana schema unconstrained without annotations": dataglossary([
+                    `a schema to define an AST, but with constraints. Contstraints point to other parts in the AST.`,
+                    `a liana schema does not specify how to resolve these constraints, only where they point to after they have been resolved.`,
+                ], d_liana_schema_in_between),
+                "lines": dataglossary([
+                    `a low level glossary to write out lines`,
+                ], d_lines),
+                "pareto 3gl high": dataglossary([
+                    `'pareto' is a set of languages. This '3gl high' instance is a high end 3rd generation level language.`,
+                    `similar to typescript, java, javascipt, c#, etc, but conforming to a liana schema.`,
+                    `memory is automatically managed, it contains namespaces and closures, and it is statically typed.`,
+                ], d_pareto_3gl_high),
+                "pareto 4gl type system": dataglossary([
+                    `'pareto' is a set of languages. This '4gl' instance is a 4th generation level language.`,
+                    `For comparison; other languages that are 4gl are SQL, XSLT, and matlab`,
+                    `4GL is suitable for non-programmers and programmers alike. It is a high-level programming language that is relatively easy to learn and use.`,
+                    `An significant concept of this language is the concept of data transformation.`,
+                ], d_pareto_4gl_type_system),
+                "pareto 4gl - typescript": dataglossary([
+                    `This is the glossary to create a typescript project from a pareto 4gl code base`,
+                ], d_pareto_4gl_typescript),
+                "semantic versioning": dataglossary([
+                    `a port of semantic versioning to a liana schema (https://semver.org/)`,
+                ], d_semantic_versioning),
+                "testresult": dataglossary([
+                    `a glossary containing types to write out a testresult`,
+                ], d_testresult),
+                "text": dataglossary([
+                    `a glossary only containing a text type, used as input for parsing`,
+                ], d_text),
+                "typescript intermediate": dataglossary([
+                    `a glossary containing types to target typescript for source code generation.`,
+                    `it handles some, what I would call quirks, of typescript, like:`,
+                    `-disallowed commas at the end of an type arguments definition (like <T,>)`,
+                    `-disallowed empty type arguments/parameter definition ( like <>)`,
+                    `-the strict rules for identifier names (like no spaces, no dashes, no dots, etc), like most languages have`,
+                    `-the only implicit appearance of dictionaries in many places, for example in a list of import statements`,
+                ], d_typescript_intermediate),
+                "xml": dataglossary([
+                    `a port of XML to a liana schema`,
+                ], d_xml),
             }),
             'transformations': {
                 'enrich': d({}),

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/index.ts

@@ -3,5 +3,5 @@ import * as pd from 'pareto-core-data'
 import { $ as dep_pareto_standard_library } from './pareto-standard-library/$.data'
 
 export const $ = pd.d({
-    'pareto-standard-library': { library: dep_pareto_standard_library, version: '^0.12.0' },
+    'pareto-standard-library': { library: dep_pareto_standard_library, version: '^0.15.0' },
 })

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/$.data.ts

@@ -1,9 +1,9 @@
 import * as pd from 'pareto-core-data'
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
-import { } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 import { $ as d_array } from "./modules/array/api.data"
 import { $ as d_boolean } from "./modules/boolean/api.data"

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/array/api.data.ts

@@ -1,20 +1,37 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", {}),
-        "append": algorithm("Append", {}),
-        "prepend": algorithm("Prepend", {}),
-        "zip": algorithm("Zip", {}),
-        "flattenTree": algorithm("FlattenTree", {}),
-        "unsafeSortTopologically": algorithm("SortTopologically", {}),
+        "flattenArrayOfArrays": algorithm([
+            `flatten an array of arrays`,
+        ], "FlattenArrayOfArrays", {}),
+        "append": algorithm([
+            `append an element to the end of an array`,
+        ], "Append", {}),
+        "prepend": algorithm([
+            `prepend an element to the beginning of an array`
+        ], "Prepend", {}),
+        "zip": algorithm([
+            `zip two arrays together`,
+            `the length of the resulting array is the length of the shortest input array`
+        ], "Zip", {}),
+        "flattenTree": algorithm([
+            `flatten a tree of values`,
+            `every node can be either an array, nothing or a value`
+        ], "FlattenTree", {}),
+        "unsafeSortTopologically": algorithm([
+            `sort a dictionary topologically`,
+            `the dictionary entries contains a value and a dictionary without values (only keys) that represent the dependencies`,
+            `if a circular dependency is detected, a panic is thrown`,
+            `the result is an array of key/value pairs`
+        ], "SortTopologically", {}),
 
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/array/glossary.data.ts

@@ -9,7 +9,7 @@ import {
     group,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -19,9 +19,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
 
@@ -42,8 +42,8 @@ export const $: g_glossary.D.Glossary = {
                 "ZippedArray": parametrizedType(
                     { "Benchmark": null, "Focus": null },
                     list(group({
-                        "benchmark": member(component(typeParameter("Benchmark"))),
-                        "focus": member(component(typeParameter("Focus"))),
+                        "benchmark": prop(component(typeParameter("Benchmark"))),
+                        "focus": prop(component(typeParameter("Focus"))),
                     }))
                 ),
 
@@ -55,22 +55,22 @@ export const $: g_glossary.D.Glossary = {
                 "AppendParameters": parametrizedType(
                     { "Type": null },
                     group({
-                        "array": member(component(typeReference("Array", { "Type": typeParameter("Type") }))),
-                        "element": member(component(typeParameter("Type"))),
+                        "array": prop(component(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": prop(component(typeParameter("Type"))),
                     })
                 ),
                 "PrependParameters": parametrizedType(
                     { "Type": null },
                     group({
-                        "array": member(component(typeReference("Array", { "Type": typeParameter("Type") }))),
-                        "element": member(component(typeParameter("Type"))),
+                        "array": prop(component(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": prop(component(typeParameter("Type"))),
                     })
                 ),
                 "ArrayTuple": parametrizedType(
                     { "Benchmark": null, "Focus": null },
                     group({
-                        "benchmark": member(component(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
-                        "focus": member(component(typeReference("Array", { "Type": typeParameter("Focus") }))),
+                        "benchmark": prop(component(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                        "focus": prop(component(typeReference("Array", { "Type": typeParameter("Focus") }))),
                     })
                 ),
                 "Nested": parametrizedType({ "Type": null }, stateGroup({
@@ -80,20 +80,20 @@ export const $: g_glossary.D.Glossary = {
                 })),
                 // "Array": parametrizedType({ "Type": null }, list(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
                 // "KeyValuePair": parametrizedType({ "Type": null }, group({
-                //     "key": member(text()),
-                //     "value": member(component(typeParameter("Type"))),
+                //     "key": prop(text()),
+                //     "value": prop(component(typeParameter("Type"))),
                 // })),
 
                 "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                    "value": member(component(typeParameter("Type"))),
-                    "dependencies": member(dictionary(nothing())),
+                    "value": prop(component(typeParameter("Type"))),
+                    "dependencies": prop(dictionary(nothing())),
                 }))),
 
 
                 "KeyValuePairArray": parametrizedType({ "Type": null }, list(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
                 "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": member(text()),
-                    "value": member(component(typeParameter("Type"))),
+                    "key": prop(text()),
+                    "value": prop(component(typeParameter("Type"))),
                 })),
 
             }),

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/boolean/api.data.ts

@@ -1,20 +1,34 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "array and": algorithm("Array And", {}),
-        "array or": algorithm("Array Or", {}),
-        "array xor": algorithm("Array Xor", {}),
-        "and": algorithm("And", {}),
-        "or": algorithm("Or", {}),
-        "xor": algorithm("Xor", {}),
-        "not": algorithm("Not", {}),
+        "array and": algorithm([
+            `return true if all input values are true, false otherwise`,
+        ], "Array And", {}),
+        "array or": algorithm([
+            `return true if at least one of the input values is true, false otherwise`,
+        ], "Array Or", {}),
+        "array xor": algorithm([
+            `return true if an odd number of input values is true, false otherwise`,
+        ], "Array Xor", {}),
+        "and": algorithm([
+            `return true if both input values are true, false otherwise`,
+        ], "And", {}),
+        "or": algorithm([
+            `return true if at least one of the input values is true, false otherwise`,
+        ], "Or", {}),
+        "xor": algorithm([
+            `return true if exactly one of the input values is true, false otherwise`,
+        ], "Xor", {}),
+        "not": algorithm([
+            `return true if the input value is false, false otherwise`,
+        ], "Not", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/boolean/glossary.data.ts

@@ -9,7 +9,7 @@ import {
     group,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -19,9 +19,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
@@ -34,8 +34,8 @@ export const $: g_glossary.D.Glossary = {
             'data types': d({
                 "Boolean": type(boolean()),
                 "Pair Of Booleans": type(group({
-                    "yin": member(boolean()),
-                    "yang": member(boolean()),
+                    "yin": prop(boolean()),
+                    "yang": prop(boolean()),
                 })),
                 "Array Of Booleans": type(list(boolean())),
             }),

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/buildInterfaceInitializers/api.data.ts

@@ -1,8 +1,8 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
@@ -13,10 +13,10 @@ export const $: g_project.D.API = api(
         // "buildUnsafeDictionary": algorithm("BuildUnsafeDictionary", {}),
         // "buildSafeDictionary": algorithm("BuildSafeDictionary", "DictionaryBuildStrategy", {}, {
         // }),
-        "createUnsafeDictionaryBuilder": algorithm("CreateUnsafeDictionaryBuilder", {}),
+        "createUnsafeDictionaryBuilder": algorithm([], "CreateUnsafeDictionaryBuilder", {}),
         //"createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", {}),
-        "createArrayBuilder": algorithm("CreateArrayBuilder", {}),
+        "createArrayBuilder": algorithm([], "CreateArrayBuilder", {}),
 
-        "createStringBuilder": algorithm("CreateStringBuilder", {}),
+        "createStringBuilder": algorithm([], "CreateStringBuilder", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/buildInterfaceInitializers/glossary.data.ts

@@ -9,7 +9,7 @@ import {
     group,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -28,9 +28,9 @@ import {
     sInterfaceMethod,
     streamconsumer,
 
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
@@ -47,20 +47,20 @@ export const $: g_glossary.D.Glossary = {
                 "Simple String": type(text()),
 
                 "Array": parametrizedType({ "Type": null, "EndType": null }, group({
-                    "array": member(list(component(typeParameter("Type")))),
-                    "end": member(component(typeParameter("EndType"))),
+                    "array": prop(list(component(typeParameter("Type")))),
+                    "end": prop(component(typeParameter("EndType"))),
                 })),
                 "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
-                    "dictionary": member(dictionary(component(typeParameter("Type")))),
-                    "end": member(component(typeParameter("EndType"))),
+                    "dictionary": prop(dictionary(component(typeParameter("Type")))),
+                    "end": prop(component(typeParameter("EndType"))),
                 })),
                 "String": parametrizedType({ "EndType": null }, group({
-                    "string": member(text()),
-                    "end": member(component(typeParameter("EndType"))),
+                    "string": prop(text()),
+                    "end": prop(component(typeParameter("EndType"))),
                 })),
                 "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": member(text()),
-                    "value": member(component(typeParameter("Type"))),
+                    "key": prop(text()),
+                    "value": prop(component(typeParameter("Type"))),
                 })),
 
                 "DictionaryBuildStrategy": type(stateGroup({

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/dictionary/api.data.ts

@@ -1,53 +1,58 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", {}),
+        "decorateDictionaryEntriesWithKey": algorithm([
+            `all dictionary entries are decorated with the key of the entry`,
+            `the key is added to the value of the entry`,
+        ], "DecorateDictionaryEntriesWithKey", {}),
 
-        "filter": algorithm("Filter", {}),
-        /**
-         * the keys of the outermost dictionary is combined with the key of the innermost dictionary
-         */
-        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", {}),
-        /**
-         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the last dictionary will be used.
-         */
-        "mergeAndOverwrite": algorithm("MergeAndOverwrite", {}),
-        /**
-         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the first dictionary will be used.
-         */
-        "mergeAndIgnore": algorithm("MergeAndIgnore", {}),
-        /**
-         * a dictionary with containing entries with values and a key candidate is transformed
-         * into a dictionary where the new key of the entry is the candidate. If candidates are not unique
-         * the function panics
-         */
-        "unsafeRekey": algorithm("UnsafeRekey", {}),
-        /**
-         * 2 dictionaries are combined into 1 dictionary. If keys are not unique this function panics.
-         */
-        "unsafeMerge": algorithm("UnsafeMerge", {}),
-        /**
-         * a key/value pair is added to a dictionary resulting in a new dictionary.
-         * if the key is not unique the function panics
-         */
-        "unsafeAddEntry": algorithm("UnsafeAddEntry", {}),
-        /**
-         * prepends and appends strings to all keys in the dictionary
-         */
-        "wrapKeys": algorithm("WrapKeys", {}),
-        /**
-         * a focus dictionary is matched to a benchmark dictionary resulting in a result dictionary
-         * this last dictionary contains all entries found in the benchmark dictionary.
-         * each entry value is optionally supplemented with the value of the focus entry, if found.
-         */
-        "zip": algorithm("Zip", {}),
+        "filter": algorithm([
+            `a dictionary of optional values is filtered into a regular dictionary`,
+            `if the optional value is not set, the entry is not included in the result`,
+            `if the optional value is set, the entry is included in the result`,
+        ], "Filter", {}),
+        "flattenDictionaryOfDictionaries": algorithm([
+            `flatten a dictionary of dictionaries`,
+            `the keys of the outermost dictionary is combined with the key of the innermost dictionary`,
+            `a separator is added between the keys`,
+            `if the separator appears in the keys of the outermost dictionary, it is escaped to guarantee uniqueness`,
+        ], "FlattenDictionaryOfDictionaries", {}),
+        "mergeAndOverwrite": algorithm([
+            `2 dictionaries are combined into 1 dictionary`,
+            `is a key exists in both directories, only the entry of the secondary dictionary will be used`,
+        ], "MergeAndOverwrite", {}),
+        "mergeAndIgnore": algorithm([
+            `2 dictionaries are combined into 1 dictionary`,
+            `is a key exists in both directories, only the entry of the primary dictionary will be used`,
+        ], "MergeAndIgnore", {}),
+        "unsafeRekey": algorithm([
+            `a dictionary with containing entries with a value and a key candidate is transformed`,
+            `into a dictionary where the new key of the entry is the candidate`,
+            `if candidates are not unique the function panics`,
+        ],"UnsafeRekey", {}),
+        "unsafeMerge": algorithm([
+            `2 dictionaries are combined into 1 dictionary`,
+            `if a key exists in both directories, the function panics`,
+        ], "UnsafeMerge", {}),
+        "unsafeAddEntry": algorithm([
+            `a key/value pair is added to a dictionary resulting in a new dictionary`,
+            `if the key is not unique the function panics`,
+        ], "UnsafeAddEntry", {}),
+        "wrapKeys": algorithm([
+            `prepends and appends strings to all keys in the dictionary`,
+        ], "WrapKeys", {}),
+        "zip": algorithm([
+            `a focus dictionary is matched to a benchmark dictionary resulting in a result dictionary`,
+            `this last dictionary contains all entries found in the benchmark dictionary`,
+            `each entry value is optionally supplemented with the value of the focus entry, if found`,
+        ], "Zip", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/dictionary/glossary.data.ts

@@ -9,7 +9,7 @@ import {
     group,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -19,9 +19,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
@@ -35,40 +35,40 @@ export const $: g_glossary.D.Glossary = {
                 "Boolean": type(boolean()),
                 "String": type(text()),
                 "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": member(text()),
-                    "value": member(component(typeParameter("Type"))),
+                    "key": prop(text()),
+                    "value": prop(component(typeParameter("Type"))),
                 })),
                 "Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
                 "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(component(typeParameter("Type"))))),
                 "MergeParameters": parametrizedType({ "Type": null }, group({
-                    "primary": member(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "secondary": member(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "primary": prop(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "secondary": prop(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
                 })),
                 "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
-                    "benchmark": member(component(typeParameter("Benchmark"))),
-                    "focus": member(optional(component(typeParameter("Focus")))),
+                    "benchmark": prop(component(typeParameter("Benchmark"))),
+                    "focus": prop(optional(component(typeParameter("Focus")))),
                 }))),
 
                 "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
-                    "benchmark": member(component(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
-                    "focus": member(component(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
+                    "benchmark": prop(component(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
+                    "focus": prop(component(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
                 })),
                 "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
-                    "dictionaries": member(dictionary(component(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
-                    "separator": member(text()),
-                    "escape": member(text()),// to escape if the separator appears in the key of the top level dictionary
+                    "dictionaries": prop(dictionary(component(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
+                    "separator": prop(text()),
+                    "escape": prop(text()),// to escape if the separator appears in the key of the top level dictionary
                 })),
                 "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
-                    "dictionary": member(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "keyValuePair": member(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
+                    "dictionary": prop(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "keyValuePair": prop(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
                 })),
                 "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
                 "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
                 "WrapKeysData": parametrizedType({ "Type": null }, group({
-                    "dictionary": member(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "prefix": member(text()),
-                    "suffix": member(text()),
+                    "dictionary": prop(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "prefix": prop(text()),
+                    "suffix": prop(text()),
                 })),
             }),
         },