pareto 0.57.0 → 0.59.0

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

@@ -1,19 +0,0 @@
-
-
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "indent": algorithm("Indent", null, {}),
-        "serialize": algorithm("Serialize", null, {}),
-        "stream": algorithm("Stream", null, {}),
-    }
-)

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

@@ -1,55 +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/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/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(),
-                "indent": ref(typeReference("Block"))
-            }))),
-            "Lines": type(array(group({
-                "indentation": member(number()),
-                "text": member(string()),
-            }))),
-            "Indented Lines": type(array(string())),
-            "SerializeData": type(group({
-                "block": member(ref(typeReference("Block"))),
-                "indentation": member(string()),
-            })),
-            "IndentData": type(group({
-                "lines": member(ref(typeReference("Lines"))),
-                "indentation": member(string()),
-            })),
-            "String": type(string()),
-        }),
-    },
-    'interface types': d({
-        "Lines": aInterface(aInterfaceMethod(typeReference("Lines"))),
-        "Indented Lines": aInterface(streamconsumer(aInterfaceMethod(typeReference("String")), null)),
-    }),
-    'algorithm types': d({
-        "Indent": sfunction(typeReference("Indented Lines"), data(typeReference("IndentData"))),
-        "Serialize": sfunction(typeReference("Lines"), data(typeReference("Block"))),
-        "Stream": infInit(aInterfaceReference("Lines"), {
-            "handler": aInterfaceReference("Indented Lines")
-        }),
-    }),
-}

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

@@ -1,24 +0,0 @@
-
-
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        // "map": algorithm("Map", null, {
-        //     // "resolveDictionary": sfunction("resolve", {}, "SafeResolveDictionary"),
-        //     // // "decorateDictionaryEntriesWithKey": sfunction("foreach", {}, "DecorateDictionaryEntriesWithKey"),
-        //     // // "buildDictionary": sfunction("build", {}, "BuildUnsafeDictionary"),
-        //     // // "filter": sfunction("dictionary", {}, "Filter"),
-        //     // // "isEmpty": sfunction("dictionary", {}, "IsEmpty"),
-        //     // // "merge": sfunction("array", {}, "Merge"),
-        //     // // "push": sfunction("array", {}, "Push"),
-        // }),
-    }
-)

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

@@ -1,48 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, number, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as d_liana } from "../../glossaries/auto.liana.data"
-import { $ as d_tendril } from "../../glossaries/auto.tendril.data"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "liana": {
-            'glossary': d_liana,
-            'type arguments': d({
-            }),
-        },
-        "tendril": {
-            'glossary': d_tendril,
-            'type arguments': d({
-            }),
-        },
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "TypeScript Location": type(group({
-                "file": member(string()),
-                "line": member(number()),
-                "column": member(number()),
-            }))
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Map": sfunction(
-            //FIXME this function should reference to the libraries that don't have annotations.
-            //this function is designed not to be able to produce runtime errors, so no error info is needed
-            //However, the functionality to produce a resolved, annotationless library need to be written
-            externalTypeReference("tendril", "Type Library", { "Annotation": typeReference("TypeScript Location") }),
-            data(externalTypeReference("liana", "Type Library", { "Annotation": typeReference("TypeScript Location") }))
-        ),
-    }),
-}

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

@@ -1,16 +0,0 @@
-
-
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/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/tendril2pareto/api.data.ts

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

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

@@ -1,58 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-import { } from "pareto/auto.dist/public/shorthands/cosmos"
-
-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_collation } from "./modules/collation/api.data"
-import { $ as d_dictionary } from "./modules/dictionary/api.data"
-import { $ as d_filesystem } from "./modules/filesystem/api.data"
-import { $ as d_foreach } from "./modules/foreach/api.data"
-import { $ as d_http } from "./modules/http/api.data"
-import { $ as d_json } from "./modules/json/api.data"
-import { $ as d_path } from "./modules/path/api.data"
-import { $ as d_nested } from "./modules/nested/api.data"
-import { $ as d_numerical_predicates } from "./modules/numerical_predicates/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"
-
-export const $: g_project.D.Library = {
-    'author': "Corno",
-    'description': "A library that contains very common functionality that cannot be implemented purely in Pareto",
-    'license': "TBD",
-
-    'type': ['impure', null],
-    'module sets': {
-        'public': {
-            'glossaries': d({}),
-            'modules': d({
-                "arithmetic": d_arithmetic,
-                "array": d_array,
-                "boolean": d_boolean,
-                "build": d_build,
-                "collation": d_collation,
-                "dictionary": d_dictionary,
-                "filesystem": d_filesystem,
-                "foreach": d_foreach,
-                "http": d_http,
-                "json": d_json,
-                "nested": d_nested,
-                "numerical predicates": d_numerical_predicates,
-                "path": d_path,
-                "resolve": d_resolve,
-                "string": d_string,
-                "tostring": d_tostring,
-            })
-        },
-        'private': {
-            'glossaries': d({}),
-            'modules': d({}),
-        }
-    }
-}

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

@@ -1,26 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "arrayMax": algorithm("ArrayMax", null, {}),
-        "arrayMin": algorithm("ArrayMin", null, {}),
-        "arraySum": algorithm("ArraySum", null, {}),
-        "dictionaryMax": algorithm("DictionaryMax", null, {}),
-        "dictionaryMin": algorithm("DictionaryMin", null, {}),
-        "dictionarySum": algorithm("DictionarySum", null, {}),
-        "divideWithRemainder": algorithm("DivideWithRemainder", null, {}),
-        "increment": algorithm("Increment", "IncrementConfig", {}),
-        "max": algorithm("Max", null, {}),
-        "array_multiply": algorithm("Array Multiply", null, {}),
-        "negate": algorithm("Negate", null, {}),
-        "subtract": algorithm("Subtract", null, {}),
-    }
-)

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

@@ -1,76 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
-    type, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Number": type(number()),
-            "OptionalNumber": type(optional(number())),
-            "NumberRange": type(array(number())),
-            "DivisionData": type(group({
-                "numerator": member(number()),
-                "denominator": member(number()),
-            })),
-            "NumberTuple": type(group({
-                "yin": member(number()),
-                "yang": member(number()),
-            })),
-            "DivisionResult": type(optional(group({
-                "quotient": member(number()),
-                "remainder": member(number()),
-
-            }))),
-            "SubtractData": type(group({
-                "minuend": member(number()),
-                "subtrahend": member(number()),
-            })),
-            "NumberDictionary": type(dictionary(number())),
-            "NumberArray": type(array(number())),
-
-            "IncrementConfig": type(group({
-                "stepsize": member(number())
-            }))
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Increment": sfunction(typeReference("Number"), data(typeReference("Number"))),
-        "Array Multiply": sfunction(typeReference("Number"), data(typeReference("NumberRange"))),
-        "Negate": sfunction(typeReference("Number"), data(typeReference("Number"))),
-        /**
-        * if the denominator is 0, the return value is null
-        * (division by 0),
-        */
-        "DivideWithRemainder": sfunction(typeReference("DivisionResult"), data(typeReference("DivisionData"))),
-        /**
-         * calculates the max of an array of numbers. If there are no entries, the result value is 0
-         */
-        "ArrayMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
-        "ArrayMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
-        "ArraySum": sfunction(typeReference("Number"), data(typeReference("NumberArray"))),
-        /**
-         * calculates the max of a dictionary of number. If there are no entries, the result value is 0
-         */
-        "DictionaryMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
-        "DictionaryMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
-        /**
-        * calculates the max of a tuple of numbers
-        */
-        "DictionarySum": sfunction(typeReference("Number"), data(typeReference("NumberDictionary"))),
-
-        "Max": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
-        "Subtract": sfunction(typeReference("Number"), data(typeReference("SubtractData"))),
-    }),
-}

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

@@ -1,21 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "getLastElement": algorithm("GetLastElement", null, {}),
-        //FIXME "getElementAt": algorithm("GetElementAt", null, {}),
-        "getLength": algorithm("GetLength", null, {}),
-        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", null, {}),
-        "push": algorithm("Push", null, {}),
-        "matchArrays": algorithm("MatchArrays", null, {}),
-
-    }
-)

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

@@ -1,60 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, data, dictionary, externalTypeReference, group, member, number, optional, parametrizedType, ref, sfunction,
-    type, typeParameter, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Length": type(number()),
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
-            "ArrayOfArrays": parametrizedType({ "Type": null }, array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
-            "GetElementAtData": parametrizedType({ "Type": null }, group({
-                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                "index": member(number()),
-            })),
-            "PushParameters": parametrizedType({ "Type": null }, group({
-                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                "element": member(ref(typeParameter("Type"))),
-            })),
-            "OptionalElement": parametrizedType({ "Type": null }, optional(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") }))),
-            })),
-
-            "MatchedArrays": parametrizedType({ "Benchmark": null, "Focus": null }, array(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(ref(typeParameter("Focus"))),
-            }))),
-
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "GetElementAt": sfunction(typeParameter("Type"), data(typeReference("GetElementAtData", { "Type": typeParameter("Type") })), { "Type": null }),
-        "GetLastElement": sfunction(typeReference("OptionalElement", { "Type": typeParameter("Type") }), data(typeReference("Array", { "Type": typeParameter("Type") })), { "Type": null }),
-        "GetLength": sfunction(typeReference("Length"), data(typeReference("Array", { "Type": typeParameter("Type") })), { "Type": null }),
-        "FlattenArrayOfArrays": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })), { "Type": null }),
-        "Push": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("PushParameters", { "Type": typeParameter("Type") })), { "Type": null }),
-
-
-        "MatchArrays": sfunction(
-            typeReference("MatchedArrays", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
-            data(typeReference("ArrayTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
-            { "Benchmark": null, "Focus": null }
-        ),
-    }),
-}

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

@@ -1,21 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-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, {}),
-    }
-)

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

@@ -1,45 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array,
-    boolean,
-    data,
-    externalTypeReference,
-    group,
-    member,
-    number,
-    sfunction,
-    type,
-    typeReference,
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "Pair Of Booleans": type(group({
-                "yin": member(boolean()),
-                "yang": member(boolean()),
-            })),
-            "Array Of Booleans": type(array(boolean())),
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Array And": sfunction(typeReference("Boolean"), data(typeReference("Array Of Booleans"))),
-        "Array Or": sfunction(typeReference("Boolean"), data(typeReference("Array Of Booleans"))),
-        "Array Xor": sfunction(typeReference("Boolean"), data(typeReference("Array Of Booleans"))),
-        "And": sfunction(typeReference("Boolean"), data(typeReference("Pair Of Booleans"))),
-        "Or": sfunction(typeReference("Boolean"), data(typeReference("Pair Of Booleans"))),
-        "Xor": sfunction(typeReference("Boolean"), data(typeReference("Pair Of Booleans"))),
-        "Not": sfunction(typeReference("Boolean"), data(typeReference("Boolean"))),
-    }),
-
-}

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

@@ -1,25 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, sInterface, sInterfaceMethod, string, taggedUnion, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        // "buildArray": algorithm("BuildArray", null, {}),
-        // "buildUnsafeDictionary": algorithm("BuildUnsafeDictionary", null, {}),
-        // "buildSafeDictionary": algorithm("BuildSafeDictionary", "DictionaryBuildStrategy", {}, {
-        // }),
-        "createUnsafeDictionaryBuilder": algorithm("CreateUnsafeDictionaryBuilder", null, {}),
-        "createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", "DictionaryBuildStrategy", {}),
-        "createArrayBuilder": algorithm("CreateArrayBuilder", null, {}),
-
-
-        "createStringBuilder": algorithm("CreateStringBuilder", "Startstring", {
-        }),
-    }
-)

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

@@ -1,133 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    aInterfaceMethod,
-    aInterfaceReference,
-    array, dictionary, ref, typeParameter, group, sInf, member,
-    sfunction,
-    sInterfaceMethod, sInterfaceReference, streamconsumer, string, taggedUnion, type, typeReference, aInterface, sInterface, parametrizedType,
-    infInit
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
-
-            "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "Simple String": type(string()),
-
-            "Array": parametrizedType({ "Type": null, "EndType": null }, group({
-                "array": member(array(ref(typeParameter("Type")))),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
-                "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "String": parametrizedType({ "EndType": null }, group({
-                "string": member(string()),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-
-
-
-
-
-            "DictionaryBuildStrategy": type(taggedUnion({
-                "ignore": group({}),
-                "overwrite": group({}),
-            })),
-            "Startstring": type(string()),
-        }),
-    },
-    'interface types': d({
-        "Array": aInterface(aInterfaceMethod(typeReference("Array", {
-            "Type": typeParameter("Type"),
-            "EndType": typeParameter("EndType")
-        })), { "Type": null, "EndType": null }),
-        "Dictionary": aInterface(aInterfaceMethod(typeReference("Dictionary", {
-            "Type": typeParameter("Type"),
-            "EndType": typeParameter("EndType")
-        })), { "Type": null, "EndType": null }),
-        "Elements": aInterface(streamconsumer(
-            aInterfaceMethod(typeParameter("Type")),
-            aInterfaceMethod(typeParameter("EndType")),
-        ), { "Type": null, "EndType": null }),
-        "Entries": aInterface(streamconsumer(
-            aInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })),
-            aInterfaceMethod(typeParameter("EndType")),
-        ), { "Type": null, "EndType": null }),
-        "DuplicatesHandler": aInterface(streamconsumer(
-            aInterfaceMethod(typeReference("Simple String")),
-            aInterfaceMethod(null),
-        )),
-        "StringConsumer": aInterface(aInterfaceMethod(typeReference("String", { "EndType": typeParameter("EndType") })), { "EndType": null }),
-        "StringStreamConsumer": aInterface(streamconsumer(
-            aInterfaceMethod(typeReference("Simple String")),
-            aInterfaceMethod(typeParameter("EndType")),
-        ), { "EndType": null }),
-        "Add": sInterface(sInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })), { "Type": null }),
-        "Push": sInterface(sInterfaceMethod(typeParameter("Type")), { "Type": null }),
-
-
-
-
-    }),
-    'algorithm types': d({
-        "CreateArrayBuilder": infInit(aInterfaceReference("Elements", {
-            "Type": typeParameter("Type"),
-            "EndType": typeParameter("EndType"),
-        }), {
-            "handler": aInterfaceReference("Array", {
-                "Type": typeParameter("Type"),
-                "EndType": typeParameter("EndType"),
-            }),
-        }, { "Type": null, "EndType": null }),
-        "CreateUnsafeDictionaryBuilder": infInit(aInterfaceReference("Entries", {
-            "Type": typeParameter("Type"),
-            "EndType": typeParameter("EndType"),
-        }), {
-            "handler": aInterfaceReference("Dictionary", {
-                "Type": typeParameter("Type"),
-                "EndType": typeParameter("EndType")
-            }),
-        }, { "Type": null, "EndType": null }),
-        "CreateSafeDictionaryBuilder": infInit(aInterfaceReference("Entries", {
-            "Type": typeParameter("Type"),
-            "EndType": typeParameter("EndType"),
-        }), {
-            "handler": aInterfaceReference("Dictionary", {
-                "Type": typeParameter("Type"),
-                "EndType": typeParameter("EndType")
-            }),
-            "duplicatesHandler": aInterfaceReference("DuplicatesHandler"),
-
-        }, { "Type": null, "EndType": null }),
-        "CreateStringBuilder": infInit(aInterfaceReference("StringStreamConsumer", { "EndType": typeParameter("EndType") }), {
-            "handler": aInterfaceReference("StringConsumer", { "EndType": typeParameter("EndType") }),
-        }, { "EndType": null }),
-        // "BuildArray": sfunction(typeReference("Simple Array", {
-        //     "Type": typeParameter("Type"),
-        // }), sInf(sInterfaceReference("Push", { "Type": typeParameter("Type") })), { "Type": null }),
-        // "BuildUnsafeDictionary": sfunction(typeReference("Simple Dictionary", {
-        //     "Type": typeParameter("Type"),
-        // }), sInf(sInterfaceReference("Add", { "Type": typeParameter("Type") })), { "Type": null }),
-        // "BuildSafeDictionary": sfunction(typeReference("Simple Dictionary", {
-        //     "Type": typeParameter("Type"),
-        // }), sInf(sInterfaceReference("Add", { "Type": typeParameter("Type") })), { "Type": null }),
-
-    }),
-
-}