pareto 0.64.0 → 0.66.0

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

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

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

@@ -24,6 +24,10 @@ export const $: g_project.D.Library = {
     'module sets': {
         'public': {
             'glossaries': d({}),
+            'transformations': {
+                'enrich': d({}),
+                'yield': d({}),
+            },
             'modules': d({
                 "array": d_array,
                 "boolean": d_boolean,
@@ -36,6 +40,10 @@ export const $: g_project.D.Library = {
         },
         'private': {
             'glossaries': d({}),
+            'transformations': {
+                'enrich': d({}),
+                'yield': d({}),
+            },
             'modules': d({}),
         }
     }

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

@@ -5,17 +5,16 @@ 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,
     {
-        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", null, {}),
-        "append": algorithm("Append", null, {}),
-        "prepend": algorithm("Prepend", null, {}),
-        "zip": algorithm("Zip", null, {}),
-        "flattenTree": algorithm("FlattenTree", null, {}),
-        "unsafeSortTopologically": algorithm("SortTopologically", null, {}),
+        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", {}),
+        "append": algorithm("Append", {}),
+        "prepend": algorithm("Prepend", {}),
+        "zip": algorithm("Zip", {}),
+        "flattenTree": algorithm("FlattenTree", {}),
+        "unsafeSortTopologically": algorithm("SortTopologically", {}),
 
     }
 )

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

@@ -1,10 +1,24 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, data, dictionary, externalTypeReference, group, member, null_, number, optional, parametrizedType, ref, sfunction,
-    string,
-    taggedUnion,
-    type, typeParameter, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
@@ -22,64 +36,64 @@ export const $: g_glossary.D.Glossary = {
                 //out
                 "Array": parametrizedType(
                     { "Type": null },
-                    array(ref(typeParameter("Type")))
+                    list(component(typeParameter("Type")))
                 ),
 
                 "ZippedArray": parametrizedType(
                     { "Benchmark": null, "Focus": null },
-                    array(group({
-                        "benchmark": member(ref(typeParameter("Benchmark"))),
-                        "focus": member(ref(typeParameter("Focus"))),
+                    list(group({
+                        "benchmark": member(component(typeParameter("Benchmark"))),
+                        "focus": member(component(typeParameter("Focus"))),
                     }))
                 ),
 
                 //in
                 "ArrayOfArrays": parametrizedType(
                     { "Type": null },
-                    array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+                    list(component(typeReference("Array", { "Type": typeParameter("Type") })))),
 
                 "AppendParameters": parametrizedType(
                     { "Type": null },
                     group({
-                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                        "element": member(ref(typeParameter("Type"))),
+                        "array": member(component(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(component(typeParameter("Type"))),
                     })
                 ),
                 "PrependParameters": parametrizedType(
                     { "Type": null },
                     group({
-                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                        "element": member(ref(typeParameter("Type"))),
+                        "array": member(component(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(component(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") }))),
+                        "benchmark": member(component(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                        "focus": member(component(typeReference("Array", { "Type": typeParameter("Focus") }))),
                     })
                 ),
-                "Nested": parametrizedType({ "Type": null }, taggedUnion({
-                    "single": ref(typeParameter("Type")),
-                    "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
-                    "none": null_(),
+                "Nested": parametrizedType({ "Type": null }, stateGroup({
+                    "single": component(typeParameter("Type")),
+                    "multiple": list(component(typeReference("Nested", { "Type": typeParameter("Type") }))),
+                    "none": nothing(),
                 })),
-                // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                // "Array": parametrizedType({ "Type": null }, list(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
                 // "KeyValuePair": parametrizedType({ "Type": null }, group({
-                //     "key": member(string()),
-                //     "value": member(ref(typeParameter("Type"))),
+                //     "key": member(text()),
+                //     "value": member(component(typeParameter("Type"))),
                 // })),
 
                 "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                    "value": member(ref(typeParameter("Type"))),
-                    "dependencies": member(dictionary(null_())),
+                    "value": member(component(typeParameter("Type"))),
+                    "dependencies": member(dictionary(nothing())),
                 }))),
 
 
-                "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "KeyValuePairArray": parametrizedType({ "Type": null }, list(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
                 "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": member(string()),
-                    "value": member(ref(typeParameter("Type"))),
+                    "key": member(text()),
+                    "value": member(component(typeParameter("Type"))),
                 })),
 
             }),

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

@@ -5,17 +5,16 @@ 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,
     {
-        "array_and": algorithm("Array And", null, {}),
-        "array_or": algorithm("Array Or", null, {}),
-        "array_xor": algorithm("Array Xor", null, {}),
-        "and": algorithm("And", null, {}),
-        "or": algorithm("Or", null, {}),
-        "xor": algorithm("Xor", null, {}),
-        "not": algorithm("Not", null, {}),
+        "array_and": algorithm("Array And", {}),
+        "array_or": algorithm("Array Or", {}),
+        "array_xor": algorithm("Array Xor", {}),
+        "and": algorithm("And", {}),
+        "or": algorithm("Or", {}),
+        "xor": algorithm("Xor", {}),
+        "not": algorithm("Not", {}),
     }
 )

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

@@ -1,15 +1,23 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array,
     boolean,
+    component,
     data,
+    dictionary,
     externalTypeReference,
     group,
+    integer,
+    list,
     member,
-    number,
+    nothing,
+    optional,
+    parametrizedType,
     sfunction,
+    stateGroup,
+    text,
     type,
+    typeParameter,
     typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -29,7 +37,7 @@ export const $: g_glossary.D.Glossary = {
                     "yin": member(boolean()),
                     "yang": member(boolean()),
                 })),
-                "Array Of Booleans": type(array(boolean())),
+                "Array Of Booleans": type(list(boolean())),
             }),
         },
     },

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

@@ -5,20 +5,18 @@ 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, sInterface, sInterfaceMethod, string, taggedUnion, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        // "buildArray": algorithm("BuildArray", null, {}),
-        // "buildUnsafeDictionary": algorithm("BuildUnsafeDictionary", null, {}),
+        // "buildArray": algorithm("BuildArray", {}),
+        // "buildUnsafeDictionary": algorithm("BuildUnsafeDictionary", {}),
         // "buildSafeDictionary": algorithm("BuildSafeDictionary", "DictionaryBuildStrategy", {}, {
         // }),
-        "createUnsafeDictionaryBuilder": algorithm("CreateUnsafeDictionaryBuilder", null, {}),
-        "createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", "DictionaryBuildStrategy", {}),
-        "createArrayBuilder": algorithm("CreateArrayBuilder", null, {}),
+        "createUnsafeDictionaryBuilder": algorithm("CreateUnsafeDictionaryBuilder", {}),
+        //"createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", {}),
+        "createArrayBuilder": algorithm("CreateArrayBuilder", {}),
 
-        "createStringBuilder": algorithm("CreateStringBuilder", "Startstring", {
-        }),
+        "createStringBuilder": algorithm("CreateStringBuilder", {}),
     }
 )

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

@@ -1,12 +1,33 @@
 import * as pd from 'pareto-core-data'
 
 import {
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
+
+    aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, dictionary, ref, typeParameter, group, sInf, member,
-    sfunction,
-    sInterfaceMethod, sInterfaceReference, streamconsumer, string, taggedUnion, type, typeReference, aInterface, sInterface, parametrizedType,
-    infInit
+    infInit,
+    sInterface,
+    sInterfaceMethod,
+    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"
@@ -20,33 +41,33 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+                "Simple Array": parametrizedType({ "Type": null }, list(component(typeParameter("Type")))),
 
-                "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-                "Simple String": type(string()),
+                "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
+                "Simple String": type(text()),
 
                 "Array": parametrizedType({ "Type": null, "EndType": null }, group({
-                    "array": member(array(ref(typeParameter("Type")))),
-                    "end": member(ref(typeParameter("EndType"))),
+                    "array": member(list(component(typeParameter("Type")))),
+                    "end": member(component(typeParameter("EndType"))),
                 })),
                 "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
-                    "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                    "end": member(ref(typeParameter("EndType"))),
+                    "dictionary": member(dictionary(component(typeParameter("Type")))),
+                    "end": member(component(typeParameter("EndType"))),
                 })),
                 "String": parametrizedType({ "EndType": null }, group({
-                    "string": member(string()),
-                    "end": member(ref(typeParameter("EndType"))),
+                    "string": member(text()),
+                    "end": member(component(typeParameter("EndType"))),
                 })),
                 "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": member(string()),
-                    "value": member(ref(typeParameter("Type"))),
+                    "key": member(text()),
+                    "value": member(component(typeParameter("Type"))),
                 })),
 
-                "DictionaryBuildStrategy": type(taggedUnion({
+                "DictionaryBuildStrategy": type(stateGroup({
                     "ignore": group({}),
                     "overwrite": group({}),
                 })),
-                "Startstring": type(string()),
+                // "Startstring": type(text()),
             }),
         },
 

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

@@ -5,50 +5,49 @@ 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,
     {
-        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
+        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", {}),
 
-        "filter": algorithm("Filter", null, {}),
+        "filter": algorithm("Filter", {}),
         /**
          * the keys of the outermost dictionary is combined with the key of the innermost dictionary
          */
-        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", null, {}),
+        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", {}),
         /**
          * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the last dictionary will be used.
          */
-        "mergeAndOverwrite": algorithm("MergeAndOverwrite", null, {}),
+        "mergeAndOverwrite": algorithm("MergeAndOverwrite", {}),
         /**
          * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the first dictionary will be used.
          */
-        "mergeAndIgnore": algorithm("MergeAndIgnore", null, {}),
+        "mergeAndIgnore": algorithm("MergeAndIgnore", {}),
         /**
          * a dictionary with containing entries with values and a key candidate is transformed
          * into a dictionary where the new key of the entry is the candidate. If candidates are not unique
          * the function panics
          */
-        "unsafeRekey": algorithm("UnsafeRekey", null, {}),
+        "unsafeRekey": algorithm("UnsafeRekey", {}),
         /**
          * 2 dictionaries are combined into 1 dictionary. If keys are not unique this function panics.
          */
-        "unsafeMerge": algorithm("UnsafeMerge", null, {}),
+        "unsafeMerge": algorithm("UnsafeMerge", {}),
         /**
          * a key/value pair is added to a dictionary resulting in a new dictionary.
          * if the key is not unique the function panics
          */
-        "unsafeAddEntry": algorithm("UnsafeAddEntry", null, {}),
+        "unsafeAddEntry": algorithm("UnsafeAddEntry", {}),
         /**
          * prepends and appends strings to all keys in the dictionary
          */
-        "wrapKeys": algorithm("WrapKeys", null, {}),
+        "wrapKeys": algorithm("WrapKeys", {}),
         /**
          * a focus dictionary is matched to a benchmark dictionary resulting in a result dictionary
          * this last dictionary contains all entries found in the benchmark dictionary.
          * each entry value is optionally supplemented with the value of the focus entry, if found.
          */
-        "zip": algorithm("Zip", null, {}),
+        "zip": algorithm("Zip", {}),
     }
 )