pith. sign in

arxiv: 2602.12973 · v2 · submitted 2026-02-13 · 💻 cs.PL

Meta-Monomorphizing Specializations

Federico Bruzzone , Walter Cazzola This is my paper

Pith reviewed 2026-05-15 22:45 UTC · model grok-4.3

classification 💻 cs.PL
keywords meta-monomorphizationspecializationmetaprogrammingmonomorphizationtype coherenceRust macroszero-cost abstractionpolymorphic specialization
0
0 comments X

The pith

Meta-monomorphization turns metaprogramming into a way to express zero-cost specializations while keeping standard compilers and coherence intact.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper aims to achieve expressive zero-cost specialization without forcing trade-offs between power and type-system soundness. It does so by repurposing monomorphization through compile-time metaprogramming that generates traits and implementations encoding the desired constraints directly in the type structure. This produces deterministic dispatch without overlapping instances for first-order, predicate-based, and higher-ranked cases, including those involving lifetimes. A Rust macro implementation shows the method stays compatible with existing optimization pipelines, matches or beats runtime TypeId dispatch on benchmarks, and removes many ad-hoc workarounds found in public codebases. If the approach holds, specialization moves from a compiler-internal feature to a disciplined metaprogramming layer that any language with macros could adopt.

Core claim

By generating meta-monomorphized traits and implementations via metaprogramming, specialization constraints are encoded directly into the type structure so that standard monomorphization produces deterministic, coherent dispatch for first-order, predicate-based, and higher-ranked polymorphic specialization, including cases with lifetime parameters.

What carries the argument

Meta-monomorphized traits and implementations, which encode specialization constraints directly into the type structure to produce coherent dispatch.

If this is right

  • Specialization patterns involving lifetimes, higher-ranked types, compound predicates, and wildcard matching become expressible while remaining zero-cost.
  • Existing optimization pipelines continue to work unchanged because the generated code uses only standard monomorphization.
  • Many current workarounds in Rust codebases for achieving similar effects can be replaced by direct, idiomatic specializations.
  • Performance equals or exceeds runtime TypeId-based dispatch on micro-benchmarks while adding expressiveness that runtime dispatch cannot provide.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same macro-based technique could be ported to other languages that support compile-time code generation without altering their core type checkers.
  • Compiler maintainers might eventually deprecate built-in specialization mechanisms in favor of exposing this metaprogramming layer for easier evolution.
  • New compound predicates that combine multiple constraints could be explored once the basic coherence guarantee is accepted.

Load-bearing premise

Generating the traits and implementations via macros will always avoid overlapping instances and coherence violations across all supported specialization forms.

What would settle it

A single documented case of overlapping trait implementations or a coherence error produced by the macro-generated code for any of the formalized specialization patterns would refute the claim.

Figures

Figures reproduced from arXiv: 2602.12973 by Federico Bruzzone, Walter Cazzola.

Figure 1
Figure 1. Figure 1: Distribution and types of specializable functions and their correlation with the total number of [PITH_FULL_IMAGE:figures/full_fig_p023_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Distribution of functions and specializable functions by kind. [PITH_FULL_IMAGE:figures/full_fig_p023_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Runtime evaluation across the 8 micro-benchmarks. The x-axis is logarithmic in base 2 to make the [PITH_FULL_IMAGE:figures/full_fig_p027_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Overheads of the specialized implementation. Compilation time remains comparable across variants, [PITH_FULL_IMAGE:figures/full_fig_p028_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Coefficient of variation at the largest input size. Lower values indicate more stable measurements. [PITH_FULL_IMAGE:figures/full_fig_p028_5.png] view at source ↗
read the original abstract

Achieving zero-cost specialization remains a fundamental challenge in programming language and compiler design. It often necessitates trade-offs between expressive power and type system soundness, as the interaction between conditional compilation and static dispatch can easily lead to unforeseen coherence violations and increased complexity in the formal model. This paper introduces meta-monomorphizing specializations, a novel framework that achieves specialization by repurposing monomorphization through compile-time metaprogramming. Instead of modifying the host compiler, our approach generates meta-monomorphized traits and implementations that encode specialization constraints directly into the type structure, enabling deterministic, coherent dispatch without overlapping instances. We formalize this method for first-order, predicate-based, and higher-ranked polymorphic specialization, also in presence of lifetime parameters. Our evaluation, based on a Rust implementation using only existing macro facilities, demonstrates that meta-monomorphization enables expressive specialization patterns while maintaining full compatibility with standard optimization pipelines. We show that specialization can be realized as a disciplined metaprogramming layer, offering a practical, language-agnostic path to high-performance abstraction. A comprehensive study of public Rust codebases further validates our approach, revealing numerous workarounds that meta-monomorphization can eliminate, leading to more idiomatic and efficient code. An empirical evaluation on 16 micro-benchmarks confirms that compile-time specialization matches or outperforms runtime TypeId-based dispatch, and demonstrates expressiveness gains on patterns -- such as lifetime-based dispatch, higher-ranked types, compound predicates, and wildcard matching -- that runtime dispatch structurally cannot express.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The paper introduces meta-monomorphizing specializations, a framework that repurposes monomorphization via compile-time metaprogramming (macros) in Rust to generate meta-monomorphized traits and implementations. These encode specialization constraints directly into the type structure, enabling deterministic coherent dispatch without overlapping instances. The approach is formalized for first-order, predicate-based, higher-ranked, and lifetime-parameterized polymorphism forms. An implementation using only existing Rust macro facilities is evaluated on 16 micro-benchmarks (showing performance matching or exceeding runtime TypeId dispatch) and via a study of public Rust codebases (identifying workarounds that the method can eliminate), with claims of full compatibility with standard optimization pipelines.

Significance. If the central claim holds—that macro-generated traits/impls produce coherent, deterministic dispatch across the listed polymorphism forms without coherence violations—this provides a practical, compiler-agnostic route to expressive zero-cost specialization. It could eliminate common Rust workarounds, enable patterns (lifetime-based dispatch, higher-ranked types, compound predicates) unreachable by runtime dispatch, and demonstrate metaprogramming as a disciplined layer for high-performance abstractions. The empirical results and codebase analysis add concrete utility evidence.

major comments (2)
  1. [§3] §3 (formalization of higher-ranked and lifetime-parameterized cases): the claim that meta-monomorphization prevents overlapping instances and coherence violations by construction is load-bearing for the entire argument, yet the text provides no explicit derivation or counterexample check showing how generated impls navigate Rust orphan rules and lifetime elision for higher-ranked trait bounds; without this, the deterministic dispatch guarantee cannot be verified.
  2. [§5] §5 (empirical evaluation, 16 micro-benchmarks table): the performance comparison to runtime dispatch is presented as matching or outperforming, but the results do not report per-benchmark variance, number of runs, or statistical tests, and the coverage of 'compound predicates' and 'wildcard matching' patterns is not broken out, undermining the expressiveness-gains claim.
minor comments (2)
  1. [Implementation] The macro definitions and generated code examples are referenced but not included in the main text or appendix, reducing reproducibility of the 'disciplined metaprogramming layer' claim.
  2. [Abstract] Abstract and §4: the 'comprehensive study of public Rust codebases' is mentioned without stating the number of repositories, search methodology, or quantitative counts of identified workarounds, which should be added for clarity.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for their detailed and constructive review. We address each major comment below and indicate the revisions we will make to strengthen the manuscript.

read point-by-point responses

  1. Referee: [§3] §3 (formalization of higher-ranked and lifetime-parameterized cases): the claim that meta-monomorphization prevents overlapping instances and coherence violations by construction is load-bearing for the entire argument, yet the text provides no explicit derivation or counterexample check showing how generated impls navigate Rust orphan rules and lifetime elision for higher-ranked trait bounds; without this, the deterministic dispatch guarantee cannot be verified.

    Authors: We agree that §3 would be strengthened by an explicit derivation. In the revised manuscript we will add a new subsection that walks through the generation rules for higher-ranked and lifetime-parameterized cases, shows how the resulting trait bounds are placed to satisfy Rust orphan rules, and provides concrete counterexample checks demonstrating the absence of overlapping instances under lifetime elision. This will make the coherence guarantee directly verifiable from the text. revision: yes

  2. Referee: [§5] §5 (empirical evaluation, 16 micro-benchmarks table): the performance comparison to runtime dispatch is presented as matching or outperforming, but the results do not report per-benchmark variance, number of runs, or statistical tests, and the coverage of 'compound predicates' and 'wildcard matching' patterns is not broken out, undermining the expressiveness-gains claim.

    Authors: We accept the critique. The revised §5 will report the number of runs performed (100 iterations per benchmark), include per-benchmark standard deviations, and add a brief statistical comparison (paired t-tests) between meta-monomorphized and TypeId dispatch. We will also augment the table with an explicit column or supplementary breakdown that isolates the subset of benchmarks exercising compound predicates and wildcard matching, thereby clarifying the expressiveness gains. revision: yes

Circularity Check

0 steps flagged

No circularity; novel metaprogramming construction presented independently

full rationale

The paper introduces meta-monomorphizing specializations as a new framework that repurposes monomorphization via macros to generate traits and implementations encoding specialization constraints. It formalizes the approach for first-order, predicate-based, higher-ranked, and lifetime-parameterized forms, then evaluates via a Rust macro implementation, codebase study, and micro-benchmarks. No equations, fitted parameters, predictions that reduce to inputs, or load-bearing self-citations appear in the derivation. The central claim rests on the explicit construction and its demonstrated compatibility with existing pipelines rather than any reduction to prior results by definition or self-reference.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 1 invented entities

The framework rests on standard assumptions about monomorphization and macro expansion in Rust-like languages plus the new metaprogramming constructs introduced by the paper.

axioms (1)
  • domain assumption Monomorphization and macro facilities in the host language can be repurposed to generate coherent specialized traits without introducing overlapping instances.
    Invoked when claiming deterministic dispatch and full compatibility with existing optimization pipelines.
invented entities (1)
  • meta-monomorphized traits and implementations no independent evidence
    purpose: To encode specialization constraints directly into the type structure
    New construct generated at compile time to achieve the specialization effect.

pith-pipeline@v0.9.0 · 5565 in / 1307 out tokens · 43110 ms · 2026-05-15T22:45:34.867818+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

101 extracted references · 101 canonical work pages

  1. [1]

    Aho, Ravi Sethi, and Jeffrey D

    Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman. 1986.Compilers: Principles, Techniques, and Tools. Addison Wesley, Reading, Massachusetts

    work page 1986

  2. [2]

    2001.Modern C++ Design: Generic Programming and Design Patterns Applied

    Andrei Alexandrescu. 2001.Modern C++ Design: Generic Programming and Design Patterns Applied. Addison-Wesley

    work page 2001

  3. [3]

    Sinclair, Samuel Grayson, and Sarita Adve

    Johnathan Alsop, Weon Taek Na, Matthew D. Sinclair, Samuel Grayson, and Sarita Adve. 2022. A Case for Fine-grain Coherence Specialization in Heterogeneous Systems.ACM Transactions on Architecture and Code Optimization19, 3 (Sept. 2022), 41:1–41:26

    work page 2022

  4. [4]

    Andrew Ayers, Richard Schooler, and Robert Gottlieb. 1997. Aggressive Inlining. InProceedings of the 18th Conference on Programming Language Design and Implementation (PLDI’97), A. Michael Berman (Ed.). ACM, Las Vegas, NV, USA, 134–145

    work page 1997

  5. [5]

    Franz Baader, Ralf Molitor, and Stephan Tobies. 1999. Tractable and Decidable Fragments of Conceptual Graphs. In Proceedings of the 7th International Conference on Conceptual Structures (ICCS’99) (LNCS 1640), William M. Tepfenhart and Walling R. Cyre (Eds.). Springer, Blackburg, VA, USA, 480–493. ACM Trans. Program. Lang. Syst., Vol. 1, No. 1, Article . P...

    work page 1999

  6. [6]

    Bruno Bachelet, Antoine Mahul, and Loïc Yon. 2013. Template Metaprogramming Techniques for Concept-Based Specialization.Scientific Programming21, 1-2 (Jan. 2013), 43–61

    work page 2013

  7. [7]

    Patrik Backhouse, Roland Carland Jansson, Johan Jeuring, and Lambert G. L. T. Meertens. 1998. Generic Programming: An Introduction. InProceedings of the 3rd International School on Advanced Functional Programming (AFP’98) (LNCS 1608), S. Doaitse Swierstra, Pedro Rangel Henriques, and José Nuno Oliveira (Eds.). Springer, Braga, Portugal, 28–115

    work page 1998

  8. [8]

    Bacon, Susan L

    David F. Bacon, Susan L. Graham, and Oliver J. Sharp. 1994. Compiler Transformations for High-Performance Computing.ACM Computing Surveys26, 4 (Dec. 1994), 345–420

    work page 1994

  9. [9]

    Bergstra and John V

    Jan A. Bergstra and John V. Tucker. 1995. Equational Specifications, Complete Term Rewriting Systems, and Computable and Semicomputable Algebras.Journal of ACM42, 6 (Nov. 1995), 1194–1230

    work page 1995

  10. [10]

    Philip Bille. 2005. A Survey on Tree Edit Distance and Related Problems.Theoretical Computer Science337, 1-3 (June 2005), 217–239

    work page 2005

  11. [11]

    Richard Bird and Lambert Meertens. 1998. Nested Datatypes. InProceedings of the 4th International Conference on Mathematics of Program Construction (MPC’98) (LNCS 1422). Springer, Marstrand, Sweden, 52–67

    work page 1998

  12. [12]

    Chandrasekhar Boyapati, Robert Lee, and Martin Rinard. 2002. Ownership Types for Safe Programming: Preventing Data Races And Deadlocks. InProceedings of the 17th Annual ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’02), Satoshi Matsuoka (Ed.). ACM Press, Seattle, WA, USA, 211–230

    work page 2002

  13. [13]

    Federico Bruzzone, Walter Cazzola, and Luca Favalli. 2026. Code Less to Code More: Streamlining Language Server Protocol and Type System Development for Language Families.Journal of Systems and Software231 (Jan. 2026). doi:10.1016/j.jss.2025.112554

    work page doi:10.1016/j.jss.2025.112554 2026

  14. [14]

    Federico Bruzzone, Walter Cazzola, and Luca Favini. 2026. Prioritizing Configuration Relevance via Compiler-Based Refined Feature Ranking. arXiv:2601.16008 [cs.PL] https://arxiv.org/abs/2601.16008

    work page arXiv 2026

  15. [15]

    Eugene Burmako. 2013. Scala Macros: Let Our Powers Combine! On How Rich Syntax and Static Types Work with Meta-Programming. InProceedings of the 4th Workshop on Scala (SCALA’13). ACM, Montpellier, France

    work page 2013

  16. [16]

    Giarrusso, and Klaus Ostermann

    Yufei Cai, Paolo G. Giarrusso, and Klaus Ostermann. 2016. System F-Omega with Equirecursive Types for Datatype- Generic Programming. InProceedings of the 43rd Symposium on Principles of Programming Languages (POPL’16), Rupak Majumdar (Ed.). ACM, St. Petersburg, FL, USA, 30–43

    work page 2016

  17. [17]

    Cooper, Ken Kennedy, and Linda Torczon

    David Callahan, Keith D. Cooper, Ken Kennedy, and Linda Torczon. 1986. Interprocedural Constant Propagation. In Proceedings of the Sigplan Symposium on Compiler Construction (SCC’86), Richard L. Wexelblat (Ed.). ACM, Palo Alto, CA, USA, 152–161

    work page 1986

  18. [18]

    Luca Cardelli and Peter Wegner. 1985. On Understanding Types, Data Abstraction, and Polymorphism.ACM Computing Surveys17, 4 (Dec. 1985), 471–523

    work page 1985

  19. [19]

    John Cavazos and Michael F. P. O’Boyle. 2005. Automatic Tuning of Inlining Heuristics. InProceedings of the 2005 ACM/IEEE Conference on Supercomputing (SC’05), Jeff Kuehn and Wes Kaplow (Eds.). IEEE, Seattle, WA, USA, 14–14

    work page 2005

  20. [20]

    Henry Cejtin, Suresh Jagannathan, and Stephen Weeks. 2000. Flow-Directed Closure Conversion for Typed Languages. InProceedings of the 9th European Symposium on Programming (ESOP’00) (LNCS 1782), Gert Smolka (Ed.). Springer, Berlin, Germany, 56–71

    work page 2000

  21. [21]

    Adam Chlipala. 2010. Ur: Statically-Typed Metaprogramming with Type-Level Record Computation. InProceedings of the 31st Conference on Programming Language Design and Implementation (PLDI’10), Alex Aiken (Ed.). ACM, Toronto, Canada, 122–133

    work page 2010

  22. [22]

    David G Clarke, John M Potter, and James Noble. 1998. Ownership types for flexible alias protection. InProceedings of 13th International Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA’98), Craig Chambers (Ed.). ACM, Vancouver, BC, Canada, 48–64

    work page 1998

  23. [23]

    Clinger and Jonathan Rees

    William D. Clinger and Jonathan Rees. 1991. Macros That Work. InProceedings of the 18th Symposium on Principles of Programming Languages (POPL’91), David Wise (Ed.). ACM, Orlando, FL, USA, 155–162

    work page 1991

  24. [24]

    Clinger and Mitchell Wand

    William D. Clinger and Mitchell Wand. 2021. Hygenic Macro Technology. InProceedings of the 4th History of Programming Languages Conference (HOPL’21), Guy L. Steele Jr and Richard P. Gabriel (Eds.). ACM, Virtual, 1–110

    work page 2021

  25. [25]

    Cooper, Mary W

    Keith D. Cooper, Mary W. Hall, and Ken Kennedy. 1992. Procedure Cloning. InProceedings of the 4th International Conference on Computer Languages (ICCL’92), Carl K. Chang (Ed.). IEEE, Oakland, CA, USA, 95–105

    work page 1992

  26. [26]

    Cooper, Mary W

    Keith D. Cooper, Mary W. Hall, and Ken Kennedy. 1993. A Methodology for Procedure Cloning.Computer Languages 19, 2 (April 1993), 105–117

    work page 1993

  27. [27]

    Cooper and Linda Torczon

    Keith D. Cooper and Linda Torczon. 2022.Engineering a Compiler. Morgan Kaufmann

    work page 2022

  28. [28]

    Pierre-Louis Curien and Giorgio Ghelli. 1992. Coherence of Subsumption, Minimum Typing and Type-Checking in F≤.Mathematical Structures in Computer Science2, 1 (March 1992), 55–91

    work page 1992

  29. [29]

    Rosen, Mark N

    Ron Cytron, Jeanne Ferrante, Barry K. Rosen, Mark N. Wegman, and F. Kenneth Zadeck. 1991. Efficiently Computing Static Single Assignment Form and the Control Dependence Graph.ACM Transactions on Programming Languages and Systems13, 4 (Oct. 1991), 451–490

    work page 1991

  30. [30]

    Dibyendu Das. 2003. Function Inlining Versus Function Cloning.Sigplan Notices38, 6 (June 2003), 23–29. ACM Trans. Program. Lang. Syst., Vol. 1, No. 1, Article . Publication date: April 2026. Meta-Monomorphizing Specializations33

    work page 2003

  31. [31]

    2010.Compiling Scala for Performance

    Iulian Dragos. 2010.Compiling Scala for Performance. PhD Thesis. École Polytechnique Fédérale de Lausanne, Lausanne, Switzerland

    work page 2010

  32. [32]

    Eisenberg

    Richard A. Eisenberg. 2017. Levity Polymorphism. InProceedings of the 38th Conference on Programming Language Design and Implementation (PLDI’17), Martin Vechev (Ed.). ACM, Barcelona, Spain, 525–539

    work page 2017

  33. [33]

    1972.Interprétation Fonctionnelle et Élimination des Coupures de l’Arithmétique d’Ordre Supérieur

    Jean-Yves Girard. 1972.Interprétation Fonctionnelle et Élimination des Coupures de l’Arithmétique d’Ordre Supérieur. PhD Thesis. Université Paris VII, Paris, France

    work page 1972

  34. [34]

    Jean-Yves Girard. 1987. Linear Logic.Theoretical Computer Science50, 1 (1987), 1–101

    work page 1987

  35. [35]

    1995.Advances in Linear Logic

    Jean-Yves Girard, Yves Lafont, and Laurent Regnier. 1995.Advances in Linear Logic. Cambridge University Press

    work page 1995

  36. [36]

    Robert Griesemer, Raymond Hu, Wen Kokke, Julien Lange, Ian Lance Taylor, Bernardo Toninho, Philip Wadler, and Nobuko Yoshida. 2020. Featherweight Go. InProceedings of the 35th Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’20), David Grove (Ed.). ACM, Chicago, IL, USA, 1–29

    work page 2020

  37. [37]

    Hall, Kevin Hammond, Simon L

    Cordelia V. Hall, Kevin Hammond, Simon L. Peyton Jones, and Philip L. Wadler. 1996. Type Classes in Haskell.ACM Transactions on Programming Languages and Systems18, 2 (March 1996), 109–138

    work page 1996

  38. [38]

    Hallett and Kfoury

    J.J. Hallett and Kfoury. Assef J. 2005. Programming Examples Needing Polymorphic Recursion.Electronic Notes in Theoretical Computer Science136 (July 2005), 57–102

    work page 2005

  39. [39]

    Fritz Henglein. 1993. Type Inference with Polymorphic Recursion.ACM Transactions on Programming Languages and Systems15, 2 (April 1993), 253–289

    work page 1993

  40. [40]

    David Herman and Mitchell Wand. 2008. A Theory of Hygieninc Macros. InProoceedings of the 17th European Conference on Programming Languages and Systems (ESOP’08) (LNCS 4960), Sophia Drossopoulou (Ed.). Springer, Budapest, Hungary, 48–62

    work page 2008

  41. [41]

    Roger Hindley. 1969. The Principal Type-Scheme of an Object in Combinatory Logic.Transactions of the America Mathematical Society146 (Dec. 1969), 29–60

    work page 1969

  42. [42]

    Anders Kiel Hovgaard, Troels Henriksen, and Martin Elsman. 2018. High-Performance Defunctionalisation in Futhark. InProceedings of the International Symposium on Trends in Functional Programming (TFP’18) (LNCS 11457), MichałPałka and Magnus Myreen (Eds.). Springer, Gothenburg, Sweden, 136–156

    work page 2018

  43. [43]

    Robert Husák, Jan Kofroň, Jakub Míšek, and Filip Zavoral. 2022. Using Procedure Cloning for Performance Optimiza- tion of Compiled Dynamic Languages. InProceedings of the 17th International Conference on Software Technologies (ICSOFT’22), Hans-Georg Fill and Marten van Sinderen (Eds.). ScitePress, Lisbon, Portugal, 175–186

    work page 2022

  44. [44]

    Shengyi Jiang, Chen Cui, and Bruno C. d. S. Oliveira. 2025. Bidirectional Higher-Rank Polymorphism with Intersection and Union Types. InProceedings of the 52nd Symposium on Principles of Programming Languages (POPL’25), Armando Solar-Lezama (Ed.). ACM, Denver, CO, USA, 2118–2148

    work page 2025

  45. [45]

    Mark P. Jones. 1993.Coherence for Qualified Types. Research Report YALEU/DCS/RR-989. Yale University, New Haven, CT, USA

    work page 1993

  46. [46]

    Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, and Derek Dreyer. 2017. RustBelt: Securing the Foundations of the Rust Programming Language. InProceedings of the 44th Symposium on Principles of Programming Languages (POPL’17), Andrew D. Gordon (Ed.). ACM, Paris, France, 66:1–66:34

    work page 2017

  47. [47]

    Andrew Kennedy and Claudio V. Russo. 2005. Generalized Algebraic Data Types and Object-Oriented Programming. In Proceedings of 19th ACM International Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA’05), Richard P. Gabriel (Ed.). ACM, San Diego, CA, USA, 21–40

    work page 2005

  48. [48]

    Andrew Kennedy and Don Syme. 2001. Design and Implementation of Generics for the.NETCommon Language Runtime. InProceedings of the ACM Conference on Programming Language Design and Implementation (PLDI01). Snowbird, Utah, USA, 1–12

    work page 2001

  49. [49]

    Ken Kennedy and John R. Allen. 2001.Optimizing Compilers for Modern Architectures: A Dependence-Based Approach. Morgan Kaufmann Publishers Inc

    work page 2001

  50. [50]

    Kfoury, Jerzy Tiuryn, and Pawel Urzyczyn

    Assaf J. Kfoury, Jerzy Tiuryn, and Pawel Urzyczyn. 1993. Type Reconstruction in the Presence of Polymorphic Recursion.ACM Transactions on Programming Languages and Systems15, 2 (April 1993), 290–311

    work page 1993

  51. [51]

    2026.The Rust Programming Language(third ed.)

    Steve Klabnik, Carol Nichols, and Chris Krycho. 2026.The Rust Programming Language(third ed.). No Starch Press

    work page 2026

  52. [52]

    Jens Knoop, Oliver Rüthing, and Bernhard Steffen. 1994. Partial Dead Code Elimination. InProceedings of the 15th Annual Conference on Programming Language Design and Implementation (PLDI’94), Vivek Sarkar, Barbara G. Ryder, and Mary Lou Soffa (Eds.). ACM, Orlando, FL, USA, 147–158

    work page 1994

  53. [53]

    Kohlbecker, Daniel P

    Eugene E. Kohlbecker, Daniel P. Friedman, Matthias Felleisen, and Bruce F. Duba. 1986. Hygienic Macro Expansion. In Proceedings of the 3rd Conference on LISP and Functional Programming (LFP’86), William L. Scherlis, John H. Williams, and Richard P. Gabriel (Eds.). ACM, Cambridge, MA, USA, 151–161

    work page 1986

  54. [54]

    Chris Lattner and Vikram Adve. 2004. LLVM: A Compilation Framework for Lifelong Program Analysis and Transformation. InProceedings of the 2nd International Symposium on Code Generation and Optimization (CGO’04), Michael D. Smith (Ed.). IEEE, San José, CA, USA, 75–86. ACM Trans. Program. Lang. Syst., Vol. 1, No. 1, Article . Publication date: April 2026. 3...

    work page 2004

  55. [55]

    Konstantin Läufer. 1996. Type Classes with Existential Types.Journal of Functional Programming6, 3 (May 1996), 485–518

    work page 1996

  56. [56]

    Lehmann and Michael B

    Daniel J. Lehmann and Michael B. Smyth. 1981. Algebraic Specification of Data Types: A Synthetic Approach.Journal of Mathematical Systems Theory14, 2 (Dec. 1981), 97–139

    work page 1981

  57. [57]

    Xavier Leroy. 1992. Unboxed Objects and Polymorphic Typing. InProceedings of the 19th Annual ACM Symposium on Principle of Programming Languages (POPL’92), Ravi Sethi (Ed.). ACM, Albuquerque, NM, USA, 177–188

    work page 1992

  58. [58]

    Yannis Lilis and Anthony Savidis. 2019. A Survey of Metaprogramming Languages.ACM Computing Surveys52, 6 (Oct. 2019)

    work page 2019

  59. [59]

    Matthew Lutze, Philipp Schuster, and Jonathan Immanuel Brachthäuser. 2025. The Simple Essence of Monomorphiza- tion. InProceedings of the 40th Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA’25), Shriram Krishnamurthi and Sukyoung Ryu (Eds.). ACM, Singapore, 1015–1041

    work page 2025

  60. [60]

    José Pedro Magalhães, Stefan Holdermans, Johan Jeuring, and Andres Löh. 2010. Optimizing Generics Is Easy!. In Proceedings of the 19th Workshop on Partial Evaluation and Program Manipulation (PEPM’10), John P. Gallagher and Janis Voitländer (Eds.). ACM, Madrid, Spain, 33–42

    work page 2010

  61. [61]

    Matsakis

    Nicholas D. Matsakis. 2015. Specialization. RFC 1210. https://rust-lang.github.io/rfcs/1210-impl-specialization.html

    work page 2015

  62. [62]

    Matsakis

    Nicholas D. Matsakis. 2015. Specialization. Discussion on RFC 1210. https://github.com/rust-lang/rfcs/pull/1210

    work page 2015

  63. [63]

    Matsakis

    Nicholas D. Matsakis. 2018. Maximally Minimal Specialization: Always Applicable impls. Blog Post. https: //smallcultfollowing.com/babysteps/blog/2018/02/09/maximally-minimal-specialization-always-applicable-impls/

    work page 2018

  64. [64]

    Matsakis and Felix S

    Nicholas D. Matsakis and Felix S. Klock. 2014. The Rust Language.ACM SIGAda Letters34, 3 (Oct. 2014), 103–104

    work page 2014

  65. [65]

    John McCarthy. 1960. Recursive Functions of Symbolic Expressions and Their Computation by Machine (Part I). Commun. ACM3, 4 (April 1960), 184–195

    work page 1960

  66. [66]

    Robin Milner. 1978. A Theory of Type Polymorphism in Programming.Journal of Computer and System Sciences17, 3 (Dec. 1978), 348–375

    work page 1978

  67. [67]

    Mitchell and Gordon D

    John C. Mitchell and Gordon D. Plotkin. 1988. Abstract Types Have Existential Type.ACM Transactions on Programming Languages and Systems10, 3 (July 1988), 470–502

    work page 1988

  68. [68]

    Muchnick

    Steven S. Muchnick. 1997.Advanced Compiler Design and Implementation(first ed.). Morgan Kaufmann

    work page 1997

  69. [69]

    Musser and Alexander A

    David R. Musser and Alexander A. Stepanov. 1988. Generic Programming. InProceedings of the 13th International Symposium on Symbolic and Algebraic Computation (ISAAC’88) (LNCS 358), Patrizia M. Gianni (Ed.). Springer, Rome, Italy, 13–25

    work page 1988

  70. [70]

    Martin Odersky. 1992. Observers for Linear Types. InProceedings of the 4th European Symposium on Programming (ESOP’92) (LNCS 582), Bernd Krieg-Brückner (Ed.). Springer, Rennes, France, 390–407

    work page 1992

  71. [71]

    2008.Programming in Scala

    Martin Odersky, Lex Spoon, and Bill Venners. 2008.Programming in Scala. Aritma Press

    work page 2008

  72. [72]

    1999.Purely Functional Data Structures(first ed.)

    Chris Okasaki. 1999.Purely Functional Data Structures(first ed.). Cambridge University Press

    work page 1999

  73. [73]

    Mateusz Pawlik and Nikolaus Augsten. 2011. RTED: A Robust Algorithm for the Tree Edit Distance. InProceedings of the 38th International Conference on Very Large Data Bases (VLDB’12), José Blakely, Joseph M. Hellerstein, Nick Koudas, Wolfgang Lehner, Sunita Sarawagi, and Uwe Röhm (Eds.). ACM, Instanbul, Turkey, 334–345

    work page 2011

  74. [74]

    Mateusz Pawlik and Nikolaus Augsten. 2015. Efficient Computation of the Tree Edit Distance.ACM Transactions on Database Systems40, 1 (March 2015), 3:1–3:40

    work page 2015

  75. [75]

    Francis Jeffry Pelletier and Allen Hazen. 2021. Natural Deduction Systems in Logic. InThe Stanford Encyclopedia of Philosophy, Edward N. Zalta and Uri Nodelman (Eds.). Stanford University

    work page 2021

  76. [76]

    2003.Haskell 98 Language and Libraries

    Simon Peyton Jones. 2003.Haskell 98 Language and Libraries. Cambridge University Press

    work page 2003

  77. [77]

    Jones, and Erik Meijer

    Simon Peyton Jones, Mark P. Jones, and Erik Meijer. 1997. Type Classes: An Exploration of the Design Space. In Proceedings of the 2nd Workshop on Haskell (Haskell’97), John Launchbury (Ed.). ACM, Amsterdam, The Netherlands, 1–16

    work page 1997

  78. [78]

    Benjamin C. Pierce. 2002.Types and Programming Languages. MIT Press

    work page 2002

  79. [79]

    Reynolds

    John C. Reynolds. 1974. Towards a Theory of Type Structure. InProceedings of 1974 Programming Symposium (LNCS 19), Bernard J. Robinet (Ed.). Springer, Paris, France, 408–423

    work page 1974

  80. [80]

    Eric S. Roberts. 1986.Thinking Recursively(first ed.). John Wiley and Sons, Inc

    work page 1986

Showing first 80 references.