derw
Version:
An Elm-inspired language that transpiles to TypeScript
689 lines (688 loc) • 22.9 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateEnglish = void 0;
const List = __importStar(require("../stdlib/List"));
const Common_1 = require("./Common");
function generateTag(tag) {
function generateTypeArg(arg) {
return (function (type_) {
return arg.name + ": " + type_ + "";
})(generateType(arg.type));
}
const typeDefArgs = (function (y) {
return y.join(",\n ");
})(List.map(generateTypeArg, tag.args));
const funcDefArgsStr = tag.args.length > 0 ? `{ ${typeDefArgs} }` : "";
return (function (y) {
return y + funcDefArgsStr;
})(generateType({
kind: "FixedType",
name: tag.name,
args: []
}));
}
function generateUnionType(syntax) {
const tags = (function (y) {
return y.join("\n| ");
})(List.map(generateTag, syntax.tags));
const prefixed = (0, Common_1.prefixLines)(tags, 4);
return `type ${generateType(syntax.type)} =\n${tags}`;
}
function generateUnionUntaggedType(syntax) {
const values = (function (y) {
return y.join("\n| ");
})(List.map(generateStringValue, syntax.values));
const prefixed = (0, Common_1.prefixLines)(values, 4);
return `type ${generateType(syntax.type)} =\n${prefixed}`;
}
function generateProperty(syntax) {
return `${syntax.name}: ${generateType(syntax.type)}`;
}
function generateTypeAlias(syntax) {
const properties = (function (y) {
return y.join(",\n ");
})(List.map(generateProperty, syntax.properties));
const typeDef = generateType(syntax.type);
return `type alias ${typeDef} = {\n ${properties}\n}`;
}
function generateListType(args) {
if (args.length > 0 && args[0].kind === "GenericType") {
return `List ${generateType(args[0])}`;
}
else {
const fixedArgs = List.filter(function (type_) {
return type_.kind === "FixedType";
}, args);
switch (fixedArgs.length) {
case 0: {
return "List any";
}
case fixedArgs.length: {
if (fixedArgs.length === 1) {
const [x] = fixedArgs;
if (x.kind === "FixedType" && x.args.length > 0) {
return `List (${generateType(x)})`;
}
else {
return `List ${generateType(x)}`;
}
;
}
}
default: {
return `List (${fixedArgs.map(generateType).join(" | ")})`;
}
}
;
}
}
function generateTopLevelType(type_) {
switch (type_.kind) {
case "GenericType": {
return generateType(type_);
}
case "FixedType": {
const { name, args } = type_;
if (name === "List") {
return generateType(type_);
}
else {
const genericArgs = List.filter(function (type_) {
return type_.kind === "GenericType" || type_.kind === "FixedType";
}, args);
if (genericArgs.length === 0) {
return name;
}
else {
return `${name} ${genericArgs.map(generateType).join(" ")}`;
}
;
}
;
}
case "FunctionType": {
return generateType(type_);
}
case "ObjectLiteralType": {
return ``;
}
}
}
function generateType(type_) {
switch (type_.kind) {
case "GenericType": {
const { name } = type_;
return name;
}
case "FixedType": {
const { name, args } = type_;
if (name === "List") {
return generateListType(args);
}
else {
const genericArgs = List.filter(function (type_) {
return type_.kind === "GenericType";
}, args);
if (genericArgs.length === 0) {
return name;
}
else {
return `${name} ${genericArgs.map(generateType).join(" ")}`;
}
;
}
;
}
case "FunctionType": {
const { args } = type_;
return `(${args.map(generateType).join(" -> ")})`;
}
case "ObjectLiteralType": {
return ``;
}
}
}
function generateField(field) {
const value = generateExpression(field.value);
return `${field.name}: ${value}`;
}
function generateObjectLiteral(literal) {
const fields = (function (y) {
return y.join(",\n ");
})(literal.fields.map(generateField));
if (literal.base === null) {
if (literal.fields.length === 1) {
return `{ ${fields} }`;
}
else {
return `{\n ${fields}\n}`;
}
;
}
else {
if (literal.fields.length === 1) {
return `{ ${literal.base.body}, ${fields} }`;
}
else {
return `{\n ${literal.base.body},\n ${fields}\n}`;
}
;
}
}
function generateValue(value) {
return value.body;
}
function generateStringValue(string) {
return `"${string.body}"`;
}
function generateFormatStringValue(string) {
return "`" + string.body + "`";
}
function generateListValue(list) {
switch (list.items.length) {
case 0: {
return "An empty list";
}
case list.items.length: {
if (list.items.length === 1) {
const [x] = list.items;
return `A list containing ${generateExpression(x)} only`;
}
}
default: {
return `A list containing:\n${(0, Common_1.prefixLines)(list.items.map(generateExpression).join(",\n"), 4)}`;
}
}
}
function generateListRange(list) {
return `[ ${list.start.body}..${list.end.body} ]`;
}
function generateLetBlock(body) {
switch (body.length) {
case 0: {
return "";
}
case body.length: {
if (body.length >= 1) {
const [x, ...ys] = body;
const prefixedLet = (0, Common_1.prefixLines)("\nlet", 4);
const prefixedBody = (function (y) {
return y.join("\n\n");
})(List.map(generateBlock, body));
const prefixedLines = (0, Common_1.prefixLines)(prefixedBody, 8);
const prefixedIn = (0, Common_1.prefixLines)("\nin", 4);
return `${prefixedLet}\n${prefixedLines}${prefixedIn}${(0, Common_1.prefixLines)("", 8)}`;
}
}
default: {
return "";
}
}
}
function generateIfStatement(ifStatement) {
const maybeIfLetBody = generateLetBlock(ifStatement.ifLetBody);
const maybeElseLetBody = generateLetBlock(ifStatement.elseLetBody);
const predicate = generateExpression(ifStatement.predicate);
const ifIndent = maybeIfLetBody === "" ? 4 : 8;
const ifBody = (function (lines) {
return (0, Common_1.prefixLines)(lines, ifIndent);
})(generateExpression(ifStatement.ifBody));
const elseIndent = maybeElseLetBody === "" ? 4 : 8;
const elseBody = (function (lines) {
return (0, Common_1.prefixLines)(lines, elseIndent);
})(generateExpression(ifStatement.elseBody));
return `if ${predicate} then${maybeIfLetBody}\n${ifBody}\nelse${maybeElseLetBody}\n${elseBody}\n`;
}
function generateConstructor(constructor) {
switch (constructor.pattern.fields.length) {
case 0: {
return constructor.constructor;
}
default: {
return `${constructor.constructor} ${generateObjectLiteral(constructor.pattern)}`;
}
}
}
function generateListDestructurePart(part) {
switch (part.kind) {
case "EmptyList": {
return "An empty list";
}
case "StringValue": {
const { body } = part;
return `"${body}"`;
}
case "FormatStringValue": {
const { body } = part;
return "`" + body + "`";
}
case "Value": {
const { body } = part;
return body;
}
case "Destructure": {
const { pattern } = part;
if (pattern.length === 0) {
return part.constructor;
}
else {
return `${part.constructor} ${pattern}`;
}
;
}
}
}
function generateBranchPattern(branchPattern) {
switch (branchPattern.kind) {
case "Destructure": {
const { pattern } = branchPattern;
if (pattern.length === 0) {
return branchPattern.constructor;
}
else {
return `${branchPattern.constructor} ${pattern}`;
}
;
}
case "StringValue": {
const { body } = branchPattern;
return `"${body}"`;
}
case "FormatStringValue": {
const { body } = branchPattern;
return "`" + body + "`";
}
case "EmptyList": {
return "An empty list";
}
case "ListDestructure": {
const { parts } = branchPattern;
return (function (y) {
return y.join(" is in a list element from ");
})(List.map(generateListDestructurePart, parts));
}
case "Default": {
return "Nothing else matches";
}
}
}
function generateBranch(branch) {
const maybeLetBody = generateLetBlock(branch.letBody);
const bodyIndent = maybeLetBody === "" ? 4 : 9;
const body = (function (y) {
return (0, Common_1.prefixLines)(`return ${y}`, bodyIndent);
})(generateExpression(branch.body));
const pattern = generateBranchPattern(branch.pattern);
return `Is it ${pattern}? ->${maybeLetBody}\n${body}`;
}
function generateCaseStatement(caseStatement) {
const predicate = generateExpression(caseStatement.predicate);
const branches = (function (y) {
return (0, Common_1.prefixLines)(y, 4);
})((function (y) {
return y.join("\n\n");
})(List.map(generateBranch, caseStatement.branches)));
return `Check the value of ${predicate}\n${branches}`;
}
function generateAddition(addition) {
const left = generateExpression(addition.left);
const right = generateExpression(addition.right);
return `${left} plus ${right}`;
}
function generateSubtraction(subtraction) {
const left = generateExpression(subtraction.left);
const right = generateExpression(subtraction.right);
return `${left} subtracts ${right}`;
}
function generateMultiplication(multiplication) {
const left = generateExpression(multiplication.left);
const right = generateExpression(multiplication.right);
return `${left} multiplied by ${right}`;
}
function generateDivision(division) {
const left = generateExpression(division.left);
const right = generateExpression(division.right);
return `${left} divided by ${right}`;
}
function generateMod(mod) {
const left = generateExpression(mod.left);
const right = generateExpression(mod.right);
return `${left} mod ${right}`;
}
function generateLeftPipe(leftPipe) {
const left = generateExpression(leftPipe.left);
const right = generateExpression(leftPipe.right);
return `Send ${left} as the last argument to ${right}`;
}
function generateRightPipe(rightPipe) {
const left = generateExpression(rightPipe.left);
const right = generateExpression(rightPipe.right);
return `Send ${right} as the last argument to ${left}`;
}
function generateModuleReference(moduleReference) {
const left = moduleReference.path.join(".");
const right = generateExpression(moduleReference.value);
return `${left}.${right}`;
}
function generateFunctionCallArg(arg) {
switch (arg.kind) {
case "Constructor": {
return `(${generateExpression(arg)})`;
}
case "FunctionCall": {
return `(${generateExpression(arg)})`;
}
case "ModuleReference": {
const { value } = arg;
switch (value.kind) {
case "Constructor": {
return `(${generateExpression(arg)})`;
}
case "FunctionCall": {
return `(${generateExpression(arg)})`;
}
default: {
return generateExpression(arg);
}
}
;
}
case "ListPrepend": {
return `(${generateExpression(arg)})`;
}
default: {
return generateExpression(arg);
}
}
}
function generateFunctionCall(functionCall) {
if (functionCall.args.length === 0) {
return `${functionCall.name}()`;
}
else {
const args = (function (y) {
return y.join(" ");
})(List.map(generateFunctionCallArg, functionCall.args));
return `${functionCall.name} ${args}`;
}
}
function generateLambda(lambda) {
const args = (function (y) {
return y.join(" ");
})(List.map(function (arg) {
return arg;
}, lambda.args));
const body = generateExpression(lambda.body);
return `(\\${args} -> ${body})`;
}
function generateLambdaCall(lambdaCall) {
const args = (function (y) {
return y.join(", ");
})(List.map(function (arg) {
return `${arg}: any`;
}, lambdaCall.args));
const argsValues = (function (y) {
return y.join(", ");
})(List.map(generateExpression, lambdaCall.args));
const body = generateExpression(lambdaCall.lambda.body);
return `(function(${args}) {\n return ${body};\n})(${argsValues})`;
}
function generateEquality(equality) {
const left = generateExpression(equality.left);
const right = generateExpression(equality.right);
return `${left} is equal to ${right}`;
}
function generateInEquality(inEquality) {
const left = generateExpression(inEquality.left);
const right = generateExpression(inEquality.right);
return `${left} is not equal to ${right}`;
}
function generateLessThan(lessThan) {
const left = generateExpression(lessThan.left);
const right = generateExpression(lessThan.right);
return `${left} is less than ${right}`;
}
function generateLessThanOrEqual(lessThanOrEqual) {
const left = generateExpression(lessThanOrEqual.left);
const right = generateExpression(lessThanOrEqual.right);
return `${left} is less than or equal to ${right}`;
}
function generateGreaterThan(greaterThan) {
const left = generateExpression(greaterThan.left);
const right = generateExpression(greaterThan.right);
return `${left} is greater than ${right}`;
}
function generateGreaterThanOrEqual(greaterThanOrEqual) {
const left = generateExpression(greaterThanOrEqual.left);
const right = generateExpression(greaterThanOrEqual.right);
return `${left} is greater than or equal to ${right}`;
}
function generateAnd(and) {
const left = generateExpression(and.left);
const right = generateExpression(and.right);
return `${left} and ${right}`;
}
function generateOr(or) {
const left = generateExpression(or.left);
const right = generateExpression(or.right);
return `${left} or ${right}`;
}
function generateListPrepend(prepend) {
const left = generateExpression(prepend.left);
const right = generateExpression(prepend.right);
return `Add ${left} as a list item to the front of ${right}`;
}
function generateExpression(expression) {
switch (expression.kind) {
case "Value": {
return generateValue(expression);
}
case "StringValue": {
return generateStringValue(expression);
}
case "FormatStringValue": {
return generateFormatStringValue(expression);
}
case "ListValue": {
return generateListValue(expression);
}
case "ListRange": {
return generateListRange(expression);
}
case "ObjectLiteral": {
return generateObjectLiteral(expression);
}
case "IfStatement": {
return generateIfStatement(expression);
}
case "CaseStatement": {
return generateCaseStatement(expression);
}
case "Addition": {
return generateAddition(expression);
}
case "Subtraction": {
return generateSubtraction(expression);
}
case "Multiplication": {
return generateMultiplication(expression);
}
case "Division": {
return generateDivision(expression);
}
case "Mod": {
return generateMod(expression);
}
case "And": {
return generateAnd(expression);
}
case "Or": {
return generateOr(expression);
}
case "ListPrepend": {
return generateListPrepend(expression);
}
case "LeftPipe": {
return generateLeftPipe(expression);
}
case "RightPipe": {
return generateRightPipe(expression);
}
case "ModuleReference": {
return generateModuleReference(expression);
}
case "FunctionCall": {
return generateFunctionCall(expression);
}
case "Lambda": {
return generateLambda(expression);
}
case "LambdaCall": {
return generateLambdaCall(expression);
}
case "Constructor": {
return generateConstructor(expression);
}
case "Equality": {
return generateEquality(expression);
}
case "InEquality": {
return generateInEquality(expression);
}
case "LessThan": {
return generateLessThan(expression);
}
case "LessThanOrEqual": {
return generateLessThanOrEqual(expression);
}
case "GreaterThan": {
return generateGreaterThan(expression);
}
case "GreaterThanOrEqual": {
return generateGreaterThanOrEqual(expression);
}
}
}
function generateFunctionArg(arg) {
switch (arg.kind) {
case "FunctionArg": {
const { name, type } = arg;
return `${name} with the type ${generateType(type)}`;
}
case "AnonFunctionArg": {
const { index, type } = arg;
return `_${index} with the type ${generateType(type)}`;
}
}
}
function generateFunction(function_) {
const args = (function (y) {
return y.join("\n");
})(List.map(generateFunctionArg, function_.args));
const maybeLetBody = generateLetBlock(function_.letBody);
const returnType = generateTopLevelType(function_.returnType);
const bodyIndent = maybeLetBody === "" ? 4 : 8;
const body = (function (y) {
return (0, Common_1.prefixLines)(y, bodyIndent);
})(generateExpression(function_.body));
return (function (y) {
return y.join("\n");
})([`${function_.name} is a function with the arguments:`, (0, Common_1.prefixLines)(args, 4), `${function_.name} returns a value of the type ${returnType}`, `${function_.name} is defined as: ${maybeLetBody}`, `${body}`]);
}
function generateConst(constDef) {
const body = (function (y) {
return (0, Common_1.prefixLines)(y, 4);
})(generateExpression(constDef.value));
const typeDef = generateTopLevelType(constDef.type);
return (function (y) {
return y.join("\n");
})([`${constDef.name} is a constant with the type ${typeDef}`, `${constDef.name} is assigned to:`, `${body}`]);
}
function generateImportModule(module) {
const partExposing = module.exposing.length === 0 ? "" : ` exposing (${module.exposing.join(", ")} )`;
switch (module.alias.kind) {
case "Just": {
const { value } = module.alias;
return `import ${module.name} as ${value}${partExposing}`;
}
case "Nothing": {
return `import ${module.name}${partExposing}`;
}
}
}
function generateImportBlock(imports) {
return (function (y) {
return y.join("\n");
})(List.map(generateImportModule, imports.modules));
}
function generateExportBlock(exports) {
return `exposing (${exports.names.join(", ")})`;
}
function generateBlock(syntax) {
switch (syntax.kind) {
case "Import": {
return generateImportBlock(syntax);
}
case "Export": {
return generateExportBlock(syntax);
}
case "UnionType": {
return generateUnionType(syntax);
}
case "UnionUntaggedType": {
return generateUnionUntaggedType(syntax);
}
case "TypeAlias": {
return generateTypeAlias(syntax);
}
case "Typeclass": {
return "";
}
case "Impl": {
return "";
}
case "Function": {
return generateFunction(syntax);
}
case "Const": {
return generateConst(syntax);
}
case "Comment": {
return "";
}
case "MultilineComment": {
return "";
}
}
}
function generateEnglish(module) {
return (function (y) {
return y.join("\n\n");
})(List.filter(function (line) {
return line.length > 0;
}, List.map(generateBlock, module.body)));
}
exports.generateEnglish = generateEnglish;