pareto 0.64.0 → 0.65.0

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

@@ -11,7 +11,7 @@ import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     glos,
     {
-        "map Library 2 Directory": algorithm("Map Library 2 Directory", null, {}),
+        "map Library 2 Directory": algorithm("Map Library 2 Directory", {}),
 
     }
 )

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

@@ -1,7 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, member, null_, parametrizedType, ref, sfunction, 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"
@@ -16,16 +34,16 @@ 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, {}),
+            "in": imp(d_in['data glossary'], {}),
+            "out": imp(d_out['data glossary'], {}),
+            "cts": imp(d_cts['data glossary'], {}),
         }),
         'root': {
             'namespaces': d({}),
             'data types': d({
                 "In": type(group({
-                    "$": member(ref(externalTypeReference("in", "Typescript Package"))),
-                    "library": member(ref(externalTypeReference("cts", "Library"))),
+                    "$": member(component(externalTypeReference("in", "Typescript Package"))),
+                    "library": member(component(externalTypeReference("cts", "Library"))),
                 }))
             }),
         },

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

@@ -7,11 +7,10 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 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,
     {
-        "map Block 2 Lines": algorithm("Map Block 2 Lines", null, {}),
+        "map Block 2 Lines": algorithm("Map Block 2 Lines", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen_indented_file_2_fountain_pen_indented_file/glossary.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,16 +33,16 @@ export const $: g_glossary.D.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({}),
             'data types': d({
                 // "SerializeData": type(group({
-                //     "block": member(ref(externalTypeReference("in", "Block"))),
+                //     "block": member(component(externalTypeReference("in", "Block"))),
                 // })),
-                // "String": type(string()),
+                // "String": type(text()),
             }),
         },
     },

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

@@ -7,12 +7,11 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 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,
     {
-        "map Lines 2 Lines": algorithm("Map Lines 2 Lines", null, {}),
-        "stream": algorithm("Stream", null, {}),
+        "map Lines 2 Lines": algorithm("Map Lines 2 Lines", {}),
+        "stream": algorithm("Stream", {}),
     }
 )

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

@@ -1,10 +1,31 @@
 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,
+
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+    infInit,
+    streamconsumer,
 } 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"
@@ -17,17 +38,17 @@ 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({}),
             'data types': d({
                 "IndentData": type(group({
-                    "lines": member(ref(externalTypeReference("in", "Lines"))),
-                    "indentation": member(string()),
+                    "lines": member(component(externalTypeReference("in", "Lines"))),
+                    "indentation": member(text()),
                 })),
-                "String": type(string()),
+                "String": type(text()),
             }),
         },
     },

package/auto.pareto/auto.dependencies/pareto-pure/modules/graphviz_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 Graph 2 Block": algorithm("Map Graph 2 Block", null, {}),
+        "map Graph 2 Block": algorithm("Map Graph 2 Block", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/graphviz_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.graphviz.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({}),

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

@@ -5,12 +5,11 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterface, sInterfaceMethod, streamconsumer, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
 
     {
-        "map Compilation Unit 2 Block": algorithm("Map Compilation Unit 2 Block", null, {})
+        "map Compilation Unit 2 Block": algorithm("Map Compilation Unit 2 Block", {}),
     }
 )

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

@@ -1,27 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    dictionary,
-    typeReference,
+    boolean,
+    component,
     data,
-    sfunction,
-    ref,
-    typeParameter,
+    dictionary,
     externalTypeReference,
-    parametrizedType,
-    optional,
     group,
+    imp,
+    integer,
+    list,
     member,
-    aInterface,
-    streamconsumer,
-    aInterfaceMethod,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
     type,
-    string,
-    boolean,
-    sInterface,
-    sInterfaceMethod,
-    array,
-    imp,
+    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"
@@ -34,8 +32,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'data glossary': {
         'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
+            "in": imp(d_in['data glossary'], {}),
+            "out": imp(d_out['data glossary'], {}),
         }),
 
         'glossary parameters': d({}),
@@ -43,7 +41,7 @@ export const $: g_glossary.D.Glossary = {
             'namespaces': d({}),
             'data types': d({
                 "Map Data": type(group({
-                    "compilation unit": member(ref(externalTypeReference("in", "Compilation Unit", {}))),
+                    "compilation unit": member(component(externalTypeReference("in", "Compilation Unit", {}))),
                 })),
             }),
         },

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

@@ -5,13 +5,12 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterface, sInterfaceMethod, streamconsumer, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
 
     {
-        "map Semantic Version from Text": algorithm("Map Semantic Version from Text", null, {})
+        "map Semantic Version from Text": algorithm("Map Semantic Version from Text", {}),
 
     }
 )

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

@@ -1,27 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    dictionary,
-    typeReference,
+    boolean,
+    component,
     data,
-    sfunction,
-    ref,
-    typeParameter,
+    dictionary,
     externalTypeReference,
-    parametrizedType,
-    optional,
     group,
+    imp,
+    integer,
+    list,
     member,
-    aInterface,
-    streamconsumer,
-    aInterfaceMethod,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
     type,
-    string,
-    boolean,
-    sInterface,
-    sInterfaceMethod,
-    array,
-    imp,
+    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"
@@ -34,8 +32,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'data glossary': {
         'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
+            "in": imp(d_in['data glossary'], {}),
+            "out": imp(d_out['data glossary'], {}),
         }),
         'glossary parameters': d({}),
         'root': {

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

@@ -5,13 +5,12 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterface, sInterfaceMethod, streamconsumer, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
 
     {
-        "map Model 2 Root": algorithm("Map Model 2 Root", null, {})
+        "map Model 2 Root": algorithm("Map Model 2 Root", {}),
 
     }
 )

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

@@ -1,26 +1,9 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    dictionary,
-    typeReference,
     data,
     sfunction,
-    ref,
-    typeParameter,
     externalTypeReference,
-    parametrizedType,
-    optional,
-    group,
-    member,
-    aInterface,
-    streamconsumer,
-    aInterfaceMethod,
-    type,
-    string,
-    boolean,
-    sInterface,
-    sInterfaceMethod,
-    array,
     imp,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -34,8 +17,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'data glossary': {
         'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
+            "in": imp(d_in['data glossary'], {}),
+            "out": imp(d_out['data glossary'], {}),
         }),
         'glossary parameters': d({}),
         'root': {

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

@@ -11,6 +11,6 @@ import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     glos,
     {
-        "map": algorithm("Map", null, {})
+        "map": algorithm("Map", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_cosmos_type_system/glossary.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, optional, 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 d_out } from "../../glossaries/auto.cosmos_type_system.data"
@@ -17,42 +32,42 @@ 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({}),
             'data types': d({
                 "MapData": type(group({
-                    "mapped library": member(ref(typeReference("Mapped Library"))),
-                    "settings": member(ref(typeReference("Mapping Settings"))),
+                    "mapped library": member(component(typeReference("Mapped Library"))),
+                    "settings": member(component(typeReference("Mapping Settings"))),
                 })),
                 "Mapped Library": type(group({
-                    "library": member(ref(externalTypeReference("in", "Type Library", {}))),
-                    "terminal mapping": member(ref(typeReference("Terminal Mapping"))),
+                    "library": member(component(externalTypeReference("in", "Type Library", {}))),
+                    "terminal mapping": member(component(typeReference("Terminal Mapping"))),
                 })),
 
-                "Terminal Mapping": type(dictionary(taggedUnion({
-                    "boolean": null_(),
-                    "integer": null_(),
-                    "text": null_(),
+                "Terminal Mapping": type(dictionary(stateGroup({
+                    "boolean": nothing(),
+                    "integer": nothing(),
+                    "text": nothing(),
                 }))),
                 "Mapping Settings": type(group({
                     "annotations": member(boolean()),
                     "datamodel": member(optional(group({
                         "constraints mapping": member(group({
                             "terminal values": member(boolean()),
-                            "constraints": member(optional(taggedUnion({
+                            "constraints": member(optional(stateGroup({
                                 "optional": group({}),
                                 "required": group({}),
                             }))),
                         })),
                     }))),
                     // "visitor interface": member(optional(group({
-                    //     "datamodel": member(taggedUnion({
+                    //     "datamodel": member(stateGroup({
                     //         "internal": group({}),
                     //         "exernal": group({
-                    //             "location": member(string()),
+                    //             "location": member(text()),
                     //         }),
                     //     })),
                     // }))),

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

@@ -11,7 +11,7 @@ import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     glos,
     {
-        "createResolver": algorithm("CreateResolver", null, {}),
-        "createSerializer": algorithm("CreateSerializer", null, {}),
+        "createResolver": algorithm("CreateResolver", {}),
+        "createSerializer": algorithm("CreateSerializer", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_pareto/glossary.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, optional, 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 d_out } from "../../glossaries/auto.pareto.data"
@@ -17,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({}),

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

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