pareto 0.58.0 → 0.60.0

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

@@ -1,7 +1,9 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, data, dictionary, externalTypeReference, group, member, number, optional, parametrizedType, ref, sfunction,
+    array, data, dictionary, externalTypeReference, group, member, null_, number, optional, parametrizedType, ref, sfunction,
+    string,
+    taggedUnion,
     type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -16,37 +18,104 @@ export const $: g_glossary.D.Glossary = {
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
-            "ArrayOfArrays": parametrizedType({ "Type": null }, array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+            //out
+            "Array": parametrizedType(
+                { "Type": null },
+                array(ref(typeParameter("Type")))
+            ),
 
-            "AppendParameters": parametrizedType({ "Type": null }, group({
-                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                "element": member(ref(typeParameter("Type"))),
-            })),
-            "PrependParameters": parametrizedType({ "Type": null }, group({
-                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                "element": member(ref(typeParameter("Type"))),
-            })),
-            "ArrayTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
-                "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
-                "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+            "ZippedArray": parametrizedType(
+                { "Benchmark": null, "Focus": null },
+                array(group({
+                    "benchmark": member(ref(typeParameter("Benchmark"))),
+                    "focus": member(ref(typeParameter("Focus"))),
+                }))
+            ),
+
+            //in
+            "ArrayOfArrays": parametrizedType(
+                { "Type": null },
+                array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+
+            "AppendParameters": parametrizedType(
+                { "Type": null },
+                group({
+                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                    "element": member(ref(typeParameter("Type"))),
+                })
+            ),
+            "PrependParameters": parametrizedType(
+                { "Type": null },
+                group({
+                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                    "element": member(ref(typeParameter("Type"))),
+                })
+            ),
+            "ArrayTuple": parametrizedType(
+                { "Benchmark": null, "Focus": null },
+                group({
+                    "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                    "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+                })
+            ),
+            "Nested": parametrizedType({ "Type": null }, taggedUnion({
+                "single": ref(typeParameter("Type")),
+                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
+                "none": null_(),
             })),
-            "ZippedArray": parametrizedType({ "Benchmark": null, "Focus": null }, array(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(ref(typeParameter("Focus"))),
+            // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+            // "KeyValuePair": parametrizedType({ "Type": null }, group({
+            //     "key": member(string()),
+            //     "value": member(ref(typeParameter("Type"))),
+            // })),
+
+            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
+                "value": member(ref(typeParameter("Type"))),
+                "dependencies": member(dictionary(null_())),
             }))),
 
+
+            "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Append": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("AppendParameters", { "Type": typeParameter("Type") })), { "Type": null }),
-        "Prepend": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("PrependParameters", { "Type": typeParameter("Type") })), { "Type": null }),
-        "FlattenArrayOfArrays": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })), { "Type": null }),
+        "Append": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("AppendParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "Prepend": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("PrependParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "FlattenArrayOfArrays": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })),
+            { "Type": null },
+        ),
+        "FlattenTree": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("Nested", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
         "Zip": sfunction(
             typeReference("ZippedArray", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
             data(typeReference("ArrayTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
             { "Benchmark": null, "Focus": null }
         ),
+
+
+        "SortTopologically": sfunction(
+            typeReference("KeyValuePairArray", { "Type": typeParameter("Type") }),
+            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
     }),
 }

package/auto.pareto/auto.dependencies/{pareto-standard-library/modules/build → pareto-pure/auto.dependencies/pareto-standard-library/modules/buildInterfaceInitializers}/api.data.ts

@@ -18,7 +18,6 @@ export const $: g_project.D.API = api(
         "createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", "DictionaryBuildStrategy", {}),
         "createArrayBuilder": algorithm("CreateArrayBuilder", null, {}),
 
-
         "createStringBuilder": algorithm("CreateStringBuilder", "Startstring", {
         }),
     }

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

@@ -0,0 +1,167 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, dictionary, ref, typeParameter, group, sInf, member,
+    sfunction,
+    sInterfaceMethod, sInterfaceReference, streamconsumer, string, taggedUnion, type, typeReference, aInterface, sInterface, parametrizedType,
+    infInit
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+
+            "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "Simple String": type(string()),
+
+            "Array": parametrizedType({ "Type": null, "EndType": null }, group({
+                "array": member(array(ref(typeParameter("Type")))),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
+                "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "String": parametrizedType({ "EndType": null }, group({
+                "string": member(string()),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+
+            "DictionaryBuildStrategy": type(taggedUnion({
+                "ignore": group({}),
+                "overwrite": group({}),
+            })),
+            "Startstring": type(string()),
+        }),
+    },
+    'interface types': d({
+        "Array": aInterface(
+            aInterfaceMethod(typeReference("Array", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType")
+            })),
+            { "Type": null, "EndType": null }
+        ),
+        "Dictionary": aInterface(
+            aInterfaceMethod(typeReference("Dictionary", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType")
+            })),
+            { "Type": null, "EndType": null }
+        ),
+        "Elements": aInterface(
+            streamconsumer(
+                aInterfaceMethod(typeParameter("Type")),
+                aInterfaceMethod(typeParameter("EndType")),
+            ),
+            { "Type": null, "EndType": null }
+        ),
+        "Entries": aInterface(
+            streamconsumer(
+                aInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })),
+                aInterfaceMethod(typeParameter("EndType")),
+            ),
+            { "Type": null, "EndType": null }
+        ),
+        "DuplicatesHandler": aInterface(
+            streamconsumer(
+                aInterfaceMethod(typeReference("Simple String")),
+                aInterfaceMethod(null),
+            )
+        ),
+        "StringConsumer": aInterface(
+            aInterfaceMethod(typeReference("String", { "EndType": typeParameter("EndType") })),
+            { "EndType": null }
+        ),
+        "StringStreamConsumer": aInterface(
+            streamconsumer(
+                aInterfaceMethod(typeReference("Simple String")),
+                aInterfaceMethod(typeParameter("EndType")),
+            ),
+            { "EndType": null }
+        ),
+        "Add": sInterface(
+            sInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "Push": sInterface(
+            sInterfaceMethod(typeParameter("Type")),
+            { "Type": null }
+        ),
+    }),
+    'algorithm types': d({
+        "CreateArrayBuilder": infInit(
+            aInterfaceReference("Elements", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType"),
+            }),
+            {
+                "handler": aInterfaceReference("Array", {
+                    "Type": typeParameter("Type"),
+                    "EndType": typeParameter("EndType"),
+                }),
+            },
+            { "Type": null, "EndType": null }
+        ),
+        "CreateUnsafeDictionaryBuilder": infInit(
+            aInterfaceReference("Entries", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType"),
+            }),
+            {
+                "handler": aInterfaceReference("Dictionary", {
+                    "Type": typeParameter("Type"),
+                    "EndType": typeParameter("EndType")
+                }),
+            },
+            { "Type": null, "EndType": null }
+        ),
+        "CreateSafeDictionaryBuilder": infInit(
+            aInterfaceReference("Entries", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType"),
+            }),
+            {
+                "handler": aInterfaceReference("Dictionary", {
+                    "Type": typeParameter("Type"),
+                    "EndType": typeParameter("EndType")
+                }),
+                "duplicatesHandler": aInterfaceReference("DuplicatesHandler"),
+
+            },
+            { "Type": null, "EndType": null }
+        ),
+        "CreateStringBuilder": infInit(
+            aInterfaceReference("StringStreamConsumer", { "EndType": typeParameter("EndType") }),
+            {
+                "handler": aInterfaceReference("StringConsumer", { "EndType": typeParameter("EndType") }),
+            },
+            { "EndType": null }
+        ),
+        // "BuildArray": sfunction(typeReference("Simple Array", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Push", { "Type": typeParameter("Type") })), { "Type": null }),
+        // "BuildUnsafeDictionary": sfunction(typeReference("Simple Dictionary", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Add", { "Type": typeParameter("Type") })), { "Type": null }),
+        // "BuildSafeDictionary": sfunction(typeReference("Simple Dictionary", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Add", { "Type": typeParameter("Type") })), { "Type": null }),
+
+    }),
+
+}

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

@@ -64,7 +64,6 @@ export const $: g_glossary.D.Glossary = {
             })),
             "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
-
             "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
         }),
@@ -111,8 +110,11 @@ export const $: g_glossary.D.Glossary = {
             typeReference("Dictionary", { "Type": typeParameter("Type") }),
             data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
             { "Type": null }
-        ),       
-         "DecorateDictionaryEntriesWithKey": sfunction(typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }), data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }),
+        ),
+        "DecorateDictionaryEntriesWithKey": sfunction(
+            typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }
+        ),
 
     }),
 

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

@@ -10,6 +10,5 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = api(
     glos,
     {
-        "flatten": algorithm("Flatten", null, {})
     }
 )

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

@@ -14,16 +14,10 @@ export const $: g_glossary.D.Glossary = {
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "Nested": parametrizedType({ "Type": null }, taggedUnion({
-                "single": ref(typeParameter("Type")),
-                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type")}))),
-                "none": null_(),
-            })),
             "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Flatten": sfunction(typeReference("Array", { "Type": typeParameter("Type")}), data(typeReference("Nested", { "Type": typeParameter("Type")})), { "Type": null })
     }),
 }

package/auto.pareto/auto.dependencies/{pareto-standard-library/modules/arithmetic → pareto-pure/auto.dependencies/pareto-standard-library/modules/number}/api.data.ts

@@ -10,9 +10,11 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = api(
     glos,
     {
-        "divideWithRemainder": algorithm("DivideWithRemainder", null, {}),
+        "add": algorithm("Add", null, {}),
         "increment": algorithm("Increment", "IncrementConfig", {}),
+        "min": algorithm("Min", null, {}),
         "max": algorithm("Max", null, {}),
+        "multiply": algorithm("Multiply", null, {}),
         "negate": algorithm("Negate", null, {}),
         "subtract": algorithm("Subtract", null, {}),
     }

package/auto.pareto/auto.dependencies/{pareto-standard-library/modules/arithmetic → pareto-pure/auto.dependencies/pareto-standard-library/modules/number}/glossary.data.ts

@@ -19,19 +19,10 @@ export const $: g_glossary.D.Glossary = {
             "Number": type(number()),
             "OptionalNumber": type(optional(number())),
             "NumberRange": type(array(number())),
-            "DivisionData": type(group({
-                "numerator": member(number()),
-                "denominator": member(number()),
-            })),
             "NumberTuple": type(group({
                 "yin": member(number()),
                 "yang": member(number()),
             })),
-            "DivisionResult": type(optional(group({
-                "quotient": member(number()),
-                "remainder": member(number()),
-
-            }))),
             "SubtractData": type(group({
                 "minuend": member(number()),
                 "subtrahend": member(number()),
@@ -46,30 +37,33 @@ export const $: g_glossary.D.Glossary = {
     },
     'interface types': d({}),
     'algorithm types': d({
+        "Add": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
+        "Multiply": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
         "Increment": sfunction(typeReference("Number"), data(typeReference("Number"))),
-        "Array Multiply": sfunction(typeReference("Number"), data(typeReference("NumberRange"))),
+        // "Array Multiply": sfunction(typeReference("Number"), data(typeReference("NumberRange"))),
         "Negate": sfunction(typeReference("Number"), data(typeReference("Number"))),
         /**
-        * if the denominator is 0, the return value is null
+        * if the denominator is 0, the return value is not set
         * (division by 0),
         */
-        "DivideWithRemainder": sfunction(typeReference("DivisionResult"), data(typeReference("DivisionData"))),
+     
         /**
          * calculates the max of an array of numbers. If there are no entries, the result value is 0
          */
-        "ArrayMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
-        "ArrayMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
-        "ArraySum": sfunction(typeReference("Number"), data(typeReference("NumberArray"))),
+        // "ArrayMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
+        // "ArrayMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
+        // "ArraySum": sfunction(typeReference("Number"), data(typeReference("NumberArray"))),
         /**
          * calculates the max of a dictionary of number. If there are no entries, the result value is 0
          */
-        "DictionaryMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
-        "DictionaryMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
+        // "DictionaryMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
+        // "DictionaryMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
         /**
         * calculates the max of a tuple of numbers
         */
         "DictionarySum": sfunction(typeReference("Number"), data(typeReference("NumberDictionary"))),
 
+        "Min": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
         "Max": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
         "Subtract": sfunction(typeReference("Number"), data(typeReference("SubtractData"))),
     }),

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

@@ -0,0 +1,16 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "divide": algorithm("Divide", null, {}),
+        "divisionRemainder": algorithm("DivisionRemainder", null, {}),
+    }
+)

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

@@ -0,0 +1,36 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
+    type, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "OptionalNumber": type(optional(number())),
+            "DivisionData": type(group({
+                "numerator": member(number()),
+                "denominator": member(number()),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        /**
+        * if the denominator is 0, the return value is not set
+        * (division by 0),
+        */
+        "Divide": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
+        "DivisionRemainder": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
+    }),
+     
+}

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

@@ -10,6 +10,5 @@ import { glossary, group, member, number, sInterface, sInterfaceMethod, string,
 export const $: g_project.D.API = api(
     glos,
     {
-        "unsafeSortTopologically": algorithm("SortTopologically", null, {}),
     }
 )

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

@@ -29,24 +29,10 @@ export const $: g_glossary.D.Glossary = {
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
 
-            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                "value": member(ref(typeParameter("Type"))),
-                "dependencies": member(dictionary(null_())),
-            }))),
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "SortTopologically": sfunction(
-            typeReference("Array", { "Type": typeParameter("Type") }),
-            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
     }),
 }

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

@@ -12,6 +12,14 @@ export const $: g_project.D.API = api(
     {
         "join": algorithm("Join", null, {}),
         "repeat": algorithm("Repeat", null, {}),
-        "foo": algorithm("Foo", null, {}),
+
+
+        "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
+        "getLengthAsString": algorithm("GetLengthAsString", null, {}),
+        
+        //this one implicitely sorts the keys
+        //"getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
+
+        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
     }
 )

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

@@ -4,7 +4,7 @@ import {
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, boolean, data, group, member, number, optional, sfunction, streamconsumer, string, type, typeReference
+    array, boolean, data, dictionary, group, member, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
@@ -27,6 +27,19 @@ export const $: g_glossary.D.Glossary = {
                 "contextString": member(string()),
                 "times": member(number()),
             })),
+
+            "StringArray": type(array(string())),
+
+            "Configuration": type(group({
+                "separator": member(string()),
+                "maximum": member(optional(group({
+                    "maximum": member(number()),
+                    "suffix": member(string()),
+                }))),
+            })),
+            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+
         }),
     },
     'interface types': d({}),
@@ -35,5 +48,10 @@ export const $: g_glossary.D.Glossary = {
         "Join": sfunction(typeReference("String"), data(typeReference("JoinData"))),
         "Repeat": sfunction(typeReference("String"), data(typeReference("RepeatData"))),
         "Foo": sfunction(typeReference("String"), data(typeReference("String"))),
+
+        "GetLengthAsString": sfunction(typeReference("String"), data(typeReference("Array", { "T": typeParameter("T") })), { "T": null }),
+        "GetArrayAsString": sfunction(typeReference("String"), data(typeReference("StringArray"))),
+        //"GetKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
+        "GetNumberOfKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null }),
     }),
 }

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

@@ -9,11 +9,6 @@ import { glossary, member, type, group, string, optional, number } from "pareto-
 export const $: g_project.D.API = api(
     glos,
     {
-        "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
-        "getLengthAsString": algorithm("GetLengthAsString", null, {}),
-        "getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
-
-        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
 
     }
 )

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

@@ -19,24 +19,10 @@ export const $: g_glossary.D.Glossary = {
         'data types': d({
             "String": type(string()),
             "Array": parametrizedType({ "T": null }, array(ref(typeParameter("T")))),
-            "StringArray": type(array(string())),
             "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
-
-
-            "Configuration": type(group({
-                "separator": member(string()),
-                "maximum": member(optional(group({
-                    "maximum": member(number()),
-                    "suffix": member(string()),
-                }))),
-            })),
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "GetLengthAsString": sfunction(typeReference("String"), data(typeReference("Array", { "T": typeParameter("T") })), { "T": null}),
-        "GetArrayAsString": sfunction(typeReference("String"), data(typeReference("StringArray"))),
-        "GetKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
-        "GetNumberOfKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
     }),
 }