metaprogramming

Bilingual

Lisp moving Forth moving Lisp
2 months ago
- Common Lisp macros are used to implement a minimalist Forth interpreter, demonstrating macro power and flexibility.
- Forth's key concepts—abstract registers, threaded code, immediacy (compile-time execution), and dictionary—are implemented using Lisp data structures and metaprogramming.
- The chapter emphasizes 'duality of syntax': the ability to change program semantics with minimal code modifications, a core advantage of macros.
- Forth's threaded code allows transparent control over compilation, enabling features like tail calls, recursion, and custom control structures (if/then, begin/again).
- The final code converts Forth threads into executable Lisp code (flubifying), showing cross-language translation via macros.
- Macros let Lisp overcome 'Flub' language limitations (opaque code blocks), enabling non-local branches and stack manipulation.
(Ab)Using Overload Sets to Create Ad-Hoc Template APIs in D
2 months ago
- Overload sets are collections of functions with the same name in the same scope that participate in overload resolution, and they can be used as alias parameters to enable generic programming.
- Template specialization on integer values allows treating an overload set like an array, enabling compile-time lookup tables, code generation, and dispatch based on integral constants.
- A unified vector interface can be built by using a shared template header with an integer dimension parameter, allowing dimension-generic code without duplicating type definitions.
- An ad-hoc template API is defined by the existence of successful matches in the resolution logic rather than a central definition, enabling flexible and extensible interfaces.
- Overload sets can be swapped (e.g., std.conv.to) to let users provide custom implementations, making APIs more flexible and fixable.
- Shared header mechanics in D allow overload sets to work across different declaration patterns (enum, function, template, struct) as long as the template header matches.
Flexible Metaprogramming with Rhombus
3 months ago
- Rhombus is a new programming language combining Racket's metaprogramming with Python-like syntax.
- It uses indentation-based syntax with ':' for blocks and '|' for branch separation, similar to Python.
- Rhombus supports immutable data structures by default, using tree-based lists for efficient operations.
- The language features advanced for loops with reducers (e.g., math.product) for concise code.
- Macros in Rhombus use syntax objects with metadata for error handling and hygienic/non-hygienic options.
- It allows user-defined grammatical contexts and extensions, supporting language-oriented programming.
- Rhombus includes gradual typing with annotations for error messages and performance optimization.
- The language is backed by the Racket project, licensed under MIT/Apache 2.0, and suitable for academic and professional use.

metaprogramming

Lisp moving Forth moving Lisp

(Ab)Using Overload Sets to Create Ad-Hoc Template APIs in D

Flexible Metaprogramming with Rhombus