Lowering on Thunderseethe's Devlog

Lowering Top Level Items

Tue, 04 Mar 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post lowers top level functions from our prior pass . It extends the row language with support for items (top level functions) in our IR.

Last time saw us endeavoring upon a trilogy to bring rows crashing down from their high-flying AST nodes into the realities of our lowly IR. Our goals this time are less highfalutin. We’re going to be lowering items. I can’t tell you how relieved I am to see this titled “.Items”, not “.Items[0]”.

The Heart of Lowered Rows

Wed, 26 Feb 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post continues lowering rows from our previous post .

Last time we upgraded lower_ty_scheme to support rows and saw how we’d use it’s evidence to inform lower_ast. We’re getting to the heart of lowering rows this time: generating and applying our evidence terms.

The Types of Lowered Rows

Tue, 18 Feb 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post continues lowering rows from our previous post .

Last time we learned how we’re going to lower row types and made some row addendums for IR and Type. Today, we’ll update lower_ty_scheme, using those addendums, to generate types for Evidence.

Quick Refresher

Here’s a quick rundown of the stuff we’ll need from types/rows .

Lowering Row Types, Evidently

Tue, 11 Feb 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post undertakes lowering rows building on our previous pass that inferred row types. It extends the lowering we did for the base language.

Last time , we lowered types/base into our IR. That was exciting, but I professed some anxieties that all we had really done is swap an Ast:: prefix for an IR:: prefix. Today, we’re going to assuage those concerns by lowering types/rows . A more seismic lowering. Recall that row types provide data types for our language. Rows are great in the surface language and the type checker but start to lose their luster once we need to represent them in memory.

Escaping the Typechecker, an Implementation

Tue, 04 Feb 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post builds on the previous lowering post . Now that we have some more theory about lowering we undertake Implementation this time around.

Armed with the knowledge of IR and Type from last time , we can finally write some code:

fn lower(
 ast: Ast<TypedVar>, 
 scheme: ast::TypeScheme
) -> (IR, Type) {
 let (ir_ty, types) = lower_ty_scheme(scheme);

 todo!()
}

One line down. That’s great progress (especially compared to last post)!

Lowering our AST to Escape the Typechecker

Tue, 28 Jan 2025 00:00:00 +0000

Making a Language

This post is part of the making a language series . A series that teaches you how to implement a programming language using Rust.

This post covers turning our typed AST into our intermediate representation for our base language. It builds on the outputs of the previous pass where we inferred types for the base language.

We’ve been in type checking so long it’s becoming a tar pit deep enough to rival picking a parser. Our only hope of escape is to delve deeper, lest we find ourselves fretting over the endlessly enticing type checker features available to adjoin. We’re always free to return to our type checker older and wiser. But this series is called making a language, not type check until our motivation evaporates.