derw/build/types.js

An Elm-inspired language that transpiles to TypeScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GreaterThan = exports.LessThanOrEqual = exports.LessThan = exports.InEquality = exports.Equality = exports.CaseStatement = exports.Branch = exports.ListDestructure = exports.EmptyList = exports.Default = exports.LambdaCall = exports.Lambda = exports.FunctionCall = exports.ModuleReference = exports.RightPipe = exports.LeftPipe = exports.ListPrepend = exports.Or = exports.And = exports.Mod = exports.Division = exports.Multiplication = exports.Subtraction = exports.Addition = exports.IfStatement = exports.ElseIfStatement = exports.Constructor = exports.Destructure = exports.FormatStringValue = exports.ListRange = exports.ListValue = exports.StringValue = exports.ObjectLiteral = exports.Field = exports.Value = exports.AnonFunctionArg = exports.FunctionArg = exports.Impl = exports.Typeclass = exports.TypeclassFunction = exports.TypeAlias = exports.Property = exports.UnionUntaggedType = exports.UnionType = exports.Tag = exports.TagArg = exports.FunctionType = exports.ObjectLiteralType = exports.FixedType = exports.GenericType = void 0;
exports.contextModuleToModule = exports.ContextModule = exports.Module = exports.DoBlock = exports.UnparsedBlock = exports.MultilineComment = exports.Comment = exports.Export = exports.Import = exports.ImportModule = exports.Const = exports.Function = exports.isLeftPipeableExpression = exports.isSimpleValue = exports.GreaterThanOrEqual = void 0;
function GenericType(name) {
    return {
        kind: "GenericType",
        name,
    };
}
exports.GenericType = GenericType;
function FixedType(name, args) {
    return {
        kind: "FixedType",
        name,
        args,
    };
}
exports.FixedType = FixedType;
function ObjectLiteralType(properties) {
    return {
        kind: "ObjectLiteralType",
        properties,
    };
}
exports.ObjectLiteralType = ObjectLiteralType;
function FunctionType(args) {
    return {
        kind: "FunctionType",
        args,
    };
}
exports.FunctionType = FunctionType;
function TagArg(name, type) {
    return {
        kind: "TagArg",
        name,
        type,
    };
}
exports.TagArg = TagArg;
function Tag(name, args) {
    return {
        kind: "Tag",
        name,
        args,
    };
}
exports.Tag = Tag;
function UnionType(type, tags) {
    return {
        kind: "UnionType",
        type,
        tags,
    };
}
exports.UnionType = UnionType;
function UnionUntaggedType(type, values) {
    return {
        kind: "UnionUntaggedType",
        type,
        values,
    };
}
exports.UnionUntaggedType = UnionUntaggedType;
function Property(name, type) {
    return {
        kind: "Property",
        name,
        type,
    };
}
exports.Property = Property;
function TypeAlias(type, properties) {
    return {
        kind: "TypeAlias",
        type,
        properties,
    };
}
exports.TypeAlias = TypeAlias;
function TypeclassFunction(name, returnType, args) {
    return {
        kind: "TypeclassFunction",
        name,
        returnType,
        args,
    };
}
exports.TypeclassFunction = TypeclassFunction;
function Typeclass(name, variables, functions) {
    return {
        kind: "Typeclass",
        name,
        variables,
        functions,
    };
}
exports.Typeclass = Typeclass;
function Impl(name, qualifier, functions) {
    return {
        kind: "Impl",
        name,
        qualifier,
        functions,
    };
}
exports.Impl = Impl;
function FunctionArg(name, type) {
    return {
        kind: "FunctionArg",
        name,
        type,
    };
}
exports.FunctionArg = FunctionArg;
function AnonFunctionArg(index, type) {
    return {
        kind: "AnonFunctionArg",
        index,
        type,
    };
}
exports.AnonFunctionArg = AnonFunctionArg;
function Value(body) {
    return {
        kind: "Value",
        body,
    };
}
exports.Value = Value;
function Field(name, value) {
    return {
        kind: "Field",
        name,
        value,
    };
}
exports.Field = Field;
function ObjectLiteral(base, fields) {
    return {
        kind: "ObjectLiteral",
        base,
        fields,
    };
}
exports.ObjectLiteral = ObjectLiteral;
function StringValue(body) {
    return {
        kind: "StringValue",
        body,
    };
}
exports.StringValue = StringValue;
function ListValue(items) {
    return {
        kind: "ListValue",
        items,
    };
}
exports.ListValue = ListValue;
function ListRange(start, end) {
    return {
        kind: "ListRange",
        start,
        end,
    };
}
exports.ListRange = ListRange;
function FormatStringValue(body) {
    return {
        kind: "FormatStringValue",
        body,
    };
}
exports.FormatStringValue = FormatStringValue;
function Destructure(constructor, pattern) {
    return {
        kind: "Destructure",
        constructor,
        pattern,
    };
}
exports.Destructure = Destructure;
function Constructor(constructor, pattern) {
    return {
        kind: "Constructor",
        constructor,
        pattern,
    };
}
exports.Constructor = Constructor;
function ElseIfStatement(predicate, body, letBody) {
    return {
        kind: "ElseIfStatement",
        predicate,
        body,
        letBody,
    };
}
exports.ElseIfStatement = ElseIfStatement;
function IfStatement(predicate, ifBody, ifLetBody, elseIf, elseBody, elseLetBody) {
    return {
        kind: "IfStatement",
        predicate,
        ifBody,
        ifLetBody,
        elseIf,
        elseBody,
        elseLetBody,
    };
}
exports.IfStatement = IfStatement;
function Addition(left, right) {
    return {
        kind: "Addition",
        left,
        right,
    };
}
exports.Addition = Addition;
function Subtraction(left, right) {
    return {
        kind: "Subtraction",
        left,
        right,
    };
}
exports.Subtraction = Subtraction;
function Multiplication(left, right) {
    return {
        kind: "Multiplication",
        left,
        right,
    };
}
exports.Multiplication = Multiplication;
function Division(left, right) {
    return {
        kind: "Division",
        left,
        right,
    };
}
exports.Division = Division;
function Mod(left, right) {
    return {
        kind: "Mod",
        left,
        right,
    };
}
exports.Mod = Mod;
function And(left, right) {
    return {
        kind: "And",
        left,
        right,
    };
}
exports.And = And;
function Or(left, right) {
    return {
        kind: "Or",
        left,
        right,
    };
}
exports.Or = Or;
function ListPrepend(left, right) {
    return {
        kind: "ListPrepend",
        left,
        right,
    };
}
exports.ListPrepend = ListPrepend;
function LeftPipe(left, right) {
    return {
        kind: "LeftPipe",
        left,
        right,
    };
}
exports.LeftPipe = LeftPipe;
function RightPipe(left, right) {
    return {
        kind: "RightPipe",
        left,
        right,
    };
}
exports.RightPipe = RightPipe;
function ModuleReference(path, value) {
    return {
        kind: "ModuleReference",
        path,
        value,
    };
}
exports.ModuleReference = ModuleReference;
function FunctionCall(name, args) {
    return {
        kind: "FunctionCall",
        name,
        args,
    };
}
exports.FunctionCall = FunctionCall;
function Lambda(args, body) {
    return {
        kind: "Lambda",
        args,
        body,
    };
}
exports.Lambda = Lambda;
function LambdaCall(lambda, args) {
    return {
        kind: "LambdaCall",
        lambda,
        args,
    };
}
exports.LambdaCall = LambdaCall;
function Default() {
    return {
        kind: "Default",
    };
}
exports.Default = Default;
function EmptyList() {
    return {
        kind: "EmptyList",
    };
}
exports.EmptyList = EmptyList;
function ListDestructure(parts) {
    return {
        kind: "ListDestructure",
        parts,
    };
}
exports.ListDestructure = ListDestructure;
function Branch(pattern, body, letBody) {
    return {
        kind: "Branch",
        pattern,
        body,
        letBody,
    };
}
exports.Branch = Branch;
function CaseStatement(predicate, branches) {
    return {
        kind: "CaseStatement",
        predicate,
        branches,
    };
}
exports.CaseStatement = CaseStatement;
function Equality(left, right) {
    return {
        kind: "Equality",
        left: left,
        right,
    };
}
exports.Equality = Equality;
function InEquality(left, right) {
    return {
        kind: "InEquality",
        left,
        right,
    };
}
exports.InEquality = InEquality;
function LessThan(left, right) {
    return {
        kind: "LessThan",
        left,
        right,
    };
}
exports.LessThan = LessThan;
function LessThanOrEqual(left, right) {
    return {
        kind: "LessThanOrEqual",
        left,
        right,
    };
}
exports.LessThanOrEqual = LessThanOrEqual;
function GreaterThan(left, right) {
    return {
        kind: "GreaterThan",
        left,
        right,
    };
}
exports.GreaterThan = GreaterThan;
function GreaterThanOrEqual(left, right) {
    return {
        kind: "GreaterThanOrEqual",
        left,
        right,
    };
}
exports.GreaterThanOrEqual = GreaterThanOrEqual;
function isSimpleValue(kind) {
    return ([
        "StringValue",
        "FormatStringValue",
        "ListValue",
        "ListRange",
        "Value",
        "Addition",
        "Subtraction",
        "Multiplication",
        "Division",
        "Mod",
        "Lambda",
        "Equality",
        "InEquality",
        "LessThan",
        "LessThanOrEqual",
        "GreaterThan",
        "GreaterThanOrEqual",
        "And",
        "Or",
        "ListPrepend",
        "ModuleReference",
        "FunctionCall",
        "LeftPipe",
        "ObjectLiteral",
        "Constructor",
    ].indexOf(kind) > -1);
}
exports.isSimpleValue = isSimpleValue;
function isLeftPipeableExpression(expression) {
    return ([
        "LeftPipe",
        "ModuleReference",
        "FunctionCall",
        "Lambda",
        "Value",
    ].indexOf(expression.kind) > -1);
}
exports.isLeftPipeableExpression = isLeftPipeableExpression;
function Function(name, returnType, args, letBody, body, doBody) {
    return {
        kind: "Function",
        name,
        returnType,
        args,
        letBody,
        body,
        doBody: doBody ? doBody : null,
    };
}
exports.Function = Function;
function Const(name, type, letBody, value) {
    return {
        kind: "Const",
        name,
        type,
        letBody,
        value,
    };
}
exports.Const = Const;
function ImportModule(name, alias, exposing, namespace) {
    return {
        kind: "ImportModule",
        name,
        alias,
        exposing,
        namespace,
    };
}
exports.ImportModule = ImportModule;
function Import(modules) {
    return {
        kind: "Import",
        modules,
    };
}
exports.Import = Import;
function Export(names) {
    return {
        kind: "Export",
        names,
    };
}
exports.Export = Export;
function Comment(body) {
    return {
        kind: "Comment",
        body,
    };
}
exports.Comment = Comment;
function MultilineComment(body) {
    return {
        kind: "MultilineComment",
        body,
    };
}
exports.MultilineComment = MultilineComment;
function UnparsedBlock(kind, lineStart, lines) {
    return {
        kind,
        lineStart,
        lines,
    };
}
exports.UnparsedBlock = UnparsedBlock;
function DoBlock(expressions) {
    return {
        kind: "DoBlock",
        expressions,
    };
}
exports.DoBlock = DoBlock;
function Module(name, body, errors) {
    return {
        kind: "Module",
        name,
        body,
        errors,
    };
}
exports.Module = Module;
function ContextModule(name, body, unparsedBody, errors) {
    return {
        kind: "ContextModule",
        name,
        body,
        unparsedBody,
        errors,
    };
}
exports.ContextModule = ContextModule;
function contextModuleToModule(module) {
    return Module(module.name, module.body, module.errors);
}
exports.contextModuleToModule = contextModuleToModule;