Experience Seamless Full Ebook Downloads for Every Genre at textbookfull.

com

Practical Foundations For Programming Languages

2nd Edition Robert Harper

https://textbookfull.com/product/practical-foundations-for-
programming-languages-2nd-edition-robert-harper/

OR CLICK BUTTON

DOWNLOAD NOW

Explore and download more ebook at https://textbookfull.com

 Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Foundations of Programming Languages Second Edition Lee

https://textbookfull.com/product/foundations-of-programming-languages-
second-edition-lee/

textboxfull.com

Foundations of Programming Languages Kent D. Lee

https://textbookfull.com/product/foundations-of-programming-languages-
kent-d-lee/

textboxfull.com

Concepts of Programming Languages Global Edition Robert W.

Sebesta [Sebesta R.W.]

https://textbookfull.com/product/concepts-of-programming-languages-
global-edition-robert-w-sebesta-sebesta-r-w/

textboxfull.com

Concepts of programming languages Twelfth Edition Sebesta

https://textbookfull.com/product/concepts-of-programming-languages-
twelfth-edition-sebesta/

textboxfull.com
Concepts of programming languages 11th Edition Sebesta

https://textbookfull.com/product/concepts-of-programming-
languages-11th-edition-sebesta/

textboxfull.com

Programming Languages and Systems Amal Ahmed

https://textbookfull.com/product/programming-languages-and-systems-
amal-ahmed/

textboxfull.com

Understanding Programming Languages 1st Edition Cliff B.

Jones

https://textbookfull.com/product/understanding-programming-
languages-1st-edition-cliff-b-jones/

textboxfull.com

Programming Languages and Systems 1st Edition Nobuko

Yoshida

https://textbookfull.com/product/programming-languages-and-
systems-1st-edition-nobuko-yoshida/

textboxfull.com

Foundations of Psychological Testing A Practical Approach

6th Edition Leslie A Miller Robert L Lovler

https://textbookfull.com/product/foundations-of-psychological-testing-
a-practical-approach-6th-edition-leslie-a-miller-robert-l-lovler/

textboxfull.com
 Practical Foundations for Programming Languages

This text develops a comprehensive theory of programming languages based on type sys-
tems and structural operational semantics. Language concepts are precisely defined by their
static and dynamic semantics, presenting the essential tools both intuitively and rigorously
while relying on only elementary mathematics. These tools are used to analyze and prove
properties of languages and provide the framework for combining and comparing language
features. The broad range of concepts includes fundamental data types such as sums and
products, polymorphic and abstract types, dynamic typing, dynamic dispatch, subtyping
and refinement types, symbols and dynamic classification, parallelism and cost semantics,
and concurrency and distribution. The methods are directly applicable to language imple-
mentation, to the development of logics for reasoning about programs, and to the formal
verification language properties such as type safety.
This thoroughly revised second edition includes exercises at the end of nearly every
chapter and a new chapter on type refinements.

Robert Harper is a professor in the Computer Science Department at Carnegie Mellon

University. His main research interest is in the application of type theory to the design
and implementation of programming languages and to the mechanization of their meta-
theory. Harper is a recipient of the Allen Newell Medal for Research Excellence and the
Herbert A. Simon Award for Teaching Excellence, and is an Association for Computing
Machinery Fellow.
Practical Foundations for
Programming Languages
Second Edition

Robert Harper
Carnegie Mellon University
 32 Avenue of the Americas, New York, NY 10013

Cambridge University Press is part of the University of Cambridge.

It furthers the University’s mission by disseminating knowledge in the pursuit of

education, learning, and research at the highest international levels of excellence.

www.cambridge.org
Information on this title: www.cambridge.org/9781107150300
© Robert Harper 2016

This publication is in copyright. Subject to statutory exception

and to the provisions of relevant collective licensing agreements,
no reproduction of any part may take place without the written
permission of Cambridge University Press.
First published 2016

Printed in the United States of America

A catalog record for this publication is available from the British Library.

Library of Congress Cataloging in Publication Data

Names: Harper, Robert, 1957–
Title: Practical foundations for programming languages / Robert Harper,
Carnegie Mellon University.
Description: Second edition. | New York NY : Cambridge University Press,
2016. | Includes bibliographical references and index.
Identifiers: LCCN 2015045380 | ISBN 9781107150300 (alk. paper)
Subjects: LCSH: Programming languages (Electronic computers)
Classification: LCC QA76.7 .H377 2016 | DDC 005.13–dc23
LC record available at http://lccn.loc.gov/2015045380

ISBN 978-1-107-15030-0 Hardback

Cambridge University Press has no responsibility for the persistence or accuracy of
URLs for external or third-party Internet Web sites referred to in this publication
and does not guarantee that any content on such Web sites is, or will remain,
accurate or appropriate.
 Contents

Preface to the Second Edition page xv

Preface to the First Edition xvii

Part I Judgments and Rules

1 Abstract Syntax 3
1.1 Abstract Syntax Trees 3
1.2 Abstract Binding Trees 6
1.3 Notes 10

2 Inductive Definitions 12
2.1 Judgments 12
2.2 Inference Rules 12
2.3 Derivations 14
2.4 Rule Induction 15
2.5 Iterated and Simultaneous Inductive Definitions 17
2.6 Defining Functions by Rules 18
2.7 Notes 19

3 Hypothetical and General Judgments 21

3.1 Hypothetical Judgments 21
3.2 Hypothetical Inductive Definitions 24
3.3 General Judgments 26
3.4 Generic Inductive Definitions 27
3.5 Notes 28

Part II Statics and Dynamics

4 Statics 33
4.1 Syntax 33
4.2 Type System 34
4.3 Structural Properties 35
4.4 Notes 37
vi Contents

5 Dynamics 39
5.1 Transition Systems 39
5.2 Structural Dynamics 40
5.3 Contextual Dynamics 42
5.4 Equational Dynamics 44
5.5 Notes 46

6 Type Safety 48
6.1 Preservation 48
6.2 Progress 49
6.3 Run-Time Errors 50
6.4 Notes 52

7 Evaluation Dynamics 53
7.1 Evaluation Dynamics 53
7.2 Relating Structural and Evaluation Dynamics 54
7.3 Type Safety, Revisited 55
7.4 Cost Dynamics 56
7.5 Notes 57

Part III Total Functions

8 Function Definitions and Values 61

8.1 First-Order Functions 61
8.2 Higher-Order Functions 62
8.3 Evaluation Dynamics and Definitional Equality 65
8.4 Dynamic Scope 66
8.5 Notes 67

9 System T of Higher-Order Recursion 69

9.1 Statics 69
9.2 Dynamics 70
9.3 Definability 71
9.4 Undefinability 73
9.5 Notes 75

Part IV Finite Data Types

10 Product Types 79
10.1 Nullary and Binary Products 79
10.2 Finite Products 81
10.3 Primitive Mutual Recursion 82
10.4 Notes 83
vii Contents

11 Sum Types 85
11.1 Nullary and Binary Sums 85
11.2 Finite Sums 86
11.3 Applications of Sum Types 88
11.4 Notes 91

Part V Types and Propositions

12 Constructive Logic 95
12.1 Constructive Semantics 95
12.2 Constructive Logic 96
12.3 Proof Dynamics 100
12.4 Propositions as Types 101
12.5 Notes 101

13 Classical Logic 104

13.1 Classical Logic 105
13.2 Deriving Elimination Forms 109
13.3 Proof Dynamics 110
13.4 Law of the Excluded Middle 111
13.5 The Double-Negation Translation 113
13.6 Notes 114

Part VI Infinite Data Types

14 Generic Programming 119

14.1 Introduction 119
14.2 Polynomial Type Operators 119
14.3 Positive Type Operators 122
14.4 Notes 123

15 Inductive and Coinductive Types 125

15.1 Motivating Examples 125
15.2 Statics 128
15.3 Dynamics 130
15.4 Solving Type Equations 131
15.5 Notes 132

Part VII Variable Types

16 System F of Polymorphic Types 137

16.1 Polymorphic Abstraction 137
16.2 Polymorphic Definability 140
16.3 Parametricity Overview 142
16.4 Notes 144
viii Contents

17 Abstract Types 146

17.1 Existential Types 146
17.2 Data Abstraction 149
17.3 Definability of Existential Types 150
17.4 Representation Independence 151
17.5 Notes 153

18 Higher Kinds 154

18.1 Constructors and Kinds 155
18.2 Constructor Equality 156
18.3 Expressions and Types 157
18.4 Notes 158

Part VIII Partiality and Recursive Types

19 System PCF of Recursive Functions 161

19.1 Statics 162
19.2 Dynamics 163
19.3 Definability 165
19.4 Finite and Infinite Data Structures 167
19.5 Totality and Partiality 167
19.6 Notes 169

20 System FPC of Recursive Types 171

20.1 Solving Type Equations 171
20.2 Inductive and Coinductive Types 172
20.3 Self-Reference 174
20.4 The Origin of State 176
20.5 Notes 177

Part IX Dynamic Types

21 The Untyped λ-Calculus 181

21.1 The λ-Calculus 181
21.2 Definability 182
21.3 Scott’s Theorem 184
21.4 Untyped Means Uni-Typed 186
21.5 Notes 187

22 Dynamic Typing 189

22.1 Dynamically Typed PCF 189
22.2 Variations and Extensions 192
22.3 Critique of Dynamic Typing 194
22.4 Notes 195
ix Contents

23 Hybrid Typing 198

23.1 A Hybrid Language 198
23.2 Dynamic as Static Typing 200
23.3 Optimization of Dynamic Typing 201
23.4 Static versus Dynamic Typing 203
23.5 Notes 204

Part X Subtyping

24 Structural Subtyping 207

24.1 Subsumption 207
24.2 Varieties of Subtyping 208
24.3 Variance 211
24.4 Dynamics and Safety 215
24.5 Notes 216

25 Behavioral Typing 219

25.1 Statics 220
25.2 Boolean Blindness 226
25.3 Refinement Safety 228
25.4 Notes 229

Part XI Dynamic Dispatch

26 Classes and Methods 235

26.1 The Dispatch Matrix 235
26.2 Class-Based Organization 238
26.3 Method-Based Organization 239
26.4 Self-Reference 240
26.5 Notes 242

27 Inheritance 245
27.1 Class and Method Extension 245
27.2 Class-Based Inheritance 246
27.3 Method-Based Inheritance 248
27.4 Notes 249

Part XII Control Flow

28 Control Stacks 253

28.1 Machine Definition 253
28.2 Safety 255
28.3 Correctness of the K Machine 256
28.4 Notes 259
x Contents

29 Exceptions 260
29.1 Failures 260
29.2 Exceptions 262
29.3 Exception Values 263
29.4 Notes 264

30 Continuations 266
30.1 Overview 266
30.2 Continuation Dynamics 268
30.3 Coroutines from Continuations 269
30.4 Notes 272

Part XIII Symbolic Data

31 Symbols 277
31.1 Symbol Declaration 277
31.2 Symbol References 280
31.3 Notes 282

32 Fluid Binding 284

32.1 Statics 284
32.2 Dynamics 285
32.3 Type Safety 286
32.4 Some Subtleties 287
32.5 Fluid References 288
32.6 Notes 289

33 Dynamic Classification 291

33.1 Dynamic Classes 291
33.2 Class References 293
33.3 Definability of Dynamic Classes 294
33.4 Applications of Dynamic Classification 295
33.5 Notes 296

Part XIV Mutable State

34 Modernized Algol 301

34.1 Basic Commands 301
34.2 Some Programming Idioms 306
34.3 Typed Commands and Typed Assignables 307
34.4 Notes 310

35 Assignable References 313

35.1 Capabilities 313
35.2 Scoped Assignables 314
xi Contents

35.3 Free Assignables 316

35.4 Safety 318
35.5 Benign Effects 320
35.6 Notes 321

36 Lazy Evaluation 323

36.1 PCF By-Need 323
36.2 Safety of PCF By-Need 326
36.3 FPC By-Need 328
36.4 Suspension Types 329
36.5 Notes 331

Part XV Parallelism

37 Nested Parallelism 335

37.1 Binary Fork-Join 335
37.2 Cost Dynamics 338
37.3 Multiple Fork-Join 341
37.4 Bounded Implementations 342
37.5 Scheduling 346
37.6 Notes 348

38 Futures and Speculations 350

38.1 Futures 350
38.2 Speculations 351
38.3 Parallel Dynamics 352
38.4 Pipelining with Futures 354
38.5 Notes 356

Part XVI Concurrency and Distribution

39 Process Calculus 359

39.1 Actions and Events 359
39.2 Interaction 361
39.3 Replication 363
39.4 Allocating Channels 364
39.5 Communication 366
39.6 Channel Passing 369
39.7 Universality 371
39.8 Notes 372

40 Concurrent Algol 375

40.1 Concurrent Algol 375
40.2 Broadcast Communication 378
40.3 Selective Communication 380
xii Contents

40.4 Free Assignables as Processes 382

40.5 Notes 383

41 Distributed Algol 385

41.1 Statics 385
41.2 Dynamics 388
41.3 Safety 390
41.4 Notes 391

Part XVII Modularity

42 Modularity and Linking 395

42.1 Simple Units and Linking 395
42.2 Initialization and Effects 396
42.3 Notes 398

43 Singleton Kinds and Subkinding 399

43.1 Overview 399
43.2 Singletons 400
43.3 Dependent Kinds 402
43.4 Higher Singletons 405
43.5 Notes 407

44 Type Abstractions and Type Classes 409

44.1 Type Abstraction 410
44.2 Type Classes 412
44.3 A Module Language 414
44.4 First- and Second-Class 418
44.5 Notes 419

45 Hierarchy and Parameterization 422

45.1 Hierarchy 422
45.2 Abstraction 425
45.3 Hierarchy and Abstraction 427
45.4 Applicative Functors 429
45.5 Notes 431

Part XVIII Equational Reasoning

46 Equality for System T 435

46.1 Observational Equivalence 435
46.2 Logical Equivalence 439
46.3 Logical and Observational Equivalence Coincide 440
46.4 Some Laws of Equality 443
46.5 Notes 444
xiii Contents

47 Equality for System PCF 445

47.1 Observational Equivalence 445
47.2 Logical Equivalence 446
47.3 Logical and Observational Equivalence Coincide 446
47.4 Compactness 449
47.5 Lazy Natural Numbers 452
47.6 Notes 453

48 Parametricity 454
48.1 Overview 454
48.2 Observational Equivalence 455
48.3 Logical Equivalence 456
48.4 Parametricity Properties 461
48.5 Representation Independence, Revisited 464
48.6 Notes 465

49 Process Equivalence 467

49.1 Process Calculus 467
49.2 Strong Equivalence 469
49.3 Weak Equivalence 472
49.4 Notes 473

Part XIX Appendices

A Background on Finite Sets 477

Bibliography 479
Index 487
 Preface to the Second Edition

Writing the second edition to a textbook incurs the same risk as building the second version
of a software system. It is difficult to make substantive improvements, while avoiding the
temptation to overburden and undermine the foundation on which one is building. With the
hope of avoiding the second system effect, I have sought to make corrections, revisions,
expansions, and deletions that improve the coherence of the development, remove some
topics that distract from the main themes, add new topics that were omitted from the first
edition, and include exercises for almost every chapter.
The revision removes a number of typographical errors, corrects a few material errors
(especially the formulation of the parallel abstract machine and of concurrency in Algol),
and improves the writing throughout. Some chapters have been deleted (general pattern
matching and polarization, restricted forms of polymorphism), some have been completely
rewritten (the chapter on higher kinds), some have been substantially revised (general
and parametric inductive definitions, concurrent and distributed Algol), several have been
reorganized (to better distinguish partial from total type theories), and a new chapter
has been added (on type refinements). Titular attributions on several chapters have been
removed, not to diminish credit, but to avoid confusion between the present and the original
formulations of several topics. A new system of (pronounceable!) language names has been
introduced throughout. The exercises generally seek to expand on the ideas in the main
text, and their solutions often involve significant technical ideas that merit study. Routine
exercises of the kind one might include in a homework assignment are deliberately few.
My purpose in writing this book is to establish a comprehensive framework for formu-
lating and analyzing a broad range of ideas in programming languages. If language design
and programming methodology are to advance from a trade-craft to a rigorous discipline,
it is essential that we first get the definitions right. Then, and only then, can there be mean-
ingful analysis and consolidation of ideas. My hope is that I have helped to build such a
foundation.
I am grateful to Stephen Brookes, Evan Cavallo, Karl Crary, Jon Sterling, James R.
Wilcox and Todd Wilson for their help in critiquing drafts of this edition and for their
suggestions for modification and revision. I thank my department head, Frank Pfenning,
for his support of my work on the completion of this edition. Thanks also to my editors, Ada
Brunstein and Lauren Cowles, for their guidance and assistance. And thanks to Andrew
Shulaev for corrections to the draft.
Neither the author nor the publisher make any warranty, express or implied, that the
definitions, theorems, and proofs contained in this volume are free of error, or are consistent
with any particular standard of merchantability, or that they will meet requirements for any
particular application. They should not be relied on for solving a problem whose incorrect
xvi Preface to the Second Edition

solution could result in injury to a person or loss of property. If you do use this material
in such a manner, it is at your own risk. The author and publisher disclaim all liability for
direct or consequential damage resulting from its use.

Pittsburgh
July 2015
 Preface to the First Edition

Types are the central organizing principle of the theory of programming languages. Lan-
guage features are manifestations of type structure. The syntax of a language is governed
by the constructs that define its types, and its semantics is determined by the interactions
among those constructs. The soundness of a language design—the absence of ill-defined
programs—follows naturally.
The purpose of this book is to explain this remark. A variety of programming language
features are analyzed in the unifying framework of type theory. A language feature is defined
by its statics, the rules governing the use of the feature in a program, and its dynamics, the
rules defining how programs using this feature are to be executed. The concept of safety
emerges as the coherence of the statics and the dynamics of a language.
In this way, we establish a foundation for the study of programming languages. But
why these particular methods? The main justification is provided by the book itself. The
methods we use are both precise and intuitive, providing a uniform framework for explaining
programming language concepts. Importantly, these methods scale to a wide range of
programming language concepts, supporting rigorous analysis of their properties. Although
it would require another book in itself to justify this assertion, these methods are also
practical in that they are directly applicable to implementation and uniquely effective as a
basis for mechanized reasoning. No other framework offers as much.
Being a consolidation and distillation of decades of research, this book does not provide
an exhaustive account of the history of the ideas that inform it. Suffice it to say that much
of the development is not original but rather is largely a reformulation of what has gone
before. The notes at the end of each chapter signpost the major developments but are
not intended as a complete guide to the literature. For further information and alternative
perspectives, the reader is referred to such excellent sources as Constable (1986, 1998),
Girard (1989), Martin-Löf (1984), Mitchell (1996), Pierce (2002, 2004), and Reynolds
(1998).
The book is divided into parts that are, in the main, independent of one another. Parts
I and II, however, provide the foundation for the rest of the book and must therefore be
considered prior to all other parts. On first reading, it may be best to skim Part I, and begin
in earnest with Part II, returning to Part I for clarification of the logical framework in which
the rest of the book is cast.
Numerous people have read and commented on earlier editions of this book and have
suggested corrections and improvements to it. I am particularly grateful to Umut Acar,
Jesper Louis Andersen, Carlo Angiuli, Andrew Appel, Stephanie Balzer, Eric Bergstrom,
Guy E. Blelloch, Iliano Cervesato, Lin Chase, Karl Crary, Rowan Davies, Derek Dreyer,
Dan Licata, Zhong Shao, Rob Simmons, and Todd Wilson for their extensive efforts in
xviii Preface to the First Edition

reading and criticizing the book. I also thank the following people for their suggestions:
Joseph Abrahamson, Arbob Ahmad, Zena Ariola, Eric Bergstrome, William Byrd, Alejan-
dro Cabrera, Luis Caires, Luca Cardelli, Manuel Chakravarty, Richard C. Cobbe, James
Cooper, Yi Dai, Daniel Dantas, Anupam Datta, Jake Donham, Bill Duff, Matthias Felleisen,
Kathleen Fisher, Dan Friedman, Peter Gammie, Maia Ginsburg, Byron Hawkins, Kevin
Hely, Kuen-Bang Hou (Favonia), Justin Hsu, Wojciech Jedynak, Cao Jing, Salil Joshi,
Gabriele Keller, Scott Kilpatrick, Danielle Kramer, Dan Kreysa, Akiva Leffert, Ruy Ley-
Wild, Karen Liu, Dave MacQueen, Chris Martens, Greg Morrisett, Stefan Muller, Tom
Murphy, Aleksandar Nanevski, Georg Neis, David Neville, Adrian Trejo Nuñez, Cyrus
Omar, Doug Perkins, Frank Pfenning, Jean Pichon, Benjamin Pierce, Andrew M. Pitts,
Gordon Plotkin, David Renshaw, John Reynolds, Andreas Rossberg, Carter Schonwald,
Dale Schumacher, Dana Scott, Shayak Sen, Pawel Sobocinski, Kristina Sojakova, Daniel
Spoonhower, Paulo Tanimoto, Joe Tassarotti, Peter Thiemann, Bernardo Toninho, Michael
Tschantz, Kami Vaniea, Carsten Varming, David Walker, Dan Wang, Jack Wileden, Sergei
Winitzki, Roger Wolff, Omer Zach, Luke Zarko, and Yu Zhang. I am very grateful to the
students of 15-312 and 15-814 at Carnegie Mellon who have provided the impetus for the
preparation of this book and who have endured the many revisions to it over the last ten
years.
I thank the Max Planck Institute for Software Systems for its hospitality and support.
I also thank Espresso a Mano in Pittsburgh, CB2 Cafe in Cambridge, and Thonet Cafe
in Saarbrücken for providing a steady supply of coffee and a conducive atmosphere for
writing.
This material is, in part, based on work supported by the National Science Foundation
under Grant Nos. 0702381 and 0716469. Any opinions, findings, and conclusions or rec-
ommendations expressed in this material are those of the author(s) and do not necessarily
reflect the views of the National Science Foundation.

Robert Harper
Pittsburgh
March 2012
 PART I

Judgments and Rules

 1 Abstract Syntax

Programming languages express computations in a form comprehensible to both people

and machines. The syntax of a language specifies how various sorts of phrases (expressions,
commands, declarations, and so forth) may be combined to form programs. But what are
these phrases? What is a program made of?
The informal concept of syntax involves several distinct concepts. The surface, or con-
crete, syntax is concerned with how phrases are entered and displayed on a computer. The
surface syntax is usually thought of as given by strings of characters from some alphabet
(say, ASCII or Unicode). The structural, or abstract, syntax is concerned with the structure
of phrases, specifically how they are composed from other phrases. At this level, a phrase
is a tree, called an abstract syntax tree, whose nodes are operators that combine several
phrases to form another phrase. The binding structure of syntax is concerned with the
introduction and use of identifiers: how they are declared, and how declared identifiers can
be used. At this level, phrases are abstract binding trees, which enrich abstract syntax trees
with the concepts of binding and scope.
We will not concern ourselves in this book with concrete syntax but will instead consider
pieces of syntax to be finite trees augmented with a means of expressing the binding and
scope of identifiers within a syntax tree. To prepare the ground for the rest of the book, we
define in this chapter what is a “piece of syntax” in two stages. First, we define abstract
syntax trees, or ast’s, which capture the hierarchical structure of a piece of syntax, while
avoiding commitment to their concrete representation as a string. Second, we augment
abstract syntax trees with the means of specifying the binding (declaration) and scope
(range of significance) of an identifier. Such enriched forms of abstract syntax are called
abstract binding trees, or abt’s for short.
Several functions and relations on abt’s are defined that give precise meaning to the
informal ideas of binding and scope of identifiers. The concepts are infamously difficult to
define properly and are the mother lode of bugs for language implementors. Consequently,
precise definitions are essential, but they are also fairly technical and take some getting
used to. It is probably best to skim this chapter on first reading to get the main ideas, and
return to it for clarification as necessary.

1.1 Abstract Syntax Trees

An abstract syntax tree, or ast for short, is an ordered tree whose leaves are variables, and
whose interior nodes are operators whose arguments are its children. Ast’s are classified
4 Abstract Syntax

into a variety of sorts corresponding to different forms of syntax. A variable stands for an
unspecified, or generic, piece of syntax of a specified sort. Ast’s can be combined by an
operator, which has an arity specifying the sort of the operator and the number and sorts
of its arguments. An operator of sort s and arity s1 , . . . , sn combines n ≥ 0 ast’s of sort
s1 , . . . , sn , respectively, into a compound ast of sort s.
The concept of a variable is central and therefore deserves special emphasis. A variable
is an unknown object drawn from some domain. The unknown can become known by
substitution of a particular object for all occurrences of a variable in a formula, thereby
specializing a general formula to a particular instance. For example, in school algebra
variables range over real numbers, and we may form polynomials, such as x 2 + 2 x + 1,
that can be specialized by substitution of, say, 7 for x to obtain 72 + (2 × 7) + 1, which can
be simplified according to the laws of arithmetic to obtain 64, which is (7 + 1)2 .
Abstract syntax trees are classified by sorts that divide ast’s into syntactic categories.
For example, familiar programming languages often have a syntactic distinction between
expressions and commands; these are two sorts of abstract syntax trees. Variables in abstract
syntax trees range over sorts in the sense that only ast’s of the specified sort of the variable
can be plugged in for that variable. Thus, it would make no sense to replace an expression
variable by a command, nor a command variable by an expression, the two being different
sorts of things. But the core idea carries over from school mathematics, namely that a
variable is an unknown, or a place-holder, whose meaning is given by substitution.
As an example, consider a language of arithmetic expressions built from numbers,
addition, and multiplication. The abstract syntax of such a language consists of a single
sort Exp generated by these operators:

1. An operator num[n] of sort Exp for each n ∈ N.

2. Two operators, plus and times, of sort Exp, each with two arguments of sort Exp.

The expression 2 + (3 × x), which involves a variable, x, would be represented by the ast

plus(num[2]; times(num[3]; x))

of sort Exp, under the assumption that x is also of this sort. Because, say, num[4], is an ast
of sort Exp, we may plug it in for x in the above ast to obtain the ast

plus(num[2]; times(num[3]; num[4])),

which is written informally as 2 + (3 × 4). We may, of course, plug in more complex ast’s
of sort Exp for x to obtain other ast’s as result.
The tree structure of ast’s provides a very useful principle of reasoning, called structural
induction. Suppose that we wish to prove that some property P(a) holds for all ast’s a of a
given sort. To show this, it is enough to consider all the ways in which a can be generated
and show that the property holds in each case under the assumption that it holds for its
constituent ast’s (if any). So, in the case of the sort Exp just described, we must show

1. The property holds for any variable x of sort Exp: prove that P(x).
2. The property holds for any number, num[n]: for every n ∈ N, prove that P(num[n]).
5 1.1 Abstract Syntax Trees

3. Assuming that the property holds for a1 and a2 , prove that it holds for plus(a1 ; a2 ) and
times(a1 ; a2 ): if P(a1 ) and P(a2 ), then P(plus(a1 ; a2 )) and P(times(a1 ; a2 )).

Because these cases exhaust all possibilities for the formation of a, we are assured that
P(a) holds for any ast a of sort Exp.
It is common to apply the principle of structural induction in a form that takes account of
the interpretation of variables as place-holders for ast’s of the appropriate sort. Informally, it
is often useful to prove a property of an ast involving variables in a form that is conditional
on the property holding for the variables. Doing so anticipates that the variables will be
replaced with ast’s that ought to have the property assumed for them, so that the result of
the replacement will have the property as well. This amounts to applying the principle of
structural induction to properties P(a) of the form “if a involves variables x1 , . . . , xk , and
Q holds of each xi , then Q holds of a,” so that a proof of P(a) for all ast’s a by structural
induction is just a proof that Q(a) holds for all ast’s a under the assumption that Q holds
for its variables. When there are no variables, there are no assumptions, and the proof of P
is a proof that Q holds for all closed ast’s. On the other hand, if x is a variable in a, and we
replace it by an ast b for which Q holds, then Q will hold for the result of replacing x by b
in a.
For the sake of precision, we now give precise definitions of these concepts. Let S be
a finite set of sorts. For a given set S of sorts, an arity has the form (s1 , . . . , sn )s, which
specifies the sort s ∈ S of an operator taking n ≥ 0 arguments, each of sort si ∈ S. Let
O = { Oα } be an arity-indexed family of disjoint sets of operators Oα of arity α. If o is
an operator of arity (s1 , . . . , sn )s, we say that o has sort s and has n arguments of sorts
s 1 , . . . , sn .
Fix a set S of sorts and an arity-indexed family O of sets of operators of each arity. Let
X = { Xs }s∈S be a sort-indexed family of disjoint finite sets Xs of variables x of sort s.
When X is clear from context, we say that a variable x is of sort s if x ∈ Xs , and we say
that x is fresh for X , or just fresh when X is understood, if x ∈ / Xs for any sort s. If x is
fresh for X and s is a sort, then X , x is the family of sets of variables obtained by adding
x to Xs . The notation is ambiguous in that the sort s is not explicitly stated but determined
from context.
The family A[X ] = { A[X ]s }s∈S of abstract syntax trees, or ast’s, of sort s is the smallest
family satisfying the following conditions:

1. A variable of sort s is an ast of sort s: if x ∈ Xs , then x ∈ A[X ]s .

2. Operators combine ast’s: if o is an operator of arity (s1 , . . . , sn )s, and if a1 ∈ A[X ]s1 ,
. . . , an ∈ A[X ]sn , then o(a1 ; . . . ;an ) ∈ A[X ]s .

It follows from this definition that the principle of structural induction can be used to prove
that some property P holds of every ast. To show P(a) holds for every a ∈ A[X ], it is
enough to show:

1. If x ∈ Xs , then Ps (x).
2. If o has arity (s1 , . . . , sn )s and Ps1 (a1 ) and . . . and Psn (an ), then Ps (o(a1 ; . . . ;an )).
6 Abstract Syntax

For example, it is easy to prove by structural induction that A[X ] ⊆ A[Y] whenever
X ⊆ Y.
Variables are given meaning by substitution. If a ∈ A[X , x]s  , and b ∈ A[X ]s , then
[b/x]a ∈ A[X ]s  is the result of substituting b for every occurrence of x in a. The ast a is
called the target, and x is called the subject, of the substitution. Substitution is defined by
the following equations:

1. [b/x]x = b and [b/x]y = y if x = y.

2. [b/x]o(a1 ; . . . ;an ) = o([b/x]a1 ; . . . ;[b/x]an ).

For example, we may check that

[num[2]/x]plus(x; num[3]) = plus(num[2]; num[3]).
We may prove by structural induction that substitution on ast’s is well-defined.

Theorem 1.1. If a ∈ A[X , x], then for every b ∈ A[X ] there exists a unique c ∈ A[X ]
such that [b/x]a = c

Proof By structural induction on a. If a = x, then c = b by definition; otherwise, if

a = y = x, then c = y, also by definition. Otherwise, a = o(a1 , . . . , an ), and we have
by induction unique c1 , . . . , cn such that [b/x]a1 = c1 and . . . [b/x]an = cn , and so c is
c = o(c1 ; . . . ;cn ), by definition of substitution.

1.2 Abstract Binding Trees

Abstract binding trees, or abt’s, enrich ast’s with the means to introduce new variables and
symbols, called a binding, with a specified range of significance, called its scope. The scope
of a binding is an abt within which the bound identifier can be used, either as a place-holder
(in the case of a variable declaration) or as the index of some operator (in the case of a
symbol declaration). Thus, the set of active identifiers can be larger within a subtree of
an abt than it is within the surrounding tree. Moreover, different subtrees may introduce
identifiers with disjoint scopes. The crucial principle is that any use of an identifier should
be understood as a reference, or abstract pointer, to its binding. One consequence is that
the choice of identifiers is immaterial, so long as we can always associate a unique binding
with each use of an identifier.
As a motivating example, consider the expression let x be a1 in a2 , which introduces
a variable x for use within the expression a2 to stand for the expression a1 . The variable
x is bound by the let expression for use within a2 ; any use of x within a1 refers to a
different variable that happens to have the same name. For example, in the expression
let x be 7 in x + x occurrences of x in the addition refer to the variable introduced by the
let. On the other hand, in the expression let x be x ∗ x in x + x, occurrences of x within
the multiplication refer to a different variable than those occurring within the addition. The
7 1.2 Abstract Binding Trees

latter occurrences refer to the binding introduced by the let, whereas the former refer to
some outer binding not displayed here.
The names of bound variables are immaterial insofar as they determine the same
binding. So, for example, let x be x ∗ x in x + x could just as well have been written
let y be x ∗ x in y + y, without changing its meaning. In the former case, the variable x
is bound within the addition, and in the latter, it is the variable y, but the “pointer structure”
remains the same. On the other hand, the expression let x be y ∗ y in x + x has a different
meaning to these two expressions, because now the variable y within the multiplication
refers to a different surrounding variable. Renaming of bound variables is constrained to
the extent that it must not alter the reference structure of the expression. For example, the
expression
let x be 2 in let y be 3 in x + x

has a different meaning than the expression

let y be 2 in let y be 3 in y + y,

because the y in the expression y + y in the second case refers to the inner declaration, not
the outer one as before.
The concept of an ast can be enriched to account for binding and scope of a variable.
These enriched ast’s are called abstract binding trees, or abt’s for short. Abt’s generalize
ast’s by allowing an operator to bind any finite number (possibly zero) of variables in each
argument. An argument to an operator is called an abstractor and has the form x1 , . . . , xk .a.
The sequence of variables x1 , . . . , xk are bound within the abt a. (When k is zero, we elide
the distinction between .a and a itself.) Written in the form of an abt, the expression
let x be a1 in a2 has the form let(a1 ; x.a2 ), which more clearly specifies that the variable
x is bound within a2 , and not within a1 . We often write x to stand for a finite sequence
x1 , . . . , xn of distinct variables and write x .a to mean x1 , . . . , xn .a.
To account for binding, operators are assigned generalized arities of the form
(υ1 , . . . , υn )s, which specifies operators of sort s with n arguments of valence υ1 , . . . , υn .
In general a valence υ has the form s1 , . . . , sk .s, which specifies the sort of an argument as
well as the number and sorts of the variables bound within it. We say that a sequence x of
variables is of sort s to mean that the two sequences have the same length k and that the
variable xi is of sort si for each 1 ≤ i ≤ k.
Thus, to specify that the operator let has arity (Exp, Exp.Exp)Exp indicates that it is
of sort Exp whose first argument is of sort Exp and binds no variables and whose second
argument is also of sort Exp and within which is bound one variable of sort Exp. The
informal expression let x be 2 + 2 in x × x may then be written as the abt

let(plus(num[2]; num[2]); x.times(x; x))

in which the operator let has two arguments, the first of which is an expression, and the
second of which is an abstractor that binds one expression variable.
Fix a set S of sorts and a family O of disjoint sets of operators indexed by their generalized
arities. For a given family of disjoint sets of variables X , the family of abstract binding
8 Abstract Syntax

trees, or abt’s B[X ], is defined similarly to A[X ], except that X is not fixed throughout the
definition but rather changes as we enter the scopes of abstractors.
This simple idea is surprisingly hard to make precise. A first attempt at the definition is
as the least family of sets closed under the following conditions:

1. If x ∈ Xs , then x ∈ B[X ]s .
2. For each operator o of arity (s1 .s1 , . . . , sn .sn )s, if a1 ∈ B[X , x1 ]s1 , . . . , and an ∈
B[X , xn ]sn , then o( xn .an ) ∈ B[X ]s .
x1 .a1 ; . . . ;

The bound variables are adjoined to the set of active variables within each argument, with
the sort of each variable determined by the valence of the operator.
This definition is almost correct but fails to properly account for renaming of bound vari-
ables. An abt of the form let(a1 ; x.let(a2 ; x.a3 )) is ill-formed according to this definition,
because the first binding adds x to X , which implies that the second cannot also add x to
X , x, because it is not fresh for X , x. The solution is to ensure that each of the arguments
is well-formed regardless of the choice of bound variable names, which is achieved using
fresh renamings, which are bijections between sequences of variables. Specifically, a fresh
renaming (relative to X ) of a finite sequence of variables x is a bijection ρ : x ↔ x 
between x and x  , where x  is fresh for X . We write 
ρ (a) for the result of replacing each
occurrence of xi in a by ρ(xi ), its fresh counterpart.
This is achieved by altering the second clause of the definition of abt’s using fresh
renamings as follows:

For each operator o of arity (s1 .s1 , . . . , sn .sn )s, if for each 1 ≤ i ≤ n and each fresh
renaming ρi : xi ↔ xi , we have ρi (ai ) ∈ B[X , xi ], then o( xn .an ) ∈ B[X ]s .
x1 .a1 ; . . . ;

The renaming ρi (ai ) of each ai ensures that collisions cannot occur and that the abt is valid
for almost all renamings of any bound variables that occur within it.
The principle of structural induction extends to abt’s and is called structural induction
modulo fresh renaming. It states that to show that P[X ](a) holds for every a ∈ B[X ], it is
enough to show the following:

1. if x ∈ Xs , then P[X ]s (x).

2. For every o of arity (s1 .s1 , . . . , sn .sn )s, if for each 1 ≤ i ≤ n, P[X , xi ]si (
ρi (ai )) holds
for every ρi : xi ↔ xi with xi ∈ / X , then P[X ]s (o( x1 .a1 ; . . . ;
xn .an )).

The second condition ensures that the inductive hypothesis holds for all fresh choices of
bound variable names, and not just the ones actually given in the abt.
As an example let us define the judgment x ∈ a, where a ∈ B[X , x], to mean that x
occurs free in a. Informally, this means that x is bound somewhere outside of a, rather
than within a itself. If x is bound within a, then those occurrences of x are different
from those occurring outside the binding. The following definition ensures that this is the
case:
9 1.2 Abstract Binding Trees

1. x ∈ x.
2. x ∈ o( xn .an ) if there exists 1 ≤ i ≤ n such that for every fresh renaming
x1 .a1 ; . . . ;
ρ : xi ↔ zi we have x ∈  ρ (ai ).

The first condition states that x is free in x but not free in y for any variable y other than x.
The second condition states that if x is free in some argument, independently of the choice
of bound variable names in that argument, then it is free in the overall abt.
The relation a =α b of α-equivalence (so-called for historical reasons) means that a and
b are identical up to the choice of bound variable names. The α-equivalence relation is the
strongest congruence containing the following two conditions:

1. x =α x.
xn .an ) =α o(
x1 .a1 ; . . . ;
2. o( xn .an ) if for every 1 ≤ i ≤ n, ρi (ai ) =α ρi (ai ) for
x1 .a1 ; . . . ;
all fresh renamings ρi : xi ↔ zi and ρi : xi ↔ zi .

The idea is that we rename xi and xi consistently, avoiding confusion, and check that ai
and ai are α-equivalent. If a =α b, then a and b are α-variants of each other.
Some care is required in the definition of substitution of an abt b of sort s for free
occurrences of a variable x of sort s in some abt a of some sort, written [b/x]a. Substitution
is partially defined by the following conditions:

1. [b/x]x = b, and [b/x]y = y if x = y.

2. [b/x]o( x1 .a1 ; . . . ;
xn .an ) = o(
x1 .a1 ; . . . ; xn .an ), where, for each 1 ≤ i ≤ n, we require
/ b, and we set ai = [b/x]ai if x ∈
that xi ∈ / xi , and ai = ai otherwise.

The definition of [b/x]a is quite delicate and merits careful consideration.

One trouble spot for substitution is to notice that if x is bound by an abstractor within
a, then x does not occur free within the abstractor and hence is unchanged by substitution.
For example, [b/x]let(a1 ; x.a2 ) = let([b/x]a1 ; x.a2 ), there being no free occurrences of
x in x.a2 . Another trouble spot is the capture of a free variable of b during substitution.
For example, if y ∈ b and x = y, then [b/x]let(a1 ; y.a2 ) is undefined, rather than
being let([b/x]a1 ; y.[b/x]a2 ), as one might at first suspect. For example, provided that
x = y, [y/x]let(num[0]; y.plus(x; y)) is undefined, not let(num[0]; y.plus(y; y)), which
confuses two different variables named y.
Although capture avoidance is an essential characteristic of substitution, it is, in a sense,
merely a technical nuisance. If the names of bound variables have no significance, then
capture can always be avoided by first renaming the bound variables in a to avoid any
free variables in b. In the foregoing example, if we rename the bound variable y to
y  to obtain a   let(num[0]; y  .plus(x; y  )), then [b/x]a  is defined and is equal to
let(num[0]; y  .plus(b; y  )). The price for avoiding capture in this way is that substitution
is only determined up to α-equivalence, and so we may no longer think of substitution as a
function but only as a proper relation.
Exploring the Variety of Random
Documents with Different Content
 ASARIAS (vakavasti). Eivät ole — niinkuin ovat täällä.

KUSTAAVA. Niin, lapsettomiksihan te, näemmä, olette jääneet.

ASARIAS (synkästi). Niinhän tuota ollaan. (Vihaisesti.) Mutta se on

sen Kaisan vika. Ja sen tautta minä siitä lähden eroon.

KUSTAAVA. Niin, niin. Mikäs siinä muu auttaa? Erota pitää, kun se
kerran sen vika on.

ASARIAS (edelleen äkäisesti). Ja otan toisen — toisen eukon.

KUSTAAVA. Tietenkin. Eihän sitä ilman jää.

ASARIAS. Ja sen tautta nyt olen tänne tullutkin.

KUSTAAVA. Sehän passaa hyvin, kun rovastikin tänään tulee

tänne.

ASARIAS. Muiden tietämättä tänne läksinkin, että sen asian

paremmin selvitetyksi saisin.

KUSTAAVA. Parasta onkin, ettei hiisku kellekään mitään, ei

sanaakaan, ennenkuin asia on selvä.

ASARIAS. Ville vain sen toistaiseksi tietää, ja hänen neuvostaan

tänne oikeastaan tulinkin.

KUSTAAVA. No, ei se minunkaan suustani pitemmälle pääse, siitä

Asarias saa olla huoleti.

ASARIAS (joka on lopettanut kahvinsa, panee kupin

kiikkulaudalle). Kiitoksia! (Nyökäyttää päätään Kustaavalle ja
pyyhkäisee samalla oikean korvansa ylitse.)
 KUSTAAVA. Vielä kahvia lisää?

ASARIAS. Ei enää, kiitoksia! En häntä huoli.

KUSTAAVA. Eikö maita?

ASARIAS (katkerasti). Ei maita. Niin on äitelää koko elämä jo, ettei

häntä välitä enää mistään.

KUSTAAVA. Ei nyt Asarias tuolla lailla saa surra. Kyllä se siitä

muuttuu vielä.

ASARIAS. Olettepa te yhtä hyvä kuin ennenkin. Ymmärrätte ja

säälitte minua.

KUSTAAVA (esiliinan kolkkaan silmiään pyyhkien). Mitenkäs?

Ymmärränhän minä ja säälin.

ASARIAS (kääntyy poispäin ja pyyhkii silmiään hihan suulla).

Toisen onnettomuutta. (Kääntyy sitten äkkiä ja polkaisee jalkaansa.)
Mutta nyt siitä tulee loppu.

KUSTAAVA (hätkähtää). Niin, loppu tulee, tietysti! (Korjaa

kahvivehkeet.) Minä sen näen selvästi. Asariaksen täytyy erota.
Muutenhan sitä tulee ihan hulluksi.

ASARIAS. Ja minä otan toisen, otan.

KUSTAAVA. Tietysti, Asarias hyvä, tietysti. (Lähtee pelästyneenä

viedä kyyhöttämään kahvivehkeitä pois.) Istuu nyt siinä ja rauhoittuu
vähän! (Menee sisään.)

ASARIAS. Saattaahan tuon. (Istuutuu laudalle, miettii hetken ja

katsahtaa sitten ylös ikkunaan. Ojentaa kätensä ja yrittää nykiä
ikkunaan kipattua pyyhettä, mutta jättää sen paikalleen. Vihdoin hän
kuiskaa hiljalleen ikkunaan päin.) Anni! Anni, hoi! (Istuutuu
hajareisin kiikkulaudalle selin portaikkoon päin.)

ANNI (hiipii samalla portaikolle ja istuutuu, selin Asariakseen päin,

portaikon penkille kuuntelemaan, silloin tällöin kumartuen
kaidepuiden taakse piiloon).

ASARIAS. Sielläkö Anni on? (Ikkunasta vedetään pyyhe sisään,

mutta ikkunavarjostin jätetään lasin eteen, niin ettei Asarias tiedä,
että sisällä vastaa hänelle puolikovaa KAISA, koettaen matkia Annin
ääntä.)

KAISAN ÄÄNI. Täällä.

ASARIAS (ihastuen). Onko? No, enkö vieläkään pääse sisään?

KAISA. Ei, ei.

ASARIAS. Eikä nähdäkään saa?

KAISA: Ei.

ASARIAS. Milloinkas?

KAISA. Jälkeen puol'sen.

ASARIAS. Jälkeenkö puolisen vasta?

KAISA. Niin.

ASARIAS (väräjävällä äänellä). Anni hyvä! Minä olen niin kovin

onneton.
KAISA. Niin minäkin.

ASARIAS. Niinkö?

KAISA. Niin.

ASARIAS. No, sittenhän se passaa?

KAISA. Passaa.

ASARIAS. Minä otan eron Kaisasta,

KAISA. Ottaa pitää.

ASARIAS. Eroattekos tekin?

KAISA. Eroamme.

ASARIAS. No, sittenhän se passaa?

KAISA. Passaa.

ASARIAS. Lähdetäänkös rovastin puheille?

KAISA. Lähdetään.

ASARIAS. Vielä tänäpäivänä? Eikö niin?

KAISA. Niin.

ASARIAS. No, sittenhän se passaa?

KAISA. Passaa.

ASARIAS. Niin että nyt minä sittenkin sinut saan, oma kulta…?
KAISA. Saadaanhan nähdä.

ASARIAS. Miksi niin: saadaanhan nähdä?

KAISA. Lupaatkos rakastaa minua?

ASARIAS. Lupaanko rakastaa?

KAISA. Niin.

ASARIAS (pannen kätensä ristiin). Myötä- ja vastoinkäymisessä.

KAISA. Niinhän Kaisallekin lupasit.

ASARIAS. Ettäkö niin Kaisallekin lupasin?

KAISA. Niin.

ASARIAS. Se tuli vahingossa luvatuksi.

KAISA. Jos tulee nytkin?

ASARIAS. Ettäkö tulee nytkin? Ei tule enää.

KAISA. Ja vielä purat?

ASARIAS. En pura.

KAISA. Vannotkos?

ASARIAS. Vannon, niin totta kuin tässä hajareisin istun.

KAISA. Teetkös kaikki, mitä käsken.

 ASARIAS. Kaikki teen, mitä käsket. Käske vaikka kaivoon
menemään.

KAISA. Vuota sitten.

ASARIAS. Vuotan, vuotan, vaikka vuoden. (Kaisa tukkii jälleen

pyyhkeellä lasin.) Anni, Anni, hoi! Elähän vielä! Jokos se nyt sen
tukki?! (Nousee ja astuu pari askelta pihaan, kääntyy ja huomaa
Annin portaikolla.) Kah! Lisa, kuulehan! (ANNI nousee, mutta ei ole
kuulevinaan. Asarias huutaa.) Liisa! Tulehan tänne, Liisa! (ANNI ei
ota kuullakseen, vaan pujahtaa sisään.) Mokomakin kuuro!
Kaikenlaisia lastenpiikoja ne ottavatkin.

VILLE (tulee samassa portaikolle, kantaen vasua, jossa on likaisia

lastenvaatteita). Asarias, hoi!

ASARIAS. Hoi?! Hoi?!

VILLE (laskeutuu alas pihaan). Anni lähetti sinulle paljon terveisiä

ja käski menemään rantaan näitä lastenriepuja pesemään.

(Työntää vasua Asariaksen käsiin.)

ASARIAS (kummastellen). Häh?

VILLE. Sanoi sinun mielelläsi tekevän vaikka mitä hänelle.

ASARIAS. Teenhän minä, mitä osaan.

(Ottaa vastahakoisesti käsiinsä vasun.)

VILLE. Osaathan sinä toki tuon!

ASARIAS. Mutta onhan teillä täällä lastenpiika.

 VILLE. Eihän se mitä kerkiä näitä töitä tekemään.

ASARIAS. Kukas ne sitten?

VILLE. Tavallisesti minä.

ASARIAS. Sinä?

VILLE. Minä, minä, tietysti. Mutta sentauttahan se nyt tahtoi ensin

nähdä, pystytkö sinäkin tähän.

ASARIAS (uljaasti). Pystynkö? (Nostaa vasun olkapäälleen.) Kai

minä pystyn siihen, mihin toinenkin mies.

VILLE. No, ala laputtaa rantaan sitten.

ASARIAS. Milloinkas näiden käskettiin olla valmiit?

VILLE. Niin pian kuin vain ehdit. (ASARIAS aivastaa, jolloin vasu
putoaa maahan hänen olkapäältään ja rievut maahan.) Noh? Mikäs
sinulle nyt tuli?

ASARIAS (aivastaa toisen kerran). Kylläpäs niissä hynttyissä onkin

lemu!

VILLE. Ihan kuin parhaissa apilaheinissä! (Kerää Asariaksen

kanssa rievut uudelleen vasuun, jonka nostaa Asariaksen olkapäälle.)
Noin!

ASARIAS. En minä tämäntapaista apilaheinän hajua ole vielä

koskaan nenässäni tuntenut.

VILLE. No, nyt sen tunnet. Mutta elä nyt pudota enää!
 ASARIAS. Ehkäpä sitten tähänkin tottuu. (Lähtee perällepäin.)

VILLE. Tottuu. Kaikkeen sitä tässä maailmassa on totuttava.

ASARIAS (kääntyy). Kuulehan! Onko siellä suopaakin, millä pestä?

VILLE. Kaikki sieltä löytyy. Mene vain!

ASARIAS. No. Hyvästi sitten ja — terveisiä! (Menee kiireesti

perälle.)

VILLE. Hyvästi! Hyvästi! (Viittaa kädellään portaikolle päin.) Saatte

tulla jo! ('ANNI ja KAISA tulevat portaikolle.)

KAISA. Joko hän meni?

ANNI. Ihanko todenperään meni?

VILLE. Meni. Ja sen se teki rakkaus, joka on "suurin näistä

kaikista", kun uskoo ja toivoo.

KAISA (tulee pihaan). No, enpäs olisi uskonut.

ANNI (tulee myös). Ihan minun jo on sääli Asariasta.

KAISA. Minun ei vähääkään.

VILLE. Ja niin oli sokea ja kuuro, ettei huomannut Kaisan hänelle

koko ajan ikkunasta puhuvan.

ANNI. Eikä minuakaan näy tuntevan ollenkaan.

VILLE. Vielä häntä! Tuommoista laihaa ja romuluista! (Naurua.)

KAISA. Antaa hänen nyt sitten tehdä urakkansa loppuun.

 ANNI. Eihän hän siitä iltaankaan valmistu.

VILLE. Ammoin siksi kun rovasti tulee. Minä käyn hänet

hakemassa pois, jahka on vähän aikaa siellä molskutellut.

KAISA. Ei, Ville. Nyt ei auta muu kuin pysyä tosissaan loppuun
asti, kun tämän olen kuullut ja nähnyt.

VILLE. Ihanko todenperään eroon asti?

ANNI. Eihän nyt toki, Kaisa?

KAISA. Rovastiin asti. Tulkoon mikä ryöppy tahansa!

VILLE. Niinkö tahdot?

KAISA. Niin tahdon. Ja sitä puhun äidillekin.

ANNI. Anna olla, Kaisa!

KAISA. Enkä anna.

VILLE. No kuinka vain sitten. Ehkä tuo ei haittaa tulevaisuuden

varalle.

(HETA ja KUSTAAVA tulevat portaikolle.)

KUSTAAVA. Täälläkö te olette kaikki? (Tulee alas pihalle.)

KAISA. Täällä. Tulkaa tekin!

HETA (tulee myös). Entäs Asarias? Missäs hän on?

VILLE (iskien silmää Kaisalle). Meni vähän rantaan. Mikä lie

unhottunut veneeseen.
 KUSTAAVA (Annille). Siellä jo Maiju kuului vähän pirisevän.

ANNI. Minä menen. (Menee sisälle.)

KUSTAAVA. Olisi vähän puitakin tuvassa tarvittu, Ville.

VILLE. Ai, todenperään. Minä kannan heti. (Menee perälle ja

rakennuksen taitse vasemmalle.)

KAISA. Minäkin sitten menen Annia auttamaan. (Yrittää poistua.)

KUSTAAVA (pidättäen). Elähän mene vielä!

HETA. Niin. Sinun kanssasi justiinsa, Kaisa, meidän pitikin saada

puhua.

KAISA. No?

HETA. Kun nyt Kustaavakin on nähnyt, että se Asarias-raukka

sinun tähtesi on ihan hulluksi tulemaisillaan…

KUSTAAVA. Eikä vain ole tulemaisillaan, onkin jo ihan hullu.

KAISA. Jopa te nyt minulle uutisen kerroitte. Olenhan sen jo

itsekin kauan tietänyt.

HETA. Niin, eihän siinä sitten auta muu kuin suostua, Kaisa hyvä,
ihan kaikkeen, mitä se tahtoo.

KUSTAAVA. Niin, ja ellet suostu, niin…

KAISA (Hetalle). Mitä te nyt turhaan intätte! Suostunhan minä,

suostun. Vieläpä vaadinkin eroa. Sillä kuka sitä semmoisen hullun
kanssa yhdessä elämään rupeaa. Olenhan nyt itsekin nähnyt ja
kuullut, kuinka hullu hän on. Niinpä sitten pitäkääkin poikanne
kokonaan ja päästäkää minut hänestä irti ja eroon, niin ettei koskaan
tässä maailmassa yhdyttäisi emmekä toistemme silmien eteenkään
sattuisi.

KUSTAAVA. Ähäs! Siinä sen kuulit.

HETA. Vai sinä nyt sitten itsekin vaadit eroa Asariaksesta?

KAISA. Vaadin ja vaatimalla vaadin, jopa vaatimasta päästyänikin

vaadin.

KUSTAAVA. Sittenhän asia on selvä.

HETA. Tietenkin, Eikä rovastillakaan voi olla mitään sitä vastaan.

Selvähän se on asia.

KAISA. Selvä hyvinkin, kun minä samalla saan irti

naimaosuutenikin.

KUSTAAVA. Kuulitko, Heta, mitä se sanoi?…

HETA. Oho-ho! Vai on sulla vielä semmoinenkin vaatimus?

KAISA. Onpa hyvinkin.

HETA. JO minä nyt jotakin kuulin!

KUSTAAVA. Jo minä todella jotakin kuulin!

KAISA. Kuulitte, minkä kuulitte. Ei suinkaan minua niin vain pellolle

ajeta maata kiertämään?
 HETA (salavihjauksella). Eihän tuo syyttä tapahdu — omienkaan
sanojesi mukaan.

KUSTAAVA (samoin). Niin, niin. Onhan siihen syytä kaikenlaista.

KAISA. On kun on. Mutta mikä syy siinä lopulta toden sanoo,
Asariaksenko vai minun, se saadaan vielä nähdä. Ja tänään vielä,
jahka rovastin puheille päästään. Niin, vielä tänä päivänä.

(Menee topakasti, niin että piha tömisee, sisään.)

HETA (katsoen hänen jälkeensä). Keh-keh, sitä!

KUSTAAVA. Keh-keh, todenperään! On sillä sisua!

HETA. Tuon on sille Ville opettanut.

KUSTAAVA. Niinkö luulet?

HETA. Mistäs se sen olisi saanut?

KUSTAAVA. No, jos se siihen luottaa, niin kuka sen tietää kuinka
sitten käykään.

HETA. Pitäisi asiaa tiedustella siltä Villeltä, niinkö se oikein meinaa.

(VILLE tulee perältä kantaen puutaakkaa tupaan.) Ras, tuossahan se
onkin.

KUSTAAVA. Anna olla! Älä koske siihen asiaan nyt!

HETA. Olkoon! Ehkä on parasta.

KUSTAAVA (Villelle). Kiitoksia, Ville!

 VILLE. Rah, mitä nyt joutavia! (Menee taakkoineen sisään.)

KUSTAAVA. Mutta olisi se hyvä ollut sinulle saada se Kaisa pois ja

toinen miniä sijaan.

HETA. Kuka sitäkään tietää!

KUSTAAVA. Tiedän minä sen kuitenkin, ettei se Raisa sinulle

alunpitäen ollut mieluinen, eihän?

HETA. Jumalan tahto. Mutta eihän se nyt huonokaan ole.

KUSTAAVA. Väkisinhän se tuli kuitenkin, kun ei Asarias silloin

Annia saanut.

HETA. Siksipä se Asarias Annia nyt vielä onnettomuudessaan

muistelee ja omakseen toivoo.

KUSTAAVA. No, kukapa sen tietää, ehkä se toivo vielä toteutuukin,

kuka sen tietää.

VILLE (palaa kiireesti sisältä). Käykää pois sieltä sisään pian!

Asarias näkyy jo tulevan rannasta takaisin.

KUSTAAVA. Tulkoon! Ja parhaaksi tuleekin.

HETA. Niin, Ville, minun täytyy saada puhutella häntä nyt.

VILLE. Hullujako te olette! Hänhän suuttuisi minuun silmittömästi.

HETA. Rauhoittaahan minun pitää poikaparkaani.

KUSTAAVA. Niin, niin, anna meidän jo!

 VILLE. Rauhoittaa? Vielä hän hurjemmaksi vain siitä kävisi.
Minähän
häntä olen koettanut rauhoittaa. (Ajaa Hetan ja Rustaavan sisään.)
Menkää, menkää pian! Muuten meidät tässä vielä riitelemässä
yllättää.
So!

HETA. No, jos niin luulet, niin… Mennään sitten!

KUSTAAVA. Kun ei enää ihmisten näkyvissä saa olla!

(Hän ja Heta rientävät toisiaan tuuppien sisään.)

VILLE (heidän jälkeensä). Minä kyllä kutsun kaikki sitten, jahka

olen hänelle asian selvittänyt. Pysykääkin alallanne siellä siksi!
(Itsekseen.) No, jo tästä koko soppa tuleekin, kun nuokin pääsivät
kauhaa kiertämään! Ei tässä auta muu kuin toimittaa mies makuulle.
(ASARIAS ilmestyy perälle, astuen hyvin väsyneesti.) Rah! Siinäkö
sinä jo olet?

ASARIAS. Eivätkös silmäsi enää erota?

VILLE. Erottaahan sinut, mutta missäs ne sotkut ovat?

ASARIAS. Kuule, Ville! Akkojen töihin minä en rupee.

VILLE. No! Enhän minä siihen pakota. Mutta mitäs se Anni siihen
sanoo?

ASARIAS. Häh! Anniko?

VILLE. Niin, niin. Hänellehän sinä lupasit tehdä kaikki, mitä

käskee.
 ASARIAS. Sano, että olen tällä kertaa niin väsynyt, etten jaksa.
(Heittäytyy rentonaan laudalle.)

VILLE. Keskenkö se pesu sitten sulta jäikin?

ASARIAS. Kesken. Raukaisee niin, että nukun siihen paikkaan.

VILLE. Elä toki siihen! Onhan aitassa vuode, niinkuin sinulle

sanoin.

ASARIAS (nousten). No, minä lähden sinne.

VILLE. Tule! Tule! (Menee aitan puolelle.)

ASARIAS (ikkunaan). Hyvää yötä nyt! Minä menen makaamaan.

Kuuletteko?

VILLE. Kyllä ne kuulivat. Joudu nyt vain!

ASARIAS (lönkyttää pihan poikki). Mikä helkkarin kiire sinulla nyt

on?

VILLE (avaa aitan oven). Kah, että kerkiät nousta siksi kun rovasti
saapuu ja pääset avioeroasi hänelle selittelemään.

ASARIAS. Avioko…?

VILLE. No, niin! Eroasi Kaisasta.

ASARIAS. Kah, kun ihan oli unohtunut koko juttu.

VILLE. Astu sisään nyt vain! (Koettaa tuupata Asariasta aittaan.)

ASARIAS. Maltahan, maitahan!

 VILLE. No, mitä nyt vielä?

ASARIAS. Kuulehan! Eikö siitä Kaisasta ole kuulunut mitään?

VILLE. Mitäs siitä olisi kuulunut?

ASARIAS. Eipäs, näät, lähtenyt perässäkään tulemaan, kun

karkuun läksin.

VILLE. Vähät hän sinusta välittää.

ASARIAS. Niinkö luulet?

VILLE. Siltähän tuo näyttää.

ASARIAS. On se sitten koko juupeli.

VILLE. Iloissaan kai on vielä, että läksit.

ASARIAS. Kah! Enhän minä sille ole mitään pahaa tehnyt.

VILLE. Kaipa kuitenkin, koska noin omatuntosi nuhtelee.

ASARIAS. Eikä nuhtele.

VILLE. Näkeehän sen. On maar sinun häntä jo vähän ikäväkin.

ASARIAS. Ikävä mikä ikävä! Nukuttaa vain vähäsen.

VILLE. Ja näin maata pannessa muistui sitten Kaisakin mieleen,

vai?

ASARIAS (naurahtaen). No, olihan Kaisa välistä rattoisakin. Oikein

naurattaakin, kun sen kanssa olleet kaikki lystit muistaa.
 VILLE. Näetsen! Johan sinä rupeat peräytymään koko jutusta.

ASARIAS. Eikös hänestä sitten enää saa haastellakaan?

VILLE. Haastele, haastele, mutta haastele sitten rovastin kanssa!

Ja unissakin saat haastella, jos tahdot! (Tuuppaa Asariaksen aittaan.)
Mene jo! So!

ASARIAS (aitasta). Elä vain pane lukkoon, Ville! Elä pane lukkoon!

VILLE (sulkien oven). Lähdet vielä karkuun.

ASARIAS (aitasta). Enkä lähde karkuun.

VILLE (lukitsee oven). Kuka sinut tietää, kun tässä jo Kaisasta

puhuit, niin peräytymään vielä lähdet.

ASARIAS (aitasta). Enkä peräydy, en.

VILLE. Lupaatko varmasti, ettet peräydy?

ASARIAS (aitasta). Lupaan, lupaan varmasti.

VILLE (aukaisee oven ja katsoo sisään). Kah, johan sinä olet

pitkälläsi.

ASARIAS (aitasta). Jo, jo.

VILLE. No, nuku sitten rauhassa! Kyllä minä sinut ajoissa herätän.
Unta saat vielä nähdä Kaisastasi, mutta et muuta. (Sulkee jälleen
oven lukkoon.) "Levätköön hän nyt vahvass' rauhass', mutt' me kuin
olemm' tuonen kauhass'…" Meidän pitää olla ihan hiljaa. (On hetken
vaiti, painaa sitten korvansa lukon kohdalle ja kuuntelee kotvan.)
Jopa, todenperään, mies parka nukahti; alkaa jo kuorsata. (Juoksee
pihan poikki portaikolle päin.) Tulkaa nyt! Nyt saatte tulla. (Viittaa
kädellään.)

HETA (kapalolapsi sylissä ilmestyy portaikolle). Tullaan Ja tullaan

uhallammekin. (Laskeutuu pihaan, lasta sylissään sylkytellen.) Missä
se poikaparka on?

KUSTAAVA (tulee perässä portaikolle, toinen kapalolapsi

sylissään). Tullaan. Ei tätä piilosilla oloa enää jaksa. (Laskeutuu
myöskin pihaan, lasta sylissään sylkytellen.) Mutta missäs Asarias
on?

(Portaikolle ilmestyvät myös ANNI ja KAISA, kummallakin

sylissään yksi ensimmäisistä kaksosista.)

VILLE (huitoen heitä takaisin). Joko te nyt tulette — koko roikka!

ANNI (laskeutuu pihaan). Täytyyhän sitä jo.

KAISA (laskeutuu samoin pihaan). Nähköön nyt meidät kaikki

samalla ja kuulkoon…!

HETA, KUSTAAVA, ANNI ja KAISA (yhtaikaa). Mutta missäs Asarias

on?

VILLE (kuiskaten). Tuolla makaa aitassa, — juuri nukkui. Mutta jos

te nyt hänet herätätte, niin piru teidät kaikki perii, sillä hän tulee
ihan raivohulluksi teidät tässä nähdessään.

(HETA, KUSTAAVA, ANNI ja KAISA hyssyttelevät ja

tuudittelevat lapsia koko ajan.)

HETA (kuiskaten). Poikaparka!

 KUSTAAVA (samoin). Levätköön sitten!

ANNI (samoin). Räikistä vaivoistaan!

KAISA (samoin). Kunnes rovastin luo mennään.

VILLE (samoin). Parasta on. Sillä nyt hän tuolla näkee unta, että
piha on täynnä taivaan enkeleitä ja heillä kullakin lapsi sylissään, ja
niiden enkelien joukossa on hänen oma Kaisansa. Niin että menkää
sisään nyt!

HETA, KUSTAAVA, ANNI ja KAISA (astuvat, pihaa kiertäen,

peräkkäin sisään, hyssytellen lapsia ja laulavat kuiskaten). Mennään,
mennään, mennään! Mennään, mennään sisään!

VILLE (käy vielä tunnustelemassa aitan ovea, kuunnellen.) Nukkuu

kuin porsas autuaitten unta. (Aikoo sitten mennä muiden jäljessä
sisään, mutta pysähtyy äkkiä ja katsoo perälle.) Jopas tuolla
rovastikin saapuu! No, nyt sitä saadaan juhla! (Juoksee ylös
portaikolle.)
KOLMAS NÄYTÖS

Vehmasmäen talon tupakamari. Peräseinässä, keskellä, ovi. Oikealla

ikkuna, jonka alaruutujen edessä ikkunavarjostin (joka myös voi olla
ikkunan alapuolta peittämään naulattu vaate) ja toisessa
rikkinäisessä lasissa tukkeena pyyhe. Ikkunan edessä pieni pöytä.
Etualalla säilikkö eli piironki ja sen päällä peili, virsikirja y.m. Säilikön
edessä kiikkutuoli ja pöydän kummallakin puolen sekä peränurkassa
tuoleja. Vasemmassa seinässä ovi pieneen sivuhuoneeseen;
peränurkassa rapattu uuni ja uunin ja sivuhuoneen oven välissä
pesukaappi. Etualalla samalla puolella vierekkäin kaksi sänkyä, jotka
ovat kokoon lykätyt ja joiden vaatteet ovat peitetyt molempien yli
ulottuvalla valkoisella verholla tahi lakanalla.

VILLE (avaten ulkoa peräoven). Rovasti on hyvä ja käy tänne

tupakamariin.

ROVASTI (tulee palttoo päällä, pieni laukku kädessä). Jaaha,

jaaha. Vai nyt sitä sitten on ristittävä taas?

(VILLE ja ANNI seuraavat. Ville auttaa palttoota

rovastin päältä Anni seisoskelee ujona ovensuussa.)

VILLE. Niinhän sitä on…

 (Ripustaa palttoon oven lähellä olevaan naulaan.)

ROVASTI. Sehän on niinkuin olla pitääkin. Luonnon laki ja Jumalan

suoma.

VILLE. Sitähän se lienee.

ROVASTI (istuutuen kiikkutuoliin; Annille.) No! Ja nuori emäntä voi

hyvin?

ANNI. Kiitoksia kysymästä! Hyvinhän minä.

ROVASTI. No, se on hyvä se. Ei sitten hätää mitään.

ANNI. Mutta kuinkas ruustinna jaksaa?… Ei ole mukana tällä

kertaa.

ROVASTI. Kiitoksia, emäntä! Hiljalleen. Siinähän se menee.

Terveisiä käski kaikille sanomaan, mutta ei päässyt tällä kertaa
tulemaan. Joukkoahan sitä on siellä meilläkin ja puuhaa paljon.

VILLE. Arvaahan sen.

ANNI. Niin, — suuressa pappilassa.

ROVASTI. Siellä ovatkin kaikki yhdeksän lasta nyt koolla, suuret ja

pienet, niin että onhan siinä ahertelemista ja huolta.

VILLE. Ja rovasti jaksaa itse saatavillaan käydä?

ROVASTI. Eihän se hiiri makaavan kissan suuhun juokse.

VILLE (naurahtaen). Eipä ei.

 ANNI. Kahvia kai saan tuoda nyt?

ROVASTI. Kiitoksia vain, emäntä hyvä, mutta ei nyt. Syötyä sitten

juon.
Kun on poltetta sydänalassa, niin täytyy jättää vähemmälle.

ANNI. Vai niin? No, kuinka vain sitten. Saadaanhan se vielä

ruokakin.
(Kääntyy ja puikahtaa seuraavan keskustelun alussa huomaamatta
ulos.)

VILLE. Mutta ehkäpä rovasti tahtoisi heittäytyä vähän pitkäkseen,

kun on rattailla tänne rytyytellyt?

ROVASTI (nousten). Vaatisihan se vanhan ruumis vähän sitäkin.

(Ojentelee raajojaan.)

VILLE. On tässä pienessä sivukamarissa sänkysohva valmiina, jos

että niinkuin haluttaisi… (Aukaisee vasemmalle vievää ovea.)

ROVASTI. Kiitoksia, kiitoksia! Siellä kai on sitten vähän vettäkin,

kun on maantien pölyssä hiestynyt?

VILLE. Pitäisi sitä tässä pesulaitteessa olla. (Aukoo pesukaapin

kantta ja ovea.) On. Anni on jo siihen veden ja pyyhkeenkin
toimittanut kastetta varten.

ROVASTI. Kiitos, kiitos! Ketkäs niille kaksosille sitten kummeiksi

tulevat?

VILLE. Oisivathan ne täältäpäin Heikki Rutanen eukkoineen ja

Torsalosta vaimoineen Asarias Pöllänen, entinen isäntäni.
 ROVASTI. Vai Asarias Pöllänen ja hänen Kaisansa?

VILLE. Rovasti näkyy muistavan?

ROVASTI (naurahtaen). Kuinka en häntä muistaisi, Asariasta?

Monta kertaa olen sen naimajutulle perästäpäinkin nauranut.

VILLE. Onhan sillä omat metkunsa toisinaan, Asariaksella.

ROVASTI. No, onko hän nyt tyytyväinen ja onnellinen?

VILLE (hiukan veitikkamaisesti). Ehkäpä se sen itsekin rovastille

sanoo.

ROVASTI (nauraen). Vai niin, vai niin! No, onkos hänen äitinsä
täällä kanssa?

VILLE (kuin edellä). Kyllä. Ja täällä meillä asuu Anninkin äitipuoli,

Kustaava Mansikka, jonka rovasti ehkä myöskin siltä reissulta
muistanee?

ROVASTI. No, kyllä. Hauskoja tuttavuuksia! Hauskoja tuttavuuksia!

Hah-hah-hah-hah! (Vatsaansa pidellen.) Sitten taitaa olla parasta,
että todellakin heittäydyn hiukan levolle ennenkuin puheisiin
ruvetaan, vai mitä arvelee Ville?

VILLE (kuin edellä). Taitaa olla parasta, arvoisa herra rovasti.

ROVASTI (yhä nauraen). No, minä menen, minä menen.

(Menee vasemmalle ja sulkee oven. VILLE seisoo hetkisen

oven kohdalla, kuin miettien, kääntyy sitten ja katsoo
varjostimen takaa ikkunasta pihalle.)
 HETA (aukaisee hiljakseen peräoven, josta kurkistaa sisään, niin
että pää vain näkyy, ja kuiskaa). Ville!

VILLE (kääntyen). Häh?

HETA. Yksinkö olet?

VILLE. Yksin.

HETA (tullen sisään). Missäs rovasti on?

VILLE. Pani juuri vähäksi aikaa maata tuonne sivuhuoneeseen.

HETA. Kuulehan! Kaisaa ei saa laskea rovastin puheille.

VILLE. Miks'ei?

HETA. Kun minä sanon "ei", niin se on "ei".

VILLE. Mitenkäs minä sen estää voin?

HETA. Estää pitää. Muuten se tuo tuhon koko meidän talollemme.

VILLE. Kuinka niin?

HETA. Kuulehan! Sano sinä, joka kaikki tiedät, onko vaimolla

naimaosuus miehensä omaisuuteen?

VILLE. Senhän nyt pässikin tietää, että on.

HETA. Ja kuinka suuri sitten?

VILLE. Puolet ainakin.

 HETA. Herra hyvästi siunaa ja varjele! Sittenhän se vie kumoon
koko talomme sen Asariaksen eron kautta.

VILLE. Eihän se Kaisa vie, — Asariashan se Kaisasta eron tahtoo.

Syynhän tiedätte.

HETA (hätääntyen). Mikä ihme tästä tuleekaan!

VILLE. Ei muu kuin mikä tuleman piti.

HETA (kuin edellä). Ei saa tulla, ei saa tulla! Se on meidän

estettävä mahdilla millä tahansa.

VILLE. Kun ei vain olisi myöhäistä jo.

KAISA (tulee). Ville hoi!

VILLE. Mikä nyt vielä?

KAISA. Menehän katsomaan! Kuulin, kuin Asarias olisi jo aitan

ovea ryskyttänyt, kun panit lukkoon.

VILLE (kuin hätääntyen). Tuliko se pannuksi? No, se oli

vahingossa.
Täytyyhän se sieltä päästää. Nyt on aikakin jo. (Rientää ulos.)

KAISA. Täälläkös tekin?

HETA. Puhu hiljaa, rovasti nukkuu! Yrität sitten, todenperään,

sinäkin hänen puheilleen?

KAISA (puhelu käy koko ajan puoleksi kuiskaten, vaikka kiivaasti).

Kah! Kun on pakotettu.
 HETA. Etkä malta vuottaa?

KAISA. Mitäpä tuo tuosta paranisi?

HETA. Eipä häntä tiedä.

KAISA. Vielä ehkä pahenee, kun siihen syrjäisetkin sotkeutuvat.

HETA. Minuako tarkoitat?

KAISA. Kahdenhan tämän pitäisi olla kauppa.

HETA. Niinpä, kah! Jätäkin sitten sinä asia rovastiin asti viemättä.

KAISA. Vaikka asia on minunkin. Ja sitä sinne juuri Asarias on

viemässä.

HETA. Ehkäpä se sekin sen vielä jättää.

KAISA. Olen minä jo siksi vanha ja viisas, etten niin vain loukkuun
mene. Eteeni katson minäkin.

HETA. Saattaa ehkä käydä pahemmin kuin luuletkaan ja toivot.

KAISA. Huonostipa, näemmä, jo on muutenkin minun käynyt, ettei

enää pahemmasta pelkoa.

HETA. No, en sitten enää varoitakaan, kun et vähemmällä kuule.

KAISA. Olisipa ollut parempi ajoissa toista varoittaa, niin ei olisi

hänenkään tähtensä nyt tarvinnut olla huolissaan.

HETA. Kas, kas! Kovinpa jo olet asiastasi varma.

KAISA. Oikean asian vuoksi ei tarvitse pelätä.

 HETA. Et siis hellitä?

KAISA. En.

HETA. No, syytäkin sitten itseäsi! En puhu enää sanaakaan.

(Pyörähtää ympäri ja aikoo mennä perälle.)

KUSTAAVA (tulee samassa häntä vastaan ovessa). Joko sait hänet

järkiinsä?

HETA. Hss! (Varoittaa kädellään merkiksi, että puhuisi hiljaa.) Vielä

ja mitä! On kuin äksy tamma.

KUSTAAVA (koko ajan myös puolikovaa). Kuulehan nyt, Kaisa!

Annahan kun minäkin sinulle haastan!

KAISA. Turha on enää haastaa teidänkään, jos samaa haastatte

kuin anoppi äsken.

KUSTAAVA. Vai on turha kieltää sinua hulluutta tekemästä?

HETA. Sitähän minäkin.

KAISA. On se sitten omansorttista hulluutta, kun äsken tuossa

pihalla — ei siitä ole kuin puoli tuntia aikaa — minua siihen kehoititte
ja nyt jo siitä kiellätte.

(HETA ja KUSTAAVA katselevat ällistyneinä toisiaan.)

KAISA. Eikö ole totta?

HETA (Kustaavalle). Kukas se kehoitti?

 KUSTAAVA (Hetalle). Niin, kukas se kehoitti?

(Puhelu alkaa vähitellen käydä yhä äänekkäämmäksi, ja

kohtaus päättyy kovaan huutoon.)

HETA. Vielä häntä kysyt!

KUSTAAVA. En suinkaan minä. Sinähän siitä asiasta minulle puhua

aloit?

HETA. Sinähän siihen puutuit neuvoinesi.

KUSTAAVA. Se on helkkarin vale!

HETA. Eikä ole. Sanoihan sen Kaisakin.

KAISA (kuiskaten, varoittaen). Elkää hiidessä huutako!

KUSTAAVA (hiukan hiljempaa). Vai minä?!… Mitäs minulla sen

asian kanssa on tekemistä?

HETA (samoin). Näkyipä olevan. Olisit ennemmin varoittanut kuin

yllyttänyt, kun kerran siihen sekaannuit.

KUSTAAVA (kovempaa). Tuki jo suus'! Syrjäinen olen ja syrjässä

olen pysynyt koko ajan.

HETA. Tuki oma suus', ettei sieltä yhtä mittaa valeita valuisi.

KAISA (kuin edellä). Olkaa, Herran nimessä, hiljemmällä! (Osoittaa

vasemmalle ovelle.)

KUSTAAVA. Kuulkoon ja tulkoon, minulla ei ole mitään pelättävää.

 HETA. Näetsen, juonittelemaanpa sitten vain rupesitkin, senkin
juoruakka.

KUSTAAVA. No, ei tuo nyt kovinkaan minua enää kummastuta,

että Kaisa eroon pyrkii. Ja parasta on, että pyrkii heti!

HETA. Kas sitä! Etkös taaskin yllyttänyt?

KUSTAAVA. Niin teinkin, niinkuin kuulit.

HETA. Ja miksi on parasta? Häh?

KUSTAAVA (toisella jalallaan ruumistaan keikutellen; hiukan

viivytellen vastaustaan). Eipä tuon raukan mahda kovinkaan lysti olla
Heta Pölläsen miniänä.

HETA. Lystimpi ainakin kuin Annin pitää talossaan tuommoista

vaivaishoitolaista kuin Kustaava Mansikka on.

KUSTAAVA (itku kurkussa). Minäkö vaivaishoitolainen?

HETA (samoin). Mikäs muu sitten?

KUSTAAVA. Kyllä minä sinulle näytän, mikä minä olen.

(Yrittää käydä Hetan tukkaan käsiksi.)

KAISA (juosten väliin ja erottaen heitä). Taivaan isä! Mitä te nyt!

(HETA ja KUSTAAVA päästävät kovan itkunmöläkän.)

ROVASTI (paitahihasillaan ja pannen liperiä kaulaansa, aukaisee

oven vasemmalta). Minä tulen, minä tulen heti. (Vetäytyy takaisin.)
 (HETA ja KUSTAAVA vaikenevat äkkiä ja töytäävät perälle.
Samalla aukeaa peräovi, ja heitä vastaan tulevat VILLE ja
ASARIAS huoneeseen. KUSTAAVA pujahtaa tungoksessa ulos,
mutta HETA tulee takaisin sisälle.)

VILLE (tuuppien Asariasta eteenpäin). Tässä minä sen nyt toin.

ASARIAS (unenpöpperössä, hieroen silmiään ja katsellen

ympärilleen).
Mi… mi… mitä tämä on? Mi… mi… missä minä olen?

VILLE. Nukkui kuin pölkky. En tahtonut mitenkään saada hereille.

ASARIAS (hoksaten äkkiä Hetan ja Kaisan). Mitä hiivattia te täällä

teette?

KAISA. Kummeiksi tultiin Villen kutsusta.

VILLE. Niin juuri.

HETA (arasti). Niin, ristiäisiin tultiin — hevosella perässä.

ASARIAS (vihaisesti polkien jalkaansa). Ettekö pääse samaa tietä

kotiin?!

HETA (kuin edellä). Mitä sinä, Asarias nyt? Selviähän toki unestasi!

VILLE. Ole toki vähemmällä!

ASARIAS (Hetalle). Menkää hiiteen, sanon minä.

HETA (peräytyen pelästyksissään). Kah! Menenhän minä, menen!

Herra siunaa ja varjele! (Pujahtaa ulos peräovesta, josta samalla
näkyy KUSTAAVA eteisessä odottelemassa.)
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

textbookfull.com