pareto 0.60.0 → 0.62.0

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

@@ -12,98 +12,113 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "Length": type(number()),
-            "Boolean": type(boolean()),
-            "Character Code": type(number()),
-            "Possible Character Code": type(optional(number())),
-            "Possible Position": type(optional(number())),
 
-            "CharacterCode At Data": type(group({
-                "contextString": member(string()),
-                "index": member(number()),
-            })),
-            "CharacterArray": type(array(number())),
-            "SplitData": type(group({
-                "contextString": member(string()),
-                "splitter": member(string()),
-            })),
-            "IncludesData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
-            "SplitIn2Result": type(group({
-                "head": member(string()),
-                "tail": member(optional(string())),
-            })),
-            "SplitResult": type(array(string())),
-            "StartsWithData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
-            "EndsWithData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
-            "SubstringData": type(group({
-                "contextString": member(string()),
-                "begin": member(number()),
-                /**
-                 * I'm deliberately choosing length over end here, because length will become a 'natural' in the future
-                 * and then this function is guaranteed to not have a negative length.
-                 * going with 'end' would require a check for negative values.
-                 */
-                "length": member(number()),
-            })),
-            "ReplaceData": type(group({
-                "contextString": member(string()),
-                "pattern": member(string()),
-                "replacement": member(string()),
-            })),
-            "EscapeParameters": type(group({
-                "contextString": member(string()),
-                "escape": member(string()),
-                "patterns to escape": member(array(string())),
-            })),
-            "PadData": type(group({
-                "contextString": member(string()),
-                "targetLength": member(number()),
-                "padString": member(string()),
-            })),
-            "IndexOfData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+                "Length": type(number()),
+                "Boolean": type(boolean()),
+                "Character Code": type(number()),
+                "Possible Character Code": type(optional(number())),
+                "Possible Position": type(optional(number())),
+
+                "CharacterCode At Data": type(group({
+                    "contextString": member(string()),
+                    "index": member(number()),
+                })),
+                "CharacterArray": type(array(number())),
+                "SplitData": type(group({
+                    "contextString": member(string()),
+                    "splitter": member(string()),
+                })),
+                "IncludesData": type(group({
+                    "contextString": member(string()),
+                    "searchString": member(string()),
+                })),
+                "SplitIn2Result": type(group({
+                    "head": member(string()),
+                    "tail": member(optional(string())),
+                })),
+                "SplitResult": type(array(string())),
+                "StartsWithData": type(group({
+                    "contextString": member(string()),
+                    "searchString": member(string()),
+                })),
+                "EndsWithData": type(group({
+                    "contextString": member(string()),
+                    "searchString": member(string()),
+                })),
+                "SubstringData": type(group({
+                    "contextString": member(string()),
+                    "begin": member(number()),
+                    /**
+                     * I'm deliberately choosing length over end here, because length will become a 'natural' in the future
+                     * and then this function is guaranteed to not have a negative length.
+                     * going with 'end' would require a check for negative values.
+                     */
+                    "length": member(number()),
+                })),
+                "ReplaceData": type(group({
+                    "contextString": member(string()),
+                    "pattern": member(string()),
+                    "replacement": member(string()),
+                })),
+                "EscapeParameters": type(group({
+                    "contextString": member(string()),
+                    "escape": member(string()),
+                    "patterns to escape": member(array(string())),
+                })),
+                "PadData": type(group({
+                    "contextString": member(string()),
+                    "targetLength": member(number()),
+                    "padString": member(string()),
+                })),
+                "IndexOfData": type(group({
+                    "contextString": member(string()),
+                    "searchString": member(string()),
+                })),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
-        "CharCodeAt": sfunction(typeReference("Possible Character Code"), data(typeReference("CharacterCode At Data"))),
+        //array
+        "Split": sfunction(typeReference("SplitResult"), data(typeReference("SplitData"))),
+        "ToCharacterArray": sfunction(typeReference("CharacterArray"), data(typeReference("String"))),
+
+        //boolean
         "EndsWith": sfunction(typeReference("Boolean"), data(typeReference("EndsWithData"))),
+        "Includes": sfunction(typeReference("Boolean"), data(typeReference("IncludesData"))),
+        "StartsWith": sfunction(typeReference("Boolean"), data(typeReference("StartsWithData"))),
+
+        //number
+        "Length": sfunction(typeReference("Length"), data(typeReference("String"))),
+
+        //optional
+        "CharCodeAt": sfunction(typeReference("Possible Character Code"), data(typeReference("CharacterCode At Data"))),
+        "IndexOf": sfunction(typeReference("Possible Position"), data(typeReference("IndexOfData"))),
+
+        //string
         "Escape": sfunction(typeReference("String"), data(typeReference("EscapeParameters"))),
         "FromCharacter": sfunction(typeReference("String"), data(typeReference("Character Code"))),
         "FromCharacterArray": sfunction(typeReference("String"), data(typeReference("CharacterArray"))),
-        "Includes": sfunction(typeReference("Boolean"), data(typeReference("IncludesData"))),
-        "IndexOf": sfunction(typeReference("Possible Position"), data(typeReference("IndexOfData"))),
-        "Length": sfunction(typeReference("Length"), data(typeReference("String"))),
         "PadEnd": sfunction(typeReference("String"), data(typeReference("PadData"))),
         "PadStart": sfunction(typeReference("String"), data(typeReference("PadData"))),
         "ReplaceAll": sfunction(typeReference("String"), data(typeReference("ReplaceData"))),
         "ReplaceFirst": sfunction(typeReference("String"), data(typeReference("ReplaceData"))),
-        "Split": sfunction(typeReference("SplitResult"), data(typeReference("SplitData"))),
-        "SplitIn2": sfunction(typeReference("SplitIn2Result"), data(typeReference("SplitData"))),
-        "StartsWith": sfunction(typeReference("Boolean"), data(typeReference("StartsWithData"))),
         "Substring": sfunction(typeReference("String"), data(typeReference("SubstringData"))),
-        "ToCharacterArray": sfunction(typeReference("CharacterArray"), data(typeReference("String"))),
-        "UnsafeCharCodeAt": sfunction(typeReference("Character Code"), data(typeReference("CharacterCode At Data"))),
+
+        //composite
+        "SplitIn2": sfunction(typeReference("SplitIn2Result"), data(typeReference("SplitData"))),
+
+
+        //"UnsafeCharCodeAt": sfunction(typeReference("Character Code"), data(typeReference("CharacterCode At Data"))),
         //"TrimEnd": sfunction(typeReference("String"), data(typeReference("String"))),
 
-        "Foobar": sfunction(typeReference("String"), data(typeReference("String"))),
     }),
 }

package/auto.pareto/modules/main/glossary.data.ts

@@ -15,18 +15,20 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Message": type(string()),
-            "Exit code": type(number()),
-            "Command Line Arguments": type(group({
-                "arguments": member(array(string()))
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Message": type(string()),
+                "Exit code": type(number()),
+                "Command Line Arguments": type(group({
+                    "arguments": member(array(string()))
+                })),
+            }),
+        },
     },
     'interface types': d({
         "Main": aInterface(aInterfaceMethod(typeReference("Command Line Arguments"))),
@@ -38,6 +40,6 @@ export const $: g_glossary.D.Glossary = {
             "stdout": aInterfaceReference("Message Stream", {}),
             "stderr": aInterfaceReference("Message Stream", {}),
             "exit": aInterfaceReference("Exit")
-        }, {  }),
+        }, {}),
     }),
 }

package/auto.pareto/modules/pareto_2_fountain_pen/glossary.data.ts

@@ -27,26 +27,28 @@ import {
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as d_pareto } from "../../auto.dependencies/pareto-pure/glossaries/auto.pareto.data"
-import { $ as d_fp } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen.data"
+import { $ as d_fpif } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file.data"
 import { $ as d_l } from "../../auto.dependencies/pareto-pure/glossaries/lines.data"
 
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'imports': d({
-        "fp": imp(d_fp, {}),
-        "l": imp(d_l, {}),
-        "pareto": imp(d_pareto, {}),
-    }),
-
-    'glossary parameters': d({}),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Data": type(group({
-                "compilation unit": member(ref(externalTypeReference("pareto", "Compilation Unit", {}))),
-            })),
+    'data glossary': {
+        'imports': d({
+            "fp": imp(d_fpif, {}),
+            "l": imp(d_l, {}),
+            "pareto": imp(d_pareto, {}),
         }),
+
+        'glossary parameters': d({}),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Data": type(group({
+                    "compilation unit": member(ref(externalTypeReference("pareto", "Compilation Unit", {}))),
+                })),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/modules/string_aware_fountain_pen_2 fountain_pen/api.data.ts

@@ -10,6 +10,6 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = sh.api(
     glos,
     {
-        "map": sh.algorithm("Map", null, {}),
+        "map Block 2 Block": sh.algorithm("Map Block 2 Block", null, {}),
     }
 )

package/auto.pareto/modules/string_aware_fountain_pen_2 fountain_pen/glossary.data.ts

@@ -2,26 +2,28 @@ import * as pd from 'pareto-core-data'
 
 import * as sh from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_in } from "../../auto.dependencies/pareto-pure/glossaries/string_aware_fountain_pen.data"
-import { $ as d_out } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen.data"
+import { $ as d_in } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file_with_escaped_strings.data"
+import { $ as d_out } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file.data"
 
 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 = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "in": sh.imp(d_in, {}),
-        "out": sh.imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "in": sh.imp(d_in, {}),
+            "out": sh.imp(d_out, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map": sh.sfunction(sh.externalTypeReference("out", "Block"), sh.data(sh.externalTypeReference("in", "Block"))),
+        "Map Block 2 Block": sh.sfunction(sh.externalTypeReference("out", "Block"), sh.data(sh.externalTypeReference("in", "Block"))),
     }),
 
 }

package/auto.pareto/modules/typescript_intermediate_2_fountain_pen/api.data.ts

@@ -19,6 +19,6 @@ export const $: g_project.D.API = api(
          * the fp block can then easily be streamed to a file or console.
          * 
          */
-        "serialize": algorithm("Serialize", null, {}),
+        "map Block 2 Block": algorithm("Map Block 2 Block", null, {}),
     }
 )

package/auto.pareto/modules/typescript_intermediate_2_fountain_pen/glossary.data.ts

@@ -18,27 +18,29 @@ import {
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
 
-import { $ as d_fp } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen.data"
+import { $ as d_fpif } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file.data"
 import { $ as d_ts } from "../../auto.dependencies/pareto-pure/glossaries/typescript_intermediate.data"
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "fp": imp(d_fp, {}),
-        "ts": imp(d_ts, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "out": imp(d_fpif, {}),
+            "in": imp(d_ts, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
         "CreateQuotedString": sfunction(typeReference("String"), data(typeReference("String"))),
         "CreateApostrophedString": sfunction(typeReference("String"), data(typeReference("String"))),
         "CreateBacktickedString": sfunction(typeReference("String"), data(typeReference("String"))),
-        "Serialize": sfunction(externalTypeReference("fp", "Block"), data(externalTypeReference("ts", "Block"))),
+        "Map Block 2 Block": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Block"))),
     }),
 
 }

package/auto.pareto/modules/typescript_naming/glossary.data.ts

@@ -17,15 +17,17 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Raw Identifier": type(string()),
-            "Sanitized Identifier": type(string()),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Raw Identifier": type(string()),
+                "Sanitized Identifier": type(string()),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/package.json

@@ -3,13 +3,13 @@
     "license": "TBD",
     "description": "",
     "dependencies": {
-        "pareto-core-alg": "^0.2.2",
-        "pareto-core-bin": "^0.1.3",
-        "pareto-core-data": "^0.7.2",
+        "pareto-core-alg": "^0.2.4",
+        "pareto-core-bin": "^0.1.4",
+        "pareto-core-data": "^0.7.3",
         "pareto-core-dev": "^0.9.1",
-        "pareto-pure": "^0.20.0",
-        "pareto-standard-library": "^0.7.0",
-        "pareto-subatomic-library": "^0.6.0"
+        "pareto-pure": "^0.22.3",
+        "pareto-standard-library": "^0.10.0",
+        "pareto-subatomic-library": "^0.8.0"
     },
     "bin": {
         "boekhouding": "auto.dist/auto.bin/auto.boekhouding.js"
@@ -25,6 +25,6 @@
     "main": "auto.dist/index.js",
     "types": "auto.dist/index.d.ts",
     "name": "pareto",
-    "version": "0.60.0",
-    "content-fingerprint": "6221e14fa15197c1d4d3c3dc085e3de3c5fad9ea"
+    "version": "0.62.0",
+    "content-fingerprint": "edf7b0f767fe6fed1325f5e50422323de15518da"
 }

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

@@ -1,48 +0,0 @@
-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
-} 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 = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Block": type(array(taggedUnion({
-                "nested line": ref(typeReference("Line")),
-                "line": string(),
-                /**
-                 * this one can be used to make code generation easier.
-                 * it will be inlined
-                 */
-                "sub block": ref(typeReference("Block")),
-            }))),
-            "Line": type(array(taggedUnion({
-                "snippet": string(),
-                "indent": ref(typeReference("Block")),
-                /**
-                 * this one can be used to make code generation easier.
-                 * it will be inlined
-                 */
-                "sub line": ref(typeReference("Line")),
-            }))),
-            "Lines": type(array(group({
-                "indentation": member(number()),
-                "text": member(string()),
-            }))),
-        }),
-    },
-    'interface types': d({
-    }),
-    'algorithm types': d({
-    }),
-}

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

@@ -1,40 +0,0 @@
-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
-} 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 = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Block": type(array(taggedUnion({
-                "nested line": ref(typeReference("Line")),
-                "line": string(),
-            }))),
-            "Line": type(array(taggedUnion({
-                "snippet": string(),
-                "apostrophed string": string(),
-                "quoted string": string(),
-                "backticked string": string(),
-                "indent": ref(typeReference("Block"))
-            }))),
-            "Lines": type(array(group({
-                "indentation": member(number()),
-                "text": member(string()),
-            }))),
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-    }),
-}

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

@@ -1,36 +0,0 @@
-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
-} 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
-
-import { $ as d_in } from "../../glossaries/fountain_pen.data"
-import { $ as d_out } from "../../glossaries/fountain_pen.data"
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-
-        "in": imp(d_in, {}),
-        "out": imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            // "SerializeData": type(group({
-            //     "block": member(ref(externalTypeReference("in", "Block"))),
-            // })),
-            // "String": type(string()),
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Map": sfunction(externalTypeReference("out", "Lines"), data(externalTypeReference("in", "Block"))),
-    }),
-}