pareto-fountain-pen/dist/generated/generic/resolve.d.ts

A TypeScript library for easily generating source code files with proper indentation in the pareto programming style/language

import * as pt from 'exupery-core-types';
import * as pd from 'exupery-core-data';
import * as unresolved$ from "../interface/core/unresolved";
import * as resolved$ from "../interface/core/resolved";
export type Location_to_String<Source> = ($: Source) => string;
export type Acyclic_Entry_Reference<T_Dictionary_Entry> = {
    readonly 'entry': T_Dictionary_Entry;
    readonly 'key': string;
};
export type Parameters<Source, V, L> = {
    'location 2 string': Location_to_String<Source>;
    'parameters': {
        'lookups': L;
        'values': V;
    };
};
export type Key_Value_Location_Triplet<Source, T> = {
    'key': string;
    'value': T;
    'location': Source;
};
export type Possibly_Circular_Result<T> = pt.Computed_Value<T>;
export type Non_Circular_Result<T> = ['error', ['circular', pt.Array<string>]] | ['resolved', T];
export type Path<Source, Resolved_Element, Seed> = {
    'list': pt.Array<Resolved_Element>;
    'result': {
        'data': Seed;
    };
};
export type Resolved_Step<Resolved_Element, Seed> = {
    'element': Resolved_Element;
    'result': Seed;
};
export type _T_Location_2_String<Source> = Location_to_String<Source>;
export type _T_Location_Info = pd.Source_Location;
export type Location_Info = pd.Source_Location;
export type Acyclic_Lookup<T> = pt.Optional_Value<pt.Lookup<Non_Circular_Result<T>>>;
export type Cyclic_Lookup<T> = pt.Optional_Value<pt.Lookup<Possibly_Circular_Result<T>>>;
export type Lookup_Stack<T> = pt.Array<Acyclic_Lookup<T>>;
export type _T_Cyclic_Lookup<T> = Cyclic_Lookup<T>;
export type _T_Acyclic_Lookup<T> = Acyclic_Lookup<T>;
export type _T_Lookup_Stack<T> = Lookup_Stack<T>;
export declare const dictionary_to_lookup: <T>($: pt.Dictionary<T>, $p: null) => Acyclic_Lookup<T>;
export declare const get_possibly_circular_dependent_sibling_entry: <Source, T>($: Cyclic_Lookup<T>, $p: {
    "reference": unresolved$.Reference_To_Circular_Dependent_Sibling<Source, T>;
    "location 2 string": Location_to_String<Source>;
}) => resolved$.Reference_To_Circular_Dependent_Sibling<Source, T>;
export declare const push_stack: <T>($: pt.Array<T>, $p: {
    "element": T;
}) => pt.Array<T>;
export declare const get_entry_from_stack: <Source, T>($: Lookup_Stack<T>, $p: {
    "reference": unresolved$.Reference_To_Stacked_Dictionary_Entry<Source, T>;
    "location 2 string": Location_to_String<Source>;
}) => resolved$.Reference_To_Stacked_Dictionary_Entry<Source, T>;
export declare const get_entry: <Source, T>($: Acyclic_Lookup<T>, $p: {
    "reference": unresolved$.Reference_To_Normal_Dictionary_Entry<Source, T>;
    "location 2 string": Location_to_String<Source>;
}) => resolved$.Reference_To_Normal_Dictionary_Entry<Source, T>;
export declare const resolve_path: <Source, Unresolved_Element, Resolved_Element, Seed>($: unresolved$.List<Source, Unresolved_Element>, $p: {
    "seed": Seed;
    "map": ($: Unresolved_Element, current: Seed) => Resolved_Step<Resolved_Element, Seed>;
}) => Path<Source, Resolved_Element, Seed>;
export declare const resolve_dictionary: <Source, TUnresolved, TResolved>($: unresolved$.Dictionary<Source, TUnresolved>, $p: {
    "map": ($: Key_Value_Location_Triplet<Source, TUnresolved>, $l: {
        "possibly circular dependent siblings": Cyclic_Lookup<TResolved>;
    }) => TResolved;
    "location 2 string": ($: Source) => string;
}) => resolved$.Dictionary<Source, TResolved>;
export declare const resolve_dense_dictionary: <Source, TUnresolved, TResolved, TBenchmark>($: unresolved$.Dictionary<Source, TUnresolved>, $p: {
    "denseness benchmark": pt.Dictionary<TBenchmark>;
    "map": ($: Key_Value_Location_Triplet<Source, TUnresolved>, $l: {
        "possibly circular dependent siblings": Cyclic_Lookup<TResolved>;
    }) => TResolved;
    "location 2 string": ($: Source) => string;
}) => resolved$.Dictionary<Source, TResolved>;
export declare const resolve_dense_ordered_dictionary: <Source, TUnresolved, TResolved, TBenchmark>($: unresolved$.Dictionary<Source, TUnresolved>, $p: {
    "denseness benchmark": pt.Dictionary<TBenchmark>;
    "map": ($: Key_Value_Location_Triplet<Source, TUnresolved>, $l: {
        "possibly circular dependent siblings": Cyclic_Lookup<TResolved>;
        "not circular dependent siblings": Acyclic_Lookup<TResolved>;
    }) => TResolved;
    "location 2 string": ($: Source) => string;
}) => resolved$.Ordered_Dictionary<Source, TResolved>;
export declare const resolve_ordered_dictionary: <Source, TUnresolved, TResolved>($: unresolved$.Dictionary<Source, TUnresolved>, $p: {
    "map": ($: Key_Value_Location_Triplet<Source, TUnresolved>, $l: {
        "possibly circular dependent siblings": Cyclic_Lookup<TResolved>;
        "not circular dependent siblings": Acyclic_Lookup<TResolved>;
    }) => TResolved;
    "location 2 string": ($: Source) => string;
}) => resolved$.Ordered_Dictionary<Source, TResolved>;