import { Range } from './loc.js';
import { ErrorDetails, Result } from './result.js';
export declare type BracketKind = '(' | '[' | '{';
declare type Name = {
    value: string;
    range: Range;
};
declare const name: (value: string, range: Range) => Name;
declare const nlname: (value: string) => Name;
export declare type TaggedObject = FunctionType | CharType | PairType | StructType;
export declare type LambdaType = {
    _scamperTag: 'lambda';
    args: Name[];
    body: Exp;
    env?: Env;
};
export declare type PrimType = {
    _scamperTag: 'prim';
    fn: Prim;
};
export declare type FunctionType = LambdaType | PrimType;
export declare type CharType = {
    _scamperTag: 'char';
    value: string;
};
export declare type PairType = {
    _scamperTag: 'pair';
    fst: Value;
    snd: Value;
    isList: boolean;
};
export declare type StructType = {
    _scamperTag: 'struct';
    kind: string;
    fields: Value[];
};
/** In Scamper, a Value is, directly, a Javascript value. */
export declare type Value = boolean | number | string | null | undefined | Value[] | object | TaggedObject;
export declare const vchar: (value: string) => Value;
export declare const vlambda: (args: Name[], body: Exp, env?: Env) => Value;
export declare const vprim: (fn: Prim) => Value;
export declare const vpair: (fst: Value, snd: Value) => Value;
export declare const vstruct: (kind: string, fields: Value[]) => Value;
export declare const valueIsAny: (v: Value) => boolean;
export declare const isTaggedObject: (v: Value) => boolean;
export declare const valueIsBoolean: (v: Value) => boolean;
export declare const valueIsNumber: (v: Value) => boolean;
export declare const valueIsInteger: (v: Value) => boolean;
export declare const valueIsReal: (v: Value) => boolean;
export declare const valueIsString: (v: Value) => boolean;
export declare const valueIsNull: (v: Value) => boolean;
export declare const valueIsChar: (v: Value) => boolean;
export declare const valueIsLambda: (v: Value) => boolean;
export declare const valueIsPrim: (v: Value) => boolean;
export declare const valueIsProcedure: (v: Value) => boolean;
export declare const valueIsPair: (v: Value) => boolean;
export declare const valueIsStruct: (v: Value) => boolean;
export declare const valueIsStructKind: (v: Value, kind: string) => boolean;
export declare const valueIsAnyStructKind: (v: Value, kinds: string[]) => boolean;
export declare const valueIsObject: (v: Value) => boolean;
export declare const valueHasProperty: (v: Value, p: string) => boolean;
export declare const valueHasPropertyValue: (v: Value, p: string, x: any) => boolean;
export declare const valueIsVector: (v: Value) => boolean;
export declare const valueIsVoid: (v: Value) => boolean;
export declare const valueGetChar_: (v: Value) => string;
export declare function valueIsList(v: Value): boolean;
export declare function valueListToArray_(v: Value): Value[];
export declare function valueArrayToList(vs: Value[]): Value;
export declare function valueToString(v: Value): string;
export declare function valueEquals(v1: Value, v2: Value): boolean;
/**
 * A `Doc` is a convenience class for constructing docstrings for library
 * primitives.
 */
export declare class Doc {
    sig: string;
    args: string[];
    desc: string;
    /**
     *
     * @param sig A docstring corresponding to the signature of the function.
     * @param args An array of docstrings for each of the function's arguments.
     * @param desc A prose description of the behavior of the function.
     */
    constructor(sig: string, args: string[], desc: string);
    /**
     * @returns A string containing the docstring formatted in Markdown.
     */
    docToMarkdown(): string;
}
export declare type EnvEntry = {
    value: Value;
    source: string;
    range?: Range;
    doc?: Doc;
};
export declare const entry: (value: Value, source: string, range?: Range, doc?: Doc) => EnvEntry;
export declare class Env {
    parent?: Env;
    entries: Map<string, EnvEntry>;
    constructor(entries?: Iterable<[string, EnvEntry]>, parent?: Env);
    has(key: string): boolean;
    get(key: string): EnvEntry | undefined;
    items(): [string, EnvEntry][];
    names(): string[];
    append(key: string, value: EnvEntry): Env;
    concat(other: Env): Env;
    without(keys: string[]): Env;
    set(key: string, value: EnvEntry): void;
    setAll(entries: Iterable<[string, EnvEntry]>): void;
}
/**
 * The type of primitive function implementations.
 * @param env - the current execution environment.
 * @param args - the values passed to the primitive function.
 * @param app - the full application expression, for error-reporting purposes.
 * @returns the result of the primitive function.
 */
declare type Prim = (env: Env, args: Value[], app: Exp) => Promise<Result<Value>>;
/** Literal expressions */
declare type Lit = LBool | LNum | LChar | LStr;
declare type LBool = {
    tag: 'bool';
    value: boolean;
};
declare const lbool: (value: boolean) => LBool;
declare type LNum = {
    tag: 'num';
    value: number;
};
declare const lnum: (value: number) => LNum;
declare type LChar = {
    'tag': 'char';
    'value': string;
};
declare const lchar: (value: string) => LChar;
declare type LStr = {
    'tag': 'str';
    'value': string;
};
declare const lstr: (value: string) => LStr;
export declare function litToValue(lit: Lit): Value;
/** Expressions */
declare type Exp = EValue | EVar | ELit | ECall | ELam | EIf | ENil | EPair | ELet | ECond | EAnd | EOr | EBegin | EMatch;
export declare type EValue = {
    tag: 'value';
    range: Range;
    value: Value;
    isValue: boolean;
    isList: boolean;
};
export declare const nlevalue: (value: Value) => EValue;
export declare const unpackValue: (e: Exp) => Value;
export declare const unpackIfValue: (e: Exp) => Value;
declare type EVar = {
    tag: 'var';
    range: Range;
    value: string;
    isValue: boolean;
    isList: boolean;
};
declare const evar: (range: Range, value: string) => EVar;
declare const nlevar: (value: string) => EVar;
declare type ELit = {
    tag: 'lit';
    range: Range;
    value: Lit;
    isValue: boolean;
    isList: boolean;
};
declare const elit: (range: Range, value: Lit) => ELit;
declare const ebool: (range: Range, value: boolean) => ELit;
declare const enumber: (range: Range, value: number) => ELit;
declare const echar: (range: Range, c: string) => ELit;
declare const estr: (range: Range, s: string) => ELit;
declare const nlebool: (value: boolean) => ELit;
declare const nlenumber: (value: number) => ELit;
declare const nlechar: (c: string) => ELit;
declare const nlestr: (s: string) => ELit;
declare type ECall = {
    tag: 'call';
    range: Range;
    head: Exp;
    args: Exp[];
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const ecall: (range: Range, head: Exp, args: Exp[], bracket?: BracketKind) => ECall;
declare const nlecall: (head: Exp, args: Exp[]) => ECall;
declare type ELam = {
    tag: 'lam';
    range: Range;
    args: Name[];
    body: Exp;
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const elam: (range: Range, args: Name[], body: Exp, bracket?: BracketKind) => ELam;
declare const nlelam: (args: string[], body: Exp) => ELam;
declare type EIf = {
    tag: 'if';
    range: Range;
    e1: Exp;
    e2: Exp;
    e3: Exp;
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const eif: (range: Range, e1: Exp, e2: Exp, e3: Exp, bracket?: BracketKind) => EIf;
declare const nleif: (e1: Exp, e2: Exp, e3: Exp) => EIf;
declare type ENil = {
    tag: 'nil';
    range: Range;
    isValue: boolean;
    isList: boolean;
};
declare const enil: (range: Range) => ENil;
declare const nlenil: () => ENil;
declare type EPair = {
    tag: 'pair';
    range: Range;
    e1: Exp;
    e2: Exp;
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const epair: (range: Range, e1: Exp, e2: Exp, bracket?: BracketKind) => EPair;
declare const nlepair: (e1: Exp, e2: Exp) => EPair;
declare type LetKind = 'let' | 'let*' | 'letrec';
declare type ELet = {
    tag: 'let';
    range: Range;
    kind: LetKind;
    bindings: [Name, Exp][];
    body: Exp;
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const elet: (range: Range, kind: LetKind, bindings: [Name, Exp][], body: Exp, bracket?: BracketKind) => ELet;
declare const nlelet: (kind: LetKind, bindings: [string, Exp][], body: Exp) => ELet;
declare type ECond = {
    tag: 'cond';
    range: Range;
    branches: [Exp, Exp][];
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const econd: (range: Range, branches: [Exp, Exp][], bracket?: BracketKind) => ECond;
declare const nlecond: (branches: [Exp, Exp][]) => ECond;
declare type EAnd = {
    tag: 'and';
    range: Range;
    args: Exp[];
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const eand: (range: Range, args: Exp[], bracket?: BracketKind) => EAnd;
declare const nleand: (args: Exp[]) => EAnd;
declare type EOr = {
    tag: 'or';
    range: Range;
    args: Exp[];
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const eor: (range: Range, args: Exp[], bracket?: BracketKind) => EOr;
declare const nleor: (args: Exp[]) => EOr;
declare type EBegin = {
    tag: 'begin';
    range: Range;
    exps: Exp[];
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
export declare const ebegin: (range: Range, exps: Exp[], bracket?: BracketKind) => EBegin;
export declare const nlebegin: (exps: Exp[]) => EBegin;
declare type EMatch = {
    tag: 'match';
    range: Range;
    scrutinee: Exp;
    branches: [Pat, Exp][];
    bracket: BracketKind;
    isValue: boolean;
    isList: boolean;
};
declare const ematch: (range: Range, scrutinee: Exp, branches: [Pat, Exp][], bracket: BracketKind) => EMatch;
declare function litToString(l: Lit): string;
declare function arrayToList(es: Exp[]): Exp;
declare function unsafeListToArray(e: Exp): Exp[];
declare function isValue(e: Exp): boolean;
declare function litEquals(l1: Lit, l2: Lit): boolean;
declare function expEquals(e1: Exp, e2: Exp): boolean;
declare type Pat = PVar | PWild | PNull | PLit | PCtor;
declare type PVar = {
    tag: 'var';
    id: string;
    range: Range;
};
declare const pvar: (range: Range, id: string) => PVar;
declare type PWild = {
    tag: 'wild';
    range: Range;
};
declare const pwild: (range: Range) => PWild;
declare type PNull = {
    tag: 'null';
    range: Range;
};
declare const pnull: (range: Range) => PNull;
declare type PLit = {
    tag: 'lit';
    lit: Lit;
    range: Range;
};
declare const plit: (range: Range, lit: Lit) => PLit;
declare type PCtor = {
    tag: 'ctor';
    head: string;
    args: Pat[];
    range: Range;
};
declare const pctor: (range: Range, head: string, args: Pat[]) => PCtor;
declare function fvarsOfPat(p: Pat): string[];
export declare type SEffect = SImported | SError | SBinding | STestResult | SValue;
declare type SImported = {
    tag: 'imported';
    range: Range;
    source: string;
};
declare const simported: (source: string, range?: Range) => SImported;
declare type SError = {
    tag: 'error';
    range: Range;
    errors: ErrorDetails[];
};
declare const serror: (errors: ErrorDetails[], range?: Range) => SEffect;
declare type SBinding = {
    tag: 'binding';
    range: Range;
    name: string;
};
declare const sbinding: (name: string, range?: Range) => SBinding;
declare type STestResult = {
    tag: 'testresult';
    range: Range;
    desc: string;
    passed: boolean;
    reason?: string;
    expected?: Exp;
    actual?: Exp;
};
declare const stestresult: (desc: string, passed: boolean, reason?: string, expected?: Exp, actual?: Exp, range?: Range) => STestResult;
declare type SValue = {
    tag: 'value';
    range: Range;
    output?: Value;
};
declare const svalue: (output?: Value, range?: Range) => SValue;
declare type Stmt = SImport | SDefine | SExp | SStruct | STestCase | SEffect;
declare type SImport = {
    tag: 'import';
    range: Range;
    source: string;
};
declare const simport: (source: string, range: Range) => SImport;
declare type SDefine = {
    tag: 'define';
    range: Range;
    name: Name;
    value: Exp;
};
declare const sdefine: (name: Name, value: Exp, range?: Range) => SDefine;
declare type SStruct = {
    tag: 'struct';
    range: Range;
    id: Name;
    fields: Name[];
};
declare const sstruct: (id: Name, fields: Name[], range?: Range) => SStruct;
declare type STestCase = {
    tag: 'testcase';
    range: Range;
    desc: Exp;
    comp: Exp;
    expected: Exp;
    actual: Exp;
};
declare const stestcase: (desc: Exp, comp: Exp, expected: Exp, actual: Exp, range?: Range) => STestCase;
declare type SExp = {
    tag: 'exp';
    range: Range;
    value: Exp;
};
declare const sexp: (value: Exp, range?: Range) => SExp;
declare type Program = Stmt[];
declare function isOutputEffect(stmt: Stmt): boolean;
declare function isStmtDone(stmt: Stmt): boolean;
declare function indexOfCurrentStmt(prog: Program): number;
export { Prim, Name, name, nlname, Lit, LBool, LNum, LChar, LStr, Exp, EVar, ELit, ECall, ELam, EIf, ENil, EPair, LetKind, ELet, ECond, EAnd, EOr, lbool, lnum, lchar, lstr, ebool, enumber, echar, estr, evar, elit, ecall, elam, eif, elet, enil, epair, econd, eand, eor, ematch, nlebool, nlenumber, nlechar, nlestr, nlevar, nlecall, nlelam, nleif, nlelet, nlenil, nlepair, nlecond, nleand, nleor, litToString, arrayToList, unsafeListToArray, litEquals, expEquals, isValue, Pat, PVar, PWild, PNull, PLit, PCtor, pvar, pwild, pnull, plit, pctor, fvarsOfPat, Stmt, serror, sbinding, svalue, simported, sdefine, stestresult, sstruct, stestcase, sexp, isOutputEffect, isStmtDone, simport, Program, indexOfCurrentStmt };
//# sourceMappingURL=lang.d.ts.map