commit b7856f21730696a72f7e0e38f69958cf477ef876 · jonmsterling.com/swift-pterodactyl

+1 -1

Sources/PterodactylKernel/Control/AsyncThunk.swift

···

       4
       4
        
       

     

       5
       5
        
       import Foundation

     

       6
       6
        
       

     

       7
       7
       -
       actor AsyncThunk<Value> {

     

       7
       7
       +
       public actor AsyncThunk<Value> {

     

       8
       8
        
       	private var storage: Value?

     

       9
       9
        
       	private var thunk: (() async -> Value)?

     

       10
       10

+4 -2

Sources/PterodactylKernel/Core Types/FieldDict.swift

···

       4
       4
        
       

     

       5
       5
        
       import Foundation

     

       6
       6
        
       

     

       7
       7
       -
       struct FieldDict<Value> {

     

       7
       7
       +
       // TODO: This might be rewritten. The goal is to provide a dictionary that I can easily construct and traverse in order. Maybe ordered dictionaries from swift-collections?

     

       8
       8
       +
       public struct FieldDict<Value> {

     

       8
       9
        
       	public let elements: [(String, Value)]

     

       10
       10
       +
       	var keys: [String] { elements.map(\.0) }

     

       9
       11
        
       

     

       10
       12
        
       	init(_ dict: [(String, Value)]) {

     

       11
       13
        
       		self.elements = dict

     
···

       14
       16
        
       	subscript(key: String) -> Value? {

     

       15
       17
        
       		elements.first { $0.0 == key }?.1

     

       16
       18
        
       	}

     

       17
       17
       -
       	

     

       19
       19
       +
       

     

       18
       20
        
       	func prefix(until: String) -> Self {

     

       19
       21
        
       		var prefix: [(String, Value)] = []

     

       20
       22
        
       		for (key, value) in elements {

+36

Sources/PterodactylKernel/Core Types/Size.swift

···

       1
       1
       +
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       2
       +
       //

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       import Foundation

     

       6
       6
       +
       

     

       7
       7
       +
       /// Pterodactyl has two sizes of small things: little and moderate. Beyond these, we have things that are not types but rather “type schemes”.

     

       8
       8
       +
       public enum Size<Universe> {

     

       9
       9
       +
       	/// A “little” thing is something classified by a universe. Universes form a countable hierarchy.

     

       10
       10
       +
       	case little(universe: Universe)

     

       11
       11
       +
       	

     

       12
       12
       +
       	/// A “moderate” type is something classified by `Type`.

     

       13
       13
       +
       	case moderate

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       

     

       17
       17
       +
       extension Size: Sendable where Universe: Sendable {}

     

       18
       18
       +
       

     

       19
       19
       +
       extension Size: Equatable where Universe == () {

     

       20
       20
       +
       	public static func == (lhs: Size<Universe>, rhs: Size<Universe>) -> Bool {

     

       21
       21
       +
       		switch (lhs, rhs) {

     

       22
       22
       +
       		case (.little, .little): true

     

       23
       23
       +
       		case (.moderate, .moderate): true

     

       24
       24
       +
       		default: false

     

       25
       25
       +
       		}

     

       26
       26
       +
       	}

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       extension Size {

     

       30
       30
       +
       	func map<U>(_ f: (Universe) -> U) -> Size<U> {

     

       31
       31
       +
       		switch self {

     

       32
       32
       +
       		case let .little(universe: universe): .little(universe: f(universe))

     

       33
       33
       +
       		case .moderate: .moderate

     

       34
       34
       +
       		}

     

       35
       35
       +
       	}

     

       36
       36
       +
       }

+28 -7

Sources/PterodactylKernel/Core Types/Term.swift

···

       2
       2
        
       //

     

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

     

       4
       4
        
       

     

       5
       5
       -
       typealias Name = String

     

       5
       5
       +
       public typealias Name = String

     

       6
       6
        
       

     

       7
       7
       -
       indirect enum Term: Sendable {

     

       7
       7
       +
       public indirect enum Term: Sendable {

     

       8
       8
       +
       	

     

       9
       9
       +
       	/// A local variable, designated by a De Bruijn index.

     

       8
       10
        
       	case local(index: Int)

     

       11
       11
       +
       	

     

       12
       12
       +
       	/// A global variable, designated by a `Name`.

     

       9
       13
        
       	case global(name: Name)

     

       14
       14
       +
       	

     

       15
       15
       +
       	/// A (dependent) function.

     

       10
       16
        
       	case fun(dom: AsyncThunk<Type_>, boundName: String?, body: Term)

     

       17
       17
       +
       	

     

       18
       18
       +
       	/// A (dependent) record.

     

       11
       19
        
       	case record(boundName: String?, fields: FieldDict<FieldImpl>)

     

       20
       20
       +
       	

     

       21
       21
       +
       	/// A negative elimination-form (``Frame``) applied to a term.

     

       12
       22
        
       	case cut(term: Term, frame: Frame)

     

       23
       23
       +
       	

     

       24
       24
       +
       	/// The canonical code of a small type.

     

       25
       25
       +
       	case shrink(size: Size<Term>, type: Type_)

     

       26
       26
       +
       	

     

       27
       27
       +
       	case universeZero

     

       28
       28
       +
       	case universeSucc(_ universe: Term)

     

       29
       29
       +
       	case universeLub(_ universe1: Term, _ universe2: Term)

     

       13
       30
        
       }

     

       14
       31
        
       

     

       15
       32
        
       extension Term {

     

       16
       16
       -
       	indirect enum Type_: Sendable {

     

       33
       33
       +
       	public indirect enum Type_: Sendable {

     

       17
       34
        
       		case funType(dom: Type_, boundName: String?, fam: Type_)

     

       18
       35
        
       		case recordType(boundName: String?, fields: FieldDict<FieldSpec>)

     

       36
       36
       +
       		case universeCodes(size: Size<Term>)

     

       37
       37
       +
       		case decode(size: Size<()>, code: Term)

     

       38
       38
       +
       		

     

       39
       39
       +
       		case universeType

     

       19
       40
        
       	}

     

       20
       41
        
       	

     

       21
       21
       -
       	indirect enum Frame {

     

       42
       42
       +
       	public indirect enum Frame: Sendable {

     

       22
       43
        
       		case app(arg: Term)

     

       23
       44
        
       		case proj(fieldName: String)

     

       24
       45
        
       	}

     

       25
       46
        
       	

     

       26
       26
       -
       	struct FieldSpec {

     

       47
       47
       +
       	public struct FieldSpec: Sendable {

     

       27
       48
        
       		let type: Type_

     

       28
       49
        
       		let manifest: Term?

     

       29
       50
        
       	}

     

       30
       51
        
       	

     

       31
       31
       -
       	struct TypedTerm {

     

       52
       52
       +
       	public struct TypedTerm: Sendable {

     

       32
       53
        
       		let type: Type_

     

       33
       54
        
       		let term: Term

     

       34
       55
        
       	}

     

       35
       56
        
       	

     

       36
       36
       -
       	struct FieldImpl {

     

       57
       57
       +
       	public struct FieldImpl: Sendable {

     

       37
       58
        
       		let type: Type_

     

       38
       59
        
       		let value: Term

     

       39
       60
        
       	}

+41 -12

Sources/PterodactylKernel/Core Types/Value.swift

···

       2
       2
        
       //

     

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

     

       4
       4
        
       

     

       5
       5
       -
       struct Closure<Body>{

     

       5
       5
       +
       public struct Closure<Body> {

     

       6
       6
        
       	let evaluator: Evaluator

     

       7
       7
        
       	let body: Body

     

       8
       8
        
       }

     

       9
       9
        
       

     

       10
       10
        
       extension Closure: Sendable where Body: Sendable {}

     

       11
       11
        
       

     

       12
       12
       -
       indirect enum Value: Sendable {

     

       12
       12
       +
       public indirect enum Value: Sendable {

     

       13
       13
        
       	case shift(neutral: Neutral)

     

       14
       14
        
       	case fun(dom: AsyncThunk<Type_>, boundName: String?, closure: Closure<Term>)

     

       15
       15
        
       	case record(boundName: String?, fields: FieldDict<FieldImpl>)

     

       16
       16
       +
       	

     

       17
       17
       +
       	case shrink(size: Size<Value>, type: Type_)

     

       18
       18
       +
       	

     

       19
       19
       +
       	case universeZero

     

       20
       20
       +
       	case universeSucc(_ universe: Value)

     

       21
       21
       +
       	case universeLub(_ universe1: Value, _ universe2: Value)

     

       16
       22
        
       }

     

       17
       23
        
       

     

       18
       24
        
       extension Value {

     

       19
       19
       -
       	indirect enum Type_: Sendable {

     

       25
       25
       +
       	public indirect enum Type_: Sendable {

     

       20
       26
        
       		case funType(dom: Type_, boundName: String?, fam: Closure<Term.Type_>)

     

       21
       27
        
       		case recordType(boundName: String?, fields: FieldDict<FieldSpec>)

     

       28
       28
       +
       		

     

       29
       29
       +
       		/// The type of small universe levels.

     

       30
       30
       +
       		case universeType

     

       31
       31
       +
       		

     

       32
       32
       +
       		/// The type of `S`-small type codes for a size `S`.

     

       33
       33
       +
       		case universeCodes(size: Size<Value>)

     

       34
       34
       +
       		

     

       35
       35
       +
       		/// The decoding of a given `S`-small type code.

     

       36
       36
       +
       		case decode(size: Size<()>, code: Neutral)

     

       22
       37
        
       	}

     

       23
       23
       -
       	

     

       24
       24
       -
       	struct FieldSpec {

     

       38
       38
       +
       

     

       39
       39
       +
       	public struct FieldSpec: Sendable {

     

       25
       40
        
       		let type: Closure<Term.Type_>

     

       26
       41
        
       		let manifest: Closure<Term>?

     

       27
       42
        
       	}

     

       28
       28
       -
       	

     

       29
       29
       -
       	struct FieldImpl {

     

       43
       43
       +
       

     

       44
       44
       +
       	public struct FieldImpl: Sendable {

     

       30
       45
        
       		let type: Closure<Term.Type_>

     

       31
       46
        
       		let value: Closure<Term>

     

       32
       47
        
       	}

     

       33
       48
        
       

     

       34
       34
       -
       	indirect enum Frame {

     

       49
       49
       +
       	// TODO: Kovacs makes the argument in an application frame lazy. Doing this would be a significant change, because it would make it necessary for the plugging operation to be asynchronous.

     

       50
       50
       +
       	public indirect enum Frame: Sendable {

     

       35
       51
        
       		case app(arg: Value)

     

       36
       52
        
       		case proj(fieldName: String)

     

       37
       53
        
       	}

     

       38
       54
        
       

     

       39
       39
       -
       	typealias Spine = [Frame]

     

       55
       55
       +
       	/// When a ``Neutral`` is plugged into a ``Frame``, the frame is enriched with further information before being placed on the spine.

     

       56
       56
       +
       	public indirect enum RichFrame: Sendable {

     

       57
       57
       +
       		case app(dom: AsyncThunk<Value.Type_>, arg: Value)

     

       58
       58
       +
       		case proj(fieldName: String)

     

       59
       59
       +
       	}

     

       40
       60
        
       

     

       41
       41
       -
       	enum Head {

     

       61
       61
       +
       	public typealias Spine = [RichFrame]

     

       62
       62
       +
       

     

       63
       63
       +
       	public enum Head: Equatable, Sendable {

     

       42
       64
        
       		case local(level: Int)

     

       43
       65
        
       		case global(name: Name)

     

       44
       66
        
       	}

     

       45
       67
        
       

     

       46
       46
       -
       	struct Neutral {

     

       68
       68
       +
       	public struct Neutral: Sendable {

     

       47
       69
        
       		let head: Head

     

       48
       70
        
       		let spine: Spine

     

       49
       71
        
       		let boundary: AsyncThunk<Boundary>

     
···

       56
       78
        
       }

     

       57
       79
        
       

     

       58
       80
        
       

     

       59
       59
       -
       

     

       81
       81
       +
       extension Value.RichFrame {

     

       82
       82
       +
       	var forget: Value.Frame {

     

       83
       83
       +
       		switch self {

     

       84
       84
       +
       		case let .app(dom: _, arg: arg): .app(arg: arg)

     

       85
       85
       +
       		case let .proj(fieldName: fieldName): .proj(fieldName: fieldName)

     

       86
       86
       +
       		}

     

       87
       87
       +
       	}

     

       88
       88
       +
       }

+37 -6

Sources/PterodactylKernel/Evaluator.swift

···

       5
       5
        
       struct Evaluator {

     

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

     

       7
       7
        
       	let locals: [Value]

     

       8
       8
       -
       	

     

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

     

       8
       8
       +
       

     

       9
       9
       +
       	public 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
       12
        
       	}

     

       17
       13
        
       

     

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

     
···

       75
       71
        
       				boundName: boundName,

     

       76
       72
        
       				fields: fields.map(close(fieldImpl:))

     

       77
       73
        
       			)

     

       74
       74
       +
       		case let .shrink(size: size, type: type):

     

       75
       75
       +
       			return .shrink(

     

       76
       76
       +
       				size: size.map(evaluate(term:)),

     

       77
       77
       +
       				type: evaluate(type: type)

     

       78
       78
       +
       			)

     

       79
       79
       +
       		case .universeZero:

     

       80
       80
       +
       			return .universeZero

     

       81
       81
       +
       		case let .universeSucc(universe: universe):

     

       82
       82
       +
       			return .universeSucc(evaluate(term: universe))

     

       83
       83
       +
       		case let .universeLub(universe1, universe2):

     

       84
       84
       +
       			return .universeLub(

     

       85
       85
       +
       				evaluate(term: universe1),

     

       86
       86
       +
       				evaluate(term: universe2)

     

       87
       87
       +
       			)

     

       78
       88
        
       		}

     

       79
       89
        
       	}

     

       80
       90
        
       

     
···

       86
       96
        
       				boundName: boundName,

     

       87
       97
        
       				fam: close(body: fam)

     

       88
       98
        
       			)

     

       99
       99
       +
       

     

       89
       100
        
       		case let .recordType(boundName: boundName, fields: fields):

     

       90
       101
        
       			.recordType(boundName: boundName, fields: fields.map(close(fieldSpec:)))

     

       102
       102
       +
       

     

       103
       103
       +
       		case let .decode(size: size, code: code):

     

       104
       104
       +
       			evaluate(term: code).decode(size: size)

     

       105
       105
       +
       

     

       106
       106
       +
       		case let .universeCodes(size: size):

     

       107
       107
       +
       				.universeCodes(size: size.map(evaluate(term:)))

     

       108
       108
       +
       

     

       109
       109
       +
       		case .universeType:

     

       110
       110
       +
       			.universeType

     

       91
       111
        
       		}

     

       92
       112
        
       	}

     

       93
       113
        
       }

     

       114
       114
       +
       

     

       115
       115
       +
       extension Value {

     

       116
       116
       +
       	func decode(size: Size<()>) -> Value.Type_ {

     

       117
       117
       +
       		switch self {

     

       118
       118
       +
       		case let .shrink(_, type: type): type

     

       119
       119
       +
       		case let .shift(neutral: neutral): .decode(size: size, code: neutral)

     

       120
       120
       +
       		default: fatalError()

     

       121
       121
       +
       		}

     

       122
       122
       +
       	}

     

       123
       123
       +
       }

     

       124
       124
       +
       

     

       94
       125
        
       

     

       95
       126
        
       extension Closure where Body == Term {

     

       96
       127
        
       	func instantiate(with value: Value) -> Value {

+148

Sources/PterodactylKernel/Local Analysis/Equality.swift

···

       1
       1
       +
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       2
       +
       //

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       import Foundation

     

       6
       6
       +
       

     

       7
       7
       +
       extension LocalAnalysis {

     

       8
       8
       +
       	enum EqualityError: Error {

     

       9
       9
       +
       		case values(lhs: Value, rhs: Value, type: Value.Type_)

     

       10
       10
       +
       		case types(lhs: Value.Type_, rhs: Value.Type_)

     

       11
       11
       +
       		case heads(lhs: Value.Head, rhs: Value.Head)

     

       12
       12
       +
       		case frames(lhs: Value.RichFrame, rhs: Value.RichFrame)

     

       13
       13
       +
       		case spines(lhs: Value.Spine, rhs: Value.Spine)

     

       14
       14
       +
       	}

     

       15
       15
       +
       

     

       16
       16
       +
       	func equate(value lhs: Value, with rhs: Value, in type: Value.Type_) async throws {

     

       17
       17
       +
       		switch await (lhs.whnf(), rhs.whnf(), type.whnf()) {

     

       18
       18
       +
       		case (_, _, .universeType):

     

       19
       19
       +
       			try await equate(size: .little(universe: lhs), with: .little(universe: rhs))

     

       20
       20
       +
       

     

       21
       21
       +
       		case let (lhs, rhs, .funType(dom: dom, boundName: _, fam: fam)):

     

       22
       22
       +
       			let dom = AsyncThunk(value: dom)

     

       23
       23
       +
       			let x = fresh(type: dom)

     

       24
       24
       +
       			let frame = Value.Frame.app(arg: x)

     

       25
       25
       +
       			let lhs = lhs.plug(frame: frame)

     

       26
       26
       +
       			let rhs = rhs.plug(frame: frame)

     

       27
       27
       +
       			let fibre = fam.instantiate(with: x)

     

       28
       28
       +
       			try await next.equate(value: lhs, with: rhs, in: fibre)

     

       29
       29
       +
       

     

       30
       30
       +
       		case let (lhs, rhs, .recordType(boundName: boundName, fields: fields)):

     

       31
       31
       +
       			var fieldImpls: [(String, Value.FieldImpl)] = []

     

       32
       32
       +
       			for (key, field) in fields.elements {

     

       33
       33
       +
       				let prefixRecord: Value = .record(boundName: boundName, fields: FieldDict(fieldImpls))

     

       34
       34
       +
       				if field.manifest == nil {

     

       35
       35
       +
       					let frame = Value.Frame.proj(fieldName: key)

     

       36
       36
       +
       					let lhs = lhs.plug(frame: frame)

     

       37
       37
       +
       					let rhs = rhs.plug(frame: frame)

     

       38
       38
       +
       					let type = field.type.instantiate(with: prefixRecord)

     

       39
       39
       +
       					try await equate(value: lhs, with: rhs, in: type)

     

       40
       40
       +
       				}

     

       41
       41
       +
       

     

       42
       42
       +
       				let impl = Value.FieldImpl(

     

       43
       43
       +
       					type: field.type,

     

       44
       44
       +
       					value: Closure(

     

       45
       45
       +
       						evaluator: Evaluator(),

     

       46
       46
       +
       						body: .cut(

     

       47
       47
       +
       							term: .local(index: 0),

     

       48
       48
       +
       							frame: .proj(fieldName: key)

     

       49
       49
       +
       						)

     

       50
       50
       +
       					)

     

       51
       51
       +
       				)

     

       52
       52
       +
       				fieldImpls.append((key, impl))

     

       53
       53
       +
       			}

     

       54
       54
       +
       

     

       55
       55
       +
       		case (_, _, .universeCodes):

     

       56
       56
       +
       			try await equate(type: lhs.decode(size: .little(universe: ())), with: rhs.decode(size: .little(universe: ())))

     

       57
       57
       +
       

     

       58
       58
       +
       		case let (.shift(neutral: lhs), .shift(neutral: rhs), .decode):

     

       59
       59
       +
       			try await equate(neutral: lhs, with: rhs)

     

       60
       60
       +
       

     

       61
       61
       +
       		default:

     

       62
       62
       +
       			throw EqualityError.values(lhs: lhs, rhs: rhs, type: type)

     

       63
       63
       +
       		}

     

       64
       64
       +
       	}

     

       65
       65
       +
       

     

       66
       66
       +
       	func equate(type lhs: Value.Type_, with rhs: Value.Type_) async throws {

     

       67
       67
       +
       		switch await (lhs.whnf(), rhs.whnf()) {

     

       68
       68
       +
       

     

       69
       69
       +
       		case let (.funType(dom: dom1, boundName: _, fam: fam1), .funType(dom: dom2, boundName: _, fam: fam2)):

     

       70
       70
       +
       			try await equate(type: dom1, with: dom2)

     

       71
       71
       +
       			let x = fresh(type: AsyncThunk(value: dom1))

     

       72
       72
       +
       			let fibre1 = fam1.instantiate(with: x)

     

       73
       73
       +
       			let fibre2 = fam2.instantiate(with: x)

     

       74
       74
       +
       			try await next.equate(type: fibre1, with: fibre2)

     

       75
       75
       +
       

     

       76
       76
       +
       		case let (.recordType(boundName: boundName, fields: fields1), .recordType(boundName: _, fields: fields2)):

     

       77
       77
       +
       			let error = EqualityError.types(lhs: lhs, rhs: rhs)

     

       78
       78
       +
       			guard fields1.keys == fields2.keys else { throw error }

     

       79
       79
       +
       

     

       80
       80
       +
       			var fieldSpecs: [(String, Value.FieldSpec)] = []

     

       81
       81
       +
       

     

       82
       82
       +
       			for (key, field1) in fields1.elements {

     

       83
       83
       +
       				let field2 = fields2[key]!

     

       84
       84
       +
       				guard (field1.manifest == nil) == ((field2.manifest == nil)) else { throw error }

     

       85
       85
       +
       

     

       86
       86
       +
       				let prefixType: AsyncThunk<Value.Type_> = AsyncThunk(value: .recordType(boundName: boundName, fields: FieldDict(fieldSpecs)))

     

       87
       87
       +
       				let x = fresh(type: prefixType)

     

       88
       88
       +
       				let type1 = field1.type.instantiate(with: x)

     

       89
       89
       +
       				let type2 = field2.type.instantiate(with: x)

     

       90
       90
       +
       				try await next.equate(type: type1, with: type2)

     

       91
       91
       +
       

     

       92
       92
       +
       				if let manifest1 = field1.manifest, let manifest2 = field2.manifest {

     

       93
       93
       +
       					let value1 = manifest1.instantiate(with: x)

     

       94
       94
       +
       					let value2 = manifest2.instantiate(with: x)

     

       95
       95
       +
       					try await next.equate(value: value1, with: value2, in: type1)

     

       96
       96
       +
       				}

     

       97
       97
       +
       

     

       98
       98
       +
       				fieldSpecs.append((key, field1))

     

       99
       99
       +
       			}

     

       100
       100
       +
       

     

       101
       101
       +
       		case (.universeType, .universeType): ()

     

       102
       102
       +
       

     

       103
       103
       +
       		case let (.decode(size: size1, code: neutral1), .decode(size: size2, code: neutral2)):

     

       104
       104
       +
       			guard size1 == size2 else { throw EqualityError.types(lhs: lhs, rhs: rhs) }

     

       105
       105
       +
       			try await equate(neutral: neutral1, with: neutral2)

     

       106
       106
       +
       

     

       107
       107
       +
       		case let (.universeCodes(size: lhs), .universeCodes(size: rhs)):

     

       108
       108
       +
       			try await equate(size: lhs, with: rhs)

     

       109
       109
       +
       

     

       110
       110
       +
       		default:

     

       111
       111
       +
       			throw EqualityError.types(lhs: lhs, rhs: rhs)

     

       112
       112
       +
       		}

     

       113
       113
       +
       	}

     

       114
       114
       +
       

     

       115
       115
       +
       	func equate(head lhs: Value.Head, with rhs: Value.Head) throws {

     

       116
       116
       +
       		guard lhs == rhs else { throw EqualityError.heads(lhs: lhs, rhs: rhs) }

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

       119
       119
       +
       	func equate(frame lhs: Value.RichFrame, with rhs: Value.RichFrame) async throws {

     

       120
       120
       +
       		switch (lhs, rhs) {

     

       121
       121
       +
       		case let (.proj(fieldName: fieldName1), .proj(fieldName: fieldName2)):

     

       122
       122
       +
       			guard fieldName1 == fieldName2 else { throw EqualityError.frames(lhs: lhs, rhs: rhs) }

     

       123
       123
       +
       		case let (.app(dom: dom1, arg: arg1), .app(dom: _, arg: arg2)):

     

       124
       124
       +
       			try await equate(value: arg1, with: arg2, in: dom1.value())

     

       125
       125
       +
       		default:

     

       126
       126
       +
       			throw EqualityError.frames(lhs: lhs, rhs: rhs)

     

       127
       127
       +
       		}

     

       128
       128
       +
       	}

     

       129
       129
       +
       

     

       130
       130
       +
       	func equate(spine lhs: Value.Spine, with rhs: Value.Spine) async throws {

     

       131
       131
       +
       		guard lhs.count == rhs.count else { throw EqualityError.spines(lhs: lhs, rhs: rhs) }

     

       132
       132
       +
       

     

       133
       133
       +
       		for (index, frame1) in lhs.enumerated() {

     

       134
       134
       +
       			let frame2 = rhs[index]

     

       135
       135
       +
       			try await equate(frame: frame1, with: frame2)

     

       136
       136
       +
       		}

     

       137
       137
       +
       	}

     

       138
       138
       +
       

     

       139
       139
       +
       	func equate(neutral lhs: Value.Neutral, with rhs: Value.Neutral) async throws {

     

       140
       140
       +
       		try equate(head: lhs.head, with: rhs.head)

     

       141
       141
       +
       		try await equate(spine: lhs.spine, with: rhs.spine)

     

       142
       142
       +
       	}

     

       143
       143
       +
       	

     

       144
       144
       +
       	func equate(size lhs: Size<Value>, with rhs: Size<Value>) async throws {

     

       145
       145
       +
       		try await assertLeq(size1: lhs, size2: rhs)

     

       146
       146
       +
       		try await assertLeq(size1: rhs, size2: lhs)

     

       147
       147
       +
       	}

     

       148
       148
       +
       }

+31

Sources/PterodactylKernel/Local Analysis/LocalAnalysis.swift

···

       1
       1
       +
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       2
       +
       //

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       import Foundation

     

       6
       6
       +
       

     

       7
       7
       +
       struct LocalAnalysis {

     

       8
       8
       +
       	let depth: Int

     

       9
       9
       +
       	

     

       10
       10
       +
       	init(depth: Int = 0) {

     

       11
       11
       +
       		self.depth = depth

     

       12
       12
       +
       	}

     

       13
       13
       +
       	

     

       14
       14
       +
       	var next: Self {

     

       15
       15
       +
       		Self(depth: depth + 1)

     

       16
       16
       +
       	}

     

       17
       17
       +
       	

     

       18
       18
       +
       	func fresh(type: AsyncThunk<Value.Type_>) -> Value {

     

       19
       19
       +
       		let boundary: AsyncThunk<Value.Boundary> = AsyncThunk {

     

       20
       20
       +
       			await Value.Boundary(type: type.value(), value: nil)

     

       21
       21
       +
       		}

     

       22
       22
       +
       

     

       23
       23
       +
       		return Value.shift(

     

       24
       24
       +
       			neutral: Value.Neutral(

     

       25
       25
       +
       				head: .local(level: depth),

     

       26
       26
       +
       				spine: [],

     

       27
       27
       +
       				boundary: boundary

     

       28
       28
       +
       			)

     

       29
       29
       +
       		)

     

       30
       30
       +
       	}

     

       31
       31
       +
       }

+33 -13

Sources/PterodactylKernel/Plug.swift

···

       10
       10
        
       extension Plug {

     

       11
       11
        
       	func plug(spine: Value.Spine) -> Self {

     

       12
       12
        
       		spine.reduce(self) { partialResult, frame in

     

       13
       13
       -
       			partialResult.plug(frame: frame)

     

       13
       13
       +
       			partialResult.plug(frame: frame.forget)

     

       14
       14
        
       		}

     

       15
       15
        
       	}

     

       16
       16
        
       }

     
···

       27
       27
        
       			return impl.value.instantiate(with: self)

     

       28
       28
        
       		case let .shift(neutral: neutral):

     

       29
       29
        
       			return .shift(neutral: neutral.plug(frame: frame))

     

       30
       30
       +
       		default:

     

       31
       31
       +
       			fatalError()

     

       30
       32
        
       		}

     

       31
       33
        
       	}

     

       32
       34
        
       }

     

       33
       35
        
       

     

       34
       36
        
       extension Value.Neutral: Plug {

     

       35
       35
       -
       	// Not async now, but might need to be later.

     

       36
       37
        
       	func plug(boundary: Value.Boundary, frame: Value.Frame) async -> Value.Boundary {

     

       37
       37
       -
       		switch boundary.type {

     

       38
       38
       +
       		switch await boundary.type.whnf() {

     

       39
       39
       +
       

     

       38
       40
        
       		case let .funType(_, _, fam: fam):

     

       39
       41
        
       			guard case let .app(arg: arg) = frame else {

     

       40
       40
       -
       				fatalError("Attempted to plug element of function type into invalid frame")

     

       42
       42
       +
       				fatalError("Attempted to plug boundary of function type into invalid frame")

     

       41
       43
        
       			}

     

       42
       44
        
       			let fibre = fam.instantiate(with: arg)

     

       43
       45
        
       			return Value.Boundary(type: fibre, value: boundary.value?.plug(frame: frame))

     

       44
       44
       -
       			

     

       46
       46
       +
       

     

       45
       47
        
       		case let .recordType(boundName, fields: fields):

     

       46
       48
        
       			guard case let .proj(fieldName) = frame else {

     

       47
       47
       -
       				fatalError("Attempted to plug element of record type into invalid frame")

     

       49
       49
       +
       				fatalError("Attempted to plug boundary of record type into invalid frame")

     

       48
       50
        
       			}

     

       49
       51
        
       			guard let field = fields[fieldName] else {

     

       50
       50
       -
       				fatalError("Attempted to project invalid field from element of record type")

     

       52
       52
       +
       				fatalError("Attempted to project invalid field from boundary of record type")

     

       51
       53
        
       			}

     

       52
       54
        
       			let prefix = fields.prefix(until: fieldName)

     

       53
       55
        
       			let prefixImpls = prefix.mapWithKeys { (key, spec) in

     

       54
       56
        
       				Value.FieldImpl(

     

       55
       57
        
       					type: spec.type,

     

       56
       58
        
       					value: Closure(

     

       57
       57
       -
       						evaluator: Evaluator(globals: [:], locals: [.shift(neutral: self)]),

     

       59
       59
       +
       						evaluator: Evaluator(),

     

       58
       60
        
       						body: .cut(term: .local(index: 0), frame: .proj(fieldName: key))

     

       59
       61
        
       					)

     

       60
       62
        
       				)

     

       61
       63
        
       			}

     

       62
       64
        
       			let prefixRecord: Value = .record(boundName: boundName, fields: prefixImpls)

     

       63
       65
        
       			let fieldTypeValue = field.type.instantiate(with: prefixRecord)

     

       64
       64
       -
       			let value = boundary.value?.plug(frame: frame) ?? field.manifest.map { manifest in

     

       65
       65
       -
       				return manifest.instantiate(with: .shift(neutral: self))

     

       66
       66
       -
       			}

     

       66
       66
       +
       			let value =

     

       67
       67
       +
       				boundary.value?.plug(frame: frame)

     

       68
       68
       +
       				?? field.manifest.map { $0.instantiate(with: .shift(neutral: self)) }

     

       67
       69
        
       			return Value.Boundary(type: fieldTypeValue, value: value)

     

       70
       70
       +
       

     

       71
       71
       +
       		default:

     

       72
       72
       +
       			fatalError("Boundary has unexpected type for plugging")

     

       73
       73
       +
       		}

     

       74
       74
       +
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	func enrich(frame: Value.Frame) -> Value.RichFrame {

     

       77
       77
       +
       		switch frame {

     

       78
       78
       +
       		case let .app(arg: arg):

     

       79
       79
       +
       			let dom: AsyncThunk<Value.Type_> = AsyncThunk {

     

       80
       80
       +
       				guard case let .funType(dom: dom, _, _) = await boundary.value().type.whnf() else { fatalError() }

     

       81
       81
       +
       				return dom

     

       82
       82
       +
       			}

     

       83
       83
       +
       			return .app(dom: dom, arg: arg)

     

       84
       84
       +
       

     

       85
       85
       +
       		case let .proj(fieldName: fieldName):

     

       86
       86
       +
       			return .proj(fieldName: fieldName)

     

       68
       87
        
       		}

     

       69
       88
        
       	}

     

       70
       89
        
       

     

       71
       90
        
       	func plug(frame: Value.Frame) -> Self {

     

       72
       72
       -
       		Self(

     

       91
       91
       +
       		let richFrame = enrich(frame: frame)

     

       92
       92
       +
       		return Self(

     

       73
       93
        
       			head: head,

     

       74
       74
       -
       			spine: CollectionOfOne(frame) + spine,

     

       94
       94
       +
       			spine: spine + CollectionOfOne(richFrame),

     

       75
       95
        
       			boundary: AsyncThunk { await plug(boundary: boundary.value(), frame: frame) }

     

       76
       96
        
       		)

     

       77
       97
        
       	}

+27 -23

Sources/PterodactylKernel/Quotation.swift Sources/PterodactylKernel/Local Analysis/Quotation.swift

···

       4
       4
        
       

     

       5
       5
        
       import Foundation

     

       6
       6
        
       

     

       7
       7
       -
       struct Quotation {

     

       8
       8
       -
       	let depth: Int

     

       9
       9
       -
       	var next: Self {

     

       10
       10
       -
       		Quotation(depth: depth + 1)

     

       11
       11
       -
       	}

     

       12
       12
       -
       

     

       7
       7
       +
       extension LocalAnalysis {

     

       13
       8
        
       	func quote(type: Value.Type_) -> Term.Type_ {

     

       14
       9
        
       		switch type {

     

       10
       10
       +
       		case .universeType: return .universeType

     

       11
       11
       +
       

     

       12
       12
       +
       		case let .universeCodes(size: size):

     

       13
       13
       +
       			return .universeCodes(size: size.map(quote(value:)))

     

       14
       14
       +
       			

     

       15
       15
       +
       		case let .decode(size: size, code: code):

     

       16
       16
       +
       			return .decode(size: size, code: quote(neutral: code))

     

       17
       17
       +
       

     

       15
       18
        
       		case let .funType(dom: dom, boundName: boundName, fam: fam):

     

       16
       19
        
       			return .funType(

     

       17
       20
        
       				dom: quote(type: dom),

     
···

       56
       59
        
       		case let .shift(neutral: neutral):

     

       57
       60
        
       			return quote(neutral: neutral)

     

       58
       61
        
       

     

       62
       62
       +
       		case let .shrink(size: size, type: type):

     

       63
       63
       +
       			return .shrink(size: size.map(quote(value:)), type: quote(type: type))

     

       64
       64
       +
       

     

       65
       65
       +
       		case .universeZero:

     

       66
       66
       +
       			return .universeZero

     

       67
       67
       +
       			

     

       68
       68
       +
       		case let .universeSucc(universe: universe):

     

       69
       69
       +
       			return .universeSucc(quote(value: universe))

     

       70
       70
       +
       

     

       71
       71
       +
       		case let .universeLub(universe1, universe2):

     

       72
       72
       +
       			return .universeLub(

     

       73
       73
       +
       				quote(value: universe1),

     

       74
       74
       +
       				quote(value: universe2)

     

       75
       75
       +
       			)

     

       76
       76
       +
       

     

       59
       77
        
       		case let .fun(dom: dom, boundName: boundName, closure: closure):

     

       60
       78
        
       			return .fun(

     

       61
       79
        
       				dom: AsyncThunk { await quote(type: dom.value()) },

     
···

       82
       100
        
       		}

     

       83
       101
        
       	}

     

       84
       102
        
       

     

       85
       85
       -
       	func fresh(type: AsyncThunk<Value.Type_>) -> Value {

     

       86
       86
       -
       		let boundary: AsyncThunk<Value.Boundary> = AsyncThunk {

     

       87
       87
       -
       			await Value.Boundary(type: type.value(), value: nil)

     

       88
       88
       -
       		}

     

       89
       89
       -
       

     

       90
       90
       -
       		return Value.shift(

     

       91
       91
       -
       			neutral: Value.Neutral(

     

       92
       92
       -
       				head: .local(level: depth),

     

       93
       93
       -
       				spine: [],

     

       94
       94
       -
       				boundary: boundary

     

       95
       95
       -
       			)

     

       96
       96
       -
       		)

     

       97
       97
       -
       	}

     

       98
       98
       -
       

     

       99
       103
        
       	func quote(dom: AsyncThunk<Value.Type_>, closure: Closure<Term>) -> Term {

     

       100
       104
        
       		let x = fresh(type: dom)

     

       101
       105
        
       		let value = closure.instantiate(with: x)

     
···

       115
       119
        
       		}

     

       116
       120
        
       	}

     

       117
       121
        
       

     

       118
       118
       -
       	private func quote(frame: Value.Frame) -> Term.Frame {

     

       122
       122
       +
       	private func quote(frame: Value.RichFrame) -> Term.Frame {

     

       119
       123
        
       		switch frame {

     

       120
       120
       -
       		case let .app(arg: arg):

     

       124
       124
       +
       		case let .app(_, arg: arg):

     

       121
       125
        
       			return .app(arg: quote(value: arg))

     

       122
       126
        
       		case let .proj(fieldName: fieldName):

     

       123
       127
        
       			return .proj(fieldName: fieldName)

     

       124
       128
        
       		}

     

       125
       129
        
       	}

     

       126
       130
        
       

     

       127
       127
       -
       	private func quote(neutral: Value.Neutral) -> Term {

     

       131
       131
       +
       	public func quote(neutral: Value.Neutral) -> Term {

     

       128
       132
        
       		let headTerm = quote(head: neutral.head)

     

       129
       133
        
       		return neutral.spine.reduce(headTerm) { term, frame in

     

       130
       134
        
       			.cut(term: term, frame: quote(frame: frame))

+81

Sources/PterodactylKernel/Smallness.swift

···

       1
       1
       +
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       2
       +
       //

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       import Foundation

     

       6
       6
       +
       

     

       7
       7
       +
       extension LocalAnalysis {

     

       8
       8
       +
       	struct SizeError: Error { }

     

       9
       9
       +
       

     

       10
       10
       +
       	func assertSize(type: Value.Type_, size: Size<Value>) async throws {

     

       11
       11
       +
       		switch await type.whnf() {

     

       12
       12
       +
       

     

       13
       13
       +
       		// In principle the type of universes could be small, but I am worried about about the strictness of the semilattice operations. I know how to interpret them if universeType is exoNat as in 2LTT, but in that case universeType probably should not be fibrant.

     

       14
       14
       +
       		case .universeType, .universeCodes(size: .moderate):

     

       15
       15
       +
       			throw SizeError()

     

       16
       16
       +
       

     

       17
       17
       +
       		case let .universeCodes(size: .little(universe: littleUniverse)):

     

       18
       18
       +
       			try await assertLeq(size1: .little(universe: .universeSucc(littleUniverse)), size2: size)

     

       19
       19
       +
       

     

       20
       20
       +
       		case let .decode(size: _, code: code):

     

       21
       21
       +
       			guard case let .universeCodes(size: littleSize) = await code.boundary.value().type.whnf() else { fatalError() }

     

       22
       22
       +
       			try await assertLeq(size1: littleSize, size2: size)

     

       23
       23
       +
       			

     

       24
       24
       +
       		case let .funType(dom: dom, boundName: _, fam: fam):

     

       25
       25
       +
       			try await assertSize(type: dom, size: size)

     

       26
       26
       +
       			let domThunk = AsyncThunk(value: dom)

     

       27
       27
       +
       			let x = fresh(type: domThunk)

     

       28
       28
       +
       			let fibre = fam.instantiate(with: x)

     

       29
       29
       +
       			try await next.assertSize(type: fibre, size: size)

     

       30
       30
       +
       

     

       31
       31
       +
       		case let .recordType(boundName: boundName, fields: fields):

     

       32
       32
       +
       			var fieldSpecs: [(String, Value.FieldSpec)] = []

     

       33
       33
       +
       			for (key, fieldSpec) in fields.elements {

     

       34
       34
       +
       				if fieldSpec.manifest == nil {

     

       35
       35
       +
       					let prefixType: AsyncThunk<Value.Type_> = AsyncThunk(value: .recordType(boundName: boundName, fields: FieldDict(fieldSpecs)))

     

       36
       36
       +
       					let prefixRecord = fresh(type: prefixType)

     

       37
       37
       +
       					try await next.assertSize(type: fieldSpec.type.instantiate(with: prefixRecord), size: size)

     

       38
       38
       +
       				}

     

       39
       39
       +
       

     

       40
       40
       +
       				fieldSpecs.append((key, fieldSpec))

     

       41
       41
       +
       			}

     

       42
       42
       +
       		}

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	func assertSmall(type: Value.Type_, universe: Value) async throws {

     

       46
       46
       +
       		try await assertSize(type: type, size: .little(universe: universe))

     

       47
       47
       +
       	}

     

       48
       48
       +
       

     

       49
       49
       +
       	func assertLeq(size1: Size<Value>, size2: Size<Value>) async throws {

     

       50
       50
       +
       		switch (size1, size2) {

     

       51
       51
       +
       		case (_, .moderate): ()

     

       52
       52
       +
       		case let (.little(universe: universe1), .little(universe: universe2)):

     

       53
       53
       +
       			try await assertLeq(universe1: universe1, universe2: universe2)

     

       54
       54
       +
       		default:

     

       55
       55
       +
       			throw SizeError()

     

       56
       56
       +
       		}

     

       57
       57
       +
       	}

     

       58
       58
       +
       	

     

       59
       59
       +
       	func assertLeq(universe1: Value, universe2: Value) async throws {

     

       60
       60
       +
       		switch await (universe1.whnf(), universe2.whnf()) {

     

       61
       61
       +
       		case (.universeZero, _): ()

     

       62
       62
       +
       		case let (.universeLub(universe11, universe12), _):

     

       63
       63
       +
       			try await assertLeq(universe1: universe11, universe2: universe2)

     

       64
       64
       +
       			try await assertLeq(universe1: universe12, universe2: universe2)

     

       65
       65
       +
       		case let (.universeSucc(universe: universe1), .universeSucc(universe: universe2)):

     

       66
       66
       +
       			try await assertLeq(universe1: universe1, universe2: universe2)

     

       67
       67
       +
       		case let (_, .universeLub(universe21, universe22)):

     

       68
       68
       +
       			do {

     

       69
       69
       +
       				try await assertLeq(universe1: universe1, universe2: universe21)

     

       70
       70
       +
       			} catch {

     

       71
       71
       +
       				try await assertLeq(universe1: universe1, universe2: universe22)

     

       72
       72
       +
       			}

     

       73
       73
       +
       		case let (_, .universeSucc(universe: universe2)):

     

       74
       74
       +
       			try await assertLeq(universe1: universe1, universe2: universe2)

     

       75
       75
       +
       		case let (.shift(neutral: neutral1), .shift(neutral: neutral2)):

     

       76
       76
       +
       			try await equate(neutral: neutral1, with: neutral2)

     

       77
       77
       +
       		default:

     

       78
       78
       +
       			throw SizeError()

     

       79
       79
       +
       		}

     

       80
       80
       +
       	}

     

       81
       81
       +
       }

+13 -1

Sources/PterodactylKernel/Whnf.swift

···

       5
       5
        
       extension Value {

     

       6
       6
        
       	func whnf() async -> Value {

     

       7
       7
        
       		switch self {

     

       8
       8
       -
       		case .fun, .record : self

     

       8
       8
       +
       		case .fun, .record, .shrink, .universeZero, .universeSucc, .universeLub: self

     

       9
       9
        
       		case let .shift(neutral: neutral): await neutral.boundary.value().value ?? self

     

       10
       10
        
       		}

     

       11
       11
        
       	}

     

       12
       12
        
       }

     

       13
       13
       +
       

     

       14
       14
       +
       extension Value.Type_ {

     

       15
       15
       +
       	func whnf() async -> Self {

     

       16
       16
       +
       		switch self {

     

       17
       17
       +
       		case .funType, .recordType, .universeCodes, .universeType: return self

     

       18
       18
       +
       		case let .decode(size: size, code: neutral):

     

       19
       19
       +
       			guard let code = await neutral.boundary.value().value else { return self }

     

       20
       20
       +
       			return code.decode(size: size)

     

       21
       21
       +
       		}

     

       22
       22
       +
       	}

     

       23
       23
       +
       }

     

       24
       24
       +

-11

Tests/PterodactylKernelTests/PterodactylKernelTests.swift

···

       1
       1
       -
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       2
       -
       //

     

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

     

       4
       4
       -
       

     

       5
       5
       -
       import Testing

     

       6
       6
       -
       

     

       7
       7
       -
       @testable import PterodactylKernel

     

       8
       8
       -
       

     

       9
       9
       -
       @Test func example() async throws {

     

       10
       10
       -
       	// Write your test here and use APIs like `#expect(...)` to check expected conditions.

     

       11
       11
       -
       }

+26

Tests/PterodactylKernelTests/Quotation.swift

···

       1
       1
       +
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       2
       +
       //

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       import Testing

     

       6
       6
       +
       

     

       7
       7
       +
       @testable import PterodactylKernel

     

       8
       8
       +
       

     

       9
       9
       +
       struct QuotationTests {

     

       10
       10
       +
       	@Test func quotingNeutrals() async throws {

     

       11
       11
       +
       		let analysis = LocalAnalysis()

     

       12
       12
       +
       		let recordType1 = Term.Type_.recordType(boundName: nil, fields: FieldDict([("foo", Term.FieldSpec(type: .universeType, manifest: nil))]))

     

       13
       13
       +
       		let recordType2 = Term.Type_.recordType(boundName: nil, fields: FieldDict([("bar", Term.FieldSpec(type: recordType1, manifest: nil))]))

     

       14
       14
       +
       		let recordTypeValue = Evaluator().evaluate(type: recordType2)

     

       15
       15
       +
       		let base = Value.Neutral(head: .global(name: "X"), spine: [], boundary: AsyncThunk { Value.Boundary(type: recordTypeValue, value: nil) })

     

       16
       16
       +
       		let bar = base.plug(frame: .proj(fieldName: "bar"))

     

       17
       17
       +
       		let foo = bar.plug(frame: .proj(fieldName: "foo"))

     

       18
       18
       +
       		let term = analysis.quote(neutral: foo)

     

       19
       19
       +
       		let result =

     

       20
       20
       +
       		switch term {

     

       21
       21
       +
       		case .cut(term: .cut(term: .global(name: "X"), frame: .proj(fieldName: "bar")), frame: .proj(fieldName: "foo")): true

     

       22
       22
       +
       		default: false

     

       23
       23
       +
       		}

     

       24
       24
       +
       		#expect(result, "Neutral incorrectly quoted as: \(term)")

     

       25
       25
       +
       	}

     

       26
       26
       +
       }

+61

Tests/PterodactylKernelTests/Size.swift

···

       1
       1
       +
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       2
       +
       //

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       import Testing

     

       6
       6
       +
       @testable import PterodactylKernel

     

       7
       7
       +
       

     

       8
       8
       +
       struct SizeTests {

     

       9
       9
       +
       	@Test func leqIsReflexive() async throws {

     

       10
       10
       +
       		let analysis = LocalAnalysis()

     

       11
       11
       +
       		

     

       12
       12
       +
       		await #expect(throws: Never.self) {

     

       13
       13
       +
       			try await analysis.assertLeq(size1: .moderate, size2: .moderate)

     

       14
       14
       +
       		}

     

       15
       15
       +
       	}

     

       16
       16
       +
       	

     

       17
       17
       +
       	@Test func moderateIsNotSmall() async throws {

     

       18
       18
       +
       		let analysis = LocalAnalysis()

     

       19
       19
       +
       		

     

       20
       20
       +
       		await #expect(throws: LocalAnalysis.SizeError.self) {

     

       21
       21
       +
       			try await analysis.assertLeq(size1: .moderate, size2: .little(universe: .universeZero))

     

       22
       22
       +
       		}

     

       23
       23
       +
       	}

     

       24
       24
       +
       	

     

       25
       25
       +
       	@Test func lubIsCommutative() async throws {

     

       26
       26
       +
       		let analysis = LocalAnalysis()

     

       27
       27
       +
       		await #expect(throws: Never.self) {

     

       28
       28
       +
       			let lhs = Value.universeLub(.universeZero, .universeSucc(.universeZero))

     

       29
       29
       +
       			let rhs = Value.universeLub(.universeSucc(.universeZero), .universeZero)

     

       30
       30
       +
       			try await analysis.equate(size: .little(universe: lhs), with: .little(universe: rhs))

     

       31
       31
       +
       		}

     

       32
       32
       +
       	}

     

       33
       33
       +
       	

     

       34
       34
       +
       	@Test func lubZeroLeftUnit() async throws {

     

       35
       35
       +
       		let analysis = LocalAnalysis()

     

       36
       36
       +
       		await #expect(throws: Never.self) {

     

       37
       37
       +
       			let lhs = Value.universeLub(.universeZero, .universeSucc(.universeZero))

     

       38
       38
       +
       			let rhs = Value.universeSucc(.universeZero)

     

       39
       39
       +
       			try await analysis.equate(size: .little(universe: lhs), with: .little(universe: rhs))

     

       40
       40
       +
       		}

     

       41
       41
       +
       	}

     

       42
       42
       +
       	

     

       43
       43
       +
       	@Test func lubZeroRightUnit() async throws {

     

       44
       44
       +
       		let analysis = LocalAnalysis()

     

       45
       45
       +
       		await #expect(throws: Never.self) {

     

       46
       46
       +
       			let lhs = Value.universeLub(.universeSucc(.universeZero), .universeZero)

     

       47
       47
       +
       			let rhs = Value.universeSucc(.universeZero)

     

       48
       48
       +
       			try await analysis.equate(size: .little(universe: lhs), with: .little(universe: rhs))

     

       49
       49
       +
       		}

     

       50
       50
       +
       	}

     

       51
       51
       +
       	

     

       52
       52
       +
       	@Test func succDistributesOverLub() async throws {

     

       53
       53
       +
       		let analysis = LocalAnalysis()

     

       54
       54
       +
       		await #expect(throws: Never.self) {

     

       55
       55
       +
       			let lhs = Value.universeSucc(Value.universeLub(.universeZero, .universeSucc(.universeZero)))

     

       56
       56
       +
       			let rhs = Value.universeLub(.universeSucc(.universeSucc(.universeZero)), .universeSucc(.universeZero))

     

       57
       57
       +
       			try await analysis.equate(size: .little(universe: lhs), with: .little(universe: rhs))

     

       58
       58
       +
       		}

     

       59
       59
       +
       	}

     

       60
       60
       +
       	

     

       61
       61
       +
       }