pareto 0.60.0 → 0.62.0

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

@@ -26,47 +26,53 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "String": type(string()),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
-            "MergeParameters": parametrizedType({ "Type": null }, group({
-                "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-            })),
-            "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(optional(ref(typeParameter("Focus")))),
-            }))),
-
-            "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
-                "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
-                "focus": member(ref(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
-            })),
-            "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
-                "dictionaries": member(dictionary(ref(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
-                "separator": member(string()),
-                "escape": member(string()),// to escape if the separator appears in the key of the top level dictionary
-            })),
-            "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
-                "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
-            })),
-            "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "String": type(string()),
+                "KeyValuePair": parametrizedType({ "Type": null }, group({
+                    "key": member(string()),
+                    "value": member(ref(typeParameter("Type"))),
+                })),
+                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
+                "MergeParameters": parametrizedType({ "Type": null }, group({
+                    "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                })),
+                "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
+                    "benchmark": member(ref(typeParameter("Benchmark"))),
+                    "focus": member(optional(ref(typeParameter("Focus")))),
+                }))),
 
-            "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
+                    "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
+                    "focus": member(ref(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
+                })),
+                "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
+                    "dictionaries": member(dictionary(ref(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
+                    "separator": member(string()),
+                    "escape": member(string()),// to escape if the separator appears in the key of the top level dictionary
+                })),
+                "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
+                })),
+                "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
-        }),
+                "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "WrapKeysData": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "prefix": member(string()),
+                    "suffix": member(string()),
+                })),
+            }),
+        },
     },
     'interface types': d({
     }),
@@ -113,7 +119,13 @@ export const $: g_glossary.D.Glossary = {
         ),
         "DecorateDictionaryEntriesWithKey": sfunction(
             typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }
+            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "WrapKeys": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("WrapKeysData", { "Type": typeParameter("Type") })),
+            { "Type": null }
         ),
 
     }),

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

@@ -8,14 +8,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

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

@@ -10,30 +10,32 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Number": type(number()),
-            "OptionalNumber": type(optional(number())),
-            "NumberRange": type(array(number())),
-            "NumberTuple": type(group({
-                "yin": member(number()),
-                "yang": member(number()),
-            })),
-            "SubtractData": type(group({
-                "minuend": member(number()),
-                "subtrahend": member(number()),
-            })),
-            "NumberDictionary": type(dictionary(number())),
-            "NumberArray": type(array(number())),
-
-            "IncrementConfig": type(group({
-                "stepsize": member(number())
-            }))
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Number": type(number()),
+                "OptionalNumber": type(optional(number())),
+                "NumberRange": type(array(number())),
+                "NumberTuple": type(group({
+                    "yin": member(number()),
+                    "yang": member(number()),
+                })),
+                "SubtractData": type(group({
+                    "minuend": member(number()),
+                    "subtrahend": member(number()),
+                })),
+                "NumberDictionary": type(dictionary(number())),
+                "NumberArray": type(array(number())),
+
+                "IncrementConfig": type(group({
+                    "stepsize": member(number())
+                }))
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
@@ -46,7 +48,7 @@ export const $: g_glossary.D.Glossary = {
         * if the denominator is 0, the return value is not set
         * (division by 0),
         */
-     
+
         /**
          * calculates the max of an array of numbers. If there are no entries, the result value is 0
          */

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

@@ -10,18 +10,20 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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()),
-            })),
+    'data 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({
@@ -32,5 +34,5 @@ export const $: g_glossary.D.Glossary = {
         "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/glossary.data.ts

@@ -23,14 +23,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

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

@@ -10,11 +10,15 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = api(
     glos,
     {
-        "join": algorithm("Join", null, {}),
+        "join 2 strings": algorithm("Join 2 Strings", null, {}),
+        "join array of strings": algorithm("Join Array Of Strings", null, {}),
         "repeat": algorithm("Repeat", null, {}),
 
-
+        /**
+         * this functon joins an array of strings into a single string, using a separator, and optionally a maximum number of elements to join
+         */
         "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
+
         "getLengthAsString": algorithm("GetLengthAsString", null, {}),
         
         //this one implicitely sorts the keys

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

@@ -4,7 +4,8 @@ import {
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, boolean, data, dictionary, group, member, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, type, typeParameter, 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"
@@ -12,46 +13,78 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "JoinData": type(group({
-                "first": member(string()),
-                "second": member(string()),
-            })),
-            "RepeatData": type(group({
-                "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")))),
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+                "Join 2 Strings": type(group({
+                    "first": member(string()),
+                    "second": member(string()),
+                })),
+                "Join Array Of Strings": parametrizedType(
+                    { "Type": null },
+                    group({
+                        "array": member(array(ref(typeParameter("Type")))),
+                        "separator": member(string()),
+                    })
+                ),
+
+                "RepeatData": type(group({
+                    "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({}),
     'algorithm types': d({
-
-        "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 }),
+        "Join Array Of Strings": sfunction(
+            typeReference("String"),
+            data(typeReference("Join Array Of Strings", { "T": typeParameter("T") })),
+            { "T": null }
+        ),
+        "Join 2 Strings": sfunction(
+            typeReference("String"),
+            data(typeReference("Join 2 Strings"))
+        ),
+        "Repeat": sfunction(
+            typeReference("String"),
+            data(typeReference("RepeatData"))
+        ),
+        "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/glossary.data.ts

@@ -11,16 +11,18 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "Array": parametrizedType({ "T": null }, array(ref(typeParameter("T")))),
-            "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+                "Array": parametrizedType({ "T": null }, array(ref(typeParameter("T")))),
+                "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/astn.data.ts

@@ -14,27 +14,29 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({}),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Value": type(taggedUnion({
-                "verbose type": dictionary(ref(typeReference("Value"))),
-                "shorthand type": array(ref(typeReference("Value"))),
-                "dictionary": dictionary(ref(typeReference("Value"))),
-                "array": array(ref(typeReference("Value"))),
-                "quoted string": string(),
-                "apostrophed string": string(),
-                "backticked string": string(),
-                "raw string": string(),
-                "tagged union": group({
-                    "option": member(string()),
-                    "value": member(ref(typeReference("Value"))),
-                })
-            })),
+    'data glossary': {
+        'glossary parameters': d({
         }),
+        'imports': d({}),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Value": type(taggedUnion({
+                    "verbose type": dictionary(ref(typeReference("Value"))),
+                    "shorthand type": array(ref(typeReference("Value"))),
+                    "dictionary": dictionary(ref(typeReference("Value"))),
+                    "array": array(ref(typeReference("Value"))),
+                    "quoted string": string(),
+                    "apostrophed string": string(),
+                    "backticked string": string(),
+                    "raw string": string(),
+                    "tagged union": group({
+                        "option": member(string()),
+                        "value": member(ref(typeReference("Value"))),
+                    })
+                })),
+            }),
+        },
     },
     'interface types': d({
 

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.alan_light.data.ts

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -436,6 +437,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }