pareto 0.75.1 → 0.76.1

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

@@ -1,51 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    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"
-
-import { $ as d_out } from "../../glossaries/fountain_pen_indented_file_with_escaped_strings.data"
-import { $ as d_in } from "../../glossaries/auto.pareto_4gl_type_system.temp_in_between.data"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
- 
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Transform Library 2 Block": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Library"))),
-
-    }),
-}

package/auto.pareto/auto.dependencies/pareto-pure/modules/pareto_4gl_type_system_2_pareto_3gl_high/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,
-    {
-        "transform Library 2 Compilation Unit": algorithm([
-            `transforms a Pareto 4gl Library into a Pareto 3gl high Compilation Unit`,
-        ], "Transform Library 2 Compilation Unit", {}),
-
-    }
-)

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

@@ -1,53 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    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"
-
-import { $ as d_out } from "../../glossaries/auto.pareto_3gl_high.temp_in_between.data"
-import { $ as d_in } from "../../glossaries/auto.pareto_4gl_type_system.temp_in_between.data"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Library2ParetoComparatorsData": type(group({
-                    "library": prop(component(externalTypeReference("in", "Library"))),
-                })),
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Transform Library 2 Compilation Unit": sfunction(externalTypeReference("out", "Compilation Unit"), data(typeReference("Library2ParetoComparatorsData"))),
-
-    }),
-}

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

@@ -1,17 +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,
-    {
-        "transform Data Glossary 2 Block": algorithm([], "Transform Data Glossary 2 Block", {   }), 
-
-    }
-)

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

@@ -1,50 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    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"
-
-import { $ as d_out } from "../../glossaries/typescript_intermediate.data"
-import { $ as d_in } from "../../glossaries/auto.pareto_4gl_type_system.temp_in_between.data"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
- 
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Transform Data Glossary 2 Block": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Data Glossary"))),
-    }),
-}

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

@@ -1,17 +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,
-    {
-        "transform Library 2 Directory": algorithm([], "Transform Library 2 Directory", {}),
-
-    }
-)

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

@@ -1,56 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    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"
-
-import { $ as d_out } from "../../glossaries/fountain_pen_directory.data"
-import { $ as d_in } from "../../glossaries/auto.pareto_4gl_typescript.temp_in_between.data"
-import { $ as d_cts } from "../../glossaries/auto.pareto_4gl_type_system.temp_in_between.data"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
-            "cts": imp(d_cts, {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "In": type(group({
-                    "$": prop(component(externalTypeReference("in", "Typescript Package"))),
-                    "library": prop(component(externalTypeReference("cts", "Library"))),
-                }))
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Transform Library 2 Directory": sfunction(externalTypeReference("out", "Directory"), data(typeReference("In"))),
-
-    }),
-}

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

@@ -1,18 +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,
-
-    {
-        "transform Semantic Version from Text": algorithm([
-            `transforms a text into a semantic version type`,
-        ], "Transform Semantic Version from Text", {}),
-
-    }
-)

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

@@ -1,49 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    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"
-
-import { $ as d_in } from "../../glossaries/text.data"
-import { $ as d_out } from "../../glossaries/auto.semantic_versioning.temp_in_between.data"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
-        }),
-        'glossary parameters': d({}),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Transform Semantic Version from Text": sfunction(externalTypeReference("out", "Semantic Version"), data(externalTypeReference("in", "Text"))),
-    }),
-}

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

@@ -1,24 +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 d_glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    d_glos,
-    {
-        "annotateTestResult": algorithm([], "Annotate TestResult", {}),
-        "serializeSummary": algorithm([], "Serialize Summary", {
-            // "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", {
-            // "dictionaryForEach": libDep("pareto-standard-impure-library", "foreach", "DictionaryForEach", {}),
-        }),
-        "summarize": algorithm([], "Summarize", {}),
-
-    }
-)

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

@@ -1,169 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-
-    procedure,
-    sInterface,
-    sInterfaceMethod,
-    sInterfaceReference,
-} 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({
-                "intermediate": {
-                    'namespaces': d({
-
-                    }),
-                    'data types': d({}),
-                },
-                "summary": {
-                    'namespaces': d({
-
-                    }),
-                    'data types': d({}),
-                },
-            }),
-            'data types': d({
-                "Library": type(group({
-                    "public": prop(component(typeReference("Module Set"))),
-                    "private": prop(component(typeReference("Module Set"))),
-                })),
-                "Module Set": type(dictionary(component(typeReference("Module")))),
-                "Module": type(dictionary(component(typeReference("Algorithm")))),
-                "Algorithm": type(group({
-                    "location": prop(component(typeReference("Source Location"))),
-                    "tests": prop(optional(dictionary(component(typeReference("Test"))))),
-                })),
-                "Source Location": type(group({
-                    "file": prop(text()),
-                    "line": prop(integer()),
-                    "column": prop(integer()),
-                })),
-                "Test": type(list(component(typeReference("Error")))),
-                "Error": type(stateGroup({
-                    "content": component(typeReference("Compare Error"))
-                })),
-                "Compare Error": type(group({
-                    "location": prop(component(typeReference("Source Location"))),
-                    "path": prop(text()),
-                    "type": prop(stateGroup({
-                        "wrong number": group({
-                            "found": prop(integer()),
-                        }),
-                        "wrong text": group({
-                            "found": prop(text()),
-                        }),
-                        "wrong boolean": group({
-                            "found": prop(boolean())
-                        }),
-                        "optional value expected not to be set": nothing(),
-                        "optional value expected to be set": nothing(),
-                        "not the right state": group({
-                            "found": prop(text())
-                        }),
-                        "not enough elements": nothing(),
-                        "too many elements": nothing(),
-                        "superfluous entries": group({
-                            "keys": prop(dictionary(nothing()))
-                        }),
-                        "missing dictionary entry": group({
-                            "key": prop(text()),
-                        }),
-                    })),
-
-                })),
-                "Summary": type(group({
-                    "number of tests": prop(integer()),
-                    "number of missing tests": prop(integer()),
-                    "number of errors": prop(integer()),
-                })),
-
-                "String": type(text()),
-
-                "intLibrary": type(group({
-                    "public": prop(component(typeReference("intModule Set"))),
-                    "private": prop(component(typeReference("intModule Set"))),
-                })),
-                "intModule Set": type(dictionary(component(typeReference("intModule")))),
-                "intModule": type(dictionary(component(typeReference("intAlgorithm")))),
-                "intAlgorithm": type(group({
-                    "location": prop(component(typeReference("Source Location"))),
-                    "status": prop(stateGroup({
-                        "no tests": nothing(),
-                        "skipped": nothing(),
-                        "has tests": dictionary(component(typeReference("intTest"))),
-                    })),
-                })),
-                "intTest": type(stateGroup({
-                    "has errors": list(component(typeReference("Error"))),
-                    "has no errors": nothing(),
-                })),
-                "annotatedStatus": type(stateGroup({
-                    "has errors": nothing(),  // red
-                    "missing tests": nothing(), // yellow
-                    "no tests": nothing(), // grey
-                    "success": nothing(), // green
-                })),
-                "annotatedLibrary": type(group({
-                    "public": prop(component(typeReference("annotatedModule Set"))),
-                    "private": prop(component(typeReference("annotatedModule Set"))),
-                })),
-                "annotatedModule Set": type(group({
-                    "status": prop(component(typeReference("annotatedStatus"))),
-                    "modules": prop(dictionary(component(typeReference("annotatedModule")))),
-                })),
-                "annotatedModule": type(group({
-                    "status": prop(component(typeReference("annotatedStatus"))),
-                    "algorithms": prop(dictionary(component(typeReference("annotatedAlgorithm")))),
-                })),
-                "annotatedAlgorithm": type(group({
-                    "location": prop(component(typeReference("Source Location"))),
-                    "status": prop(component(typeReference("annotatedStatus"))),
-                    "tests": prop(dictionary(component(typeReference("annotatedTest")))),
-                })),
-                "annotatedTest": type(group({
-                    "status": prop(component(typeReference("annotatedStatus"))),
-                    "errors": prop(list(component(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

@@ -1,50 +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_boolean } from "./modules/boolean/api.data"
-import { $ as d_buildInterfaceInitializers } from "./modules/buildInterfaceInitializers/api.data"
-import { $ as d_dictionary } from "./modules/dictionary/api.data"
-import { $ as d_number } from "./modules/number/api.data"
-import { $ as d_optional } from "./modules/optional/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': ['primitive', null],
-    'module sets': {
-        'public': {
-            'glossaries': d({}),
-            'transformations': {
-                'enrich': d({}),
-                'yield': d({}),
-            },
-            'modules': d({
-                "array": d_array,
-                "boolean": d_boolean,
-                "build interface initializers": d_buildInterfaceInitializers,
-                "dictionary": d_dictionary,
-                "number": d_number,
-                "optional": d_optional,
-                "string": d_string,
-            })
-        },
-        'private': {
-            'glossaries': d({}),
-            'transformations': {
-                'enrich': d({}),
-                'yield': d({}),
-            },
-            'modules': d({}),
-        }
-    }
-}

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

@@ -1,37 +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,
-    {
-        "flattenArrayOfArrays": algorithm([
-            `flatten an array of arrays`,
-        ], "FlattenArrayOfArrays", {}),
-        "append": algorithm([
-            `append an element to the end of an array`,
-        ], "Append", {}),
-        "prepend": algorithm([
-            `prepend an element to the beginning of an array`
-        ], "Prepend", {}),
-        "zip": algorithm([
-            `zip two arrays together`,
-            `the length of the resulting array is the length of the shortest input array`
-        ], "Zip", {}),
-        "flattenTree": algorithm([
-            `flatten a tree of values`,
-            `every node can be either an array, nothing or a value`
-        ], "FlattenTree", {}),
-        "unsafeSortTopologically": algorithm([
-            `sort a dictionary topologically`,
-            `the dictionary entries contains a value and a dictionary without values (only keys) that represent the dependencies`,
-            `if a circular dependency is detected, a panic is thrown`,
-            `the result is an array of key/value pairs`
-        ], "SortTopologically", {}),
-
-    }
-)