pareto 0.74.0 → 0.75.0

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/filesystem/api.data.ts

@@ -1,15 +1,17 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "createFileWriter": algorithm("CreateFileWriter", {}),
+        "createFileWriter": algorithm([
+            `create a file writer interface`
+        ], "CreateFileWriter", {}),
     }
 )

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

@@ -6,7 +6,7 @@ import {
     type,
     group,
     typeReference,
-    member,
+    prop,
     text,
     dictionary,
     nothing,
@@ -19,11 +19,11 @@ import {
     aInterfaceMethod,
     component,
     infref,
-} 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 d_lines } from "../../glossaries/lines.data"
 
-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.Glossary = {
@@ -37,12 +37,12 @@ export const $: g_glossary.D.Glossary = {
             'data types': d({
                 "File Path": type(list(text())),
                 "File Write Data": type(group({
-                    "directory path": member(component(typeReference("File Path"))),
-                    "file name": member(text()),
-                    "data": member(component(externalTypeReference("lines", "Lines"))),
+                    "directory path": prop(component(typeReference("File Path"))),
+                    "file name": prop(text()),
+                    "data": prop(component(externalTypeReference("lines", "Lines"))),
                 })),
                 "Root Data": type(group({
-                    "context directory": member(text()),
+                    "context directory": prop(text()),
                 })),
             }),
         },

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/api.data.ts

@@ -1,22 +1,25 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, integer, sInterface, sInterfaceMethod, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, prop, integer, sInterface, sInterfaceMethod, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "parse": algorithm("Parse", {}),
+        "parse": algorithm([
+            `parse a json string into a possible data structure`
+        ], "Parse", {}),
+        "serialize": algorithm([
+            `serialize a data structure into a json string`
+        ], "Serialize", {}),
 
-        /**
-         * this one is impure because it uses needs to inspect strings to escape them properly
-         */
-        "serialize": algorithm("Serialize", {}),
-
-        "unsafeParse": algorithm("UnsafeParse", {}),
+        "unsafeParse": algorithm([
+            `parse a json string into a data structure`,
+            `if the json is invalid, panic`
+        ], "UnsafeParse", {}),
     }
 )

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

@@ -2,14 +2,14 @@ import * as pd from 'pareto-core-data'
 
 import {
     list, afunction, boolean, data, dictionary,
-    glossaryParameter, group, member, integer, optional, component, sfunction, text, type, typeReference,
+    glossaryParameter, group, prop, integer, optional, component, sfunction, text, type, typeReference,
     stateGroup,
     nothing,
     sInterface,
     sInterfaceMethod
-} 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
 

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/api.data.ts

@@ -1,18 +1,26 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "smallerThan": algorithm("SmallerThan", {}),
-        "greaterThan": algorithm("GreaterThan", {}),
-        "isZero": algorithm("IsZero", {}),
-        "equal": algorithm("Equal", {}),
+        "smallerThan": algorithm([
+            `is the focus number smaller than the benchmark number`
+        ], "SmallerThan", {}),
+        "greaterThan": algorithm([
+            `is the focus number greater than the benchmark number`
+        ], "GreaterThan", {}),
+        "isZero": algorithm([
+            `is the number zero`
+        ], "IsZero", {}),
+        "equal": algorithm([
+            `are the two numbers equal`
+        ], "Equal", {}),
     }
 )

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

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    list, boolean, data, dictionary, externalTypeReference, group, member, integer, optional, sfunction,
+    list, boolean, data, dictionary, externalTypeReference, group, prop, integer, optional, sfunction,
     type, 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
 
@@ -20,12 +20,12 @@ export const $: g_glossary.D.Glossary = {
                 "Boolean": type(boolean()),
                 "Number": type(integer()),
                 "NumberPair": type(group({
-                    "yin": member(integer()),
-                    "yang": member(integer()),
+                    "yin": prop(integer()),
+                    "yang": prop(integer()),
                 })),
                 "CompareData": type(group({
-                    "benchmark": member(integer()),
-                    "focus": member(integer()),
+                    "benchmark": prop(integer()),
+                    "focus": prop(integer()),
                 })),
 
             }),

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

@@ -1,32 +1,68 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "charCodeAt": algorithm("CharCodeAt", {}),
-        "endsWith": algorithm("EndsWith", {}),
-        "escape": algorithm("Escape", {}),
-        "fromCharacterArray": algorithm("FromCharacterArray", {}),
-        "fromCharacter": algorithm("FromCharacter", {}),
-        "includes": algorithm("Includes", {}),
-        "indexOf": algorithm("IndexOf", {}),
-        "length": algorithm("Length", {}),
-        "padEnd": algorithm("PadEnd", {}),
-        "padStart": algorithm("PadStart", {}),
-        "replaceAll": algorithm("ReplaceAll", {}),
-        "replaceFirst": algorithm("ReplaceFirst", {}),
-        "split": algorithm("Split", {}),
-        "splitIn2": algorithm("SplitIn2", {}),
-        "startsWith": algorithm("StartsWith", {}),
-        "substring": algorithm("Substring", {}),
-        "toCharacterArray": algorithm("ToCharacterArray", {}),
+        "charCodeAt": algorithm([
+            `returns the unicode value of the character at the specified index`
+        ], "CharCodeAt", {}),
+        "endsWith": algorithm([
+            `does the string end with the specified value`
+        ], "EndsWith", {}),
+        "escape": algorithm([
+            `prepend the string with the escape string if it starts with the specified value`
+        ], "Escape", {}),
+        "fromCharacterArray": algorithm([
+            `create a string from a character array`
+        ], "FromCharacterArray", {}),
+        "fromCharacter": algorithm([
+            `create a string from a single character`
+        ], "FromCharacter", {}),
+        "includes": algorithm([
+            `does the string include the specified value`
+        ], "Includes", {}),
+        "indexOf": algorithm([
+            `returns the index of the optional specified value if it is found`
+        ], "IndexOf", {}),
+        "length": algorithm([
+            `returns the length of the string`
+        ], "Length", {}),
+        "padEnd": algorithm([
+            `pad the string at the end with the specified value until it reaches the specified length`
+        ], "PadEnd", {}),
+        "padStart": algorithm([
+            `pad the string at the start with the specified value until it reaches the specified length`
+        ], "PadStart", {}),
+        "replaceAll": algorithm([
+            `replace all occurrences of the specified value with the replacement value`
+        ], "ReplaceAll", {}),
+        "replaceFirst": algorithm([
+            `replace only the first occurrence of the specified value with the replacement value`
+        ], "ReplaceFirst", {}),
+        "split": algorithm([
+            `split the string into an array of substrings using the specified value as the separator`
+        ], "Split", {}),
+        "splitIn2": algorithm([
+            `split the string into 2 substrings using the specified value as the separator`,
+        ], "SplitIn2", {}),
+        "startsWith": algorithm([
+            `does the string start with the specified value`
+        ], "StartsWith", {}),
+        "substring": algorithm([
+            `get a substring of the string using the specified begin and length`,
+            `it will be empty if the begin is out of bounds`,
+            `it will be truncated if begin + length is out of bounds`,
+        ], "Substring", {}),
+        "toCharacterArray": algorithm([
+            `convert the string to a character array`
+        ], "ToCharacterArray", {}),
         //"unsafeCharCodeAt": algorithm("UnsafeCharCodeAt", {}),
 
         //candidates:

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

@@ -4,10 +4,10 @@ import {
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-     list, boolean, data, group, member, integer, optional, sfunction, streamconsumer, text, type, typeReference
-} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+     list, boolean, data, group, prop, integer, optional, sfunction, streamconsumer, text, type, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 const d = pd.d
 
@@ -28,59 +28,59 @@ export const $: g_glossary.D.Glossary = {
                 "Possible Position": type(optional(integer())),
 
                 "CharacterCode At Data": type(group({
-                    "contextString": member(text()),
-                    "index": member(integer()),
+                    "contextString": prop(text()),
+                    "index": prop(integer()),
                 })),
                 "CharacterArray": type(list(integer())),
                 "SplitData": type(group({
-                    "contextString": member(text()),
-                    "splitter": member(text()),
+                    "contextString": prop(text()),
+                    "splitter": prop(text()),
                 })),
                 "IncludesData": type(group({
-                    "contextString": member(text()),
-                    "searchString": member(text()),
+                    "contextString": prop(text()),
+                    "searchString": prop(text()),
                 })),
                 "SplitIn2Result": type(group({
-                    "head": member(text()),
-                    "tail": member(optional(text())),
+                    "head": prop(text()),
+                    "tail": prop(optional(text())),
                 })),
                 "SplitResult": type(list(text())),
                 "StartsWithData": type(group({
-                    "contextString": member(text()),
-                    "searchString": member(text()),
+                    "contextString": prop(text()),
+                    "searchString": prop(text()),
                 })),
                 "EndsWithData": type(group({
-                    "contextString": member(text()),
-                    "searchString": member(text()),
+                    "contextString": prop(text()),
+                    "searchString": prop(text()),
                 })),
                 "SubstringData": type(group({
-                    "contextString": member(text()),
-                    "begin": member(integer()),
+                    "contextString": prop(text()),
+                    "begin": prop(integer()),
                     /**
                      * 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(integer()),
+                    "length": prop(integer()),
                 })),
                 "ReplaceData": type(group({
-                    "contextString": member(text()),
-                    "pattern": member(text()),
-                    "replacement": member(text()),
+                    "contextString": prop(text()),
+                    "pattern": prop(text()),
+                    "replacement": prop(text()),
                 })),
                 "EscapeParameters": type(group({
-                    "contextString": member(text()),
-                    "escape": member(text()),
-                    "patterns to escape": member(list(text())),
+                    "contextString": prop(text()),
+                    "escape": prop(text()),
+                    "patterns to escape": prop(list(text())),
                 })),
                 "PadData": type(group({
-                    "contextString": member(text()),
-                    "targetLength": member(integer()),
-                    "padString": member(text()),
+                    "contextString": prop(text()),
+                    "targetLength": prop(integer()),
+                    "padString": prop(text()),
                 })),
                 "IndexOfData": type(group({
-                    "contextString": member(text()),
-                    "searchString": member(text()),
+                    "contextString": prop(text()),
+                    "searchString": prop(text()),
                 })),
             }),
         },

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

@@ -1,8 +1,8 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
@@ -10,6 +10,11 @@ export const $: g_project.D.API = api(
     glos,
     {
 
-        "create Valid File Name": algorithm("Create Valid File Name", {}),
+        "create Valid File Name": algorithm([
+            `turns a string into a valid file name, escaping all the characters that are not allowed in a file name`,
+            `like slashes, colons, etc.`,
+            `see https://en.wikipedia.org/wiki/Filename#Reserved_characters_and_words`,
+            `and https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file`,
+        ], "Create Valid File Name", {}),
     }
 )

package/auto.pareto/modules/filesystem_naming/glossary.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.Glossary = {
@@ -34,8 +34,8 @@ export const $: g_glossary.D.Glossary = {
             'namespaces': d({}),
             'data types': d({
                 "Create Valid File Name": type(group({
-                    "raw filename": member(text()),
-                    "escape spaces": member(boolean()),
+                    "raw filename": prop(text()),
+                    "escape spaces": prop(boolean()),
                 })),
                 "Sanitized File Name": type(text()),
             }),

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

@@ -1,14 +1,14 @@
 import * as pd from 'pareto-core-data'
 
-import * as sh from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import * as sh from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
 export const $: g_project.D.API = sh.api(
     glos,
     {
-        "map Block 2 Block": sh.algorithm("Map Block 2 Block", {}),
+        "transform Block 2 Block": sh.algorithm([], "Transform Block 2 Block", {}),
     }
 )

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

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
-import * as sh from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import * as sh from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
 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"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
@@ -23,7 +23,7 @@ export const $: g_glossary.D.Glossary = {
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map Block 2 Block": sh.sfunction(sh.externalTypeReference("out", "Block"), sh.data(sh.externalTypeReference("in", "Block"))),
+        "Transform Block 2 Block": sh.sfunction(sh.externalTypeReference("out", "Block"), sh.data(sh.externalTypeReference("in", "Block"))),
     }),
 
 }

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

@@ -1,14 +1,16 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "temp_compile_boekhouding": algorithm("Main", {}),
+        "temp_compile_boekhouding": algorithm([
+                `this function compiles the boekhouding to an Alan file`,
+        ], "Main", {}),
     }
 )

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

@@ -8,14 +8,14 @@ import {
     infInit,
     integer,
     list,
-    member,
+    prop,
     streamconsumer,
     text,
     type,
     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
 
@@ -30,7 +30,7 @@ export const $: g_glossary.D.Glossary = {
                 "Message": type(text()),
                 "Exit code": type(integer()),
                 "Command Line Arguments": type(group({
-                    "arguments": member(list(text()))
+                    "arguments": prop(list(text()))
                 })),
             }),
         },

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

@@ -1,17 +1,16 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        /**
-         * this algorithm is not pure because it uses subatomic algorithms ('isEmpty' and several string operations)
-         */
-        "compilation Unit 2 Indented Lines": algorithm("Compilation Unit 2 Indented Lines", {}),
+        "compilation Unit 2 Indented Lines": algorithm([
+            `this function takes a compilation unit and returns a string with the indented lines`,
+        ],"Compilation Unit 2 Indented Lines", {}),
     }
 )

package/auto.pareto/modules/pareto_3gl_high_2_lines/glossary.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_in } from "../../auto.dependencies/pareto-pure/glossaries/auto.pareto_3gl_high.temp_in_between.data"
 // import { $ as d_fpif } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file.data"
@@ -43,7 +43,7 @@ export const $: g_glossary.D.Glossary = {
             'namespaces': d({}),
             'data types': d({
                 "Data": type(group({
-                    "compilation unit": member(component(externalTypeReference("in", "Compilation Unit", {}))),
+                    "compilation unit": prop(component(externalTypeReference("in", "Compilation Unit", {}))),
                 })),
             }),
         },

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

@@ -1,8 +1,8 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
 
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
 
 import { $ as glos } from "./glossary.data"
 
@@ -10,15 +10,19 @@ export const $: g_project.D.API = api(
     glos,
     {
 
-        "createQuotedString": algorithm("CreateQuotedString", {}),
-        "createApostrophedString": algorithm("CreateBacktickedString", {}),
-        "createBacktickedString": algorithm("CreateApostrophedString", {}),
+        "createQuotedString": algorithm([
+            `this function wraps a string in quotes and escapes all the occurences of quotes in the string`,
+        ], "CreateQuotedString", {}),
+        "createApostrophedString": algorithm([
+            `this function wraps a string in apostrophes and escapes all the occurences of apostrophes in the string`,
+        ], "CreateBacktickedString", {}),
+        "createBacktickedString": algorithm([
+            `this function wraps a string in backticks and escapes all the occurences of backticks in the string`,
+        ],"CreateApostrophedString", {}),
 
-        /**
-         * this function serializes a typescript block to a fountain pen block.
-         * the fp block can then easily be streamed to a file or console.
-         * 
-         */
-        "map Block 2 Block": algorithm("Map Block 2 Block", {}),
+        "transform Block 2 Block": algorithm([
+            `this function serializes a typescript block to a fountain pen indented file block.`,
+            `the fp block can then easily be streamed to a file or to the console`,
+        ], "Transform Block 2 Block", {}),
     }
 )