pareto 0.63.0 → 0.65.0

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

@@ -1,14 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, afunction, boolean, computed, data, dictionary,
-    glossaryParameter, group, member, number, optional, ref, sfunction, string, type, typeReference,
-    taggedUnion,
-    null_,
-    sInterface,
-    sInterfaceMethod,
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
     imp,
-    externalTypeReference
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    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"
@@ -22,18 +33,18 @@ export const $: g_glossary.D.Glossary = {
         'glossary parameters': d({
         }),
         'imports': d({
-            "fp": imp(d_fountain_pen, {}),
+            "fp": imp(d_fountain_pen['data glossary'], {}),
         }),
         'root': {
             'namespaces': d({}),
             'data types': d({
                 "Directory": type(group({
-                    "nodes": member(dictionary(taggedUnion({
-                        "allowed manual": null_(),
-                        "allowed automatic": null_(),
-                        "file": ref(externalTypeReference("fp", "Block")),
-                        "template": ref(externalTypeReference("fp", "Block")),
-                        "directory": ref(typeReference("Directory")),
+                    "nodes": member(dictionary(stateGroup({
+                        "allowed manual": nothing(),
+                        "allowed automatic": nothing(),
+                        "file": component(externalTypeReference("fp", "Block")),
+                        "template": component(externalTypeReference("fp", "Block")),
+                        "directory": component(typeReference("Directory")),
                     })))
                 }))
             }),

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

@@ -1,12 +1,26 @@
 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
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    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"
 const d = pd.d
 
@@ -18,27 +32,27 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Block": type(array(taggedUnion({
-                    "nested line": ref(typeReference("Line")),
-                    "line": string(),
+                "Block": type(list(stateGroup({
+                    "nested line": component(typeReference("Line")),
+                    "line": text(),
                     /**
                      * this one can be used to make code generation easier.
                      * it will be inlined
                      */
-                    "sub block": ref(typeReference("Block")),
+                    "sub block": component(typeReference("Block")),
                 }))),
-                "Line": type(array(taggedUnion({
-                    "snippet": string(),
-                    "indent": ref(typeReference("Block")),
+                "Line": type(list(stateGroup({
+                    "snippet": text(),
+                    "indent": component(typeReference("Block")),
                     /**
                      * this one can be used to make code generation easier.
                      * it will be inlined
                      */
-                    "sub line": ref(typeReference("Line")),
+                    "sub line": component(typeReference("Line")),
                 }))),
-                "Lines": type(array(group({
-                    "indentation": member(number()),
-                    "text": member(string()),
+                "Lines": type(list(group({
+                    "indentation": member(integer()),
+                    "text": member(text()),
                 }))),
             }),
         },

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

@@ -1,10 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    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"
@@ -18,20 +33,20 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Block": type(array(taggedUnion({
-                    "nested line": ref(typeReference("Line")),
-                    "line": string(),
+                "Block": type(list(stateGroup({
+                    "nested line": component(typeReference("Line")),
+                    "line": text(),
                 }))),
-                "Line": type(array(taggedUnion({
-                    "snippet": string(),
-                    "apostrophed string": string(),
-                    "quoted string": string(),
-                    "backticked string": string(),
-                    "indent": ref(typeReference("Block"))
+                "Line": type(list(stateGroup({
+                    "snippet": text(),
+                    "apostrophed string": text(),
+                    "quoted string": text(),
+                    "backticked string": text(),
+                    "indent": component(typeReference("Block"))
                 }))),
-                "Lines": type(array(group({
-                    "indentation": member(number()),
-                    "text": member(string()),
+                "Lines": type(list(group({
+                    "indentation": member(integer()),
+                    "text": member(text()),
                 }))),
             }),
         },

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

@@ -1,10 +1,25 @@
 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
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    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"
@@ -18,7 +33,7 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Lines": type(array(string())),
+                "Lines": type(list(text())),
             }),
         },
     },

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

@@ -1,9 +1,26 @@
 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
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    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"
 
 const d = pd.d
@@ -30,103 +47,103 @@ export const $: g_glossary.D.Glossary = {
             }),
             'data types': d({
                 "Library": type(group({
-                    "public": member(ref(typeReference("Module Set"))),
-                    "private": member(ref(typeReference("Module Set"))),
+                    "public": member(component(typeReference("Module Set"))),
+                    "private": member(component(typeReference("Module Set"))),
                 })),
-                "Module Set": type(dictionary(ref(typeReference("Module")))),
-                "Module": type(dictionary(ref(typeReference("Algorithm")))),
+                "Module Set": type(dictionary(component(typeReference("Module")))),
+                "Module": type(dictionary(component(typeReference("Algorithm")))),
                 "Algorithm": type(group({
-                    "location": member(ref(typeReference("Source Location"))),
-                    "tests": member(optional(dictionary(ref(typeReference("Test"))))),
+                    "location": member(component(typeReference("Source Location"))),
+                    "tests": member(optional(dictionary(component(typeReference("Test"))))),
                 })),
                 "Source Location": type(group({
-                    "file": member(string()),
-                    "line": member(number()),
-                    "column": member(number()),
+                    "file": member(text()),
+                    "line": member(integer()),
+                    "column": member(integer()),
                 })),
-                "Test": type(array(ref(typeReference("Error")))),
-                "Error": type(taggedUnion({
-                    "content": ref(typeReference("Compare Error"))
+                "Test": type(list(component(typeReference("Error")))),
+                "Error": type(stateGroup({
+                    "content": component(typeReference("Compare Error"))
                 })),
                 "Compare Error": type(group({
-                    "location": member(ref(typeReference("Source Location"))),
-                    "path": member(string()),
-                    "type": member(taggedUnion({
+                    "location": member(component(typeReference("Source Location"))),
+                    "path": member(text()),
+                    "type": member(stateGroup({
                         "wrong number": group({
-                            "found": member(number()),
+                            "found": member(integer()),
                         }),
                         "wrong text": group({
-                            "found": member(string()),
+                            "found": member(text()),
                         }),
                         "wrong boolean": group({
                             "found": member(boolean())
                         }),
-                        "optional value expected not to be set": null_(),
-                        "optional value expected to be set": null_(),
+                        "optional value expected not to be set": nothing(),
+                        "optional value expected to be set": nothing(),
                         "not the right state": group({
-                            "found": member(string())
+                            "found": member(text())
                         }),
-                        "not enough elements": null_(),
-                        "too many elements": null_(),
+                        "not enough elements": nothing(),
+                        "too many elements": nothing(),
                         "superfluous entries": group({
-                            "keys": member(dictionary(null_()))
+                            "keys": member(dictionary(nothing()))
                         }),
                         "missing dictionary entry": group({
-                            "key": member(string()),
+                            "key": member(text()),
                         }),
                     })),
 
                 })),
                 "Summary": type(group({
-                    "number of tests": member(number()),
-                    "number of missing tests": member(number()),
-                    "number of errors": member(number()),
+                    "number of tests": member(integer()),
+                    "number of missing tests": member(integer()),
+                    "number of errors": member(integer()),
                 })),
 
                 "intLibrary": type(group({
-                    "public": member(ref(typeReference("intModule Set"))),
-                    "private": member(ref(typeReference("intModule Set"))),
+                    "public": member(component(typeReference("intModule Set"))),
+                    "private": member(component(typeReference("intModule Set"))),
                 })),
-                "intModule Set": type(dictionary(ref(typeReference("intModule")))),
-                "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
+                "intModule Set": type(dictionary(component(typeReference("intModule")))),
+                "intModule": type(dictionary(component(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"))),
+                    "location": member(component(typeReference("Source Location"))),
+                    "status": member(stateGroup({
+                        "no tests": nothing(),
+                        "skipped": nothing(),
+                        "has tests": dictionary(component(typeReference("intTest"))),
                     })),
                 })),
-                "intTest": type(taggedUnion({
-                    "has errors": array(ref(typeReference("Error"))),
-                    "has no errors": null_(),
+                "intTest": type(stateGroup({
+                    "has errors": list(component(typeReference("Error"))),
+                    "has no errors": nothing(),
                 })),
-                "annotatedStatus": type(taggedUnion({
-                    "has errors": null_(),  // red
-                    "missing tests": null_(), // yellow
-                    "no tests": null_(), // grey
-                    "success": null_(), // green
+                "annotatedStatus": type(stateGroup({
+                    "has errors": nothing(),  // red
+                    "missing tests": nothing(), // yellow
+                    "no tests": nothing(), // grey
+                    "success": nothing(), // green
                 })),
                 "annotatedLibrary": type(group({
-                    "public": member(ref(typeReference("annotatedModule Set"))),
-                    "private": member(ref(typeReference("annotatedModule Set"))),
+                    "public": member(component(typeReference("annotatedModule Set"))),
+                    "private": member(component(typeReference("annotatedModule Set"))),
                 })),
                 "annotatedModule Set": type(group({
-                    "status": member(ref(typeReference("annotatedStatus"))),
-                    "modules": member(dictionary(ref(typeReference("annotatedModule")))),
+                    "status": member(component(typeReference("annotatedStatus"))),
+                    "modules": member(dictionary(component(typeReference("annotatedModule")))),
                 })),
                 "annotatedModule": type(group({
-                    "status": member(ref(typeReference("annotatedStatus"))),
-                    "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
+                    "status": member(component(typeReference("annotatedStatus"))),
+                    "algorithms": member(dictionary(component(typeReference("annotatedAlgorithm")))),
                 })),
                 "annotatedAlgorithm": type(group({
-                    "location": member(ref(typeReference("Source Location"))),
-                    "status": member(ref(typeReference("annotatedStatus"))),
-                    "tests": member(dictionary(ref(typeReference("annotatedTest")))),
+                    "location": member(component(typeReference("Source Location"))),
+                    "status": member(component(typeReference("annotatedStatus"))),
+                    "tests": member(dictionary(component(typeReference("annotatedTest")))),
                 })),
                 "annotatedTest": type(group({
-                    "status": member(ref(typeReference("annotatedStatus"))),
-                    "errors": member(array(ref(typeReference("Error")))),
+                    "status": member(component(typeReference("annotatedStatus"))),
+                    "errors": member(list(component(typeReference("Error")))),
                 })),
             }),
         },

package/auto.pareto/auto.dependencies/{pareto-standard-library/modules/nested/glossary.data.ts → pareto-pure/glossaries/text.data.ts}

@@ -1,25 +1,44 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, 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"
-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 }, array(ref(typeParameter("Type"))))
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-    }),
-}
+import * as pd from 'pareto-core-data'
+
+import {
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    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"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Text": type(text()),
+            }),
+        },
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+    }),
+}

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

@@ -1,10 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    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"
@@ -18,48 +33,48 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Block": type(array(taggedUnion({
-                    "nested line": ref(typeReference("Line")),
-                    "line": string(),
+                "Block": type(list(stateGroup({
+                    "nested line": component(typeReference("Line")),
+                    "line": text(),
 
                     //specials
 
                     /**
                      * this one can be used to transform a dictionary into an array of blocks. The order is not controllable.
                      */
-                    "block dictionary": dictionary(ref(typeReference("Block"))),
+                    "block dictionary": dictionary(component(typeReference("Block"))),
                 }))),
-                "Line": type(array(taggedUnion({
-                    "snippet": string(),
-                    "indent": ref(typeReference("Block")),
+                "Line": type(list(stateGroup({
+                    "snippet": text(),
+                    "indent": component(typeReference("Block")),
 
                     //specials
-                    "apostrophed string": string(),
-                    "quoted string": string(),
-                    "backticked string": string(),
-                    "identifier": string(),
+                    "apostrophed string": text(),
+                    "quoted string": text(),
+                    "backticked string": text(),
+                    "identifier": text(),
                     // /**
                     //  * this one is necessary because TypeScript does not allow trailing commas in certain places.
                     //  * for example in type arguments.
                     //  */
-                    // "array without trailing commas": array(ref(typeReference("Line"))),
+                    // "array without trailing commas": list(component(typeReference("Line"))),
                     /**
                      * this one can be used to transform a dictionary into an array of line parts. The order is not controllable.
                      * typescript sometimes handles empty dictoinaries in impure ways and sometimes doesn't accept a trailing comma.
                      */
                     "line dictionary": group({
-                        "dictionary": member(dictionary(ref(typeReference("Line")))),
-                        "if empty": member(ref(typeReference("Line"))),
+                        "dictionary": member(dictionary(component(typeReference("Line")))),
+                        "if empty": member(component(typeReference("Line"))),
                         "if not empty": member(group({
-                            "prefix": member(ref(typeReference("Line"))),
-                            "suffix": member(ref(typeReference("Line"))),
+                            "prefix": member(component(typeReference("Line"))),
+                            "suffix": member(component(typeReference("Line"))),
                             "add commas in between": member(boolean()),
                         })),
                     }),
                 }))),
-                "Lines": type(array(group({
-                    "indentation": member(number()),
-                    "text": member(string()),
+                "Lines": type(list(group({
+                    "indentation": member(integer()),
+                    "text": member(text()),
                 }))),
             }),
         },

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

@@ -5,7 +5,6 @@ import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_t
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
@@ -15,6 +14,6 @@ export const $: g_project.D.API = api(
          * Serialization to this format can be done in a pure way.
          * serialization from this format to an array of strings is not pure, specifically for 1 reason so far: apostrophed strings.
          */
-        "map Root 2 Block": algorithm("Map Root 2 Block", null, {}),
+        "map Root 2 Block": algorithm("Map Root 2 Block", {}),
     }
 )

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

@@ -1,18 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
+    boolean,
+    component,
     data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
     sfunction,
+    stateGroup,
+    text,
     type,
-    group,
+    typeParameter,
     typeReference,
-    member,
-    string,
-    dictionary,
-    null_,
-    array,
-    imp,
-    externalTypeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import { $ as d_in } from "../../glossaries/auto.alan_light.data"
@@ -25,8 +32,8 @@ export const $: g_glossary.D.Glossary = {
     'data glossary': {
         'glossary parameters': d({}),
         'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
+            "in": imp(d_in['data glossary'], {}),
+            "out": imp(d_out['data glossary'], {}),
         }),
         'root': {
             'namespaces': d({}),