pareto 0.60.0 → 0.62.0

package/auto.pareto/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-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-subatomic-library/glossaries/lines.data.ts

@@ -11,14 +11,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({
-            "Lines": type(array(string())),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Lines": type(array(string())),
+            }),
+        },
     },
     'interface types': d({
     }),

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

@@ -11,38 +11,50 @@ 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")))),
-            "Boolean": type(boolean()),
-            "EnrichedArray": parametrizedType({ "Type": null }, array(group({
-                "value": member(ref(typeParameter("Type"))),
-                "isFirst": member(boolean()),
-                "isLast": member(boolean()),
-                "position": member(number()),
-            }))),
-            "GetElementAtData": parametrizedType({ "Type": null }, group({
-                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                "index": member(number()),
-            })),
-            "Length": type(number()),
-            "OptionalValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
-            "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
-            
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+                "Boolean": type(boolean()),
+                "EnrichedArray": parametrizedType({ "Type": null }, array(group({
+                    "value": member(ref(typeParameter("Type"))),
+                    "isFirst": member(boolean()),
+                    "isLast": member(boolean()),
+                    "position": member(number()),
+                }))),
+                "GetElementAtData": parametrizedType({ "Type": null }, group({
+                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                    "index": member(number()),
+                })),
+                "Length": type(number()),
+                "OptionalValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
+                "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
+
+
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
+        //array
         "EnrichWithPositionInformation": sfunction(
             typeReference("EnrichedArray", { "Type": typeParameter("Type") }),
             data(typeReference("Array", { "Type": typeParameter("Type") })),
             { "Type": null }
         ),
+
+        //boolean
+        "IsEmpty": sfunction(
+            typeReference("Boolean"),
+            data(typeReference("Array", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+
+        //optional
         "GetPossibleElementAt": sfunction(
             typeReference("OptionalValue", { "Type": typeParameter("Type") }),
             data(typeReference("GetElementAtData", { "Type": typeParameter("Type") })),
@@ -58,16 +70,16 @@ export const $: g_glossary.D.Glossary = {
             data(typeReference("Array", { "Type": typeParameter("Type") })),
             { "Type": null }
         ),
+
+        //number
         "GetLength": sfunction(
             typeReference("Length"),
             data(typeReference("Array", { "Type": typeParameter("Type") })),
             { "Type": null }
         ),
-        "IsEmpty": sfunction(
-            typeReference("Boolean"),
-            data(typeReference("Array", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
+
+        //other
+
         "UnsafeGetElementAt": sfunction(
             typeReference("Value", { "Type": typeParameter("Type") }),
             data(typeReference("GetElementAtData", { "Type": typeParameter("Type") })),

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

@@ -27,24 +27,26 @@ 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()),
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "DictionaryAndKey": parametrizedType({ "Type": null }, group({
-                "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                "key": member(string()),
-            })),
-            
-            "Number": type(number()),
-            "PossibleValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
-            "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "DictionaryAndKey": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                    "key": member(string()),
+                })),
+
+                "Number": type(number()),
+                "PossibleValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
+                "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
+
+            }),
+        },
     },
     'interface types': d({
     }),
@@ -66,7 +68,7 @@ export const $: g_glossary.D.Glossary = {
             { "Type": null }
         ),
 
-        "Size": sfunction(    
+        "Size": sfunction(
             typeReference("Number"),
             data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
             { "Type": null }

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/filesystem/glossary.data.ts

@@ -27,23 +27,25 @@ 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({
-        "lines": imp(d_lines, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "File Path": type(array(string())),
-            "File Write Data": type(group({
-                "directory path": member(ref(typeReference("File Path"))),
-                "file name": member(string()),
-                "data": member(ref(externalTypeReference("lines", "Lines"))),
-            })),
-            "Root Data": type(group({
-                "context directory": member(string()),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "lines": imp(d_lines, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "File Path": type(array(string())),
+                "File Write Data": type(group({
+                    "directory path": member(ref(typeReference("File Path"))),
+                    "file name": member(string()),
+                    "data": member(ref(externalTypeReference("lines", "Lines"))),
+                })),
+                "Root Data": type(group({
+                    "context directory": member(string()),
+                })),
+            }),
+        },
     },
     'interface types': d({
         "RootFileWriter": aInterface(aInterfaceMethod(typeReference("Root Data"), infref(aInterfaceReference("FileWriter")))),

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/glossary.data.ts

@@ -14,28 +14,31 @@ 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()),
-            "Result": type(taggedUnion({
-                "success": ref(typeReference("Value")),
-                "error": string(),
-            })),
-            //"Result": type(ref(glossaryParameter("Type"))),
-            "Value": type(taggedUnion({
-                "object": dictionary(ref(typeReference("Value"))),
-                "array": array(ref(typeReference("Value"))),
-                "string": string(),
-                "number": number(),
-                "boolean": boolean(),
-                "null": null_(),
-            })),
 
+    'data glossary': {
+        'glossary parameters': d({
         }),
+        'imports': d({}),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+                "Result": type(taggedUnion({
+                    "success": ref(typeReference("Value")),
+                    "error": string(),
+                })),
+                //"Result": type(ref(glossaryParameter("Type"))),
+                "Value": type(taggedUnion({
+                    "object": dictionary(ref(typeReference("Value"))),
+                    "array": array(ref(typeReference("Value"))),
+                    "string": string(),
+                    "number": number(),
+                    "boolean": boolean(),
+                    "null": null_(),
+                })),
+
+            }),
+        },
     },
     'interface types': d({
 

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/glossary.data.ts

@@ -10,24 +10,26 @@ 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()),
-            "Number": type(number()),
-            "NumberPair": type(group({
-                "yin": member(number()),
-                "yang": member(number()),
-            })),
-            "CompareData": type(group({
-                "benchmark": member(number()),
-                "focus": member(number()),
-            })),
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "Number": type(number()),
+                "NumberPair": type(group({
+                    "yin": member(number()),
+                    "yang": member(number()),
+                })),
+                "CompareData": type(group({
+                    "benchmark": member(number()),
+                    "focus": member(number()),
+                })),
+
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

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

@@ -27,9 +27,7 @@ export const $: g_project.D.API = api(
         "startsWith": algorithm("StartsWith", null, {}),
         "substring": algorithm("Substring", null, {}),
         "toCharacterArray": algorithm("ToCharacterArray", null, {}),
-        "unsafeCharCodeAt": algorithm("UnsafeCharCodeAt", null, {}),
-
-        "foobar": algorithm("Foobar", null, {}),
+        //"unsafeCharCodeAt": algorithm("UnsafeCharCodeAt", null, {}),
 
         //candidates: