Nikaia
Menu
v0.0.1343pre-alpha GitHub

Archived decision records

These records were replaced by a later record that states the same decisions in their current form. They are kept for one purpose: to show how a decision was reached - the options weighed then, the measurements of the day, the route. Nothing here is normative and nothing outside docs/history/ cites a record here (scripts/check-adr-refs.py refuses it). For the decision itself, read the record in the right-hand column.

ADR Title Now Its decisions there
006 Cleanup That Can Pause — the Cleanup Trait ADR-297 D1→D1, D2→D3, D3→D5, D4→D4, D5→D6, D6→D10
007 The Scannerless Grammar Protocol, and Two Ways to Bind a Hole ADR-296 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D6, D7→D7, D8→D8
008 Tethered Slices in User Structs — the Tether-State Lattice ADR-283 D1→D1, D2→D2, D3→D2, D4→D11, D5→D3, D6→D4, D7→D5, D8→D6, D9→D7
009 Parallel Parsing — Frames, Monoid Folds, and Format Assumptions ADR-296 D1→D9, D2→D10, D3→D11, D4→D12, D5→D13, D6→D14, D7→D15
011 Stage 0 Lowering — the Grammar Protocol onto the Parser Backend ADR-296 D1→D16, D2→D17, D3→D18, D4→D19, D5→D20, D6→D21, D7→D22, D8→D23
012 Diagnostics — Reporting Errors in the File the User Wrote ADR-300 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D6, D7→D7, D8→D8
018 The Handler Sees the Request, Because the Lambda Already Could ADR-289 D1→D17, D2→D18, D3→D19, D4→D20, D5→D21
022 One Lambda Form. fn: Is Removed ADR-277 D1→D1, D2→D3, D3→D4, D4→D5
026 Compile-Time I/O — What a Build May Read, and What May Run While It Reads ADR-310 D1→D1, D2→D2
027 sync Is Earned, Not Entered ADR-288 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D6
028 The Type Checker Already Knew ADR-288 D1→D7, D2→D8, D3→D9, D4→D10, D5→D11, D6→D12
029 A Higher-Order Function Does What Its Lambda Does ADR-288 D1→D13, D2→D14, D3→D15, D4→D16
030 A Program Is More Than One File, and That Is Name Resolution ADR-286 D1→D1, D2→D1, D3→D2, D4→D3, D5→D7, D6→D8, D7→D9
031 A Signature May Name Its Receiver’s Type Arguments ADR-288 D1→D17, D2→D18, D3→D19, D4→D20
032 A Hole Is Code, and Every Analysis Has to See It ADR-309 D1→D11, D2→D12, D3→D13, D4→D14, D5→D2
033 Program Order Is a Guarantee Where It Is Observable ADR-292 D1→D1, D2→D3, D3→D3, D4→D3, D5→D1, D6→D5, D7→D7, D8→D7, D9→D2, D10→D6
034 A Handler That Can Return Makes the Next Statement Conditional ADR-292 D1→D1, D2→D1
035 The f Goes on the String, Because the Mark Belongs on the Construct ADR-309 D1→D1, D2→D4, D3→D2, D4→D3, D5→D15
036 A Stack Trace Is Asked For, and the Site Is Free ADR-280 D1→D1, D2→D2, D3→D3, D4→D4
038 The Runtime Is Ours, and So Is the HTTP Server ADR-303 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D6, D7→D7
039 The Lock Has One Shared Form and Four Doors, and Taking a Lock Inside a Lock Is Refused ADR-281 D1→D4, D2→D28, D3→D29, D4→D30, D5→D31, D6→D32, D7→D33, D8→D36, D9→D3, D10→D10
040 A Handle on a Shared Value Is Duplicated, Never Moved ADR-312 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5
041 Naming a Lambda’s Arguments Is the Normal Form; the Automatic Names Are Experimental ADR-277 D1→D2, D2→D2
043 An Overflow Aborts, at Every Build. Wrapping and Saturating Get Names ADR-285 D1→D5, D2→D6, D3→D7, D4→D12, D5→D29, D6→D8, D7→D13
044 One Location Table, and Every Abort Points at the Nikaia Line ADR-300 D1→D9, D2→D10, D3→D11
045 The Crossing Verdict Takes the Destination ADR-312 D1→D6, D2→D7, D3→D8
046 use Names a Unit of Code and Brings Nothing In ADR-286 D1→D10, D2→D11, D3→D12, D4→D13, D5→D14
047 A Package Is a Directory, and a Library Arrives by Path ADR-286 D1→D1, D2→D15
048 A Length Is an i64, and the Numeric Surface Is the One the Page Names ADR-285 D1→D1, D2→D2
049 The Automatic a, b, c Are Withdrawn ADR-277 D1→D2
050 Statement Order Is the Written Order, and overlap { … } Is How a Program Asks for Less ADR-292 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D6, D7→D7
051 This Language’s Keywords Are Reserved Words ADR-298 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5
052 T? Is a Type, null Is a Word, and the Some(…) Is the Compiler’s to Write ADR-278 D1→D1, D2→D2, D3→D3, D4→D5, D5→D4, D6→D9, D7→D13, D8→D16
053 One Rust Crate per Nikaia Package ADR-286 D1→D19, D2→D20, D3→D21, D4→D22
054 as Names a Type This Language Offers, and a Count Goes In as an i64 ADR-285 D1→D14, D2→D15
057 Locked[T] Is Decided Per Value, Not Per Build Setting ADR-281 D1→D5, D2→D6, D3→D7, D4→D9
058 A Response May Be Bytes the Program Never Read, and std Decides How They Travel ADR-289 D1→D22, D2→D23, D3→D24, D4→D25, D5→D26, D6→D27, D7→D28, D8→D29, D9→D30
059 access Reads and update Writes, and the One Block That Changes a Value Says mut ADR-281 D1→D11, D2→D12, D3→D12
060 A Literal No Use Constrains Takes the First Type That Holds It ADR-285 D1→D20, D2→D21, D3→D23
061 A Shared Does Not Go Into Code Nothing Describes, So at One User Thread Its Count Is Plain ADR-312 D1→D9, D2→D10, D3→D11
062 A Target That Lets Foreign Code Call In Is a Target, and the Boundary Is Where the Safe Shape Is Paid For ADR-284 D1→D1, D2→D2, D3→D3
063 A Constant Written Only in Literals Takes the First Type That Holds It, and a Name Pins What Its Value Took ADR-285 D1→D22, D2→D26, D3→D28
064 SharedMut[T] Names the Capability, a Call Makes the Hull, and There Is One Spelling ADR-281 D1→D1, D2→D2, D3→D3
065 A Door Over Several Locks Is a Call the Compiler Types, and update_all Hands Back One Value Per Lock ADR-281 D1→D17, D2→D18, D3→D19
066 ?. Reaches a Member, and a Method Is One ADR-278 D1→D10, D2→D11, D3→D12, D4→D15, D5→D13, D6→D14
067 sync Means One Thing — Never Pauses — and touches Gets the Inference It Was Written For ADR-288 D1→D21, D2→D22, D3→D23
068 A Value Whose Type Is Not Known Is Converted Into the Nullable Slot, Not Left Alone ADR-278 D1→D7, D2→D6, D3→D8
069 http Leaves std and Becomes a Package, So It Can Ripen at Its Own Speed ADR-289 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5
070 There Is No Unconditional Loop Keyword — while true Is the Unconditional Loop ADR-276 D1→D1, D2→D2, D3→D6, D4→D9
071 break, continue and loop Are Reserved Words, and None of Them Is a Construct ADR-276 D1→D9, D2→D11, D3→D9, D4→D10
072 A File a Build Reads Is Named Three Times, and a Build Given No List Reads Nothing ADR-310 D1→D4, D2→D5, D3→D6, D4→D7, D5→D8, D6→D9, D7→D10, D8→D11
073 const Is a Declaration That Must Be Evaluated at Build Time — a let That Merely Folds Is Not One ADR-287 D1→D1, D2→D3, D3→D4, D4→D5, D5→D6, D6→D7
074 A Type Parameter Is a Type Inside Its Own Body and a Variable at Every Call Site ADR-295 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5
075 A Build-Time Body May Call What Is sync and Touches at Most the Build’s Parameters ADR-287 D1→D13, D2→D14, D3→D15, D4→D16, D5→D17, D6→D18
076 A Name the Language Below Reserves Is Escaped Where It Is Written, and Refused Only Where It Cannot Be ADR-298 D1→D9, D2→D10, D3→D11, D4→D12
077 The Word Is comptime, Because a Keyword Should Say When and Not Whether It Changes ADR-287 D1→D1, D2→D2, D3→D8
078 A Trait Is Declared, and a Bound Is Answered from the Declaration ADR-295 D1→D6, D2→D7, D3→D8, D4→D9
079 Growable Going In, Fixed Coming Out — and the Lookup Is the Compiler’s, Not an Interface ADR-311 D1→D1, D2→D2, D3→D6, D4→D7, D5→D16
082 A Grammar Is Entered by a Call, and Every pub Rule Is an Entry ADR-296 D1→D24, D2→D25, D3→D26, D4→D27
084 break and continue Are in the Language, Unlabelled and Carrying No Value ADR-276 D1→D11, D2→D12, D3→D13, D4→D16, D5→D17, D6→D18, D7→D1, D8→D19
085 The Unconditional Loop Is Lowered to loop, and the Preamble Gets No allow ADR-276 D1→D3, D2→D3, D3→D4, D4→D5
086 A Head Parses the Same Language as a Body, Minus the Forms a { Begins — So && and || Join It ADR-301 D1→D1, D2→D2, D3→D3, D4→D6, D5→D8
087 A Head Holds Every Expression; Only a Brace-Led One Needs Parentheses ADR-301 D1→D4, D2→D5, D3→D6, D4→D7, D5→D8
088 Reflection Is Data, Not a Syntax Tree — and macro, quote and with Are Reserved Words That Are Not Constructs ADR-304 D1→D1, D2→D2, D3→D3, D4→D5, D5→D7, D6→D9
089 A ??’s Fallback Is One Value, or an Expression in Brackets ADR-279 D1→D1, D2→D2
090 A catch That Ignores the Error Binds _error ADR-308 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5
091 A catch Over an Expression That Cannot Fail Is Refused ADR-308 D1→D6, D2→D7, D3→D8, D4→D9, D5→D10
092 A Grammar Fold’s init, step and merge Are Code ADR-296 D1→D28, D2→D29, D3→D30, D4→D31
093 A Loop That Cannot End Needs No Unreachable return ADR-276 D1→D6, D2→D7, D3→D8
095 A Trait Reached Across a Package Is Imported by the Emitter ADR-286 D1→D28, D2→D29, D3→D30
097 A comptime Binding Where an Item Stands ADR-287 D1→D9, D2→D10, D3→D11, D4→D12
098 A let Takes One Name, or a Flat Tuple of Them ADR-291 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5
099 The Two Refusals That Come With the Lock’s Doors ADR-281 D1→D20, D2→D21, D3→D25
101 An Error That Newly Reaches a catch Is Named Once, and the Ledger Commit Is the Acknowledgement ADR-308 D1→D11, D2→D12, D3→D13, D4→D14
102 A Function Type Says What a Handler May Do, and Whether It Is Kept Is Inferred ADR-277 D1→D6, D2→D7, D3→D8, D4→D9, D5→D11
103 A Package Is Found by Version Through Cargo, Under the Crate Name nikaia_<name> ADR-286 D1→D23, D2→D24, D3→D25, D4→D26, D5→D27
104 A Foreign Crate Is Described Before It Is Called, and nikaia describe Writes the Draft ADR-290 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5
106 A Bound Takes a Path, and the Ledger Records a Trait and Each impl Where They Were Written ADR-295 D1→D10, D2→D11, D3→D12, D4→D13, D5→D14
107 Text Is One Type, String, Whose State the Compiler Picks — and &str Is the Assertion That It Is a View ADR-282 D1→D1, D2→D2, D3→D7, D4→D26, D5→D27
109 A Trait Method May Pause Unless It Says sync — and the Language Below Is Rust 1.75 or Newer ADR-288 D1→D24, D2→D25, D3→D26, D4→D27
110 An update Block Says mut and Nothing Else, May Run More Than Once, and the Compiler Picks the Lock ADR-281 D1→D12, D2→D13, D3→D14, D4→D15, D5→D16, D6→D18
111 What Leaves a Lock Is Stamped Seen[T], and Nothing Stamped Goes Back In Blind ADR-281 D1→D22, D2→D23, D3→D24, D4→D25, D5→D26, D6→D27
112 A Cleanup That Did Not Finish Is a Failure of the Program — Exit 70, Said on the Panic Path ADR-297 D1→D7, D2→D8, D3→D9
113 ?. Reaches Through a View, and the Receiver Stays Usable ADR-278 D1→D16, D2→D17, D3→D18, D4→D23
114 Reading a Map Through the Brackets Is a T?, Because a Key Is Data ADR-293 D1→D1, D2→D2, D3→D3, D4→D4
115 An overlap Keeps Every Failure — the First in Written Order Wins, the Rest Are Attached as secondary ADR-292 D1→D8, D2→D9, D3→D10, D4→D11
116 from Is a Name, and a File a Build Reads Is asset("…") ADR-310 D1→D12, D2→D3, D3→D13
117 loop, const, macro and quote Are Names, and Their Messages Move to the Undeclared-Name Help ADR-298 D1→D6, D2→D7, D3→D8
120 A Grammar’s Vocabulary Is One Page, an Action Is the Block After the Pattern, and Two Borrowed Names Go ADR-296 D1→D32, D2→D33, D3→D34
122 A Function-Typed Parameter Lowers by Its Type — the Future Shape Unless It Says sync ADR-277 D1→D11, D2→D10, D3→D12
124 extern and unsafe Are Reserved, Because They Cost Nothing Now and a Boundary Has to Be Visible ADR-302 D1→D1, D2→D2, D3→D3, D4→D4
125 A Library for Other Languages — pub extern "C" fn Is an Entry Point, the Caller Owns the Memory, and Every Call Answers With a Status ADR-284 D1→D4, D2→D5, D3→D6, D4→D7, D5→D8, D6→D9, D7→D10, D8→D11, D9→D12, D10→D13
126 _ Is the Ignore Pattern — It Stands Where a Name Would Be Bound, and Nowhere Else ADR-291 D1→D6, D2→D7, D3→D8, D4→D9
127 A Struct Crosses the Boundary by Value When It Says extern "C", and Its Layout Is C’s ADR-284 D1→D14, D2→D15, D3→D16, D4→D17, D5→D18
128 A Symbol Is Named by the Compiler — the Prefix Is the Package’s, or One Line in [build], and No Declaration Renames Itself ADR-284 D1→D13, D2→D13
129 An Async Call Hands Back a Ticket That Can Be Cancelled, and a Stream Is the Callback the Function Already Takes ADR-284 D1→D19, D2→D20, D3→D21
130 A WebAssembly Library Is the Same Entry Point on Another Target — There Is No extern "wasm", and the Host Takes Its Buffers From the Module ADR-284 D1→D22, D2→D23, D3→D24, D4→D25
131 A Binding for Another Language Is a Generated File Over the C Library, Written by nikaia bind, and Never a Second Artifact ADR-284 D1→D26, D2→D27, D3→D28, D4→D29
134 /* … */ Is a Comment, It Nests, and It Is Not a Doc Comment ADR-307 D1→D1, D2→D2, D3→D3
136 A Number Literal May Be Written 1_000_000, 0xFF, 0b1010 or 0o17, and the Digits It Was Written In Are a Spelling ADR-285 D1→D16, D2→D17, D3→D18
137 match Takes Six More Pattern Shapes, a Guard Is if, and .. in a Pattern Is Inclusive — So ..< Is the Exclusive Range Everywhere ADR-291 D1→D10, D2→D11, D3→D12, D4→D13, D5→D14, D6→D15
138 throw, return, break and continue Are Expressions of the Never Type ADR-276 D1→D20, D2→D21, D3→D22
139 A Doc Comment Is a Language Feature, and the Ledger Carries It ADR-307 D1→D4, D2→D5, D3→D6, D4→D7
142 A Grammar’s Action May Not Pause ADR-296 D1→D35, D2→D36, D3→D37
143 The Database Driver Checks the SQL at Build Time Against the Schema — std::db Is the Protocol, the Dialect Is a Package, and the Compiler Adds One Intrinsic ADR-299 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D6
144 A Name Denotes One Thing, and the Second Declaration Is Refused ADR-286 D1→D4, D2→D5, D3→D6
145 A match’s Catch-All Arm Is else, Not _ ADR-291 D1→D16, D2→D17, D3→D18
146 A match Covers Every Case, and the Refusal Is This Compiler’s ADR-291 D1→D19, D2→D20, D3→D21
147 The C Boundary Has a View and an Opaque Handle, and No Raw Pointer ADR-302 D1→D5, D2→D6, D3→D7, D4→D8, D5→D9
148 select { … } Keeps the First Branch to Finish, and a Task Handle Has cancel() ADR-292 D1→D12, D2→D13, D3→D14, D4→D15
151 break Carries No Value, and the Refusal Names the Two Shapes That Do ADR-276 D1→D13, D2→D14, D3→D15
153 A Native Node Add-On Waits for a Program, and Is Generated C Over the C Library ADR-284 D1→D28, D2→D28, D3→D28
154 The Prelude Is a Written List, Small and Closed ADR-313 D1→D1, D2→D2, D3→D3, D4→D7, D5→D8
155 A Handle May Be Absent, and T? Is How It Says So ADR-302 D1→D10, D2→D11, D3→D12, D4→D13, D5→D14
156 Bytes Is the Language’s, and the Tether It Needs Is Refused Until It Is Built ADR-283 D1→D19, D2→D20, D3→D21, D4→D9, D5→D13, D6→D22
157 The Failure Channel Is the Error Type, Where the Ledger Names One ADR-280 D1→D9, D2→D10, D3→D11, D4→D12
158 std Names What It Throws, and It Is One Type ADR-280 D1→D5, D2→D6, D3→D7, D4→D8
159 A Library’s Error Type Is a Channel Too, and It Travels Bare ADR-280 D1→D9, D2→D13, D3→D3, D4→D12
160 A Set With Two Error Types In It Is a Generated Sum ADR-280 D1→D15, D2→D16, D3→D17, D4→D18
161 Reading a Map Through the Brackets, Built — and What It Took ADR-293 D1→D2, D2→D5, D3→D6, D4→D7, D5→D8, D6→D9, D7→D10, D8→D11
162 Diagnosis and Safety Are the Language’s — eprint, access_all, update_all ADR-313 D1→D4, D2→D5, D3→D10
163 A Block That Joins on the Executor Pauses, and Its Branches Travel in the Function’s Own Channel ADR-292 D1→D16, D2→D17, D3→D18
164 A Joining Block Has One Outcome, and a Handler on It Binds What the Branches Threw ADR-292 D1→D18, D2→D19, D3→D20
165 There Is No Postfix ?? — the Three Things One Is Reached For Each Have a Spelling ADR-279 D1→D3, D2→D4
167 The Shared Types Are the Language’s, and a Prelude Name Written With a Module Is Refused ADR-313 D1→D6, D2→D9
168 The Re-entrancy Check Is Built as a Build Option, and Part I 1.2’s Status Note Was Wrong About Two of Its Three Clauses ADR-281 D1→D36, D2→D37, D3→D38
169 A Type Says What Reading It Touches, and I/O Under a Lock Is Refused ADR-281 D1→D34, D2→D35
170 An Error Carries the Failures That Joined It, and a Body That Joins Puts an Envelope on a Bare Channel ADR-280 D1→D13, D2→D19, D3→D20
173 What a Parse Fails With Has a Name ADR-296 D1→D38, D2→D39, D3→D40
174 A Bound Is Enforced Where It Is Used ADR-295 D1→D15, D2→D16, D3→D17
175 A Build-Time Value May Be an Array ADR-311 D1→D3, D2→D4, D3→D5
176 A Map the Build Can See Is a List of Pairs, and What It Crosses As Is a Table ADR-311 D1→D8, D2→D9, D3→D10, D4→D11, D5→D12
180 A Fixed Table Holds a Declared Type as a View of One ADR-311 D1→D13, D2→D14, D3→D15
181 T::fields Is a List the Build Walks, and the Loop Over It Is Unrolled Per Type ADR-304 D1→D4, D2→D6, D3→D8, D4→D2, D5→D10
183 A Path’s Head Is One of Five Things, and a Name That Is None of Them Is Refused ADR-286 D1→D31, D2→D32, D3→D33, D4→D34, D5→D35
187 Rust Has A Stable async Closure, And A Premise Under Twelve Sentences Is False ADR-277 D1→D13, D2→D16, D3→D11
189 ?. Lends Its Receiver Where That Needs No Representation, And The Third Case Waits On The Tether ADR-278 D1→D18, D2→D18, D3→D19
190 The Tether Is Needed At An Escape And Nowhere Else — ?. Has No Escape In It ADR-278 D1→D17, D2→D20, D3→D19, D4→D17
191 ?? Joins Two Views, And A ?. Takes One Of A Binding And Not Of A Temporary ADR-278 D1→D19, D2→D20, D3→D21
192 The Body’s Run-Or-Kept Answer Decides A Code Parameter’s Shape ADR-277 D1→D11, D2→D8, D3→D14, D4→D15
193 A Description Says Whether It Threads, And The Describer Proposes The Answer ADR-290 D1→D6, D2→D7, D3→D8, D4→D9, D5→D10
194 Two Servers, Not One — The Standard One Is The Operator’s And An Application’s Is Its Own ADR-289 D1→D6, D2→D12, D3→D13, D4→D14, D5→D13
195 nikaia describe Is a Nikaia Program, Because This Language Has To Be Written In ADR-290 D1→D11, D2→D12, D3→D13, D4→D14, D5→D15
196 A Nikaia Piece Joins a Rust Program as an Ordinary Cargo Module ADR-290 D1→D16, D2→D17, D3→D18, D4→D19
197 A path Is Relative to the File It Is Written In ADR-286 D1→D16, D2→D17, D3→D18
198 std::net — the Socket std Lends, and the First Untrusted Source ADR-289 D1→D7, D2→D8, D3→D9, D4→D10, D5→D11
199 A Readiness Wait Is a Registration, Not a Worker ADR-303 D1→D8, D2→D9, D3→D10, D4→D11, D5→D12
200 nikaia serve Is Cut, And The MVP Is The Application Server Alone ADR-289 D1→D12, D2→D13, D3→D16
201 @borrowed Is Removed, And The Word That Allows A Tether Is @tethers ADR-283 D1→D4, D2→D4, D3→D4
202 A View Of The Subject Is Handed Back Without A ref, And The Ledger Names The Receiver ADR-views-3 D1→D7, D2→D4 and D7, D3→D7
205 A Bound Reaches a Caller Inside the signature, Where the Declaration Writes It ADR-295 D1→D18, D2→D19
206 A Route Is Not Refused by What Its Handler Touches, and No Report Lists It Either ADR-289 D1→D31, D2→D32, D3→D33
207 A Text Literal Is a String Where One Is Wanted — Constructed Where It Is Kept, Handed Over as It Is Where It Is Read ADR-282 D1→D3, D2→D4, D3→D5, D4→D6
208 A View of Text Is Asked for a Copy Only Where Something Keeps It — and the Refusal Says Why ADR-282 D1→D11, D2→D25
209 The Tether Is Built — a Buffer Lives in the Keep of Whatever Keeps Its Views, and the Compiler Decides Which ADR-283 D1→D9, D2→D10, D3→D11, D4→D12, D5→D4, D6→D13
210 The Joined Failures Are a Diagnostic, Not a Value — No Type for a List of Errors ADR-280 D1→D21, D2→D22, D3→D23
211 What an Error Carries Besides Itself Is One Word — the Special Cases Pay for Themselves ADR-280 D1→D24, D2→D25, D3→D26, D4→D27
212 A Sequence Says What It Is as a Whole — a Range Replays, a Pipeline Walks From Its Back End, and Every Taking Is Seen ADR-293 D1→D16, D2→D17, D3→D18, D4→D19, D5→D20
213 A Key Is Not a Position, and What Is Handed Over Is Gone — Maps With Owned Keys, and ADR-094’s Refusal Built ADR-293 D1→D27, D2→D28, D3→D29, D4→D30
214 A Taking Has a Place in Its Statement and a Path in Its Value — and a Read Through the Brackets Warns About Nothing ADR-293 D1→D31, D2→D32, D3→D33
215 What Was Left of ADR-212 §5 — insert, str::chars, a Slice’s Type, a Named Range in the Brackets, and a Copy of a View ADR-293 D1→D21, D2→D22, D3→D23, D4→D24
216 A Copy Has One Word — .clone(), and .to_owned() Is the Language Below’s ADR-282 D1→D8, D2→D9, D3→D10, D4→D3
219 The Oldest Rust Nikaia Works With Is Measured — 1.88 ADR-305 D1→D1, D2→D2, D3→D3
220 Edition 2024 for Our Crates and for the Emitted Code ADR-305 D1→D4, D2→D5, D3→D6, D4→D7
221 A Container of Structs of Views That Drops Entries Is Held, One Handle per Buffer ADR-283 D1→D14, D2→D15, D3→D16, D4→D17, D5→D18
222 A String Field or Result Is Below What Flows Into It — Text of Its Own, a View, or Either per Value ADR-282 D1→D12, D2→D22, D3→D14, D4→D17, D5→D26
223 Every Declared String Is a Position — Parameters, Annotated lets, and the Elements of a List or a Map ADR-282 D1→D12, D2→D14, D3→D15, D4→D23
224 The Rest of the Text Wall — a Hole, a String?, a List Going in Whole, and the Foreign Boundary ADR-282 D1→D12, D2→D5, D3→D16, D4→D27
225 A View Cut From Text Is Typed as One, and a Kept Argument Is Measured Against What the Receiver Says ADR-282 D1→D18, D2→D19, D3→D15
226 A View Handed Back Out of a Parameter That Holds Views Is the Buffer’s ADR-282 D1→D20, D2→D21
227 collect() Builds What the Place It Goes Into Declares ADR-293 D1→D25, D2→D26
228 A ?. View Out of a Temporary Is Held for the Rest of the Block ADR-278 D1→D21, D2→D22
232 A Published Parameter Takes Either Kind of Text From Its Own Package ADR-282 D1→D23, D2→D24
236 A Cleanup Point That Moves With a Contract Is Narrated at the Call ADR-297 D1→D12, D2→D13
237 A Described Call That Fails Is Propagated, and a Boundary the Backend Disagrees With Is Named ADR-290 D1→D20, D2→D21
238 A Word-Sized Value That Crosses Is the Word, and update Is a Compare-and-Swap ADR-281 D1→D8, D2→D18, D3→D16
239 Ownership Says When a Value Dies, and the Compiler Settles Its Cleanup There ADR-297 D1→D1, D2→D2, D3→D4, D4→D3, D5→D5, D6→D11
240 An Error Keeps Its Site When It Hops Into the Box ADR-280 D1→D28, D2→D29, D3→D20
241 A Library’s Error Travels in an Envelope Too ADR-280 D1→D13, D2→D14, D3→D10
242 A match Over a Place Lends What an Arm Only Reads ADR-291 D1→D22, D2→D23, D3→D24
244 What a pub Function Promises About Pausing ADR-288 D1→D28, D2→D29, D3→D30, D4→D31, D5→D32
248 u64 and u32 Join the Integer Types, and Integers Have Bit Operators ADR-285 D1→D3, D2→D19, D3→D9, D4→D10, D5→D11, D6→D4
249 A Number Without an Annotation Is Typed by Its Uses, and This Compiler Decides It ADR-285 D1→D23, D2→D24, D3→D25, D4→D27, D5→D30
250 Stage 1 Is Reached a Module at a Time, Leaves First, and the Share Is Measured ADR-294 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5
252 The Syntax Tree Moves to Nikaia Whole, and a Span Is Two u32 ADR-294 D1→D6, D2→D7, D3→D8, D4→D9, D5→D10, D6→D11
254 A Checked Statement Runs on a Connection It Names as Its Subject, and the Connection’s Type Carries Its Schema ADR-299 D1→D7, D2→D8, D3→D9, D4→D10, D5→D11
255 A Jump May Carry Its Condition After It ADR-276 D1→D23, D2→D24, D3→D25, D4→D26
257 The Checker’s Types Move to Nikaia, and a Measurement Decides Their Shape First ADR-294 D1→D12, D2→D13, D3→D14, D4→D15, D5→D16
259 ?? Lends Its Left Side Where the Answer Is Read, and Takes It Where It Is Kept ADR-279 D1→D5, D2→D6, D3→D7
261 The Toolchain’s Nikaia Is One Package ADR-294 D1→D17, D2→D18, D3→D19, D4→D20
262 The Grammar Parses the Holes of an f"…" ADR-309 D1→D5, D2→D6, D3→D7, D4→D8, D5→D9, D6→D10
264 An assert Is a Contract — Proved Where the Compiler Can, Checked Where It Cannot, and a Test Is a Block ADR-269 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D6, D7→D7, D8→D8, D9→D9, D10→D10, D11→D11, D12→D12, D13→D13
265 The Prover Is a Frontend, a Logic, and a Solver — and the Logic Is Built for a Parallel Solver Written in Nikaia ADR-270 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D6, D7→D7, D8→D8
266 A Written assert Is a Published Contract, Placed by Computing Back to the Entry — a Guard Is Only Observed ADR-269 D1→D14, D2→D15, D3→D16, D4→D17, D5→D18, D6→D19, D7→D20, D8→D21
267 The Solver Is a CDCL(T) Engine with One Small Proof Format, Built on a Measured Workload and Aimed at QF_LIA ADR-270 D1→D9, D2→D10, D3→D11, D4→D5, D5→D12, D6→D13, D7→D14, D8→D15, D9→D16, D10→D17, D11→D18, D12→D8
268 The Search Is Free; What a Build Uses Is a Committed Proof File ADR-270 D1→D4, D2→D4, D3→D19, D4→D20, D5→D21, D6→D22, D7→D23, D8→D15
271 An Index Check a Proof Shows Unneeded Is Not Emitted — --optimization=remove-bounds-checks:basic|aggressive ADR-306 D1→D1, D2→D2, D3→D3, D4→D4, D5→D5, D6→D11
272 What Every Write Into a List Keeps In Bounds Is Known of Every Read From It ADR-306 D1→D6, D2→D7, D3→D8, D4→D9, D5→D10, D6→D11
273 A Map of T? Values Reads One T?, and Writing null Stores It ADR-293 D1→D12, D2→D13, D3→D14, D4→D15
274 Where ??’s Answer Is Only Read, a Value That Is a Word by Its Kind Is Copied and Everything Else Is Lent ADR-279 D1→D8, D2→D9
275 A Borrowed Left Side of ?? Beside a Jump Is a View Wherever It Stands ADR-279 D1→D10, D2→D11
async-1 async Starts a Child That Runs Beside the Code After It and Is Waited For Where Its Name Is First Used; overlap and task::scope Are Removed ADR-async-5 D1→D5, D2→D6, D3→D30 (its jumps D10), D4→D9, D5→D9 (its captures D2), D6→D15, D7→D8, D8→D7, D9→D21, D10→D14 (task::cancel removed), D11→D20, D12→D32, D13→D4, D14→D18, D15→D19, D16→D22, D17→D23, D18→D10, D19→D33
async-2 Fan-Out Over a Collection Is the par_iter Chain, Whose Lambdas May Pause; the Compiler Picks Pieces or One Task per Element, Under One Rule Set; the async Loop Is Removed ADR-async-5 D1→D24, D2→D25, D3→D26, D4→D27, D5→D32, D6→D28, D7→D30, D8→D30, D9→D29
async-3 Every Task Is Started in a Group and Lives at Most as Long as It; One Word, async, Starts Every Task, and spawn Becomes Its Option ADR-async-5 D1→D1, D2→D2, D3→D3, D4→D4, D5→D13, D6→D4, D7→D16
async-4 async Is an Expression Prefix; async e Is Waited Where Its Value Is First Needed, async(handle) Gives a Handle Bound to the Group, and Only a Handle Is Cancelled ADR-async-5 D1→D5, D2→D6, D3→D7, D4→D11, D5→D12, D6→D13, D7→D9, D8→D31, D9→D10, D10→D14, D11→D22, D12→D33, D13→D34, D14→D17, D15→D16

What the archived records displaced in one another

The history of partial supersessions among these records, as the live index carried it before they were archived.

Displaced or amended By What moved
086, 087, whole 301 (consolidates) nothing decided differently: 086’s D1-D3 keep their numbers, 087’s D1-D4 are D4-D7, 086 D5 with 087 D5 is D8; 086 D4 is not carried (withdrawn by 087 D3, here D6)
051, 117, 076, whole 298 (consolidates) nothing decided differently: 051’s D1-D5 keep their numbers (D1’s list carried as the rule; the list itself is Part I 2.1’s), 117’s D1-D3 are D6-D8, 076’s D1-D4 are D9-D12
012 and 044, whole 300 (consolidates) nothing decided differently: the two records restated as one. 012’s D1-D8 keep their numbers, 044’s D1-D3 are D9-D11. 012 D2’s command line is restated as nikaia explain f.nika, as 260 D3 already had it
143, 254, whole 299 (consolidates) nothing decided differently: 143’s D1-D6 keep their numbers (D2’s execute and D3’s example as amended by 254 D1/D3), 254’s D1-D5 are D7-D11
007, 009, 011, 082, 092, 120, 142, 173, whole 296 (consolidates) nothing decided differently: 007’s D1-D8 are D1-D8, 009’s D1-D7 are D9-D15, 011’s D1-D8 are D16-D23, 082’s D1-D4 are D24-D27, 092’s D1-D4 are D28-D31, 120’s D1-D3 are D32-D34, 142’s D1-D3 are D35-D37, 173’s D1-D3 are D38-D40. Each is stated in its current form: 007 D2/D3 and 011 D1/D4 as displaced by 082 D1/D4; 011 D5 by 120 D2; 082 D1’s dot by 140 D3; the entry’s throws=["?"] by 173 D1; 007 D5’s call by 133 D3
039, 057, 059, 064, 065, 099, 110, 111, 168, 169 and 238, whole 281 (consolidates) nothing decided differently: the eleven restated as one. 064’s D1-D3 are D1-D3 (with 039 D9); 039’s D1 is D4, D2-D7 are D28-D33, D8 is D36-D37, D10 is D10 with its refusals as D20 and D25; 057’s D1-D3 are D5-D7 and D4 is D9; 238’s D1 is D8, D2 joins D18, D3 joins D16; 059’s D1 is D11, D2-D3 are D12; 110’s D1-D5 are D12-D16, D6 is D18; 065’s D1-D3 are D17-D19; 099’s D1-D3 are D20, D21, D25, and its D4 (an order of building) is not carried; 111’s D1-D6 are D22-D27; 169’s D1-D2 are D34-D35; 168’s D1-D3 are D36-D38. 039 §3’s open half stays answered by 045
006, 112, 236, 239, whole 297 (consolidates) nothing decided differently: 006 D1 is D1-D2 as refined by 239 D1-D2 (its every-exit rewrite displaced by 239 D2), 006 D2 is D3 as refined by 239 D4 (NK2602 retired), 006 D3 is D5, D4 is D4 (its parked-error hook displaced by 239 D5: standard error), D5 is D6, D6 is D10; 112 D1-D3 are D7-D9; 239 D1-D2 are D1-D2, D3 is D4, D4 is D3, D5 is D5 and D8, D6 is D11; 236 D1-D2 are D12-D13
107, 207, 208, 216, 222, 223, 224, 225, 226 and 232, whole 282 (consolidates) nothing decided differently: the ten restated as one. 107’s D1-D5 → D1, D2, D7, D26, D27; 207’s D1-D4 → D3-D6; 208’s → D11, D25; 216’s → D7, D9, D10, D8; 222’s → D12-D13, D22, D14, D17, D26; 223’s → D12-D13, D14, D15, D23; 224’s → D12, D14, D16, D27; 225’s → D18, D19, D15; 226’s → D20, D21; 232’s → D23, D24. Carried in their current form: 107 D3’s word (216), 223 D2’s hole exception (224 D2/229), 222’s mixed-as-view reading (223 D3), 223 D4 (232)
062, 125, 127, 128, 129, 130, 131 and 153, whole 284 (consolidates) nothing decided differently: 062’s D1-D3 keep their numbers; 125’s D1-D10 are D4-D13, with 128’s D1-D2 folded into D13; 127’s D1-D5 are D14-D18; 129’s D1-D3 are D19-D21; 130’s D1-D4 are D22-D25; 131’s D1-D4 are D26-D29, with 153’s D1-D3 folded into D28. 125 D1’s extern "wasm" is carried as displaced by 130 D1, and 127 D2’s fields as widened by 152 D2
033, 034, 050, 115, 148, 163, 164, whole 292 (consolidates) nothing decided differently: 050’s D1-D7 keep their numbers, 115’s D1-D4 are D8-D11, 148’s D1-D4 are D12-D15, 163’s D1-D2 are D16-D17, 164’s D1-D3 are D18-D20; 033’s live parts (touch sets, first failure in written order, the owed explanation, in-flight is not user code) are folded into D3, D5 and D6; 033’s displaced decisions, 034 D1-D2 (displaced by 050 D1, D7), 163 D3 (closed by 164 D1) and 115 D4’s example (withdrawn by 210 D2) are not carried
043, 048, 054, 060, 063, 136, 248, 249, whole 285 (consolidates) nothing decided differently: 048 D1-D2 are D1-D2; 248 D1 is D3, D6 D4, D3-D5 D9-D11, D2 D19; 043 D1-D3 are D5-D7, D6 D8, D4 D12, D7 D13 (as 048 D1 narrowed it), D5 D29, D5.5 D31; 054 D1-D2 are D14-D15; 136 D1-D3 are D16-D18; 060 D1-D2 are D20-D21, D3 not carried (displaced by 249 D1-D3); 063 D1 is D22, D2 D26 (as 249 D3 narrowed it), D3 D28; 249 D1-D3 are D23-D25, D4 D27, D5 D30
022, 041, 049, 102, 122, 187, 192, whole 277 (consolidates) nothing decided differently: 022’s D1-D4 are D1, D3-D5; 041 D1 and 049 D1 are D2 (041 D2 withdrawn by 049 D1; 041 D3 and 049 D2 one-time acts, not carried); 102’s D1-D5 are D6-D9, D11; 122’s D1 is D11 as narrowed by 192 D1, D2 is D10, D3 is D12-D13; 187’s D1 is D13, D2 is D16 (its third point displaced by 233), D3-D4 not carried; 192’s D1-D4 are D11, D8, D14, D15
073, 075, 077 and 097, whole 287 (consolidates) nothing decided differently: 073’s D1 becomes D1 as respelled by 077, and its D2-D6 become D3-D7; 077’s D1-D3 become D1, D2 and D8; 097’s D1-D4 become D9-D12; 075’s D1-D6 become D13-D18. 073 D5’s staging was already displaced by 075 and is carried only as D6’s “refused by name”
030, 046, 047, 053, 095, 103, 144, 183, 197, whole 286 (consolidates) nothing decided differently: 047 D1 → D1, D2 → D15; 030 D3-D7 → D2, D3, D7, D8, D9, with 030 D1-D2 not carried (already displaced by 047 D1); 144 D1-D3 → D4-D6; 046 D1-D5 → D10-D14; 197 D1-D3 → D16-D18; 053 D1-D4 → D19-D22; 103 D1-D5 → D23-D27; 095 D1-D3 → D28-D30; 183 D1-D5 → D31-D35
018, 058, 069, 194, 198, 200, 206, whole 289 (consolidates) nothing decided differently: 069’s D1-D5 keep their numbers (D6, a rule about the old records’ own wording, is not carried); 194’s D1 is D6, D4 is D14, D5 is D15, and D2/D3 are D12/D13 as 200 D1/D2 had already narrowed them (nikaia serve and the localhost default stay displaced); 198’s D1-D5 are D7-D11; 200’s D1-D3 are D12, D13, D16; 018’s D1-D5 are D17-D21, with 058 D1’s Bytes row in D18’s table; 058’s D1-D9 are D22-D30; 206’s D1-D3 are D31-D33
114, 161, 273, 212, 215, 227, 213 and 214, whole 293 (consolidates) nothing decided differently: the eight restated as one. 114’s D1-D4 keep their numbers, 161’s D2-D8 are D5-D11 (its D1 is D1-D4), 273’s D1-D4 are D12-D15, 212’s D1-D5 are D16-D20, 215’s D1-D4 are D21-D24, 227’s D1-D2 are D25-D26, 213’s D1-D4 are D27-D30, 214’s D1-D3 are D31-D33. Each is restated as amended: 114 D4’s index::at around a key by 213 D1; the read’s parentheses by 214 D3; 161 D2’s .to_owned() by 191 D2 and 216 D1; 212 D5’s ref Vec[$T] by 215 D3
036, 157, 158, 159, 160, 170, 210, 211, 240, 241, whole 280 (consolidates) nothing decided differently: 036 D1-D4 are D1-D4; 158 D1-D4 are D5-D8 (D7 with ADR-108 D3’s Outside); 157 D1-D4 are D9-D12 (with 159 D1 and D4); 241 D1-D2 are D13-D14, its D3 is in D10; 160 D1-D4 are D15-D18; 170 D2-D3 are D19-D20, its D1 is contained in D13; 210 D1-D3 are D21-D23; 211 D1-D4 are D24-D27; 240 D1-D2 are D28-D29, its D3 is in D20; 159 D3 is in D3; 159 D2, already displaced by 241 D1, is not carried
027, 028, 029, 031, 067, 109, 244, whole 288 (consolidates) nothing decided differently: restated as one record — 027’s D1-D6 keep their numbers, 028’s are D7-D12, 029’s D13-D16, 031’s D17-D20, 067’s D21-D23, 109’s D24-D27, 244’s D28-D32. Carried as later records left them: 027 D5 (251 D1), 028 D1/D3 (spans, 081), 029 D1 (102 D1), 029 D3 and 031 D1 spelling (251 D4), 031 D4 (074 D2), 109 D4’s number (219 D1)
074, 078, 106, 174 and 205, whole 295 (consolidates) nothing decided differently: 074’s D1-D5 keep their numbers, 078’s D1-D4 are D6-D9, 106’s D1-D5 are D10-D14, 174’s D1-D3 are D15-D17, 205’s D1-D2 are D18-D19. Restated as already displaced: 174 D1’s “not written to the ledger file” (by 106 D4), 174 D3’s “a trait this unit does not declare” (narrowed by 106 D4 and 205 D2), and the $T spelling of 074 and 205 D1 (by 251 D4)
008, 156, 201, 209 and 221, whole 283 (consolidates) nothing decided differently: 008’s D1, D2, D5 as D1-D3, D6’s inspection half as D4, D7-D8 as D5-D6, its two D9s as D7 and D8; 201’s D1 as D4; 209’s D1-D4 as D9-D12, D5 as D4, D6 as D13; 221’s D1-D5 as D14-D18; 156’s D1-D3 as D19-D21, D6 as D22. Not carried, because already displaced: 008 D3/D4’s representation (by 209), 008 D6’s assertion (by 201 D1), 156 D4-D5’s NK2303 refusal (by 209), 201 D2-D3 (withdrawn by 209 D5)
052, 066, 068, 113, 189, 190, 191, 228, whole 278 (consolidates) nothing decided differently: 052 D1-D3 → D1-D3, D4 → D5-D6, D5 → D4, D6 → D9, D7 → D13, D8 → D16; 066 D1-D3 → D10-D12, D4 → D15, D5 → D13, D6 → D14; 068 D1-D3 → D7, D6, D8; 113 D1-D4 → D16, D17, D18, D23; 189 D1-D2 → D18, D3 → D19; 190 D1 and D4 → D17, D2 → answered by D20, D3 → D19; 191 D1-D3 → D19, D20, D21-D22; 228 D1-D2 → D21-D22. Not carried: 052 D4’s “left alone” (displaced by 068 D1); 113 D2’s “tethered” and 189 D3’s tether reason (corrected by 190); 113 D2’s .to_owned() (displaced by 216 D1); 191 D4 (a test migration)
104, 193, 195, 196, 237, whole 290 (consolidates) nothing decided differently: 104 D1-D5 are D1-D5 (with 104 §5’s refusal and hash rules; D5 as narrowed by 251 D1), 193 D1-D5 are D6-D10 (D4 as narrowed by 195 D3), 195 D1-D5 are D11-D15 (D4 as narrowed by 196 D4), 196 D1-D4 are D16-D19, 237 D1-D2 are D20-D21
098, 126, 137, 145, 146 and 242, whole 291 (consolidates) nothing decided differently: the six restated as one. 098’s D1-D5 keep their numbers; 126’s D1-D4 are D6-D9 (D1’s whole-match-arm position as displaced by 145 D1); 137’s D1-D6 are D10-D15; 145’s D1-D3 are D16-D18; 146’s D1-D3 are D19-D21, with 137 §5’s or-pattern and guard coverage; 242’s D1-D3 are D22-D24
070, 071, 084, 085, 093, 138, 151 and 255, whole 276 (consolidates) nothing decided differently: the eight restated as one - 070’s D1-D3 as D1, D2 and D6 (D4, a deferral, answered by 071); 071’s D1 and D3 as D9, D4 as D10 (D2 displaced by 084 D1; D3 as ADR-117 D1 left it, loop a name); 084’s D1-D8 as D11, D12, D13, D16, D17, D18, D1, D19; 085’s D1-D4 as D3-D5; 093’s D1-D3 as D6-D8; 138’s as D20-D22; 151’s as D13-D15; 255’s as D23-D26
250, 252, 257 and 261, whole 294 (consolidates) nothing decided differently: the four records restated as one - 250’s D1-D5 with their numbers, 252’s D1-D6 as D6-D11, 257’s D1-D5 as D12-D16, 261’s D1-D4 as D17-D20. The per-file lowering in 250 D1 and 252 D1 is carried as 261 D2 displaced it (D18)
089, 165, 259, 274, 275, whole 279 (consolidates) nothing decided differently: the five records restated as one: 089’s D1-D2 are D1-D2, 165’s D1-D2 are D3-D4, 259’s D1-D3 are D5-D7, 274’s D1-D2 are D8-D9, 275’s D1-D2 are D10-D11; 259 D1 is carried as narrowed by 274 D1 (a word by its kind is copied at a read) and 275 D1 (a borrowed left side beside a jump is a view in a let too)
264 and 266, whole 269 (consolidates) nothing decided differently: the two records restated as one, 264’s D1-D13 with their numbers, 266’s D1-D8 as D14-D21
265, 267 and 268, whole 270 (consolidates, and decides one thing anew) the three restated as one - 265’s D1-D8 with their numbers, 267’s as D5 and D8-D18, 268’s as D4, D15 and D19-D23 - and the solver written in Nikaia from its first engine, by the owner’s decision, where 267 D12 had it built in Rust first
202 D3 (returns = "borrows(self)"), and the $T of 074 §3 and 205 D1 251 D4 (respells) the spelling, not the fact: the ledger writes Nikaia’s syntax, -> ref(self) String and [T](x: T) -> T. What each records is unchanged
265 D4 (an answer depends on the query and the budget, never on time or threads) 268 D1, D2 (supersedes) what has to be reproducible: the build, from the committed nikaia.proofs, instead of the search. The search may use time, threads and local state
267 D7, D8, D11 and D12’s criteria resting on them 268 D9 (narrows, replaces) switching at work counts only, the result cache keyed with the budget, lemmas shared only as a committed input, the epoch rules, identical at 1 and n threads - replaced by the committed proof file and a --locked build is byte-identical everywhere
265 D8 (the order: the port to Nikaia, step 4, before further theories and a parallel solver) 267 D12 (reorders) when the port comes: the engine is built and measured in Rust first, behind interfaces made for the port, and ported after its CDCL(T) core stands. Steps 1-3 of D8 and what they built stand
264 D5 (an assert at the top that names only parameters, and its three exclusions) 266 D2, D7 (narrows, lifts) how a precondition is found - computed back to the entry instead of read off its line - and where it can be carried: a pub fn, a method and a function value get a ledger contract and two entries. D5’s rule that a call proves or checks a precondition stands
060 D3 (there is no second answer for a use to ask for) and 063 D2 (a bare let pins the type its own value took) 249 D1-D3 (supersedes, narrows) the use-site walk D3 said was not needed: u64 and u32 are a second answer, and an index gave rustc none. A bare let pins what its uses decide, and the first type that holds it only where none asks
048 D2 (u32, u64 and isize stay out until a program asks) 248 D1 (answers) u64 and u32 - a program asked. isize and usize stay out, for D2’s reason
086 D4 087 D3 (withdraws) the exception that kept ?? out of the head for want of a reproduction. 086 D3’s rule stands and is what 087 applies; what goes is the idea that an inconsistency in where an existing construct may stand should wait for somebody to trip over it
084 §4, first row 086 §3 (corrects) what the −25 % measured. The break-less baseline could not write while i < n && running, so it nested an if; with the head grammar fixed, the flag and the jump cost the same to 165 instructions over two million turns. An A/B is about the construct only if the construct is the only difference
084 §3 085 (replaces) the fix for the while true warning — a line in the emitted preamble becomes a change to what is emitted. The defect is the same one; §3 named the wrong remedy for it, and the right one was also the prerequisite 093 had been missing
070 D2 084 (answers) its finding that break and continue are “not in the grammar, not in the parser, and not among the 29 reserved words” — they are now, and the loop they leave is the innermost one. 070 D1 is untouched: its case for a loop keyword needs a break that hands back a value, and 084 D3 refuses one
008 D6 (the @borrowed assertion) 201 D1 and D2 (narrow) the assertion, not the inspection. D6 has two halves and this displaces one: the word a struct writes to forbid a tether is gone, and the word that allows one is @tethers. D6’s own the inverse tool is inspection, not assertion is untouched — the solved state lands in the ledger and --tethers prints it — and it is the half that answers which state is this in without a reader having to ask why a word is there. What moves is the polarity: absence meant may tether and now means may not (010 D1)
194 D2 (the first of its two products) and D3’s operator half 200 D1 and D2 (narrow) the product, not the reasoning. There are two servers, and they are different products stands and is still why an application’s author is not overridden; what goes is the standard file server, cut by the owner for schedule and for value. With it go the operator’s limits — the caps are the program’s, which is what D5’s second clause already said — and the localhost default, which was fail-closed because a standard server’s author is not there to choose. D3’s --trust listing of a wide bind is untouched: it belongs to 108’s shape and not to either product
002 D1 (a Rust dependency reaches Cargo verbatim) 197 D2 (narrows) a relative path is resolved on the way through and written absolute; everything else in the table still travels untouched. 053 D1’s member directory is what made the old rule wrong
195 D4 (std gains a walk and a subprocess) 196 D4 (narrows) both are still wanted and neither is on the reading half’s critical path: the Rust half keeps the I/O and hands the grammar the text. The split is a staging, and D4 names what a stalled one looks like
193 D4 (the syn step) 195 D3 (narrows) a real parser (syn) replaces the scraper — the parser is a grammar, because the command is a Nikaia program. Every other step of that D4 stands
122 D1 192 D1 (narrows) whether the callee runs it or keeps it — the run case is impl AsyncFn(A) -> R now, chosen by the keeps column. D2 and D3 of that record stand, and D3’s measurement is what settled it
189 D3, §4 190 D1, D3 (corrects the reason) it waits on #196, with everything else that wants a state between Borrowed and Owned. Measured, three of the four shapes a ?. has are Borrowed and the fourth is NK2303’s. The conclusion - the third case lowers as it did and is not refused - stands; what it waits on is one question about ??
122 §1, D1 187 D1, D3 (corrects the premise) “Rust has no stable async closure”, which is what chose the boxed future. It is false and was false then; the shape stands on D1’s coherence half alone, and whether that is worth 8.7× is on open-decisions.md
055 §6 step 3 187 D2 (corrects the premise) the same sentence, about a task’s body. The conclusion stands for a different reason: a body is a block and not something called, so a closure around it would only be called once
033 D10’s coda 187 D2 (corrects the premise) the same sentence, about the pool vehicle. The conclusion stands for a different reason: rayon::join takes synchronous closures and nothing can await inside one
041 D2 049 D1 (completes) the automatic names were carried as experimental and warned about; they are withdrawn, and the warning and the arity-from-body rule go with them
033 D1, D7 050 D1, D7 (displaces) statement overlapping, seq and the ordering switch are withdrawn; the touch sets stay, to check an overlap block’s claim rather than to make one
046 D1 047 D1 (narrows) which unit use names — a package rather than a file. Every rule in 046 stands and ranges over packages instead; the file boundary it was written against stops existing
043 D7 048 D1 (narrows) the sources a truncating_ entry has — the machine-width type leaves the writable surface, so its two entries go and the larger integer and the float remain
030 047 D1 (narrows) a file is a module and use names one — the files of a directory are one namespace now, and use names the directory
039 §3 045 D1 (answers) the open half — a lock could not reach a task, so Part II 12.2’s counter was unwritable. The verdict takes the destination; §3’s other way out, the Mutex floor, is not taken
022 D1 041 D1 (amends) which of the two spellings is recommended — one form with two spellings is unchanged, and both still parse everywhere; the named one is what the specification teaches
021 D5 039 D8 (amends) the cache-key enumeration: the re-entrancy switch is a fourth dimension, because a build with the check and one without lower the same source to different Rust
005 D6 039 D2 (narrows) the runtime reentrancy check as the backstop for re-entering one lock through a chain of sync calls — that case is refused at compile time now, and the check becomes self-control of the new rule
013 D5 022 fn: recorded as a chaining limitation; removed as a second way to say one thing
023 D7 036 {error:full} as a format spec; f"{error.full()}" needs no new syntax
033 D5 034 D2 (amends) “started early” widened from a branch to anything the program might not have performed
033 §8.2b 033 D10 (narrows) effects degrading to strict at user_parallelism = no — the category distinction stands, the degradation belongs to task::both: two reads the kernel performs carry no user code (038 D3)
027 §7 029 effect polymorphism — a higher-order function’s sync now depends on its lambda
028 D6 029 a higher-order method carrying no sync at all
029 §4 031 a signature naming its receiver’s type arguments
024 D5 (a string literal is a &str) 035 D3, 282 D3 (narrow) where a literal is text of its own: an f"…" is a String, hole or no hole, and a plain literal is one wherever its use asks for one. A literal nothing asks of is still a view, for D5’s reason  
032 D2 (a hole that does not parse is the emitter’s to report) 262 D4 (narrows) an f"…": a hole there that does not parse is a parse error at its own position, so nothing reaches an analysis the parser did not accept. A template’s hole is still the emitter’s  
139 D2 (the ledger carries the prose) 251 D2 (supersedes) the prose leaves the contract: the compiler never read it and --locked failed on a reworded sentence. D1 stands - /// is still the item’s documentation, and the parser reads it  
038 D3 (the readiness half) 199 D1 (narrows) the mechanism and not the surface: one poller for the process with a registration each, rather than a worker blocked in a poller per wait. What a program writes is unchanged  
037 D6 045 D3 (narrows) its coda that after D6 “no type answers may not” — the lock answers it at a foreign call, so NK2501 and NK2502 stop sharing one verdict  
005 §3 040 D1 (narrows) the ban on a clone the user did not write — it reaches a clone of data and no longer a handle on a shared value, which copies no data and produces no second value  
032 D5 035 a brace deciding a literal’s type — the f decides it now  
350 A Test That Proves a T? Is Not null Makes It a T ADR-382 D1→D1, D2→D2, D3→D3, D4→D4-D6
353 A Result’s Views Point Where the Body Says, and a Viewed Buffer Outlives Its Owner’s Name ADR-views-3 D1→D8, D2→D8, D3→D9, D4→D9, D5→D10, D6→D9, D7→D10, D8→D9, D9→D9, D10→D10
354 An Element or a Field Read off a Place Is a View Where a ref T Is Declared, and a Word Is Not ADR-views-3 D1→D5, D2→D4, D3→D4
This site is open source. Improve this page.