pareto 0.73.0 → 0.75.0

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.railroad_diagram.temp_in_between.data.ts

@@ -0,0 +1,241 @@
+import * as pd from 'pareto-core-data'
+
+import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
+
+const d = pd.d
+const a = pd.a
+
+export const $: g_cosmos.D.Data__Glossary = {
+    'glossary parameters': d({
+    }),
+    'imports': d({
+    }),
+    'root': {
+        'data types': d({
+            "Diagram": {
+                'parameters': d({
+                }),
+                'type': ['group', d<g_cosmos.D.Data__Type>({
+                    "main rule": ['text', null],
+                    "rules": ['dictionary', ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Snippet",
+                    }]]],
+                })],
+            },
+            "Snippet": {
+                'parameters': d({
+                }),
+                'type': ['group', d<g_cosmos.D.Data__Type>({
+                    "occurence": ['state group', d({
+                        "once": ['nothing', null],
+                        "zero or more": ['nothing', null],
+                    })],
+                    "type": ['state group', d({
+                        "choice": ['group', d<g_cosmos.D.Data__Type>({
+                            "alternatives": ['dictionary', ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Snippet",
+                            }]]],
+                            "main alternative": ['text', null],
+                        })],
+                        "non-terminal": ['group', d<g_cosmos.D.Data__Type>({
+                            "class": ['text', null],
+                            "rule": ['text', null],
+                        })],
+                        "sequence": ['list', ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Snippet",
+                        }]]],
+                        "terminal": ['group', d<g_cosmos.D.Data__Type>({
+                            "class": ['text', null],
+                            "value": ['text', null],
+                        })],
+                    })],
+                })],
+            },
+        }),
+        'namespaces': d({
+            "Diagram": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "main rule": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "rules": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                        }),
+                                    },
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+            "Snippet": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "occurence": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "TU": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "once": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "zero or more": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "type": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "TU": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "choice": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "G": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "alternatives": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "DX": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                            "main alternative": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "non-terminal": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "G": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "class": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "rule": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "sequence": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "A": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "terminal": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "G": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "class": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "value": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+        }),
+    },
+}

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.semantic_versioning.temp_in_between.data.ts

@@ -1,6 +1,6 @@
 import * as pd from 'pareto-core-data'
 
-import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
 const a = pd.a

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

@@ -10,7 +10,7 @@ import {
     imp,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -20,9 +20,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} 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.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as d_fountain_pen } from "./fountain_pen_indented_file.data"
 
@@ -38,7 +38,7 @@ export const $: g_glossary.D.Data__Glossary = {
         'namespaces': d({}),
         'data types': d({
             "Directory": type(group({
-                "nodes": member(dictionary(stateGroup({
+                "nodes": prop(dictionary(stateGroup({
                     "allowed manual": nothing(),
                     "allowed automatic": nothing(),
                     "file": component(externalTypeReference("fp", "Block")),

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

@@ -10,7 +10,7 @@ import {
     imp,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -20,8 +20,8 @@ import {
     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"
+} 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 = {
@@ -50,8 +50,8 @@ export const $: g_glossary.D.Data__Glossary = {
                 "sub line": component(typeReference("Line")),
             }))),
             "Lines": type(list(group({
-                "indentation": member(integer()),
-                "text": member(text()),
+                "indentation": prop(integer()),
+                "text": prop(text()),
             }))),
         }),
     },

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

@@ -10,7 +10,7 @@ import {
     imp,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -20,9 +20,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} 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.cosmos__type__system"
+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 = {
@@ -44,8 +44,8 @@ export const $: g_glossary.D.Data__Glossary = {
                 "indent": component(typeReference("Block"))
             }))),
             "Lines": type(list(group({
-                "indentation": member(integer()),
-                "text": member(text()),
+                "indentation": prop(integer()),
+                "text": prop(text()),
             }))),
         }),
     },

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

@@ -10,7 +10,7 @@ import {
     imp,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -20,9 +20,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} 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.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as d_liana_schema } from "./auto.liana_schema.temp_in_between.data"
 import { $ as d_liana_resolver } from "./auto.liana_resolver.temp_in_between.data"
@@ -40,16 +40,16 @@ export const $: g_glossary.D.Data__Glossary = {
         'namespaces': d({}),
         'data types': d({
             "Project": type(group({
-                "definitions": member(dictionary(group({
-                    "type library": member(group({
-                        "schema": member(component(externalTypeReference("schema", "Type Library"))),
-                        "resolver": member(component(externalTypeReference("resolver", "Type Library"))),
+                "definitions": prop(dictionary(group({
+                    "type library": prop(group({
+                        "schema": prop(component(externalTypeReference("schema", "Type Library"))),
+                        "resolver": prop(component(externalTypeReference("resolver", "Type Library"))),
                     })),
-                    "terminal mapping": member(component(typeReference("Terminal Mapping"))),
-                    "usages": member(group({
-                        "manual": member(boolean()),
-                        "temp in between": member(boolean()),
-                        "transformation target": member(boolean()),
+                    "terminal mapping": prop(component(typeReference("Terminal Mapping"))),
+                    "usages": prop(group({
+                        "manual": prop(boolean()),
+                        "temp in between": prop(boolean()),
+                        "transformation target": prop(boolean()),
                     }))
                 })))
             })),

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

@@ -10,7 +10,7 @@ import {
     imp,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -20,9 +20,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} 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.cosmos__type__system"
+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 = {

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

@@ -10,7 +10,7 @@ import {
     imp,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -20,8 +20,8 @@ import {
     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"
+} 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
 
@@ -46,68 +46,68 @@ export const $: g_glossary.D.Data__Glossary = {
         }),
         'data types': d({
             "Library": type(group({
-                "public": member(component(typeReference("Module Set"))),
-                "private": member(component(typeReference("Module Set"))),
+                "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": member(component(typeReference("Source Location"))),
-                "tests": member(optional(dictionary(component(typeReference("Test"))))),
+                "location": prop(component(typeReference("Source Location"))),
+                "tests": prop(optional(dictionary(component(typeReference("Test"))))),
             })),
             "Source Location": type(group({
-                "file": member(text()),
-                "line": member(integer()),
-                "column": member(integer()),
+                "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": member(component(typeReference("Source Location"))),
-                "path": member(text()),
-                "type": member(stateGroup({
+                "location": prop(component(typeReference("Source Location"))),
+                "path": prop(text()),
+                "type": prop(stateGroup({
                     "wrong number": group({
-                        "found": member(integer()),
+                        "found": prop(integer()),
                     }),
                     "wrong text": group({
-                        "found": member(text()),
+                        "found": prop(text()),
                     }),
                     "wrong boolean": group({
-                        "found": member(boolean())
+                        "found": prop(boolean())
                     }),
                     "optional value expected not to be set": nothing(),
                     "optional value expected to be set": nothing(),
                     "not the right state": group({
-                        "found": member(text())
+                        "found": prop(text())
                     }),
                     "not enough elements": nothing(),
                     "too many elements": nothing(),
                     "superfluous entries": group({
-                        "keys": member(dictionary(nothing()))
+                        "keys": prop(dictionary(nothing()))
                     }),
                     "missing dictionary entry": group({
-                        "key": member(text()),
+                        "key": prop(text()),
                     }),
                 })),
 
             })),
             "Summary": type(group({
-                "number of tests": member(integer()),
-                "number of missing tests": member(integer()),
-                "number of errors": member(integer()),
+                "number of tests": prop(integer()),
+                "number of missing tests": prop(integer()),
+                "number of errors": prop(integer()),
             })),
 
             "intLibrary": type(group({
-                "public": member(component(typeReference("intModule Set"))),
-                "private": member(component(typeReference("intModule Set"))),
+                "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": member(component(typeReference("Source Location"))),
-                "status": member(stateGroup({
+                "location": prop(component(typeReference("Source Location"))),
+                "status": prop(stateGroup({
                     "no tests": nothing(),
                     "skipped": nothing(),
                     "has tests": dictionary(component(typeReference("intTest"))),
@@ -124,25 +124,25 @@ export const $: g_glossary.D.Data__Glossary = {
                 "success": nothing(), // green
             })),
             "annotatedLibrary": type(group({
-                "public": member(component(typeReference("annotatedModule Set"))),
-                "private": member(component(typeReference("annotatedModule Set"))),
+                "public": prop(component(typeReference("annotatedModule Set"))),
+                "private": prop(component(typeReference("annotatedModule Set"))),
             })),
             "annotatedModule Set": type(group({
-                "status": member(component(typeReference("annotatedStatus"))),
-                "modules": member(dictionary(component(typeReference("annotatedModule")))),
+                "status": prop(component(typeReference("annotatedStatus"))),
+                "modules": prop(dictionary(component(typeReference("annotatedModule")))),
             })),
             "annotatedModule": type(group({
-                "status": member(component(typeReference("annotatedStatus"))),
-                "algorithms": member(dictionary(component(typeReference("annotatedAlgorithm")))),
+                "status": prop(component(typeReference("annotatedStatus"))),
+                "algorithms": prop(dictionary(component(typeReference("annotatedAlgorithm")))),
             })),
             "annotatedAlgorithm": type(group({
-                "location": member(component(typeReference("Source Location"))),
-                "status": member(component(typeReference("annotatedStatus"))),
-                "tests": member(dictionary(component(typeReference("annotatedTest")))),
+                "location": prop(component(typeReference("Source Location"))),
+                "status": prop(component(typeReference("annotatedStatus"))),
+                "tests": prop(dictionary(component(typeReference("annotatedTest")))),
             })),
             "annotatedTest": type(group({
-                "status": member(component(typeReference("annotatedStatus"))),
-                "errors": member(list(component(typeReference("Error")))),
+                "status": prop(component(typeReference("annotatedStatus"))),
+                "errors": prop(list(component(typeReference("Error")))),
             })),
         }),
     },

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

@@ -10,7 +10,7 @@ import {
     imp,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -20,9 +20,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} 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.cosmos__type__system"
+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 = {

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

@@ -10,7 +10,7 @@ import {
     imp,
     integer,
     list,
-    member,
+    prop,
     nothing,
     optional,
     parametrizedType,
@@ -20,9 +20,9 @@ import {
     type,
     typeParameter,
     typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+} 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.cosmos__type__system"
+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 = {
@@ -62,18 +62,18 @@ export const $: g_glossary.D.Data__Glossary = {
                  * typescript sometimes handles empty dictoinaries in impure ways and sometimes doesn't accept a trailing comma.
                  */
                 "line dictionary": group({
-                    "dictionary": member(dictionary(component(typeReference("Line")))),
-                    "if empty": member(component(typeReference("Line"))),
-                    "if not empty": member(group({
-                        "prefix": member(component(typeReference("Line"))),
-                        "suffix": member(component(typeReference("Line"))),
-                        "add commas in between": member(boolean()),
+                    "dictionary": prop(dictionary(component(typeReference("Line")))),
+                    "if empty": prop(component(typeReference("Line"))),
+                    "if not empty": prop(group({
+                        "prefix": prop(component(typeReference("Line"))),
+                        "suffix": prop(component(typeReference("Line"))),
+                        "add commas in between": prop(boolean()),
                     })),
                 }),
             }))),
             "Lines": type(list(group({
-                "indentation": member(integer()),
-                "text": member(text()),
+                "indentation": prop(integer()),
+                "text": prop(text()),
             }))),
         }),
     },