pareto-fountain-pen/dist/generated/implementation/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";
import * as i from "../../interface/core/resolve";
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': i.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 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_Info = pd.Source_Location;
export type Location_Info = pd.Source_Location;
export declare const dictionary_to_lookup: <T>($: pt.Dictionary<T>, $p: null) => i.Acyclic_Lookup<T>;
export declare const get_possibly_circular_dependent_sibling_entry: <Source, T>($: i.Cyclic_Lookup<T>, $p: {
    "reference": unresolved$.Reference_To_Circular_Dependent_Sibling<Source, T>;
    "location 2 string": i.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>($: i.Lookup_Stack<T>, $p: {
    "reference": unresolved$.Reference_To_Stacked_Dictionary_Entry<Source, T>;
    "location 2 string": i.Location_to_String<Source>;
}) => resolved$.Reference_To_Stacked_Dictionary_Entry<Source, T>;
export declare const get_entry: <Source, T>($: i.Acyclic_Lookup<T>, $p: {
    "reference": unresolved$.Reference_To_Normal_Dictionary_Entry<Source, T>;
    "location 2 string": i.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": i.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": i.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": i.Cyclic_Lookup<TResolved>;
        "not circular dependent siblings": i.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": i.Cyclic_Lookup<TResolved>;
        "not circular dependent siblings": i.Acyclic_Lookup<TResolved>;
    }) => TResolved;
    "location 2 string": ($: Source) => string;
}) => resolved$.Ordered_Dictionary<Source, TResolved>;