@helios-lang/compiler/types/typecheck/parametric.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

/**
 * @import { Site } from "@helios-lang/compiler-utils"
 */
/**
 * @typedef {import("./common.js").TypeSchema} TypeSchema
 * @typedef {import("./common.js").GenericTypeProps} GenericTypeProps
 * @typedef {import("./common.js").GenericEnumMemberTypeProps} GenericEnumMemberTypeProps
 * @typedef {import("./common.js").EnumMemberType} EnumMemberType
 * @typedef {import("./common.js").ParameterI} ParameterI
 * @typedef {import("./common.js").InferenceMap} InferenceMap
 * @typedef {import("./common.js").DataType} DataType
 * @typedef {import("./common.js").Func} Func
 * @typedef {import("./common.js").EvalEntity} EvalEntity
 * @typedef {import("./common.js").Named} Named
 * @typedef {import("./common.js").Parametric} Parametric
 * @typedef {import("./common.js").Type} Type
 * @typedef {import("./common.js").Typed} Typed
 * @typedef {import("./common.js").TypeClass} TypeClass
 * @typedef {import("./common.js").InstanceMembers} InstanceMembers
 * @typedef {import("./common.js").TypeMembers} TypeMembers
 * @typedef {import("./common.js").TypeClassMembers} TypeClassMembers
 */
/**
 * Created by statements
 * @implements {DataType}
 */
export class GenericParametricType extends GenericType implements DataType {
}
/**
 * Created by statements
 * @implements {EnumMemberType}
 * @extends {GenericEnumMemberType}
 */
export class GenericParametricEnumMemberType extends GenericEnumMemberType implements EnumMemberType {
}
/**
 * @implements {Type}
 */
export class TypeClassImpl extends Common implements Type {
    /**
     * @param {TypeClass} typeClass
     * @param {string} name
     * @param {null | ParameterI} parameter - reference to original parameter, which is more unique than name
     */
    constructor(typeClass: TypeClass, name: string, parameter: null | ParameterI);
    /**
     * @private
     * @readonly
     * @type {string}
     */
    private readonly _name;
    /**
     * @private
     * @readonly
     * @type {null | ParameterI}
     */
    private readonly _parameter;
    /**
     * @private
     * @readonly
     * @type {InstanceMembers}
     */
    private readonly _instanceMembers;
    /**
     * @private
     * @readonly
     * @type {TypeMembers}
     */
    private readonly _typeMembers;
    /**
     * @type {InstanceMembers}
     */
    get instanceMembers(): import("./common.js").InstanceMembers;
    /**
     * @type {string}
     */
    get name(): string;
    /**
     * @type {TypeMembers}
     */
    get typeMembers(): import("./common.js").TypeMembers;
    /**
     * @type {Type}
     */
    get asType(): import("./common.js").Type;
    /**
     * @internal
     * @param {Site} site
     * @param {InferenceMap} map
     * @param {null | Type} type
     * @returns {Type}
     */
    infer(site: Site, map: InferenceMap, type: null | Type): Type;
    /**
     * Returns 'true' if 'this' is a base-type of 'type'. Throws an error if 'this' isn't a Type.
     * @param {Type} type
     * @returns {boolean}
     */
    isBaseOf(type: Type): boolean;
    /**
     * @returns {Typed}
     */
    toTyped(): Typed;
}
/**
 * @implements {DataType}
 */
export class DataTypeClassImpl extends TypeClassImpl implements DataType {
    /**
     * @param {TypeClass} typeClass
     * @param {string} name
     * @param {string} path
     * @param {null | ParameterI} parameter
     */
    constructor(typeClass: TypeClass, name: string, path: string, parameter: null | ParameterI);
    /**
     * @private
     * @readonly
     * @type {string}
     */
    private readonly _path;
    /**
     * @type {DataType}
     */
    get asDataType(): import("./common.js").DataType;
    /**
     * @type {Named}
     */
    get asNamed(): import("./common.js").Named;
    /**
     * @type {string[]}
     */
    get fieldNames(): string[];
    /**
     * @type {string}
     */
    get path(): string;
    /**
     * @param {Set<string>} parents
     * @returns {TypeSchema}
     */
    toSchema(parents?: Set<string>): TypeSchema;
}
/**
 * @implements {TypeClass}
 */
export class AnyTypeClass extends Common implements TypeClass {
    /**
     * @type {TypeClass}
     */
    get asTypeClass(): import("./common.js").TypeClass;
    /**
     * @param {Type} impl
     * @returns {TypeClassMembers}
     */
    genInstanceMembers(impl: Type): TypeClassMembers;
    /**
     * @param {Type} impl
     * @returns {TypeClassMembers}
     */
    genTypeMembers(impl: Type): TypeClassMembers;
    /**
     * @param {Type} type
     * @returns {boolean}
     */
    isImplementedBy(type: Type): boolean;
    /**
     * @param {string} name
     * @param {string} path
     * @param {null | ParameterI} parameter
     * @returns {Type}
     */
    toType(name: string, path: string, parameter?: null | ParameterI): Type;
}
/**
 * @implements {TypeClass}
 */
export class DefaultTypeClass extends Common implements TypeClass {
    /**
     * @type {TypeClass}
     */
    get asTypeClass(): import("./common.js").TypeClass;
    /**
     * @param {Type} impl
     * @returns {TypeClassMembers}
     */
    genTypeMembers(impl: Type): TypeClassMembers;
    /**
     * @param {Type} impl
     * @returns {TypeClassMembers}
     */
    genInstanceMembers(impl: Type): TypeClassMembers;
    /**
     * @param {Type} type
     * @returns {boolean}
     */
    isImplementedBy(type: Type): boolean;
    /**
     * @param {string} name
     * @param {string} path
     * @param {null | ParameterI} parameter
     * @returns {DataType}
     */
    toType(name: string, path: string, parameter?: null | ParameterI): DataType;
}
/**
 * @implements {TypeClass}
 */
export class SummableTypeClass extends Common implements TypeClass {
    /**
     * @type {TypeClass}
     */
    get asTypeClass(): import("./common.js").TypeClass;
    /**
     * @param {Type} impl
     * @returns {TypeClassMembers}
     */
    genTypeMembers(impl: Type): TypeClassMembers;
    /**
     * @param {Type} impl
     * @returns {TypeClassMembers}
     */
    genInstanceMembers(impl: Type): TypeClassMembers;
    /**
     * @param {Type} type
     * @returns {boolean}
     */
    isImplementedBy(type: Type): boolean;
    /**
     * @param {string} name
     * @param {string} path
     * @param {null | ParameterI} parameter
     * @returns {DataType}
     */
    toType(name: string, path: string, parameter?: null | ParameterI): DataType;
}
/**
 * @implements {Parametric}
 */
export class ParametricType extends Common implements Parametric {
    /**
     * @param {{
     * 	 name: string,
     *   parameters: Parameter[]
     *   apply: (types: Type[]) => DataType
     * }} props
     */
    constructor({ name, parameters, apply }: {
        name: string;
        parameters: Parameter[];
        apply: (types: Type[]) => DataType;
    });
    /**
     * @private
     * @readonly
     * @type {string}
     */
    private readonly _name;
    /**
     * @private
     * @readonly
     * @type {Parameter[]}
     */
    private readonly _parameters;
    /**
     * @private
     * @readonly
     * @type {(types: Type[]) => DataType}
     */
    private readonly _apply;
    /**
     * @type {Parametric}
     */
    get asParametric(): import("./common.js").Parametric;
    /**
     * @type {TypeClass[]}
     */
    get typeClasses(): import("./common.js").TypeClass[];
    /**
     * @param {Type[]} types
     * @param {Site} site
     * @returns {EvalEntity}
     */
    apply(types: Type[], site?: Site): EvalEntity;
    /**
     * Must infer before calling
     * @param {Site} site
     * @param {Typed[]} args
     * @param {{[name: string]: Typed}} namedArgs
     * @param {Type[]} paramTypes - so that paramTypes can be accessed by caller
     * @returns {Func}
     */
    inferCall(site: Site, args: Typed[], namedArgs?: {
        [name: string]: Typed;
    }, paramTypes?: Type[]): Func;
    /**
     * @param {Site} site
     * @param {InferenceMap} map
     * @returns {Parametric}
     */
    infer(site: Site, map: InferenceMap): Parametric;
}
export type TypeSchema = import("./common.js").TypeSchema;
export type GenericTypeProps = import("./common.js").GenericTypeProps;
export type GenericEnumMemberTypeProps = import("./common.js").GenericEnumMemberTypeProps;
export type EnumMemberType = import("./common.js").EnumMemberType;
export type ParameterI = import("./common.js").ParameterI;
export type InferenceMap = import("./common.js").InferenceMap;
export type DataType = import("./common.js").DataType;
export type Func = import("./common.js").Func;
export type EvalEntity = import("./common.js").EvalEntity;
export type Named = import("./common.js").Named;
export type Parametric = import("./common.js").Parametric;
export type Type = import("./common.js").Type;
export type Typed = import("./common.js").Typed;
export type TypeClass = import("./common.js").TypeClass;
export type InstanceMembers = import("./common.js").InstanceMembers;
export type TypeMembers = import("./common.js").TypeMembers;
export type TypeClassMembers = import("./common.js").TypeClassMembers;
import { GenericType } from "./common.js";
import { GenericEnumMemberType } from "./common.js";
import { Common } from "./common.js";
import type { Site } from "@helios-lang/compiler-utils";
import { Parameter } from "./Parameter.js";
//# sourceMappingURL=parametric.d.ts.map