@helios-lang/compiler/types/statements/TypeParameters.d.ts

Helios is a Domain Specific Language that compiles to Plutus-Core (i.e. Cardano on-chain validator scripts). Helios is a non-Haskell alternative to Plutus. With this library you can compile Helios scripts and build Cardano transactions, all you need to bu

/**
 * @typedef {import("@helios-lang/compiler-utils").Site} Site
 * @typedef {import("../typecheck/index.js").DataType} DataType
 * @typedef {import("../typecheck/index.js").EvalEntity} EvalEntity
 * @typedef {import("../typecheck/index.js").InferenceMap} InferenceMap
 */
export class TypeParameters {
    /**
     * @param {TypeParameter[]} parameterExprs
     * @param {boolean} isForFunc
     */
    constructor(parameterExprs: TypeParameter[], isForFunc: boolean);
    /**
     * @private
     * @readonly
     * @type {TypeParameter[]}
     */
    private readonly _parameterExprs;
    /**
     * @private
     * @readonly
     * @type {string}
     */
    private readonly _prefix;
    /**
     * @private
     * @type {null | Parameter[]}
     */
    private _parameters;
    /**
     * @returns {boolean}
     */
    hasParameters(): boolean;
    /**
     * @type {string[]}
     */
    get parameterNames(): string[];
    /**
     * @returns {Parameter[]}
     */
    getParameters(): Parameter[];
    /**
     * Always include the braces, even if there aren't any type parameters, so that the mutual recursion injection function has an easier time figuring out what can depend on what
     * @param {string} base
     * @returns {string}
     */
    genTypePath(base: string): string;
    /**
     * Always include the braces, even if there aren't any type parameters, so that the mutual recursion injection function has an easier time figuring out what can depend on what
     * @param {string} base
     * @returns {string}
     */
    genFuncPath(base: string): string;
    /**
     * @returns {string}
     */
    toString(): string;
    /**
     * @param {Scope} scope
     * @returns {Scope}
     */
    evalParams(scope: Scope): Scope;
    /**
     * @param {Scope} scope
     * @param {(scope: Scope) => (FuncType)} evalConcrete
     * @returns {ParametricFunc | FuncType}
     */
    evalParametricFuncType(scope: Scope, evalConcrete: (scope: Scope) => (FuncType), impl?: null): ParametricFunc | FuncType;
    /**
     * @param {Scope} scope
     * @param {(scope: Scope) => (FuncType)} evalConcrete
     * @returns {EvalEntity}
     */
    evalParametricFunc(scope: Scope, evalConcrete: (scope: Scope) => (FuncType)): EvalEntity;
    /**
     * @param {Scope} scope
     * @param {Site} site
     * @param {(scope: Scope) => DataType} evalConcrete
     * @returns {[DataType | ParametricType, Scope]}
     */
    createParametricType(scope: Scope, site: Site, evalConcrete: (scope: Scope) => DataType): [DataType | ParametricType, Scope];
}
export type Site = import("@helios-lang/compiler-utils").Site;
export type DataType = import("../typecheck/index.js").DataType;
export type EvalEntity = import("../typecheck/index.js").EvalEntity;
export type InferenceMap = import("../typecheck/index.js").InferenceMap;
import { Parameter } from "../typecheck/index.js";
import { Scope } from "../scopes/index.js";
import { FuncType } from "../typecheck/index.js";
import { ParametricFunc } from "../typecheck/index.js";
import { ParametricType } from "../typecheck/index.js";
import { TypeParameter } from "./TypeParameter.js";
//# sourceMappingURL=TypeParameters.d.ts.map