Programming in Haskell 2nd Edition Graham Hutton download pdf
Programming in Haskell 2nd Edition Graham Hutton download pdf
com
https://textbookfull.com/product/programming-in-haskell-2nd-
edition-graham-hutton/
OR CLICK BUTTON
DOWNLOAD NOW
https://textbookfull.com/product/programming-in-haskell-second-
edition-5th-printing-edition-hutton/
textboxfull.com
https://textbookfull.com/product/thinking-with-types-type-level-
programming-in-haskell-sandy-maguire/
textboxfull.com
https://textbookfull.com/product/haskell-the-ultimate-beginner-s-
guide-to-learn-haskell-programming-step-by-step-1st-edition-claudia-
alves/
textboxfull.com
https://textbookfull.com/product/the-haskell-road-to-logic-maths-and-
programming-kees-doets/
textboxfull.com
Mathematics of Program Construction 13th International
Conference MPC 2019 Porto Portugal October 7 9 2019
Proceedings Graham Hutton
https://textbookfull.com/product/mathematics-of-program-
construction-13th-international-conference-mpc-2019-porto-portugal-
october-7-9-2019-proceedings-graham-hutton/
textboxfull.com
https://textbookfull.com/product/erskine-may-parliamentary-practice-
mark-hutton/
textboxfull.com
https://textbookfull.com/product/equine-clinical-medicine-surgery-and-
reproduction-2nd-edition-graham-munroe/
textboxfull.com
https://textbookfull.com/product/haskell-school-of-music-hudak-p/
textboxfull.com
https://textbookfull.com/product/thinking-functionally-with-haskell-
richard-bird/
textboxfull.com
Programming in Haskell
Second Edition
Haskell is a purely functional language that allows programmers to rapidly develop clear, concise and
correct software. The language has grown in popularity in recent years, both in teaching and in industry.
This book is based on the author’s experience of teaching Haskell for more than 20 years. All concepts
are explained from first principles and no programming experience is required, making this book
accessible to a broad spectrum of readers. While Part I focuses on basic concepts, Part II introduces the
reader to more advanced topics.
This new edition has been extensively updated and expanded to include recent and more advanced
features of Haskell, new examples and exercises, selected solutions, and freely downloadable lecture
slides and code. The presentation is clean and simple, while also being fully compliant with the latest
version of the language, including recent changes concerning applicative, monadic, foldable and
traversable types.
GRAHAM HUTTON is Professor of Computer Science at the University of Nottingham. He has taught
Haskell to thousands of students and received numerous best lecturer awards. Hutton has served as an
editor of the Journal of Functional Programming, chair of the Haskell Symposium and the International
Conference on Functional Programming, vice-chair of the ACM Special Interest Group on Programming
Languages, and he is an ACM Distinguished Scientist.
Programming in Haskell
Second Edition
GRAHAM HUTTON
University of Nottingham
University Printing House, Cambridge CB2 8BS, United Kingdom
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/9781316626221
10.1017/9781316784099
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.
A catalogue record for this publication is available from the British Library
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.
For Annette, Callum and Tom
Contents
Foreword
Preface
2 First steps
2.1 Glasgow Haskell Compiler
2.2 Installing and starting
2.3 Standard prelude
2.4 Function application
2.5 Haskell scripts
2.6 Chapter remarks
2.7 Exercises
5 List comprehensions
5.1 Basic concepts
5.2 Guards
5.3 The zip function
5.4 String comprehensions
5.5 The Caesar cipher
5.6 Chapter remarks
5.7 Exercises
6 Recursive functions
6.1 Basic concepts
6.2 Recursion on lists
6.3 Multiple arguments
6.4 Multiple recursion
6.5 Mutual recursion
6.6 Advice on recursion
6.7 Chapter remarks
6.8 Exercises
7 Higher-order functions
7.1 Basic concepts
7.2 Processing lists
7.3 The foldr function
7.4 The foldl function
7.5 The composition operator
7.6 Binary string transmitter
7.7 Voting algorithms
7.8 Chapter remarks
7.9 Exercises
11 Unbeatable tic-tac-toe
11.1 Introduction
11.2 Basic declarations
11.3 Grid utilities
11.4 Displaying a grid
11.5 Making a move
11.6 Reading a number
11.7 Human vs human
11.8 Game trees
11.9 Pruning the tree
11.10 Minimax algorithm
11.11 Human vs computer
11.12 Chapter remarks
11.13 Exercises
13 Monadic parsing
13.1 What is a parser?
13.2 Parsers as functions
13.3 Basic definitions
13.4 Sequencing parsers
13.5 Making choices
13.6 Derived primitives
13.7 Handling spacing
13.8 Arithmetic expressions
13.9 Calculator
13.10 Chapter remarks
13.11 Exercises
15 Lazy evaluation
15.1 Introduction
15.2 Evaluation strategies
15.3 Termination
15.4 Number of reductions
15.5 Infinite structures
15.6 Modular programming
15.7 Strict application
15.8 Chapter remarks
15.9 Exercises
17 Calculating compilers
17.1 Introduction
17.2 Syntax and semantics
17.3 Adding a stack
17.4 Adding a continuation
17.5 Defunctionalising
17.6 Combining the steps
17.7 Chapter remarks
17.8 Exercises
Bibliography
Index
Foreword
It is nearly a century ago that Alonzo Church introduced the lambda calculus, and over half a century ago
that John McCarthy introduced Lisp, the world’s second oldest programming language and the first
functional language based on the lambda calculus. By now, every major programming language including
JavaScript, C++, Swift, Python, PHP, Visual Basic, Java, ... has support for lambda expressions or
anonymous higher-order functions.
As with any idea that becomes mainstream, inevitably the underlying foundations and principles get
watered down or forgotten. Lisp allowed mutation, yet today many confuse functions as first-class citizens
with immutability. At the same time, other effects such as exceptions, reflection, communication with the
outside world, and concurrency go unmentioned. Adding recursion in the form of feedback-loops to pure
combinational circuits lets us implement mutable state via flip-flops. Similarly, using one effect such as
concurrency or input/output we can simulate other effects such as mutability. John Hughes famously stated
in his classic paper Why Functional Programming Matters that we cannot make a language more
powerful by eliminating features. To that, we add that often we cannot even make a language less
powerful by removing features. In this book, Graham demonstrates convincingly that the true value of
functional programming lies in leveraging first-class functions to achieve compositionality and equational
reasoning. Or in Graham’s own words, “functional programming can be viewed as a style of programming
in which the basic method of computation is the application of functions to arguments”. These functions do
not necessarily have to be pure or statically typed in order to realise the simplicity, elegance, and
conciseness of expression that we get from the functional style.
While you can code like a functional hacker in a plethora of languages, a semantically pure and lazy,
and syntactically lean and terse language such as Haskell is still the best way to learn how to think like a
fundamentalist. Based upon decades of teaching experience, and backed by an impressive stream of
research papers, in this book Graham gently guides us through the whole gambit of key functional
programming concepts such as higher-order functions, recursion, list comprehensions, algebraic datatypes
and pattern matching. The book does not shy away from more advanced concepts. If you are still confused
by the n-th blog post that attempts to explain monads, you are in the right place. Gently starting with the IO
monad, Graham progresses from functors to applicatives using many concrete examples. By the time he
arrives at monads, every reader will feel that they themselves could have come up with the concept of a
monad as a generic pattern for composing functions with effects. The chapter on monadic parsers brings
everything together in a compelling use-case of parsing arithmetic expressions in the implementation of a
simple calculator.
This new edition not only adds many more concrete examples of concepts introduced throughout the
book, it also introduces the novel Haskell concepts of foldable and traversable types. Readers familiar
with object-oriented languages routinely use iterables and visitors to enumerate over all values in a
container, or respectively to traverse complex data structures. Haskell’s higher-kinded type classes allow
for a very concise and abstract treatment of these concepts by means of the Foldable and Traversable
classes. Last but not least, the final chapters of the book give an in-depth overview of lazy evaluation and
equational reasoning to prove and derive programs. The capstone chapter on calculating compilers
especially appeals to me because it touches a topic that has had my keen interest for many decades, ever
since my own PhD thesis on the same topic.
While there are plenty of alternative textbooks on Haskell in particular and functional programming in
general, Graham’s book is unique amongst all of these in that it uses Haskell simply as a tool for thought,
and never attempts to sell Haskell or functional programming as a silver bullet that magically solves all
programming problems. It focuses on elegant and concise expression of intent and thus makes a strong
case of how pure and lazy functional programming is an intelligible medium for efficiently reasoning
about algorithms at a high level of abstraction. The skills you acquire by studying this book will make you
a much better programmer no matter what language you use to actually program in. In the past decade,
using the first edition of this book I have taught many tens of thousands of students how to juggle with
code. With this new edition, I am looking forward to extending this streak for at least another 10 years.
Erik Meijer
Preface
How is it structured?
The book is divided into two parts. Part I introduces the basic concepts of pure programming in Haskell
and is structured around the core features of the language, such as types, functions, list comprehensions,
recursion and higher-order functions. Part II covers impure programming and a range of more advanced
topics, such as monads, parsing, foldable types, lazy evaluation and reasoning about programs. The book
contains many extended programming examples, and each chapter includes suggestions for further reading
and a series of exercises. The appendices provide solutions to selected exercises, and a summary of some
of the most commonly used definitions from the Haskell standard prelude.
Acknowledgements
I am grateful to the University of Nottingham for providing a sabbatical to produce this new edition;
Thorsten Altenkirch, Venanzio Capretta, Henrik Nilsson and other members of the FP lab for our many
enjoyable discussions; Iván Pérez Domínguez for useful comments on a number of chapters; the students
and tutors on all of my Haskell courses for their feedback; Clare Dennison, David Tranah and Abigail
Walkington at CUP for their editorial work; the GHC team for producing such a great compiler; and
finally, Catherine and Ian Hutton for getting me started in computing all those years ago.
Many thanks also to Ki Yung Ahn, Bob Davison, Philip Hölzenspies and Neil Mitchell for providing
detailed comments on the first edition, and to the following for pointing our errors and typos: Paul Brown,
Sergio Queiroz de Medeiros, David Duke, Robert Fabian, Ben Fleis, Robert Furber, Andrew Kish,
Tomoyas Kobayashi, Florian Larysch, Carlos Oroz, Douglas Philips, Bruce Turner, Gregor Ulm, Marco
Valtorta and Kazu Yamamoto. All of these comments have been taken into account when preparing the
new edition.
Graham Hutton
Part I
Basic Concepts
1
Introduction
In this chapter we set the stage for the rest of the book. We start by reviewing the notion of a function, then
introduce the concept of functional programming, summarise the main features of Haskell and its
historical background, and conclude with three small examples that give a taste of Haskell.
1.1 Functions
In Haskell, a function is a mapping that takes one or more arguments and produces a single result, and is
defined using an equation that gives a name for the function, a name for each of its arguments, and a body
that specifies how the result can be calculated in terms of the arguments.
For example, a function double that takes a number x as its argument, and produces the result x + x,
can be defined by the following equation:
double x = x + x
When a function is applied to actual arguments, the result is obtained by substituting these arguments
into the body of the function in place of the argument names. This process may immediately produce a
result that cannot be further simplified, such as a number. More commonly, however, the result will be an
expression containing other function applications, which must then be processed in the same way to
produce the final result.
For example, the result of the application double 3 of the function double to the number 3 can be
determined by the following calculation, in which each step is explained by a short comment in curly
parentheses:
double 3
= { applying double }
3 + 3
= { applying + }
6
Similarly, the result of the nested application double (double 2) in which the function double is
applied twice can be calculated as follows:
double (double 2)
= { applying the inner double }
double (2 + 2)
= { applying + }
double 4
= { applying double }
4 + 4
= { applying + }
8
Alternatively, the same result can also be calculated by starting with the outer application of the function
double rather than the inner:
double (double 2)
= { applying the outer double }
double 2 + double 2
= { applying the first double }
(2 + 2) + double 2
= { applying the first + }
4 + double 2
= { applying double }
4 + (2 + 2)
= { applying the second + }
4 + 4
= { applying + }
8
However, this approach requires two more steps than our original version, because the expression
double 2 is duplicated in the first step and hence simplified twice. In general, the order in which
functions are applied in a calculation does not affect the value of the final result, but it may affect the
number of steps required, and whether the calculation process terminates. These issues are explored in
more detail when we consider how expressions are evaluated in chapter 15.
That is, we first initialise an integer variable total to zero, and then enter a loop that ranges an integer
variable count from 1 to n, adding the current value of the counter to the total each time round the loop.
In the above program, the basic method of computation is changing stored values, in the sense that
executing the program results in a sequence of assignments. For example, the case of n = 5 gives the
following sequence, in which the final value assigned to the variable total is the required sum:
total = 0;
count = 1;
total = 1;
count = 2;
total = 3;
count = 3;
total = 6;
count = 4;
total = 10;
count = 5;
total = 15;
In general, programming languages such as Java in which the basic method of computation is changing
stored values are called imperative languages, because programs in such languages are constructed from
imperative instructions that specify precisely how the computation should proceed.
Now let us consider computing the sum of the numbers between one and n using Haskell. This would
normally be achieved using two library functions, one called [..] that is used to produce the list of
numbers between 1 and n, and the other called sum that is used to produce the sum of this list:
sum [1..n]
In this program, the basic method of computation is applying functions to arguments, in the sense that
executing the program results in a sequence of applications. For example, the case of n = 5 gives the
following sequence, in which the final value in the sequence is the required sum:
sum [1..5]
= { applying [..] }
sum [1,2,3,4,5]
= { applying sum }
1 + 2 + 3 + 4 + 5
= { applying + }
15
Most imperative languages provide some form of support for programming with functions, so the
Haskell program sum [1..n] could be translated into such languages. However, many imperative
languages do not encourage programming in the functional style. For example, many such languages
discourage or prohibit functions from being stored in data structures such as lists, from constructing
intermediate structures such as the list of numbers in the above example, from taking functions as
arguments or producing functions as results, or from being defined in terms of themselves. In contrast,
Haskell imposes no such restrictions on how functions can be used, and provides a range of features to
make programming with functions both simple and powerful.
Summing numbers
Recall the function sum used earlier in this chapter, which produces the sum of a list of numbers. In
Haskell, sum can be defined using two equations:
sum [] = 0
sum (n:ns) = n + sum ns
The first equation states that the sum of the empty list is zero, while the second states that the sum of any
non-empty list comprising a first number n and a remaining list of numbers ns is given by adding n and the
sum of ns. For example, the result of sum [1,2,3] can be calculated as follows:
sum [1,2,3]
= { applying sum }
1 + sum [2,3]
= { applying sum }
1 + (2 + sum [3])
= { applying sum }
1 + (2 + (3 + sum []))
= { applying sum }
1 + (2 + (3 + 0))
= { applying + }
6
Note that even though the function sum is defined in terms of itself and is hence recursive, it does not
loop forever. In particular, each application of sum reduces the length of the argument list by one, until the
list eventually becomes empty, at which point the recursion stops and the additions are performed.
Returning zero as the sum of the empty list is appropriate because zero is the identity for addition. That is,
0 + x = x and x + 0 = x for any number x.
In Haskell, every function has a type that specifies the nature of its arguments and results, which is
automatically inferred from the definition of the function. For example, the function sum defined above has
the following type:
Num a => [a] -> a
This type states that for any type a of numbers, sum is a function that maps a list of such numbers to a
single such number. Haskell supports many different types of numbers, including integers such as 123, and
floating-point numbers such as 3.14159. Hence, for example, sum could be applied to a list of integers, as
in the calculation above, or to a list of floating-point numbers.
Types provide useful information about the nature of functions, but, more importantly, their use allows
many errors in programs to be automatically detected prior to executing the programs themselves. In
particular, for every occurrence of function application in a program, a check is made that the type of the
actual arguments is compatible with the type of the function itself. For example, attempting to apply the
function sum to a list of characters would be reported as an error, because characters are not a type of
numbers.
Sorting values
Now let us consider a more sophisticated function concerning lists, which illustrates a number of other
aspects of Haskell. Suppose that we define a function called qsort by the following two equations:
In this definition, ++ is an operator that appends two lists together; for example, [1,2,3] ++ [4,5] =
[1,2,3,4,5]. In turn, where is a keyword that introduces local definitions, in this case a list smaller
comprising all elements a from the list xs that are less than or equal to x, together with a list larger
comprising all elements b from xs that are greater than x. For example, if x = 3 and xs = [5,1,4,2], then
smaller = [1,2] and larger = [5,4].
What does qsort actually do? First of all, we note that it has no effect on lists with a single element, in
the sense that qsort [x] = [x] for any x. It is easy to verify this property using a simple calculation:
qsort [x]
= { applying qsort }
qsort [] ++ [x] ++ qsort []
= { applying qsort }
[] ++ [x] ++ []
= { applying ++ }
[x]
In turn, we now work through the application of qsort to an example list, using the above property to
simplify the calculation:
qsort [3,5,1,4,2]
= { applying qsort }
qsort [1,2] ++ [3] ++ qsort [5,4]
= { applying qsort }
(qsort [] ++ [1] ++ qsort [2]) ++ [3]
++ (qsort [4] ++ [5] ++ qsort [])
= { applying qsort, above property}
([] ++ [1] ++ [2]) ++ [3] ++ ([4] ++ [5] ++ [])
= { applying ++ }
[1,2] ++ [3] ++ [4,5]
= { applying ++ }
[1,2,3,4,5]
In summary, qsort has sorted the example list into numerical order. More generally, this function
produces a sorted version of any list of numbers. The first equation for qsort states that the empty list is
already sorted, while the second states that any non-empty list can be sorted by inserting the first number
between the two lists that result from sorting the remaining numbers that are smaller and larger than
this number. This method of sorting is called quicksort, and is one of the best such methods known.
The above implementation of quicksort is an excellent example of the power of Haskell, being both
clear and concise. Moreover, the function qsort is also more general than might be expected, being
applicable not just with numbers, but with any type of ordered values. More precisely, the type
qsort :: Ord a => [a] -> [a]
states that, for any type a of ordered values, qsort is a function that maps between lists of such values.
Haskell supports many different types of ordered values, including numbers, single characters such as
’a’, and strings of characters such as "abcde". Hence, for example, the function qsort could also be
used to sort a list of characters, or a list of strings.
Sequencing actions
Our third and final example further emphasises the level of precision and generality that can be achieved
in Haskell. Consider a function called seqn that takes a list of input/output actions, such as reading or
writing a single character, performs each of these actions in sequence, and returns a list of resulting
values. In Haskell, this function can be defined as follows:
These two equations state that if the list of actions is empty we return the empty list of results, otherwise
we perform the first action in the list, then perform the remaining actions, and finally return the list of
results that were produced. For example, the expression seqn [getChar,getChar,getChar] reads
three characters from the keyboard using the action getChar that reads a single character, and returns a
list containing the three characters.
The interesting aspect of the function seqn is its type. One possible type that can inferred from the
above definition is the following:
seqn :: [IO a] -> IO [a]
This type states that seqn maps a list of IO (input/output) actions that produce results of some type a to a
single IO action that produces a list of such results, which captures the high-level behaviour of seqn in a
clear and concise manner. More importantly, however, the type also makes explicit that the function seqn
involves the side effect of performing input/output actions. Using types in this manner to keep a clear
distinction between functions that are pure and those that involve side effects is a central aspect of
Haskell, and brings important benefits in terms of both programming and reasoning.
In fact, the function seqn is more general than it may initially appear. In particular, the manner in which
the function is defined is not specific to the case of input/output actions, but is equally valid for other
forms of effects too. For example, it can also be used to sequence actions that may change stored values,
fail to succeed, write to a log file, and so on. This flexibility is captured in Haskell by means of the
following more general type:
seqn :: Monad m => [m a] -> m [a]
That is, for any monadic type m, of which IO is just one example, seqn maps a list of actions of type m a
into a single action that returns a list of values of type a. Being able to define generic functions such as
seqn that can be used with different kinds of effects is a key feature of Haskell.
1.6 Chapter remarks
The Haskell Report is freely available from http://www.haskell.org. More detailed historical
accounts of the development of functional languages in general, and Haskell in particular, are given in [1]
and [2].
1.7 Exercises
1. Give another possible calculation for the result of double (double 2).
In this chapter we take our first proper steps with Haskell. We start by introducing the GHC system and
the standard prelude, then explain the notation for function application, develop our first Haskell script,
and conclude by discussing a number of syntactic conventions concerning scripts.
The GHCi prompt > indicates that the system is now waiting for the user to enter an expression to be
evaluated. For example, it can be used as a calculator to evaluate simple numeric expressions:
> 2+3*4
14
> (2+3)*4
20
As a useful reference guide, appendix B presents some of the most commonly used definitions from the
standard prelude.
Moreover, function application has higher priority than all other operators in the language. For example, f
a + b means (f a) + b rather than f (a + b). The following table gives a few further examples to
illustrate the differences between function application in mathematics and in Haskell:
Note that parentheses are still required in the Haskell expression f (g x) above, because f g x on its
own would be interpreted as the application of the function f to two arguments g and x, whereas the
intention is that f is applied to one argument, namely the result of applying the function g to an argument x.
A similar remark holds for the expression f x (g y).
My first script
When developing a Haskell script, it is useful to keep two windows open, one running an editor for the
script, and the other running GHCi. As an example, suppose that we start a text editor and type in the
following two function definitions, and save the script to a file called test.hs:
double x = x + x
In turn, suppose that we leave the editor open, and in another window start up the GHCi system and
instruct it to load the new script:
$ ghci test.hs
Now both the standard prelude and the script test.hs are loaded, and functions from both can be freely
used. For example:
> quadruple 10
40
Now suppose that we leave GHCi open, return to the editor, add the following two function definitions
to those already typed in, and resave the file:
factorial n = product [1..n]
We could also have defined average ns = div (sum ns) (length ns), but writing div between its
two arguments is more natural. In general, any function with two arguments can be written between its
arguments by enclosing the name of the function in single back quotes ‘ ‘.
GHCi does not automatically reload scripts when they are modified, so a reload command must be
executed before the new definitions can be used:
> :reload
> factorial 10
3628800
For reference, the table in figure 2.1 summarises the meaning of some of the most commonly used
GHCi commands. Note that any command can be abbreviated by its first character. For example, :load
can be abbreviated by :l. The command :set editor is used to set the text editor that is used by the
system. For example, if you wish to use vim you would enter :set editor vim. The command :type is
explained in more detail in the next chapter.
Exploring the Variety of Random
Documents with Different Content
1876 1877 1878
männ- weib- männ- weib- männ- weib-
Im Alter von
liche liche liche liche liche liche
Personen Personen Personen
unter 15 Jahren 3 0·2 0·7 0·3 0·8 0·3
über 15–20 „ 13 5 15 7 16 7
„ 20–25 „ 29 9 32 8 31 9
„ 25–30 „ 23 6 28 6 31 7
„ 30–40 „ 33 6 32 7 37 8
„ 40–50 „ 46 10 50 10 55 10
„ 50–60 „ 58 12 75 9 73 13
„ 60–70 „ 72 13 75 14 82 13
„ 70–80 „ 72 13 67 13 75 19
80 und darüber 66 14 46 12 65 6
Was die W a h l d e r To d e s a r t anbelangt, Wahl der Todesart.
so lehrt die Erfahrung, dass gewisse
Selbstmordarten gegenüber anderen ungemein prävaliren. Dies
ergibt sich z. B. aus der Selbstmordstatistik für das Königreich
Preussen pro 1869.[271]
Procentverhältniss
Zusam-
To d e s a r t Männer Weiber Zusam-
men Männer Weiber
men
Erhängen 1641 266 1907 63·8 43·3 59·8
Ertränken 425 262 687 16·5 42·7 21·6
Erschiessen 320 1 321 32·4 0·1 10·1
Schnitt und Stich 89 22 111 3·5 3·6 3·5
Vergiften 61 52 113 2·4 8·5 3·5
Andere Mittel 37 11 48 1·4 1·8 1·5
Summe 2573 614 3187 100 100 100
Von den im Jahre 1871 in Frankreich Statistik der
constatirten Selbstmorden[272] geschahen Selbstmordarten.
1991 durch Erhängen, 1278 durch
Ertränken, 591 durch Erschiessen, 215 durch Kohlendunst, 152
durch Schnitt und Stich, 143 durch Herabstürzen von Monumenten
und anderen Höhen, 70 durch Gift, 50 durch diverse andere Mittel.
Von den 1871 in Böhmen vorgekommenen 551 Selbstmördern haben
sich 316 erhängt, 107 erschossen, 49 ertränkt, 53 vergiftet, 3
erstochen, 14 haben sich durch Halsschnitt, 3 durch Aderöffnen, 3
durch Ueberfahren auf der Eisenbahn, 1 durch Ersticken und 2 durch
Sprung in einen Schacht das Leben genommen.
In Wien entfielen nach S e d l a c z e k von der Summe der
Selbstmorde in Procenten:
Schnitt-
Er- Er- Herab- Er- Andere
Im Quinquennium Gift u. Stich-
hängen schiessen stürzen trinken Mittel
wunden
1854–1858 48·0 14·2 6·7 16·1 9·2 5·0 0·8
1859–1863 43·6 16·6 9·3 13·3 9·5 5·2 2·5
1864–1868 35·2 30·1 9·9 7·8 7·8 7·8 1·4
1869–1873 29·2 31·2 16·3 8·3 6·8 7·1 1·1
1874–1878 38·0 26·9 20·2 7·0 5·7 6·6 0·6
Bezüglich des Geschlechtes entfielen von der Gesammtsumme:
von von
Männern Frauen
in Procenten
Auf den Selbstmord durch Erhängen 40·5 20·4
„ „ „ „ Gift 18·8 47·5
„ „ „ „ Erschiessen 17·9 3·2
Schnitt- u.
„ „ „ „ 9·9 7·3
Stichwunden
„ „ „ „ Herabstürzen 5·4 13·1
„ „ „ „ Ertränken 6·3 7·3
„ „ „ auf andere Weise 1·2 1·2
Was andere grosse Städte betrifft, so tödteten sich Personen in
Berlin
Prag London Paris
(1869–1872
(1874– (1860– (1874–
und 1874–
1876) 1878) 1878)
1876)
Eine solche That kann nicht gut ohne Widerstand von Seite der
angegriffenen Person geschehen, welcher wieder das Zurückbleiben
von Spuren derselben erwarten lässt.
Da in einem solchen Falle die angegriffene Person instinctiv dem
Angreifer in die Arme, beziehungsweise in das Messer fällt, so
können Schnittwunden an den Händen, insbesondere an der
Innenfläche der Finger oder Hohlhände als Zeichen geleisteter
Gegenwehr zurückbleiben, deren Befund, da er bei einem
Selbstmorde kaum vorkommt, für sich allein sofort die Natur des
Falles in’s Klare stellt.[280] Wir begegnen dann in der Regel auch am
Halse mehreren Schnittwunden und deren Lage (in einem unserer
Fälle auch im Nacken) und ungleichmässige Richtung kann ebenfalls
die Einwirkung fremder Hand errathen lassen.
Wir hatten Gelegenheit, zwei solche Fälle zu beobachten. Der erste Fall betraf
ein 29jähriges Freudenmädchen, welches eines Abends blutend und halb
bewusstlos in einem öffentlichen Garten gefunden wurde. Bei der Untersuchung
im Spitale fand sich in der vorderen Halsgegend eine 4½ Zoll lange Schnittwunde,
die links unter dem Ohre begann und schief über den Kehlkopf zum Innenrande
des rechten Kopfnickers zog und blos die Brustbein-Zungenbeinmuskeln
blosslegte; dann unter dem rechten Unterkieferwinkel eine 1 Zoll lange, bis in den
Pharynx dringende, stark blutende Stichwunde, ferner zwischen Zungenbein und
Kehlkopf eine 1½ Zoll lange, blos die Haut durchtrennende Schnittwunde und
endlich an beiden Händen zahlreiche, schief über die Innenseite der Finger
hinwegziehende oberflächliche Schnittwunden. Dass hier ein Mordversuch vorlag,
war klar, und die Verletzte gab auch an, von einem ihr ganz Unbekannten
unmittelbar nach dem Coitus ohne alle Ursache auf die erwähnte Weise verletzt
worden zu sein und blieb auch bei dieser Aussage, obgleich die sonderbaren
Umstände des Falles keinen Zweifel darüber übrig liessen, dass ihr der Thäter
durchaus nicht fremd gewesen war. Die Heilung erfolgte. Die Person, welche
bereits früher Zeichen der Geistesstörung dargeboten hatte, verfiel später in
ausgesprochene Geisteskrankheit.
In einem zweiten Falle wurde eine rüstige 45jährige Frau in ihrer Wohnung von
einem Manne überfallen und ermordet. Es fand sich eine 10 Cm. lange, bis in den
Wirbelsäule-Arteriencanal dringende horizontale Schnittwunde an der rechten
Halsseite, welche die Vena jugularis int. und den Vagus durchtrennt, die Carotis
aber blos angeschnitten hatte; ferner eine Schnittwunde, die vom linken
Unterkieferwinkel schräg nach rechts und unten über das Ligam. conoideum
verlief, dieses eröffnend, dann eine nach unten abgeschrägte 5 Cm. lange
Schnittwunde, entlang dem rechten Unterkiefer bis auf den Knochen dringend und
weiter je eine kleine scharfrandige lappige Ablösung der obersten Hautschichten
an beiden Unterkiefern. Die Kuppe des linken Zeigefingers war bis auf den
Knochen vollständig und in einer Ebene schief abgekappt und in der linken
Handfläche befand sich eine geradlinige, blos die Haut durchdringende
Schnittwunde, welche vom unteren Theile des Ulnarrandes schief gegen die
Wurzel des linken Zeigefingers verlief, so dass kein Zweifel darüber bestehen
konnte, dass dieselbe, ebenso wie die Abkappung der Kuppe des linken
Zeigefingers, durch das Greifen gegen das Messer des Thäters entstanden war. —
Aehnliche Fälle werden von Ta y l o r (l. c. I, pag. 492) beschrieben und abgebildet.
Selbstmord durch D u r c h s c h n e i d u n g d e r
Durchschneidung der
Adern in den Gelenksbeugen,
Gelenksbeugen.
insbesondere in den Ellenbogen- und
Handgelenken, ist keineswegs selten. Am häufigsten betreffen die
Schnitte die linke obere Extremität und sind dort auch am tiefsten.
Das nicht seltene Vorkommen von Schnittwunden an beiden Armen
beweist, dass die Betreffenden durch eine solche
Aderdurchschneidung die Fähigkeit, ein Messer zu fassen und zu
halten, beziehungsweise Schnitte zu führen, in der Regel nicht
verlieren, was sich daraus erklärt, dass meist nur die Sehnen des
oberflächlichen Fingerbeugers durchschnitten oder noch häufiger nur
angeschnitten werden, die übrige Musculatur aber unverletzt bleibt,
wobei ihre geschütztere Lage und insbesondere die oberflächliche
Lage der Knochen und Gefässe eine Rolle spielt. Nur ausnahmsweise
sind es noch andere oberflächlich gelegene Arterien, die der
Selbstmörder durchschneidet. So obducirten wir die Leiche eines
Arztes, der sich im Bade die Arterien in beiden Hand- und
Ellenbeugen, aber auch beiderseits, und zwar mehrmals, die stark
rigiden geschlängelten Art. temporales durchschnitten hatte, und in
letzter Zeit kam hier ein Fall vor, wo bei einer Frau ausser Schnitten
in beiden Ellen- und Handbeugen auch ein Schnitt unter jeder
Mamma und ein weiterer über dem inneren linken Fussknöchel
gefunden wurde. Am seltensten werden die Schnitte gegen die
Kniekehlen gerichtet. Wir haben erst zwei solche Fälle gesehen,
einmal bei einer Frau, die sich eine grosse Zahl leichter Schnitte in
beiden Kniekehlen beigebracht, dann Hiebe mit einer Hacke gegen
den Vorderkopf versetzt hatte und ein zweitesmal bei einer Frau, wo
sich zahlreiche Schnitte an beiden Innenflächen der Kniegelenke
fanden, gegen dort befindliche Varicositäten gerichtet waren und
zwei der Varixknoten eröffnet hatten. Relativ häufig begegnet man
an einem und demselben Individuum sowohl Schnitten am Halse als
an den oberen Extremitäten, in welchem Falle diese meist später
beigebracht worden sind als jene, und ein solcher Befund ist
selbstverständlich in der Regel für sich genügend, um den
Selbstmord klarzustellen, da wohl nur bei besonderem Raffinement
des Thäters daran zu denken wäre, dass er einer von ihm durch
Halsdurchschneiden getödteten Person noch Schnittwunden in den
Gelenksbeugen beigebracht hätte, um der Sache den Anstrich eines
Selbstmordes zu geben.
Doch ist die Möglichkeit, dass ein Mord durch Durchschneidung
der Gelenksbeugen verübt werden könne, nicht unbedingt
ausgeschlossen, wie ein in Prag vorgekommener Fall beweist, in
welchem ein Vater vier seiner Kinder dadurch umbrachte, dass er
ihnen theils den Hals, theils die Gelenksbeugen, darunter auch die
Kniekehlen, durchschnitt, worauf er sich selbst durch
Halsabschneiden das Leben nahm.
Die Schnitte laufen in der Regel entlang der betreffenden
Gelenksbeugen. Doch haben wir bei einer Frau, die sich in einem
von Innen versperrten Raum durch Leuchtgas getödtet hatte, ausser
mehreren queren, mit einem bei der Leiche gefundenen Rasirmesser
gemachten seichten Hautschnitten an der Innenfläche des linken
Handgelenkes auch eine grosse Zahl paralleler, bis 6 Cm. langer,
dicht bei einander stehender seichter Schnitte an der Innenfläche
desselben Vorderarmes gefunden, die den Sehnen der Beuger der
mittleren Finger entlang verliefen.
Die Möglichkeit, dass eine Wunde, wie sie sonst beim Selbstmord durch Schnitt
in einer Gelenksbeuge vorkommt, auch zufällig erzeugt werden kann, ist nicht
ausgeschlossen. So fanden wir bei einem Mann, der in schwer berauschtem
Zustande in eine Glasthüre hineingefallen und verblutet in seinem Zimmer
gefunden worden war, eine schief verlaufende lange Wunde im inneren Antheil der
rechten Ellenbeuge, welche die Vena basilica durchschnitten hatte. Die Wunde
unterschied sich nicht wesentlich von einer solchen, wie sie beim Selbstmord
entsteht, und der Fall wurde anfangs wirklich für einen solchen gehalten.
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.
textbookfull.com