pareto 0.75.2 → 0.76.2

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

@@ -1,84 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Number": type(integer()),
-                "OptionalNumber": type(optional(integer())),
-                "NumberRange": type(list(integer())),
-                "NumberTuple": type(group({
-                    "yin": prop(integer()),
-                    "yang": prop(integer()),
-                })),
-                "SubtractData": type(group({
-                    "minuend": prop(integer()),
-                    "subtrahend": prop(integer()),
-                })),
-                "NumberDictionary": type(dictionary(integer())),
-                "NumberArray": type(list(integer())),
-            }),
-        },
-    },
-    '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"))),
-        "Negate": sfunction(typeReference("Number"), data(typeReference("Number"))),
-        /**
-        * 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
-         */
-        // "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"))),
-
-        "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-standard-library/modules/optional/api.data.ts

@@ -1,19 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "divide": algorithm([
-            `divide the numerator by the denominator (numerator / denominator = result)`,
-        ], "Divide", {}),
-        "divisionRemainder": algorithm([
-            `return the remainder of the division of the numerator by the denominator`,
-        ], "DivisionRemainder", {}),
-    }
-)

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

@@ -1,53 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "OptionalNumber": type(optional(integer())),
-                "DivisionData": type(group({
-                    "numerator": prop(integer()),
-                    "denominator": prop(integer()),
-                })),
-            }),
-        },
-    },
-    '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-standard-library/modules/resolve/api.data.ts

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

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

@@ -1,42 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    '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-standard-library/modules/string/api.data.ts

@@ -1,42 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "join 2 strings": algorithm([
-            `join 2 strings together`,
-            `a separator cannot be specified, the strings are simply concatenated`,
-            `if you need a separator, use this function twice, with the separator as the second string`,
-        ], "Join 2 Strings", {}),
-        "join array of strings": algorithm([
-            `join an array of strings together`,
-            `a separator can be specified`,
-        ], "Join Array Of Strings", {}),
-        "repeat": algorithm([
-            `repeat a string the specified number of times`,
-            `so 3 times 'foo' would be 'foofoofoo'`,
-        ], "Repeat", {}),
-
-        "getArrayAsString": algorithm([
-            `join an array of strings together`,
-            `a separator can be specified`,
-            `a maximum number of elements to join can be specified`,
-            `if the maximum number of elements is reached, a suffix string (for example '...') is appended to the result`,
-        ], "GetArrayAsString", {}),
-
-        "getLengthAsString": algorithm([
-            `return the length of a string as a string`,
-            `useful for reporting, logging, etc.`,
-        ], "GetLengthAsString", {}),
-        "getSizeAsString": algorithm([
-            `return the number of keys in an object as a string`,
-            `useful for reporting, logging, etc.`,
-        ], "GetSizeAsString", {}),
-    }
-)

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

@@ -1,107 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "String": type(text()),
-                "Join 2 Strings": type(group({
-                    "first": prop(text()),
-                    "second": prop(text()),
-                })),
-                "Join Array Of Strings": parametrizedType(
-                    { "Type": null },
-                    group({
-                        "array": prop(list(component(typeParameter("Type")))),
-                        "separator": prop(text()),
-                    })
-                ),
-
-                "RepeatData": type(group({
-                    "contextString": prop(text()),
-                    "times": prop(integer()),
-                })),
-
-                "StringArray": type(list(text())),
-                "GetArrayAsString": type(group({
-                    "array": prop(component(typeReference("StringArray"))),
-                    "configuration": prop(component(typeReference("Configuration"))),
-                })),
-
-                "Configuration": type(group({
-                    "separator": prop(text()),
-                    "maximum": prop(optional(group({
-                        "maximum": prop(integer()),
-                        "suffix": prop(text()),
-                    }))),
-                })),
-                "Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
-                "Array": parametrizedType({ "Type": null }, list(component(typeParameter("Type")))),
-
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "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("GetArrayAsString"))),
-        "GetKeysAsString": sfunction(
-            typeReference("String"),
-            data(typeReference("Dictionary", { "T": typeParameter("T") })),
-            { "T": null }
-        ),
-        "GetSizeAsString": sfunction(
-            typeReference("String"),
-            data(typeReference("Dictionary", { "T": typeParameter("T") })),
-            { "T": null }
-        ),
-    }),
-}

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

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

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

@@ -1,44 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "String": type(text()),
-                "Array": parametrizedType({ "T": null }, list(component(typeParameter("T")))),
-                "Dictionary": parametrizedType({ "T": null }, dictionary(component(typeParameter("T")))),
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-    }),
-}

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

@@ -1,46 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-import { } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import { $ as d_array } from "./modules/array/api.data"
-import { $ as d_dictionary } from "./modules/dictionary/api.data"
-import { $ as d_filesystem } from "./modules/filesystem/api.data"
-import { $ as d_json } from "./modules/json/api.data"
-import { $ as d_numerical_predicates } from "./modules/numerical_predicates/api.data"
-import { $ as d_string } from "./modules/string/api.data"
-
-export const $: g_project.D.Library = {
-    'author': "Corno",
-    'description': "A library that contains common functionality that requires inspection of built in types, like the length of an array, patterns in a string, splitting strings, keys in dictionaries, etc.",
-    'license': "TBD",
-
-    'type': ['primitive', null],
-    'module sets': {
-        'public': {
-            'glossaries': d({}),
-            'transformations': {
-                'enrich': d({}),
-                'yield': d({}),
-            },
-            'modules': d({
-                "array": d_array,
-                "dictionary": d_dictionary,
-                "filesystem": d_filesystem,
-                "json": d_json,
-                "numerical predicates": d_numerical_predicates,
-                "string": d_string,
-            })
-        },
-        'private': {
-            'glossaries': d({}),
-            'transformations': {
-                'enrich': d({}),
-                'yield': d({}),
-            },
-            'modules': d({}),
-        }
-    }
-}

package/auto.pareto/auto.dependencies/pareto-subatomic-library/glossaries/lines.data.ts

@@ -1,24 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-    list, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, prop,
-     parametrizedType, sfunction, streamconsumer, text, type, typeParameter, typeReference
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Data__Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Lines": type(list(text())),
-        }),
-    },
-}

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

@@ -1,44 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "enrichWithPositionInformation": algorithm([
-            `enrich all the elements in the array with their position in the array`
-        ], "EnrichWithPositionInformation", {}),
-        "getPossibleLastElement": algorithm([
-            `get the last element of the array as an optional value`
-        ], "GetPossibleLastElement", {}),
-        "getPossibleFirstElement": algorithm([
-            `get the first element of the array as an optional value`
-        ], "GetPossibleFirstElement", {}),
-        "getPossibleElementAt": algorithm([
-            `get the element at the specified index as an optional value`
-        ], "GetPossibleElementAt", {}),
-        "isEmpty": algorithm([
-            `is the array empty`
-        ], "IsEmpty", {}),
-        "unsafeGetLastElement": algorithm([
-            `get the last element of the array`,
-            `if the array is empty, panic`
-        ], "UnsafeGetLastElement", {}),
-        "unsafeGetFirstElement": algorithm([
-            `get the first element of the array`,
-            `if the array is empty, panic`
-        ], "UnsafeGetFirstElement", {}),
-        "unsafeGetElementAt": algorithm([
-            `get the element at the specified index`,
-            `if the index is out of bounds, panic`
-        ], "UnsafeGetElementAt", {}),
-        "getLength": algorithm([
-            `get the length of the array`
-        ], "GetLength", {}),
-    }
-)

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

@@ -1,99 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    list, boolean,
-    data, dictionary, externalTypeReference, group, prop, integer, optional, parametrizedType, component, sfunction,
-    type, typeParameter, typeReference
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Array": parametrizedType({ "Type": null }, list(component(typeParameter("Type")))),
-                "Boolean": type(boolean()),
-                "EnrichedArray": parametrizedType({ "Type": null }, list(group({
-                    "value": prop(component(typeParameter("Type"))),
-                    "isFirst": prop(boolean()),
-                    "isLast": prop(boolean()),
-                    "position": prop(integer()),
-                }))),
-                "GetElementAtData": parametrizedType({ "Type": null }, group({
-                    "array": prop(component(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "index": prop(integer()),
-                })),
-                "Length": type(integer()),
-                "OptionalValue": parametrizedType({ "Type": null }, optional(component(typeParameter("Type")))),
-                "Value": parametrizedType({ "Type": null }, component(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") })),
-            { "Type": null }
-        ),
-        "GetPossibleLastElement": sfunction(
-            typeReference("OptionalValue", { "Type": typeParameter("Type") }),
-            data(typeReference("Array", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "GetPossibleFirstElement": sfunction(
-            typeReference("OptionalValue", { "Type": typeParameter("Type") }),
-            data(typeReference("Array", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-
-        //number
-        "GetLength": sfunction(
-            typeReference("Length"),
-            data(typeReference("Array", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-
-        //other
-
-        "UnsafeGetElementAt": sfunction(
-            typeReference("Value", { "Type": typeParameter("Type") }),
-            data(typeReference("GetElementAtData", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "UnsafeGetLastElement": sfunction(
-            typeReference("Value", { "Type": typeParameter("Type") }),
-            data(typeReference("Array", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "UnsafeGetFirstElement": sfunction(
-            typeReference("Value", { "Type": typeParameter("Type") }),
-            data(typeReference("Array", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-    }),
-}

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

@@ -1,31 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-import { aInterface, aInterfaceMethod, glossary, group, prop, integer, sInterface, sInterfaceMethod, streamconsumer, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "contains": algorithm([
-            `does the dictionary contain the specified key`
-        ], "Contains", {}),
-        "getPossibleEntry": algorithm([
-            `get the entry with the specified key, if it exists`
-        ], "GetPossibleEntry", {}),
-        "isEmpty": algorithm([
-            `is the dictionary empty (no entries)`
-        ], "IsEmpty", {}),
-        "size": algorithm([
-            `returns the number of entries in the dictionary`
-        ], "Size", {}),
-
-        "unsafeGetEntry": algorithm([
-            `get the entry with the specified key, if it exists`,
-            `if the key does not exist, panic`
-        ], "UnsafeGetEntry", {}),
-    }
-)