Inlining and specialization appear in various forms throughout the implementation of modern programming languages. From mere compiler optimizations to sophisticated techniques in partial evaluation, they are omnipresent, yet each application is treated differently. This paper is an attempt at uncovering the relations between inlining (as done in production compilers) and staged computation (as done in partial evaluators) in the hope of bringing together the research advances in both fields. Using a two-level lambda calculus as the intermediate language, we show how to model inlining as a staged computation while avoiding unnecessary code duplication. The new framework allows us to define inlining annotations formally and to reason about their interactions with module code. In fact, we present a cross-module inlining algorithm that inlines all functions marked inlinable, even in the presence of ML-style parameterized modules.

8.1 Module Prelude  104

8.2 Module PreludeList  114

8.3 Module PreludeText  119

8.4 Module PreludeIO  123

The following three figures (figures 10, 11 and 12) were not shown in the original published version of the article. These figures constitute the entire static semantics of the STAL type system.

9.1 Notational Conventions  125

9.2 Lexical Syntax  126

9.3 Layout  128

9.4 Literate Comments  131

9.5 Context-Free Syntax  133

Cyclone is a type-safe programming language that provides explicit run-time code generation. The Cyclone compiler uses a template-based strategy for run-time code generation in which pre-compiled code fragments are stitched together at run time. This strategy keeps the cost of code generation low, but it requires that optimizations, such as register allocation and code motion, are applied to templates at compile time. This paper describes a principled approach to implementing such optimizations. In particular, we generalize standard flow-graph intermediate representations to support templates, define a mapping from (a subset of) Cyclone to this representation, and describe a dataflow-analysis framework that supports standard optimizations across template boundaries.

10.1 Derived Instances of Eq and Ord  140

10.2 Derived Instances of Enum  140

10.3 Derived Instances of Bounded  141

10.4 Derived Instances of Read and Show  142

10.5 An Example  143

11.1 Inlining  145

11.2 Specialization  145

12.1 Library Ratio  150

13.1 Library Complex  154

14.1 Showing Functions  158

14.2 Reading Functions  159

14.3 Miscellaneous  159

14.4 Library Numeric  160

15.1 Deriving Instances of Ix  170

15.2 Library Ix  171

16.1 Array Construction  174

16.2 Incremental Array Updates  175

16.3 Derived Arrays  176

16.4 Library Array  176

17.1 Indexing Lists  181

17.2 “Set” Operations  181

17.3 List Transformations  182

17.4 unfoldr  182

17.5 Predicates  183

17.6 The “By” Operations  183

17.7 The “generic” Operations  184

17.8 Further “zip” Operations  184

17.9 Library List  184

18.1 Library Maybe  192

19.1 Library Char  195

20.1 Naming Conventions  200

20.2 Class MonadPlus  200

20.3 Functions  201

20.4 Library Monad  202

21.1 I/O Errors  207

21.2 Files and Handles  208

21.3 Opening and Closing Files  210

21.4 Determining the Size of a File  211

21.5 Detecting the End of Input  211

21.6 Buffering Operations  211

21.7 Repositioning Handles  213

21.8 Handle Properties  213

21.9 Text Input and Output  214

21.10 Examples  215

21.11 Library IO  216