1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
import {
type ContinuationExpression,
type PrimitiveOperationExpression,
type ApplicationExpression,
type Program,
type Value,
} from '@/parser';
import { Environment, type Denotable } from '.';
import {
BadArgumentError,
InvalidStateError,
NotImplementedError,
type TracingLogger,
} from '@/utils';
import { putBuiltinsOnEnvironemtn } from './builtins';
const evaluateValue = (
value: Value,
env: Environment,
_logger: TracingLogger,
): Denotable => {
if (typeof value === 'string') {
return { type: 'string', value };
}
if ('real' in value) {
return { type: 'real', value: value.real };
}
if ('int' in value) {
return { type: 'int', value: value.int };
}
if ('name' in value) {
return env.get(value.name);
}
throw new InvalidStateError(`Invalid value: ${value}`);
};
const evaluateApplicationExpression = (
{ application }: ApplicationExpression,
env: Environment,
logger: TracingLogger,
): Denotable => {
const { fn, args } = application;
const argValues = args.map(arg =>
evaluateValue(arg, env, logger.createChild('evaluateValue')),
);
return env.apply(fn.name, argValues);
};
const evaluatePrimitiveOperation = (
{ primitiveOperation }: PrimitiveOperationExpression,
env: Environment,
logger: TracingLogger,
) => {
const { opr, operands, resultBindings, continuations } = primitiveOperation;
const operandValues = operands.map(operand =>
evaluateValue(operand, env, logger.createChild('evaluteValue')),
);
const result = env.apply(opr, operandValues);
const continuationEnvironment = env.createChild();
for (const { name } of resultBindings) {
continuationEnvironment.set(name, result);
}
if (result.type === 'bool') {
if (continuations.length > 2) {
throw new BadArgumentError(
`Expected <= 2 continuations for boolean result, got ${continuations.length}`,
);
}
if (continuations.length !== 2) {
logger.warn(
`Expected 2 continuations for boolean result, got ContinuationLength=(${continuations.length})`,
);
return result;
}
const [trueContinuation, falseContinuation] = continuations;
const childLogger = logger.createChild('continuation[true]');
const continuation = result.value ? trueContinuation : falseContinuation;
return evaluteContinuationExpression(
continuation,
continuationEnvironment,
childLogger,
);
}
if (continuations.length > 1) {
throw new BadArgumentError(
`Expected <= 1 continuations for non-boolean result, got ${continuations.length}`,
);
} else if (continuations.length === 0) {
logger.warn(
"Expected 1 continuation for non-boolean result, but there wasn't any. Implicitly returning the result", // technically undefined behavior
);
return result;
}
const [continuation] = continuations;
const childLogger = logger.createChild('continuation');
return evaluteContinuationExpression(
continuation,
continuationEnvironment,
childLogger,
);
};
const evaluteContinuationExpression = (
expr: ContinuationExpression,
env: Environment,
logger: TracingLogger,
): Denotable => {
if ('primitiveOperation' in expr) {
logger.debug('Evaluating primitive operation');
return evaluatePrimitiveOperation(
expr,
env,
logger.createChild('evaluatePrimitiveOperation'),
);
}
if ('application' in expr) {
logger.debug('Evaluating function application');
return evaluateApplicationExpression(
expr,
env,
logger.createChild('evaluateApplicationExpression'),
);
}
if ('record' in expr) {
throw new NotImplementedError('Continuation records are not supported yet');
}
if ('select' in expr) {
throw new NotImplementedError('Continuation select is not supported yet');
}
if ('offset' in expr) {
throw new NotImplementedError('Continuation offset is not supported yet');
}
if ('switch' in expr) {
throw new NotImplementedError('Continuation switch is not supported yet');
}
if ('fix' in expr) {
throw new NotImplementedError('Continuation fix is not supported yet');
}
throw new InvalidStateError(`Invalid continuation expression: ${expr}`);
};
export const evaluate = async (
ast: Program,
logger: TracingLogger,
): Promise<Denotable> => {
const globalEnvironment = putBuiltinsOnEnvironemtn(
new Environment(logger.createChild('RootEnv')),
);
return ast.reduce((_, continuation, i) => {
const exprLogger = logger.createChild(`statement[${i}]`);
return evaluteContinuationExpression(
continuation as ContinuationExpression,
globalEnvironment,
exprLogger,
);
}, null);
};
|
