pareto 0.59.0 → 0.60.0

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{alan_light_intermediate.data.ts → string_aware_fountain_pen.data.ts}

@@ -24,6 +24,8 @@ export const $: g_glossary.D.Glossary = {
             "Line": type(array(taggedUnion({
                 "snippet": string(),
                 "apostrophed string": string(),
+                "quoted string": string(),
+                "backticked string": string(),
                 "indent": ref(typeReference("Block"))
             }))),
             "Lines": type(array(group({

package/auto.pareto/{modules/alan_light_intermediate_2 fountain_pen/glossary.data.ts → auto.dependencies/pareto-pure/modules/alan_light_2_string_aware_fountain_pen/glossary.data.ts}

@@ -15,8 +15,8 @@ import {
     externalTypeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_alan_light_intermediate } from "../../auto.dependencies/pareto-pure/glossaries/alan_light_intermediate.data"
-import { $ as d_fp } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen.data"
+import { $ as d_in } from "../../glossaries/auto.alan_light.data"
+import { $ as d_out } from "../../glossaries/string_aware_fountain_pen.data"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
@@ -24,8 +24,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "ali": imp(d_alan_light_intermediate, {}),
-        "fp": imp(d_fp, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
@@ -34,7 +34,7 @@ export const $: g_glossary.D.Glossary = {
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("fp", "Block"), data(externalTypeReference("ali", "Block"))),
+        "Map": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Root"))),
     }),
 
 }

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

@@ -10,6 +10,6 @@ import { glossary, group, member, number, sInterface, sInterfaceMethod, string,
 export const $: g_project.D.API = api(
     glos,
     {
-        "serialize": algorithm("Serialize", null, {}),
+        "map": algorithm("Map", null, {}),
     }
 )

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

@@ -13,8 +13,8 @@ import {
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
-import { $ as d_astn } from "../../glossaries/astn.data"
-import { $ as d_fp } from "../../glossaries/fountain_pen.data"
+import { $ as d_in } from "../../glossaries/astn.data"
+import { $ as d_out } from "../../glossaries/fountain_pen.data"
 
 const d = pd.d
 
@@ -22,8 +22,8 @@ export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({
     }),
     'imports': d({
-        "astn": imp(d_astn, {}),
-        "fountain pen": imp(d_fp, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
@@ -34,6 +34,6 @@ export const $: g_glossary.D.Glossary = {
 
     }),
     'algorithm types': d({
-        "Serialize": sfunction(externalTypeReference("fountain pen", "Block"), data(externalTypeReference("astn", "Value"))),
+        "Map": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Value"))),
     }),
 }

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

@@ -0,0 +1,17 @@
+
+
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "map": algorithm("Map", null, {}),
+
+    }
+)

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

@@ -0,0 +1,30 @@
+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
+} 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"
+
+import { $ as d_out } from "../../glossaries/auto.graphviz.data"
+import { $ as d_in } from "../../glossaries/auto.cosmos_type_system.data"
+
+const d = pd.d
+
+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({
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("out", "Graph"), data(externalTypeReference("in", "Glossary"))),
+
+    }),
+}

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

@@ -6,28 +6,28 @@ import {
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
-import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
-import { $ as d_cosmos } from "../../glossaries/auto.cosmos_type_system.data"
+import { $ as d_out } from "../../glossaries/auto.pareto.data"
+import { $ as d_in } from "../../glossaries/auto.cosmos_type_system.data"
 
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "pareto": imp(d_pareto, {}),
-        "cosmos": imp(d_cosmos, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
         'data types': d({
             "Library2ParetoComparatorsData": type(group({
-                "library": member(ref(externalTypeReference("cosmos", "Library"))),
+                "library": member(ref(externalTypeReference("in", "Library"))),
             })),
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Library2ParetoComparators": sfunction(externalTypeReference("pareto", "Compilation Unit"), data(typeReference("Library2ParetoComparatorsData"))),
+        "Library2ParetoComparators": sfunction(externalTypeReference("out", "Compilation Unit"), data(typeReference("Library2ParetoComparatorsData"))),
 
     }),
 }

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

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

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

@@ -10,25 +10,27 @@ import {
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
 
-import { $ as d_fountain_pen } from "../../glossaries/fountain_pen.data"
+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({
-        "fp": imp(d_fountain_pen, {}),
+
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "SerializeData": type(group({
-                "block": member(ref(externalTypeReference("fp", "Block"))),
-            })),
-            "String": type(string()),
+            // "SerializeData": type(group({
+            //     "block": member(ref(externalTypeReference("in", "Block"))),
+            // })),
+            // "String": type(string()),
         }),
     },
-    'interface types': d({    }),
+    'interface types': d({}),
     'algorithm types': d({
-        "Serialize": sfunction(externalTypeReference("fp", "Lines"), data(externalTypeReference("fp", "Block"))),
-
+        "Map": sfunction(externalTypeReference("out", "Lines"), data(externalTypeReference("in", "Block"))),
     }),
 }

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

@@ -10,31 +10,31 @@ import {
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
 
-import { $ as d_fountain_pen } from "../../glossaries/fountain_pen.data"
-import { $ as d_lines } from "../../glossaries/lines.data"
+import { $ as d_in } from "../../glossaries/fountain_pen.data"
+import { $ as d_out } from "../../glossaries/lines.data"
 
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "fp": imp(d_fountain_pen, {}),
-        "lines": imp(d_lines, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
         'data types': d({
             "IndentData": type(group({
-                "lines": member(ref(externalTypeReference("fp", "Lines"))),
+                "lines": member(ref(externalTypeReference("in", "Lines"))),
                 "indentation": member(string()),
             })),
             "String": type(string()),
         }),
     },
     'interface types': d({
-        "Lines": aInterface(aInterfaceMethod(externalTypeReference("fp", "Lines"))),
+        "Lines": aInterface(aInterfaceMethod(externalTypeReference("in", "Lines"))),
         "Indented Lines": aInterface(streamconsumer(aInterfaceMethod(typeReference("String")), null)),
     }),
     'algorithm types': d({
-        "Indent": sfunction(externalTypeReference("lines", "Lines"), data(typeReference("IndentData"))),
+        "Indent": sfunction(externalTypeReference("out", "Lines"), data(typeReference("IndentData"))),
         "Stream": infInit(aInterfaceReference("Lines"), {
             "handler": aInterfaceReference("Indented Lines")
         }),

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

@@ -0,0 +1,20 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+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,
+    {
+        /**
+         * use this function to serialize to an intermediate format.
+         * 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": algorithm("Map", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/{alan_light_2_alan_light_intermediate → graphviz_2_string_aware_fountain_pen}/glossary.data.ts

@@ -15,8 +15,8 @@ import {
     externalTypeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_alan_light } from "../../glossaries/auto.alan_light.data"
-import { $ as d_alan_light_intermediate } from "../../glossaries/alan_light_intermediate.data"
+import { $ as d_in } from "../../glossaries/auto.graphviz.data"
+import { $ as d_out } from "../../glossaries/string_aware_fountain_pen.data"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
@@ -24,8 +24,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "alan light": imp(d_alan_light, {}),
-        "alan light intermediate": imp(d_alan_light_intermediate, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
@@ -34,7 +34,7 @@ export const $: g_glossary.D.Glossary = {
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("alan light intermediate", "Block"), data(externalTypeReference("alan light", "Root"))),
+        "Map": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Graph"))),
     }),
 
 }

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

@@ -26,15 +26,15 @@ import {
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
-import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
-import { $ as d_typescript_intermediate } from "../../glossaries/typescript_intermediate.data"
+import { $ as d_in } from "../../glossaries/auto.pareto.data"
+import { $ as d_out } from "../../glossaries/typescript_intermediate.data"
 
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
     'imports': d({
-        "pareto": imp(d_pareto, {}),
-        "typescript intermediate": imp(d_typescript_intermediate, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
 
     'glossary parameters': d({}),
@@ -42,12 +42,12 @@ export const $: g_glossary.D.Glossary = {
         'namespaces': d({}),
         'data types': d({
             "Map Data": type(group({
-                "compilation unit": member(ref(externalTypeReference("pareto", "Compilation Unit", {}))),
+                "compilation unit": member(ref(externalTypeReference("in", "Compilation Unit", {}))),
             })),
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("typescript intermediate", "Block"), data(typeReference("Map Data"))),
+        "Map": sfunction(externalTypeReference("out", "Block"), data(typeReference("Map Data"))),
     }),
 }

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

@@ -26,15 +26,15 @@ import {
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
-import { $ as d_tendril } from "../../glossaries/auto.tendril_resolved.data"
-import { $ as d_alan_light } from "../../glossaries/auto.alan_light.data"
+import { $ as d_in } from "../../glossaries/auto.tendril_resolved.data"
+import { $ as d_out } from "../../glossaries/auto.alan_light.data"
 
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
     'imports': d({
-        "tendril": imp(d_tendril, {}),
-        "alan light": imp(d_alan_light, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'glossary parameters': d({}),
     'root': {
@@ -44,6 +44,6 @@ export const $: g_glossary.D.Glossary = {
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("alan light", "Root"), data(externalTypeReference("tendril", "Model"))),
+        "Map": sfunction(externalTypeReference("out", "Root"), data(externalTypeReference("in", "Model"))),
     }),
 }

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

@@ -7,8 +7,8 @@ import {
     array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_cosmos } from "../../glossaries/auto.cosmos_type_system.data"
-import { $ as d_tendril } from "../../glossaries/auto.tendril_resolved.data"
+import { $ as d_out } from "../../glossaries/auto.cosmos_type_system.data"
+import { $ as d_in } from "../../glossaries/auto.tendril_resolved.data"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
@@ -16,8 +16,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "cosmos": imp(d_cosmos, {}),
-        "tendril": imp(d_tendril, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
@@ -27,7 +27,7 @@ export const $: g_glossary.D.Glossary = {
                 "settings": member(ref(typeReference("Mapping Settings"))),
             })),
             "Mapped Library": type(group({
-                "library": member(ref(externalTypeReference("tendril", "Type Library", {}))),
+                "library": member(ref(externalTypeReference("in", "Type Library", {}))),
                 "terminal mapping": member(ref(typeReference("Terminal Mapping"))),
             })),
 
@@ -67,7 +67,7 @@ export const $: g_glossary.D.Glossary = {
     'interface types': d({
     }),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("cosmos", "Glossary", {}), data(typeReference("MapData"))),
+        "Map": sfunction(externalTypeReference("out", "Glossary", {}), data(typeReference("MapData"))),
 
     }),
 }

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

@@ -7,8 +7,8 @@ import {
     array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
-import { $ as d_tendril } from "../../glossaries/auto.tendril_resolved.data"
+import { $ as d_out } from "../../glossaries/auto.pareto.data"
+import { $ as d_in } from "../../glossaries/auto.tendril_resolved.data"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
@@ -16,8 +16,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "pareto": imp(d_pareto, {}),
-        "tendril": imp(d_tendril, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
@@ -28,7 +28,7 @@ export const $: g_glossary.D.Glossary = {
     'interface types': d({
     }),
     'algorithm types': d({
-        "CreateResolver": sfunction(externalTypeReference("pareto", "Compilation Unit", {}), data(externalTypeReference("tendril", "Type Library", {}))),
-        "CreateSerializer": sfunction(externalTypeReference("pareto", "Compilation Unit", {}), data(externalTypeReference("tendril", "Type Library", {}))),
+        "CreateResolver": sfunction(externalTypeReference("out", "Compilation Unit", {}), data(externalTypeReference("in", "Type Library", {}))),
+        "CreateSerializer": sfunction(externalTypeReference("out", "Compilation Unit", {}), data(externalTypeReference("in", "Type Library", {}))),
     }),
 }

package/auto.pareto/auto.dependencies/pareto-standard-library/$.data.ts

@@ -5,12 +5,12 @@ import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.co
 const d = pd.d
 import { } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_arithmetic } from "./modules/arithmetic/api.data"
 import { $ as d_array } from "./modules/array/api.data"
 import { $ as d_boolean } from "./modules/boolean/api.data"
-import { $ as d_build } from "./modules/build/api.data"
+import { $ as d_buildInterfaceInitializers } from "./modules/buildInterfaceInitializers/api.data"
 import { $ as d_dictionary } from "./modules/dictionary/api.data"
-import { $ as d_nested } from "./modules/nested/api.data"
+import { $ as d_number } from "./modules/number/api.data"
+import { $ as d_optional } from "./modules/optional/api.data"
 import { $ as d_resolve } from "./modules/resolve/api.data"
 import { $ as d_string } from "./modules/string/api.data"
 import { $ as d_tostring } from "./modules/tostring/api.data"
@@ -25,15 +25,13 @@ export const $: g_project.D.Library = {
         'public': {
             'glossaries': d({}),
             'modules': d({
-                "arithmetic": d_arithmetic,
                 "array": d_array,
                 "boolean": d_boolean,
-                "build": d_build,
+                "build interface initializers": d_buildInterfaceInitializers,
                 "dictionary": d_dictionary,
-                "nested": d_nested,
-                "resolve": d_resolve,
+                "number": d_number,
+                "optional": d_optional,
                 "string": d_string,
-                "tostring": d_tostring,
             })
         },
         'private': {

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/array/api.data.ts

@@ -14,6 +14,8 @@ export const $: g_project.D.API = api(
         "append": algorithm("Append", null, {}),
         "prepend": algorithm("Prepend", null, {}),
         "zip": algorithm("Zip", null, {}),
+        "flattenTree": algorithm("FlattenTree", null, {}),
+        "unsafeSortTopologically": algorithm("SortTopologically", null, {}),
 
     }
 )

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/array/glossary.data.ts

@@ -1,7 +1,9 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, data, dictionary, externalTypeReference, group, member, number, optional, parametrizedType, ref, sfunction,
+    array, data, dictionary, externalTypeReference, group, member, null_, number, optional, parametrizedType, ref, sfunction,
+    string,
+    taggedUnion,
     type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -16,37 +18,104 @@ export const $: g_glossary.D.Glossary = {
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
-            "ArrayOfArrays": parametrizedType({ "Type": null }, array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+            //out
+            "Array": parametrizedType(
+                { "Type": null },
+                array(ref(typeParameter("Type")))
+            ),
 
-            "AppendParameters": parametrizedType({ "Type": null }, group({
-                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                "element": member(ref(typeParameter("Type"))),
-            })),
-            "PrependParameters": parametrizedType({ "Type": null }, group({
-                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                "element": member(ref(typeParameter("Type"))),
-            })),
-            "ArrayTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
-                "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
-                "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+            "ZippedArray": parametrizedType(
+                { "Benchmark": null, "Focus": null },
+                array(group({
+                    "benchmark": member(ref(typeParameter("Benchmark"))),
+                    "focus": member(ref(typeParameter("Focus"))),
+                }))
+            ),
+
+            //in
+            "ArrayOfArrays": parametrizedType(
+                { "Type": null },
+                array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+
+            "AppendParameters": parametrizedType(
+                { "Type": null },
+                group({
+                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                    "element": member(ref(typeParameter("Type"))),
+                })
+            ),
+            "PrependParameters": parametrizedType(
+                { "Type": null },
+                group({
+                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                    "element": member(ref(typeParameter("Type"))),
+                })
+            ),
+            "ArrayTuple": parametrizedType(
+                { "Benchmark": null, "Focus": null },
+                group({
+                    "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                    "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+                })
+            ),
+            "Nested": parametrizedType({ "Type": null }, taggedUnion({
+                "single": ref(typeParameter("Type")),
+                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
+                "none": null_(),
             })),
-            "ZippedArray": parametrizedType({ "Benchmark": null, "Focus": null }, array(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(ref(typeParameter("Focus"))),
+            // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+            // "KeyValuePair": parametrizedType({ "Type": null }, group({
+            //     "key": member(string()),
+            //     "value": member(ref(typeParameter("Type"))),
+            // })),
+
+            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
+                "value": member(ref(typeParameter("Type"))),
+                "dependencies": member(dictionary(null_())),
             }))),
 
+
+            "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Append": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("AppendParameters", { "Type": typeParameter("Type") })), { "Type": null }),
-        "Prepend": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("PrependParameters", { "Type": typeParameter("Type") })), { "Type": null }),
-        "FlattenArrayOfArrays": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })), { "Type": null }),
+        "Append": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("AppendParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "Prepend": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("PrependParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "FlattenArrayOfArrays": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })),
+            { "Type": null },
+        ),
+        "FlattenTree": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("Nested", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
         "Zip": sfunction(
             typeReference("ZippedArray", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
             data(typeReference("ArrayTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
             { "Benchmark": null, "Focus": null }
         ),
+
+
+        "SortTopologically": sfunction(
+            typeReference("KeyValuePairArray", { "Type": typeParameter("Type") }),
+            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
     }),
 }