···

       
28
       
 
       
		let manifest: Term?

     

       
29
       
 
       
	}

     

       
30
       
 
       
	

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
31
       
 
       
	struct FieldImpl {

     

       
32
       
 
       
		let type: Type_

     

       
33
       
 
       
		let value: Term

     

···

       
28
       
 
       
		let manifest: Term?

     

       
29
       
 
       
	}

     

       
30
       
 
       
	

     

       
31
       
+
       
	struct TypedTerm {

     

       
32
       
+
       
		let type: Type_

     

       
33
       
+
       
		let term: Term

     

       
34
       
+
       
	}

     

       
35
       
+
       
	

     

       
36
       
 
       
	struct FieldImpl {

     

       
37
       
 
       
		let type: Type_

     

       
38
       
 
       
		let value: Term

     

···

       
3
       
 
       
// SPDX-License-Identifier: MPL-2.0

     

       
4
       
 
       


     

       
5
       
 
       
struct Evaluator {

     

       
6
       
-
       
	let globals: [Name: Value]

     

       
7
       
 
       
	let locals: [Value]

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       


     

       
9
       
 
       
	func extendedBy(value: Value) -> Self {

     

       
10
       
 
       
		Self(globals: globals, locals: CollectionOfOne(value) + locals)

     
···

       
40
       
 
       
		case let .local(index: index):

     

       
41
       
 
       
			return locals[index]

     

       
42
       
 
       
		case let .global(name: name):

     

       
43
       
-
       
			return globals[name]!

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
44
       
 
       
		case let .cut(term: term, frame: frame):

     

       
45
       
 
       
			return evaluate(term: term)

     

       
46
       
 
       
				.plug(frame: evaluate(frame: frame))

     

···

       
3
       
 
       
// SPDX-License-Identifier: MPL-2.0

     

       
4
       
 
       


     

       
5
       
 
       
struct Evaluator {

     

       
6
       
+
       
	let globals: [Name: Term.TypedTerm]

     

       
7
       
 
       
	let locals: [Value]

     

       
8
       
+
       
	

     

       
9
       
+
       
	init(globals: [Name : Term.TypedTerm], locals: [Value]) {

     

       
10
       
+
       
		self.globals = globals

     

       
11
       
+
       
		self.locals = locals

     

       
12
       
+
       
	}

     

       
13
       
+
       
	

     

       
14
       
+
       
	init() {

     

       
15
       
+
       
		self.init(globals: [:], locals: [])

     

       
16
       
+
       
	}

     

       
17
       
 
       


     

       
18
       
 
       
	func extendedBy(value: Value) -> Self {

     

       
19
       
 
       
		Self(globals: globals, locals: CollectionOfOne(value) + locals)

     
···

       
49
       
 
       
		case let .local(index: index):

     

       
50
       
 
       
			return locals[index]

     

       
51
       
 
       
		case let .global(name: name):

     

       
52
       
+
       
			let neutral = Value.Neutral(

     

       
53
       
+
       
				head: .global(name: name),

     

       
54
       
+
       
				spine: [],

     

       
55
       
+
       
				boundary: AsyncThunk {

     

       
56
       
+
       
					let typedTerm = globals[name]!

     

       
57
       
+
       
					return Value.Boundary(

     

       
58
       
+
       
						type: evaluate(type: typedTerm.type),

     

       
59
       
+
       
						value: evaluate(term: typedTerm.term)

     

       
60
       
+
       
					)

     

       
61
       
+
       
				}

     

       
62
       
+
       
			)

     

       
63
       
+
       
			return .shift(neutral: neutral)

     

       
64
       
 
       
		case let .cut(term: term, frame: frame):

     

       
65
       
 
       
			return evaluate(term: term)

     

       
66
       
 
       
				.plug(frame: evaluate(frame: frame))