The key decision for programming language developers is whether to support generics, which influences the choice between Hindley-Milner and Bidirectional typing systems.
About:
The author of the website is thunderseethe, who maintains a development blog titled 'thunderseethe's devlog'.
Website:
Incoming Links:
Subscribe to RSS:
The blog post discusses the process of desugaring in compiler design, specifically how it transforms a Concrete Syntax Tree (CST) into an Abstract Syntax Tree (AST). It explains the importance of removing syntax sugar to focus on ...
This blog post is part of a series on implementing a programming language using Rust, focusing on the parsing phase of the compiler. The author expresses skepticism about parsing tutorials, emphasizing the complexity and multitude...
The blog post discusses advancements in a type inference system for a query-based compiler that supports the Language Server Protocol (LSP). It outlines the need for improvements to handle interactive usage, including the introduc...
A comprehensive guide on building a query-based compiler and language server in Rust, focusing on LSP integration and key IDE features.
Name resolution in programming languages is crucial for mapping variable names to memory locations, simplifying the compiler's understanding of code structure.
Modern compilers have shifted to a query-based model, enhancing efficiency and integration with IDEs, yet educational resources on this topic remain scarce.
The text discusses the misconception that Wasm stands for WebAssembly, clarifying that it is not web nor Assembly. It explains that Wasm is a portable bytecode, language agnostic, and formally specified stack machine that supports...
The post discusses the process of code emission using WebAssembly as a compiler target. It explains the use of bytecode, the structure of Wasm code, and the different sections of Wasm modules. It also delves into the execution mod...
The text discusses the closure conversion process in programming languages, specifically in Rust. It explains the need for closure conversion, the differences between hardware functions and lambdas, and the process of converting l...
The post discusses the concept of monomorphization and type erasure in programming languages. It explains how monomorphization removes polymorphism by creating a new copy of a function for each instantiation of its types, while ty...
The post is part of a series that teaches how to implement a programming language using Rust. It covers the topic of optimization in compilation, specifically focusing on simplification. The post discusses the process of simplific...
The text discusses the concept of function application and currying in functional languages. It explains the benefits and drawbacks of currying, and introduces a new approach to type inference using multiple arguments. The author ...
The text discusses the process of lowering top-level items in a programming language, explaining the differences between items and local variables, the introduction of new AST nodes, and the challenges of applying parameters to it...
The text discusses the process of lowering rows, generating and applying evidence terms, and the nodes for product row types, sum row types, and the lower_ast. It also explains the lookup_ev function and the generation of IR terms...
The text discusses the process of lowering row types and making row addendums for IR and Type. It covers the updates to lower_ty_scheme, enhancements to TypeScheme, and changes to lower_ty, lower_row_ty, and lower_closed_row_ty. I...
The text discusses the process of lowering row types into IR, focusing on the techniques of evidence passing and label erasure. It explains how to convert rows into tuples and tagged values while maintaining row operations. The au...
The text discusses the process of lowering type schemes and ASTs in a compiler, explaining the steps involved and the code required to achieve this. It covers the process of converting type variables to DeBruijn Indices, wrapping ...
0Part 5a: Lowering Our AST to Escape the Typechecker
2025-01-28 •
The text discusses the process of lowering, which is the conversion of a typed AST into an intermediate representation (IR). It explains the fundamental shift in the compiler from frontend to backend, the reification of metadata, ...
0Picking Equatable Names
2025-01-23 •
The text discusses the challenges of naming things in computer science, particularly in relation to compilers. It explains the difficulties compilers face in coming up with names and the problems that arise with equating and subst...
0Traits are a Local Maxima
2024-11-18 •
The text discusses the problems with Rust traits, focusing on the fatal flaw of traits, the orphan instance problem, and the need for global coherence. It then introduces the concept of local coherence and implicits as a potential...
0Part 4: TypeChecking Top Level Functions
2024-07-05 •
The text discusses the implementation of top-level functions in a programming language, focusing on type inference and type checking. It delves into the distinction between local variables and top-level functions, the benefits of ...
0I'm betting on Call-by-Push-Value
2024-03-09 •
The text discusses the concept of Call-by-Push-Value (CBPV) as a new evaluation strategy in programming language semantics, which combines the features of both call-by-value (CBV) and call-by-name/call-by-need (CBN). It explains h...
0In Search of the Perfect Fold
2023-11-27 •
The author discusses the challenges of writing a satisfactory fold over trees in Rust, particularly in the context of writing a compiler. They explore the limitations of using Iterator::fold as a tree fold and the advantages of us...