pareto 0.56.0 → 0.57.0

package/auto.pareto/{modules → auto.dependencies/pareto-pure/modules}/cosmos2pareto/glossary.data.ts

@@ -1,7 +1,7 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
 } from "pareto/auto.dist/public/shorthands/cosmos"
 
 import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
@@ -14,16 +14,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "pareto": {
-            'glossary': d_pareto,
-            'type arguments': d({
-            }),
-        },
-        "cosmos": {
-            'glossary': d_cosmos,
-            'type arguments': d({
-            }),
-        },
+        "pareto": imp(d_pareto, {}),
+        "cosmos": imp(d_cosmos, {}),
     }),
     'root': {
         'namespaces': d({}),

package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen/api.data.ts

@@ -0,0 +1,19 @@
+
+
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "indent": algorithm("Indent", null, {}),
+        "serialize": algorithm("Serialize", null, {}),
+        "stream": algorithm("Stream", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen/glossary.data.ts

@@ -0,0 +1,55 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Block": type(array(taggedUnion({
+                "nested line": ref(typeReference("Line")),
+                "line": string(),
+            }))),
+            "Line": type(array(taggedUnion({
+                "snippet": string(),
+                "indent": ref(typeReference("Block"))
+            }))),
+            "Lines": type(array(group({
+                "indentation": member(number()),
+                "text": member(string()),
+            }))),
+            "Indented Lines": type(array(string())),
+            "SerializeData": type(group({
+                "block": member(ref(typeReference("Block"))),
+                "indentation": member(string()),
+            })),
+            "IndentData": type(group({
+                "lines": member(ref(typeReference("Lines"))),
+                "indentation": member(string()),
+            })),
+            "String": type(string()),
+        }),
+    },
+    'interface types': d({
+        "Lines": aInterface(aInterfaceMethod(typeReference("Lines"))),
+        "Indented Lines": aInterface(streamconsumer(aInterfaceMethod(typeReference("String")), null)),
+    }),
+    'algorithm types': d({
+        "Indent": sfunction(typeReference("Indented Lines"), data(typeReference("IndentData"))),
+        "Serialize": sfunction(typeReference("Lines"), data(typeReference("Block"))),
+        "Stream": infInit(aInterfaceReference("Lines"), {
+            "handler": aInterfaceReference("Indented Lines")
+        }),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/liana2tendril/api.data.ts

@@ -0,0 +1,24 @@
+
+
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        // "map": algorithm("Map", null, {
+        //     // "resolveDictionary": sfunction("resolve", {}, "SafeResolveDictionary"),
+        //     // // "decorateDictionaryEntriesWithKey": sfunction("foreach", {}, "DecorateDictionaryEntriesWithKey"),
+        //     // // "buildDictionary": sfunction("build", {}, "BuildUnsafeDictionary"),
+        //     // // "filter": sfunction("dictionary", {}, "Filter"),
+        //     // // "isEmpty": sfunction("dictionary", {}, "IsEmpty"),
+        //     // // "merge": sfunction("array", {}, "Merge"),
+        //     // // "push": sfunction("array", {}, "Push"),
+        // }),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/liana2tendril/glossary.data.ts

@@ -0,0 +1,48 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, number, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as d_liana } from "../../glossaries/auto.liana.data"
+import { $ as d_tendril } from "../../glossaries/auto.tendril.data"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "liana": {
+            'glossary': d_liana,
+            'type arguments': d({
+            }),
+        },
+        "tendril": {
+            'glossary': d_tendril,
+            'type arguments': d({
+            }),
+        },
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "TypeScript Location": type(group({
+                "file": member(string()),
+                "line": member(number()),
+                "column": member(number()),
+            }))
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(
+            //FIXME this function should reference to the libraries that don't have annotations.
+            //this function is designed not to be able to produce runtime errors, so no error info is needed
+            //However, the functionality to produce a resolved, annotationless library need to be written
+            externalTypeReference("tendril", "Type Library", { "Annotation": typeReference("TypeScript Location") }),
+            data(externalTypeReference("liana", "Type Library", { "Annotation": typeReference("TypeScript Location") }))
+        ),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril2cosmos_type_system/api.data.ts

@@ -0,0 +1,16 @@
+
+
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "map": algorithm("Map", null, {})
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril2cosmos_type_system/glossary.data.ts

@@ -0,0 +1,73 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import { $ as d_cosmos } from "../../glossaries/auto.cosmos_type_system.data"
+import { $ as d_tendril } from "../../glossaries/auto.tendril_resolved.data"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "cosmos": imp(d_cosmos, {}),
+        "tendril": imp(d_tendril, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "MapData": type(group({
+                "mapped library": member(ref(typeReference("Mapped Library"))),
+                "settings": member(ref(typeReference("Mapping Settings"))),
+            })),
+            "Mapped Library": type(group({
+                "library": member(ref(externalTypeReference("tendril", "Type Library", {}))),
+                "terminal mapping": member(ref(typeReference("Terminal Mapping"))),
+            })),
+
+            "Terminal Mapping": type(dictionary(taggedUnion({
+                "boolean": null_(),
+                "number": null_(),
+                "string": null_(),
+            }))),
+            "Mapping Settings": type(group({
+                "annotations": member(boolean()),
+                "datamodel": member(optional(group({
+                    "constraints mapping": member(group({
+                        "terminal values": member(boolean()),
+                        "constraints": member(optional(taggedUnion({
+                            "optional": group({}),
+                            "required": group({}),
+                        }))),
+                    })),
+                }))),
+                // "visitor interface": member(optional(group({
+                //     "datamodel": member(taggedUnion({
+                //         "internal": group({}),
+                //         "exernal": group({
+                //             "location": member(string()),
+                //         }),
+                //     })),
+                // }))),
+                // "algorithms": member(group({
+                //     "serialize": member(optional(group({
+                //         //data location,
+                //     }))),
+                //     //resolve
+                // })),
+            })),
+        }),
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("cosmos", "Glossary", {}), data(typeReference("MapData"))),
+
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril2pareto/api.data.ts

@@ -0,0 +1,16 @@
+
+
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "createResolver": algorithm("CreateResolver", null, {})
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril2pareto/glossary.data.ts

@@ -0,0 +1,33 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
+import { $ as d_tendril } from "../../glossaries/auto.tendril_resolved.data"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "pareto": imp(d_pareto, {}),
+        "tendril": imp(d_tendril, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+
+        }),
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+        "CreateResolver": sfunction(externalTypeReference("pareto", "Compilation Unit", {}), data(externalTypeReference("tendril", "Type Library", {}))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/testresult/api.data.ts

@@ -0,0 +1,26 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+
+import { $ as d_glos } from "./glossary.data"
+
+
+export const $: g_project.D.API = api(
+    d_glos,
+    {
+        "annotateTestResult": algorithm("Annotate TestResult", null, {}),
+        "serializeSummary": algorithm("Serialize Summary", null, {
+            // "add": libDep("pareto-standard-impure-library", "arithmetic", "Add", {}),
+            // "isZero": libDep("pareto-standard-impure-library", "numerical__predicates", "IsZero", {}),
+            // "negate": libDep("pareto-standard-impure-library", "arithmetic", "Negate", {}),
+        }),
+        "serializeTestResult": algorithm("Serialize TestResult", null, {
+            // "dictionaryForEach": libDep("pareto-standard-impure-library", "foreach", "DictionaryForEach", {}),
+        }),
+        "summarize": algorithm("Summarize", null, {}),
+
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/testresult/glossary.data.ts

@@ -0,0 +1,144 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, number, optional, parametrizedType, procedure, ref, sfunction, sInterface, sInterfaceMethod, sInterfaceReference, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({
+            "intermediate": {
+                'namespaces': d({
+
+                }),
+                'data types': d({}),
+            },
+            "summary": {
+                'namespaces': d({
+
+                }),
+                'data types': d({}),
+            },
+        }),
+        'data types': d({
+            "Library": type(group({
+                "public": member(ref(typeReference("Module Set"))),
+                "private": member(ref(typeReference("Module Set"))),
+            })),
+            "Module Set": type(dictionary(ref(typeReference("Module")))),
+            "Module": type(dictionary(ref(typeReference("Algorithm")))),
+            "Algorithm": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "tests": member(optional(dictionary(ref(typeReference("Test"))))),
+            })),
+            "Source Location": type(group({
+                "file": member(string()),
+                "line": member(number()),
+                "column": member(number()),
+            })),
+            "Test": type(array(ref(typeReference("Error")))),
+            "Error": type(taggedUnion({
+                "content": ref(typeReference("Compare Error"))
+            })),
+            "Compare Error": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "path": member(string()),
+                "type": member(taggedUnion({
+                    "wrong number": group({
+                        "found": member(number()),
+                    }),
+                    "wrong text": group({
+                        "found": member(string()),
+                    }),
+                    "wrong boolean": group({
+                        "found": member(boolean())
+                    }),
+                    "optional value expected not to be set": null_(),
+                    "optional value expected to be set": null_(),
+                    "not the right state": group({
+                        "found": member(string())
+                    }),
+                    "not enough elements": null_(),
+                    "too many elements": null_(),
+                    "superfluous entries": group({
+                        "keys": member(dictionary(null_()))
+                    }),
+                    "missing dictionary entry": group({
+                        "key": member(string()),
+                    }),
+                })),
+
+            })),
+            "Summary": type(group({
+                "number of tests": member(number()),
+                "number of missing tests": member(number()),
+                "number of errors": member(number()),
+            })),
+
+            "String": type(string()),
+
+            "intLibrary": type(group({
+                "public": member(ref(typeReference("intModule Set"))),
+                "private": member(ref(typeReference("intModule Set"))),
+            })),
+            "intModule Set": type(dictionary(ref(typeReference("intModule")))),
+            "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
+            "intAlgorithm": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "status": member(taggedUnion({
+                    "no tests": null_(),
+                    "skipped": null_(),
+                    "has tests": dictionary(ref(typeReference("intTest"))),
+                })),
+            })),
+            "intTest": type(taggedUnion({
+                "has errors": array(ref(typeReference("Error"))),
+                "has no errors": null_(),
+            })),
+            "annotatedStatus": type(taggedUnion({
+                "has errors": null_(),  // red
+                "missing tests": null_(), // yellow
+                "no tests": null_(), // grey
+                "success": null_(), // green
+            })),
+            "annotatedLibrary": type(group({
+                "public": member(ref(typeReference("annotatedModule Set"))),
+                "private": member(ref(typeReference("annotatedModule Set"))),
+            })),
+            "annotatedModule Set": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "modules": member(dictionary(ref(typeReference("annotatedModule")))),
+            })),
+            "annotatedModule": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
+            })),
+            "annotatedAlgorithm": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "tests": member(dictionary(ref(typeReference("annotatedTest")))),
+            })),
+            "annotatedTest": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "errors": member(array(ref(typeReference("Error")))),
+            })),
+        }),
+    },
+    'interface types': d({
+        "Stringstream": sInterface(sInterfaceMethod(typeReference("String"))),
+
+    }),
+    'algorithm types': d({
+        "Annotate TestResult": sfunction(typeReference("annotatedLibrary"), data(typeReference("intLibrary"))),
+        "Summarize": sfunction(typeReference("Summary"), data(typeReference("intLibrary"))),
+        "Serialize Summary": procedure(data(typeReference("Summary")), sInterfaceReference("Stringstream")),
+        "Serialize TestResult": procedure(data(typeReference("annotatedLibrary")), sInterfaceReference("Stringstream")),
+    }),
+}

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

@@ -0,0 +1,46 @@
+import * as pd from 'pareto-core-data'
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+import { } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import { $ as d_arithmetic } from "./modules/arithmetic/api.data"
+import { $ as d_array } from "./modules/array/api.data"
+import { $ as d_boolean } from "./modules/boolean/api.data"
+import { $ as d_build } from "./modules/build/api.data"
+import { $ as d_dictionary } from "./modules/dictionary/api.data"
+import { $ as d_json } from "./modules/json/api.data"
+import { $ as d_nested } from "./modules/nested/api.data"
+import { $ as d_resolve } from "./modules/resolve/api.data"
+import { $ as d_string } from "./modules/string/api.data"
+import { $ as d_tostring } from "./modules/tostring/api.data"
+
+export const $: g_project.D.Library = {
+    'author': "Corno",
+    'description': "A library that contains very common functionality that cannot be implemented purely in Pareto",
+    'license': "TBD",
+
+    'type': ['impure', null],
+    'module sets': {
+        'public': {
+            'glossaries': d({}),
+            'modules': d({
+                "arithmetic": d_arithmetic,
+                "array": d_array,
+                "boolean": d_boolean,
+                "build": d_build,
+                "dictionary": d_dictionary,
+                "json": d_json,
+                "nested": d_nested,
+                "resolve": d_resolve,
+                "string": d_string,
+                "tostring": d_tostring,
+            })
+        },
+        'private': {
+            'glossaries': d({}),
+            'modules': d({}),
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "divideWithRemainder": algorithm("DivideWithRemainder", null, {}),
+        "increment": algorithm("Increment", "IncrementConfig", {}),
+        "max": algorithm("Max", null, {}),
+        "negate": algorithm("Negate", null, {}),
+        "subtract": algorithm("Subtract", null, {}),
+    }
+)

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

@@ -0,0 +1,76 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
+    type, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+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())),
+            "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()),
+            })),
+            "NumberDictionary": type(dictionary(number())),
+            "NumberArray": type(array(number())),
+
+            "IncrementConfig": type(group({
+                "stepsize": member(number())
+            }))
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Increment": sfunction(typeReference("Number"), data(typeReference("Number"))),
+        "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
+        * (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"))),
+        /**
+         * 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"))),
+        /**
+        * calculates the max of a tuple of numbers
+        */
+        "DictionarySum": sfunction(typeReference("Number"), data(typeReference("NumberDictionary"))),
+
+        "Max": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
+        "Subtract": sfunction(typeReference("Number"), data(typeReference("SubtractData"))),
+    }),
+}

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

@@ -0,0 +1,19 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", null, {}),
+        "append": algorithm("Append", null, {}),
+        "prepend": algorithm("Prepend", null, {}),
+        "zip": algorithm("Zip", null, {}),
+
+    }
+)