commit 4a7065c01a05d4f214014d9306614b672f11ec20 · jonmsterling.com/swift-pterodactyl

Sources/PterodactylKernel/Core Types/Term.swift

···

       28
       28
        
       		let manifest: Term?

     

       29
       29
        
       	}

     

       30
       30
        
       	

     

       31
       31
       +
       	struct TypedTerm {

     

       32
       32
       +
       		let type: Type_

     

       33
       33
       +
       		let term: Term

     

       34
       34
       +
       	}

     

       35
       35
       +
       	

     

       31
       36
        
       	struct FieldImpl {

     

       32
       37
        
       		let type: Type_

     

       33
       38
        
       		let value: Term

+22 -2

Sources/PterodactylKernel/Evaluator.swift

···

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

     

       4
       4
        
       

     

       5
       5
        
       struct Evaluator {

     

       6
       6
       -
       	let globals: [Name: Value]

     

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

     

       7
       7
        
       	let locals: [Value]

     

       8
       8
       +
       	

     

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

     

       10
       10
       +
       		self.globals = globals

     

       11
       11
       +
       		self.locals = locals

     

       12
       12
       +
       	}

     

       13
       13
       +
       	

     

       14
       14
       +
       	init() {

     

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

     

       16
       16
       +
       	}

     

       8
       17
        
       

     

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

     

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

     
···

       40
       49
        
       		case let .local(index: index):

     

       41
       50
        
       			return locals[index]

     

       42
       51
        
       		case let .global(name: name):

     

       43
       43
       -
       			return globals[name]!

     

       52
       52
       +
       			let neutral = Value.Neutral(

     

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

     

       54
       54
       +
       				spine: [],

     

       55
       55
       +
       				boundary: AsyncThunk {

     

       56
       56
       +
       					let typedTerm = globals[name]!

     

       57
       57
       +
       					return Value.Boundary(

     

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

     

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

     

       60
       60
       +
       					)

     

       61
       61
       +
       				}

     

       62
       62
       +
       			)

     

       63
       63
       +
       			return .shift(neutral: neutral)

     

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

     

       45
       65
        
       			return evaluate(term: term)

     

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