derw
Version:
An Elm-inspired language that transpiles to TypeScript
1,061 lines (1,060 loc) • 35 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.generateExpression = exports.generateDerw = void 0;
const List = __importStar(require("../stdlib/List"));
const types_1 = require("../types");
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${prefixed}`;
}
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) {
const generatedType = generateTopLevelType(syntax.type);
switch (syntax.type.kind) {
case "FunctionType": {
return `${syntax.name}: ${generatedType.slice(1, -1)}`;
}
default: {
return `${syntax.name}: ${generatedType}`;
}
}
}
function generateTypeAlias(syntax) {
const properties = (function (y) {
return y.join(",\n ");
})(List.map(generateProperty, syntax.properties));
const typeDef = generateType(syntax.type);
if (syntax.properties.length === 0) {
return `type alias ${typeDef} = {\n}`;
}
else {
return `type alias ${typeDef} = {\n ${properties}\n}`;
}
}
function generateTypeclassFunction(syntax) {
const argTypes = List.map(generateTopLevelType, syntax.args);
const returnType = generateTopLevelType(syntax.returnType);
const types = (function (y) {
return y.join(" -> ");
})(List.append(argTypes, [returnType]));
return `${syntax.name}: ${types}`;
}
function generateTypeclass(syntax) {
const variables = (function (y) {
return y.join(" ");
})(List.map(generateType, syntax.variables));
const functions = (function (y) {
return y.join("\n\n");
})(List.map(function (line) {
return (0, Common_1.prefixLines)(line, 4);
}, List.map(generateTypeclassFunction, syntax.functions)));
return `typeclass ${syntax.name} ${variables}\n${functions}`;
}
function generateImpl(syntax) {
const qualifier = generateType(syntax.qualifier);
const blocks = (function (y) {
return y.join("\n\n");
})(List.map(function (line) {
return (0, Common_1.prefixLines)(line, 4);
}, List.map(generateBlock, syntax.functions)));
return `impl ${syntax.name} ${qualifier}\n${blocks}`;
}
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 (args.length > 0 && args[0].kind === "FixedType" && args[0].args.length > 0) {
function wrapper(x) {
return `(${x})`;
}
return `${name} ${args.map(generateTopLevelType).map(wrapper).join(" ")}`;
}
else {
const genericArgs = List.filter(function (type_) {
return type_.kind === "GenericType" || type_.kind === "FixedType";
}, args);
if (genericArgs.length === 0) {
return name;
}
else {
function wrapper(newType) {
switch (newType.kind) {
case "FixedType": {
const { args } = newType;
if (args.length > 0) {
return `(${generateTopLevelType(newType)})`;
}
else {
return `${generateTopLevelType(newType)}`;
}
;
}
default: {
return `${generateTopLevelType(newType)}`;
}
}
}
const wrappedArgs = genericArgs.map(wrapper);
return `${name} ${wrappedArgs.join(" ")}`;
}
;
}
;
}
case "FunctionType": {
const { args } = type_;
return `(${args.map(generateTopLevelType).join(" -> ")})`;
}
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));
const maybePrefixed = (0, Common_1.prefixLines)(fields, 4);
if (literal.base === null) {
const _res1477476904 = `${literal.fields.length}`;
switch (_res1477476904) {
case "0": {
return "{ }";
}
case "1": {
return `{ ${fields} }`;
}
default: {
return `{\n${maybePrefixed}\n}`;
}
}
;
}
else {
if (literal.fields.length === 1) {
return `{ ${literal.base.body}, ${fields} }`;
}
else {
return `{\n ${literal.base.body},\n${maybePrefixed}\n}`;
}
;
}
}
function generateValue(value) {
return value.body;
}
function generateStringValue(string) {
return `"${string.body}"`;
}
function generateFormatStringValue(string) {
const split = string.body.split("\n");
switch (split.length) {
case split.length: {
if (split.length === 1) {
const [firstLine] = split;
return "`" + firstLine + "`";
}
}
case split.length: {
if (split.length >= 1) {
const [firstLine, ...rest] = split;
const indentedSplit = List.map(function (line) {
return " " + line;
}, split);
const joined = (function (y) {
return y.join("\n");
})(indentedSplit);
return "`\n" + joined + "\n`";
}
}
default: {
return "`" + string.body + "`";
}
}
}
function generateListValue(list) {
switch (list.items.length) {
case 0: {
return "[ ]";
}
case list.items.length: {
if (list.items.length === 1) {
const [x] = list.items;
return `[ ${generateExpression(x)} ]`;
}
}
default: {
return `[\n${(0, Common_1.prefixLines)(list.items.map(generateExpression).join(",\n"), 4)}\n]`;
}
}
}
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 generateElseIfStatement(elseIfStatement) {
const predicate = generateExpression(elseIfStatement.predicate);
const maybeLetBody = generateLetBlock(elseIfStatement.letBody);
const indent = maybeLetBody === "" ? 4 : 8;
const body = (function (lines) {
return (0, Common_1.prefixLines)(lines, indent);
})(generateExpression(elseIfStatement.body));
return `else if ${predicate} then${maybeLetBody}\n${body}`;
}
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));
const elseIfs = (function (y) {
return y.join("\n");
})(List.map(generateElseIfStatement, ifStatement.elseIf));
const prefixedElseIfs = elseIfs === "" ? "" : `${elseIfs}\n`;
return `if ${predicate} then${maybeIfLetBody}\n${ifBody}\n${prefixedElseIfs}else${maybeElseLetBody}\n${elseBody}`;
}
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 "[]";
}
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 "[]";
}
case "ListDestructure": {
const { parts } = branchPattern;
return (function (y) {
return y.join(" :: ");
})(List.map(generateListDestructurePart, parts));
}
case "Default": {
return "default";
}
}
}
function generateBranch(branch) {
const maybeLetBody = generateLetBlock(branch.letBody);
const bodyIndent = maybeLetBody === "" ? 4 : 8;
const body = (function (y) {
return (0, Common_1.prefixLines)(y, bodyIndent);
})(generateExpression(branch.body));
const pattern = generateBranchPattern(branch.pattern);
return `${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 `case ${predicate} of\n${branches}`;
}
function needsBrackets(expression) {
switch (expression.kind) {
case "FunctionCall": {
return true;
}
default: {
return false;
}
}
}
function applyBrackets(needsBrackets, generated) {
if (needsBrackets) {
return "(" + generated + ")";
}
else {
return generated;
}
}
function generateAddition(addition) {
const left = applyBrackets(needsBrackets(addition.left), generateExpression(addition.left));
const right = applyBrackets(needsBrackets(addition.right), generateExpression(addition.right));
return `${left} + ${right}`;
}
function generateSubtraction(subtraction) {
const left = applyBrackets(needsBrackets(subtraction.left), generateExpression(subtraction.left));
const right = applyBrackets(needsBrackets(subtraction.right), generateExpression(subtraction.right));
return `${left} - ${right}`;
}
function generateMultiplication(multiplication) {
const left = applyBrackets(needsBrackets(multiplication.left), generateExpression(multiplication.left));
const right = applyBrackets(needsBrackets(multiplication.right), generateExpression(multiplication.right));
return `${left} * ${right}`;
}
function generateDivision(division) {
const left = applyBrackets(needsBrackets(division.left), generateExpression(division.left));
const right = applyBrackets(needsBrackets(division.right), generateExpression(division.right));
return `${left} / ${right}`;
}
function generateMod(mod) {
const left = applyBrackets(needsBrackets(mod.left), generateExpression(mod.left));
const right = applyBrackets(needsBrackets(mod.right), generateExpression(mod.right));
return `${left} % ${right}`;
}
function generateLeftPipe(leftPipe) {
const left = generateExpression(leftPipe.left);
const right = generateExpression(leftPipe.right);
return `${left}\n |> ${right}`;
}
function generateRightPipe(rightPipe) {
const left = generateExpression(rightPipe.left);
const right = generateExpression(rightPipe.right);
return `${left}\n <| ${right}`;
}
function generateModuleReference(moduleReference) {
if (moduleReference.path.length === 0) {
return `.${generateExpression(moduleReference.value)}`;
}
else {
const left = moduleReference.path.join(".");
const right = generateExpression(moduleReference.value);
return `${left}.${right}`;
}
}
function generateFunctionCallArg(arg) {
switch (arg.kind) {
case "Constructor": {
const { pattern } = arg;
switch (pattern.fields.length) {
case 0: {
return generateExpression(arg);
}
default: {
return `(${generateExpression(arg)})`;
}
}
;
}
case "FunctionCall": {
const { args } = arg;
switch (args.length) {
case 0: {
return generateExpression(arg);
}
default: {
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)})`;
}
case "Addition": {
return `(${generateExpression(arg)})`;
}
case "Subtraction": {
return `(${generateExpression(arg)})`;
}
case "Multiplication": {
return `(${generateExpression(arg)})`;
}
case "Division": {
return `(${generateExpression(arg)})`;
}
case "Equality": {
return `(${generateExpression(arg)})`;
}
case "InEquality": {
return `(${generateExpression(arg)})`;
}
case "LessThan": {
return `(${generateExpression(arg)})`;
}
case "GreaterThan": {
return `(${generateExpression(arg)})`;
}
case "LessThanOrEqual": {
return `(${generateExpression(arg)})`;
}
case "GreaterThanOrEqual": {
return `(${generateExpression(arg)})`;
}
case "LeftPipe": {
return `(${generateExpression(arg)})`;
}
case "RightPipe": {
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);
const indent = (0, types_1.isSimpleValue)(lambda.body.kind) ? ` ${body}` : (function (y) {
return "\n" + y;
})((0, Common_1.prefixLines)(body, 4));
return `(\\${args} ->${indent})`;
}
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} == ${right}`;
}
function generateInEquality(inEquality) {
const left = generateExpression(inEquality.left);
const right = generateExpression(inEquality.right);
return `${left} != ${right}`;
}
function generateLessThan(lessThan) {
const left = generateExpression(lessThan.left);
const right = generateExpression(lessThan.right);
return `${left} < ${right}`;
}
function generateLessThanOrEqual(lessThanOrEqual) {
const left = generateExpression(lessThanOrEqual.left);
const right = generateExpression(lessThanOrEqual.right);
return `${left} <= ${right}`;
}
function generateGreaterThan(greaterThan) {
const left = generateExpression(greaterThan.left);
const right = generateExpression(greaterThan.right);
return `${left} > ${right}`;
}
function generateGreaterThanOrEqual(greaterThanOrEqual) {
const left = generateExpression(greaterThanOrEqual.left);
const right = generateExpression(greaterThanOrEqual.right);
return `${left} >= ${right}`;
}
function generateAnd(and) {
const left = generateExpression(and.left);
const right = generateExpression(and.right);
return `${left} && ${right}`;
}
function generateOr(or) {
const left = generateExpression(or.left);
const right = generateExpression(or.right);
return `${left} || ${right}`;
}
function generateListPrepend(prepend) {
const left = generateExpression(prepend.left);
const right = generateExpression(prepend.right);
return `${left} :: ${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);
}
}
}
exports.generateExpression = generateExpression;
function generateDoExpression(expression) {
switch (expression.kind) {
case "Const": {
return generateConst(expression);
}
case "Function": {
return generateFunction(expression);
}
case "FunctionCall": {
return generateFunctionCall(expression);
}
case "ModuleReference": {
return generateModuleReference(expression);
}
case "IfStatement": {
return generateIfStatement(expression);
}
}
}
function generateDoBlock(doBody) {
return (function (y) {
return `do\n${y}\nreturn`;
})((function (y) {
return (0, Common_1.prefixLines)(y, 4);
})((function (y) {
return y.join("\n\n");
})(List.map(function (expression) {
return generateDoExpression(expression);
}, doBody.expressions))));
}
const openParens = "(";
const closeParens = ")";
function typeToArg(type_) {
return (function (y) {
return y.replace(closeParens, "");
})((function (y) {
return y.replace(openParens, "");
})((function (y) {
return y.replace(" ", "_");
})((function (y) {
return y[0].toLowerCase() + y.slice(1);
})(generateTopLevelType(type_)))));
}
function generateFunctionArg(knownNames, arg) {
switch (arg.kind) {
case "FunctionArg": {
return arg.name;
}
case "AnonFunctionArg": {
const tempName = (function () {
switch (arg.type.kind) {
case "FunctionType": {
return "fn";
}
default: {
return `${typeToArg(arg.type)}`;
}
}
})();
if (knownNames.indexOf(tempName) === -1) {
return tempName;
}
else {
return `_${tempName}`;
}
;
}
}
}
function knownArgNames(args) {
switch (args.length) {
case 0: {
return [];
}
case args.length: {
if (args.length >= 1) {
const [arg, ...rest] = args;
switch (arg.kind) {
case "FunctionArg": {
return [arg.name, ...knownArgNames(rest)];
}
case "AnonFunctionArg": {
return knownArgNames(rest);
}
}
;
}
}
default: {
return [];
}
}
}
function generateFunctionArgType(arg) {
switch (arg.kind) {
case "FunctionArg": {
return generateTopLevelType(arg.type);
}
case "AnonFunctionArg": {
return generateTopLevelType(arg.type);
}
}
}
function generateFunction(function_) {
const argsTypes = (function (y) {
return y.join(" -> ");
})(List.map(generateFunctionArgType, function_.args));
const knownNames = knownArgNames(function_.args);
const args = (function (y) {
return y.join(" ");
})(List.map(function (x) {
return generateFunctionArg(knownNames, x);
}, function_.args));
const maybeLetBody = generateLetBlock(function_.letBody);
const maybeDoBody = function_.doBody === null ? "" : `\n${(0, Common_1.prefixLines)(generateDoBlock(function_.doBody), 4)}`;
const returnType = generateTopLevelType(function_.returnType);
const bodyIndent = maybeLetBody === "" && maybeDoBody === "" ? 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}: ${argsTypes} -> ${returnType}`, `${function_.name} ${args} =${maybeLetBody}${maybeDoBody}`, `${body}`]);
}
function generateConst(constDef) {
const maybeLetBody = generateLetBlock(constDef.letBody);
const bodyIndent = maybeLetBody === "" ? 4 : 8;
const body = (function (y) {
return (0, Common_1.prefixLines)(y, bodyIndent);
})(generateExpression(constDef.value));
const typeDef = generateTopLevelType(constDef.type);
return (function (y) {
return y.join("\n");
})([`${constDef.name}: ${typeDef}`, `${constDef.name} =${maybeLetBody}`, `${body}`]);
}
function generateImportModule(module) {
const partExposing = module.exposing.length === 0 ? "" : ` exposing ( ${module.exposing.join(", ")} )`;
const moduleName = (function () {
switch (module.namespace) {
case "Global": {
if (module.name.includes("/")) {
return `"${module.name}"`;
}
else {
return module.name;
}
;
}
case "Relative": {
return module.name;
}
}
})();
switch (module.alias.kind) {
case "Just": {
const { value } = module.alias;
return `import ${moduleName} as ${value}${partExposing}`;
}
case "Nothing": {
return `import ${moduleName}${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 generateComment(comment) {
return `-- ${comment.body}`;
}
function generateMultilineComment(comment) {
return `{-\n${comment.body}\n-}`;
}
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 generateTypeclass(syntax);
}
case "Impl": {
return generateImpl(syntax);
}
case "Function": {
return generateFunction(syntax);
}
case "Const": {
return generateConst(syntax);
}
case "Comment": {
return generateComment(syntax);
}
case "MultilineComment": {
return generateMultilineComment(syntax);
}
}
}
function joinBlocks(blocks) {
switch (blocks.length) {
case blocks.length: {
if (blocks.length >= 1) {
const [block, ...rest] = blocks;
const generated = generateBlock(block);
const next = joinBlocks(rest);
if (generated.trim().length === 0) {
return next;
}
else {
switch (block.kind) {
case "Comment": {
return generated + "\n" + next;
}
case "MultilineComment": {
return generated + "\n" + next;
}
default: {
return generated + "\n\n" + next;
}
}
;
}
;
}
}
default: {
return "";
}
}
}
function generateDerw(module) {
const onlyImports = List.filter(function (block) {
return block.kind === "Import";
}, module.body);
function sorter(a, b) {
if (a === b) {
return 0;
}
else {
if (a < b) {
return -1;
}
else {
return 1;
}
;
}
}
const sortedImports = (function (y) {
return y.join("\n");
})((function (y) {
return y.sort(sorter);
})(List.filter(function (line) {
return line.length > 0;
}, List.map(generateBlock, onlyImports))));
const maybeNewlines = onlyImports.length === 0 ? "" : "\n\n";
const withoutImports = (function (y) {
return y.trim();
})((function (y) {
return joinBlocks(y);
})(List.filter(function (block) {
return block.kind !== "Import";
}, module.body)));
return (function (y) {
return y.join("");
})([sortedImports, maybeNewlines, withoutImports]);
}
exports.generateDerw = generateDerw;