Introducing ReScript: Functional Programming for

Web Applications 1st Edition Danny Yang install

download

https://ebookmeta.com/product/introducing-rescript-functional-
programming-for-web-applications-1st-edition-danny-yang/

Download more ebook from https://ebookmeta.com

We believe these products will be a great fit for you. Click
the link to download now, or visit ebookmeta.com
to discover even more!

Learn ClojureScript Functional programming for the web

1st Edition Andrew Meredith

https://ebookmeta.com/product/learn-clojurescript-functional-
programming-for-the-web-1st-edition-andrew-meredith/

Introducing Functional Programming Using C#: Leveraging

a New Perspective for OOP Developers 1st Edition
Vaskaran Sarcar

https://ebookmeta.com/product/introducing-functional-programming-
using-c-leveraging-a-new-perspective-for-oop-developers-1st-
edition-vaskaran-sarcar/

Functional Programming For Dummies 1st Edition John

Paul Mueller

https://ebookmeta.com/product/functional-programming-for-
dummies-1st-edition-john-paul-mueller/

Artificial Intelligence Basics: A Non-Technical

Introduction 1st Edition Tom Taulli

https://ebookmeta.com/product/artificial-intelligence-basics-a-
non-technical-introduction-1st-edition-tom-taulli/
Graphene and its Derivatives Volume 2 Water Wastewater
Treatment and Other Environmental Applications
Kaustubha Mohanty

https://ebookmeta.com/product/graphene-and-its-derivatives-
volume-2-water-wastewater-treatment-and-other-environmental-
applications-kaustubha-mohanty/

Linux Hardening in Hostile Networks Server Security

from TLS to TOR Kyle Rankin

https://ebookmeta.com/product/linux-hardening-in-hostile-
networks-server-security-from-tls-to-tor-kyle-rankin/

Who Goes to School Margaret Hillert

https://ebookmeta.com/product/who-goes-to-school-margaret-
hillert/

Consumers and Food Understanding and Shaping Consumer

Behaviour 1st Edition Professor Marian Garcia Martinez

https://ebookmeta.com/product/consumers-and-food-understanding-
and-shaping-consumer-behaviour-1st-edition-professor-marian-
garcia-martinez/

Peril on the Page. 1st Edition Margaret Loudon.

https://ebookmeta.com/product/peril-on-the-page-1st-edition-
margaret-loudon/
Against the Clock Dark Tide Mysteries and Thrillers 8
1st Edition Mark Allan Gunnells Shane Nelson Brandon
Ford

https://ebookmeta.com/product/against-the-clock-dark-tide-
mysteries-and-thrillers-8-1st-edition-mark-allan-gunnells-shane-
nelson-brandon-ford/
Danny Yang

Introducing ReScript
Functional Programming for Web Applications
Danny Yang
Mountain View, CA, USA

ISBN 978-1-4842-8887-0 e-ISBN 978-1-4842-8888-7

https://doi.org/10.1007/978-1-4842-8888-7

© Danny Yang 2023

This work is subject to copyright. All rights are solely and exclusively
licensed by the Publisher, whether the whole or part of the material is
concerned, specifically the rights of translation, reprinting, reuse of
illustrations, recitation, broadcasting, reproduction on microfilms or in
any other physical way, and transmission or information storage and
retrieval, electronic adaptation, computer software, or by similar or
dissimilar methodology now known or hereafter developed.

The use of general descriptive names, registered names, trademarks,

service marks, etc. in this publication does not imply, even in the
absence of a specific statement, that such names are exempt from the
relevant protective laws and regulations and therefore free for general
use.

The publisher, the authors, and the editors are safe to assume that the
advice and information in this book are believed to be true and accurate
at the date of publication. Neither the publisher nor the authors or the
editors give a warranty, expressed or implied, with respect to the
material contained herein or for any errors or omissions that may have
been made. The publisher remains neutral with regard to jurisdictional
claims in published maps and institutional affiliations.

This Apress imprint is published by the registered company APress

Media, LLC, part of Springer Nature.
The registered company address is: 1 New York Plaza, New York, NY
10004, U.S.A.
Introduction
Why Learn ReScript?
JavaScript is vital to the modern web ecosystem. It’s used in the front
end to implement websites and other user interfaces, and used in the
back end to implement servers for websites and APIs.
Part of JavaScript’s ubiquity is due to its ease of use. JavaScript is
dynamic and flexible, making it easy for people to pick up. However,
this strength becomes a weakness when working on large web
applications with multiple developers – the only way to know that
JavaScript code works correctly is to actually run it, and it’s relatively
easy to make mistakes when programming in JavaScript.
What if there was a way to detect bugs in JavaScript before running
the code, or prevent many classes of bugs altogether? What if there was
a language that was concise and elegant that made it easy for
programmers to write complex web applications and hard for
programmers to make mistakes?
Enter ReScript.
ReScript is a language designed for writing web applications. It
brings a lot to the table: static typechecking, a strong type system, and
powerful language features that will change the way you program.
Here’s a glimpse of some of the features that make ReScript a great
language:
Static typechecking – Catch bugs in your code without having to run
it: undefined values, missing cases, incorrect types, and more.
Sound type system – ReScript programs that pass typechecking
cannot have runtime type errors.
Type inference – ReScript automatically infers types based on how
variables are used, allowing you to enjoy the benefits of type safety
without having to annotate every variable and function.
Immutability – Peace of mind while you program with variables and
data structures that cannot be unexpectedly modified under your
nose.
Algebraic data types and pattern matching – Cleanly define and
elegantly manipulate complex data.
 First-class bindings for React – Write React elements and JSX
directly inside ReScript files.
There are a number of other languages and tools that offer static
typechecking for web applications, but ReScript has several key
advantages over its competitors. As an example, let’s look at the
benefits ReScript has compared with another popular JavaScript
alternative, TypeScript:
ReScript is safer – Unlike ReScript’s battle-tested and sound type
system, TypeScript’s type system is unsound, so it is still possible to
have runtime type errors in a valid TypeScript program.
ReScript is faster – ReScript’s compiler is much faster than
TypeScript’s compiler, allowing for a smoother development
experience when working in large code bases.
ReScript is more concise – ReScript’s excellent type inference
means that programmers do not have to write as many type
annotations in ReScript programs compared to TypeScript programs.
Although ReScript is a relative newcomer to the web ecosystem, it’s
actually based on technology that has been battle-tested for years
before ReScript even existed. ReScript itself has proven successful as
well. Most notably, Facebook used it to build the web interface for
Messenger – a product used by hundreds of millions of people – with a
code base containing thousands of files.

History of ReScript
The lineage of ReScript can ultimately be traced back to the ML family
of languages originating from the 1960s. In particular, ReScript is
directly based on OCaml, a general-purpose programming language
that was developed in the 1980s and used today for systems
programming in academia and industry.
In 2015, Jordan Walke, the creator of the React web framework,
developed a toolchain and alternative syntax for OCaml called Reason.
Reason was designed to bridge the gap between the web and OCaml
ecosystems – it could be compiled into both native machine code and
JavaScript, allowing web developers to take advantage of OCaml’s
features. Static typechecking and OCaml’s sound type system
eliminated many common bugs in JavaScript code, and OCaml’s
immutability and functional style was a great fit for React.
Reason was compiled to JavaScript using a compiler called
BuckleScript, which was developed at Bloomberg around the same time
Reason was being created at Facebook.
Around 2020, the BuckleScript project created a new language
based on Reason that could only be compiled to JavaScript using the
BuckleScript compiler, and so ReScript was born.
ReScript has the following key differences from its predecessors:
ReScript has different syntax and features. While it looks and feels
more like JavaScript, ReScript is still based on the battle-tested
compiler and type system as Reason and OCaml, so it has the same
type safety benefits as its predecessors.
ReScript can only be compiled to JavaScript. By dropping support
for native compilation, ReScript has a simpler toolchain and standard
library, along with a feature set better suited for web development.
This makes ReScript easier for newcomers to learn and allows for
smoother integration with other web technologies.

ReScript and the Web Ecosystem

Like some other statically typed languages in the web ecosystem,
ReScript code is transpiled to JavaScript. This means that ReScript code
doesn’t directly run in the browser or on the server. Instead, the
ReScript compiler checks that the code is valid and generates JavaScript
files, which can then be imported and used like any handwritten
JavaScript file.
Being able to run in any environment that supports JavaScript
allows ReScript to be used for full-stack web development, from client-
side code that runs in the browser to server-side code that runs in
Node.js.
Since ReScript code is exactly the same as JavaScript code when it
runs, ReScript programs can easily import and use JavaScript libraries,
while JavaScript programs can call ReScript functions as easily as they
can call other JavaScript functions.
Why Learn Functional Programming?
Functional programming is a paradigm of programming that focuses on
the application and composition of functions.
In functional languages, functions are first class and can be used like
any other value (bound to variables, passed as arguments, or returned
from other functions). Complex programs are written by composing
multiple smaller functions that apply transformations to data. This can
be contrasted with the imperative and object-oriented style of many
popular languages, where programs look more like a series of
commands that read and update memory. It’s important to know that
most languages are not purely in one category or the other; many
languages fall somewhere in the middle of this spectrum, and features
from functional languages are slowly being adopted by other languages.
For example, ReScript is more functional but it also has imperative
features like loops, while JavaScript is more imperative but it also has
first-class functions.
Programming in a functional style has many benefits – programs are
cleaner and more concise, and logic is more declarative making it easier
to trace the flow of data through a program. The ability to compose
functions together and write functions that accept other functions as
arguments (higher-order functions) makes functional languages very
flexible, and the greater emphasis on immutability and purity makes it
easier to understand, write, and test programs.
As a disclaimer, I’m not some functional programming purist here to
convince you that functional programming is the best way to solve
every problem. Instead, I view functional programming as a useful tool
in a programmer’s tool belt, albeit a tool that not enough people know
about or know how to use.
Unlike many other functional programming books, the explanations
in this book are designed to be accessible to those without a formal
background in computer science. I do not expect readers to have
experience with statically typed languages or functional programming
concepts.

About This Book

This book is written for anyone who is interested in learning ReScript
or wants to learn the basics of functional programming using ReScript.
The book is structured as an overview of ReScript’s features,
building up from the basics to eventually cover complex data types,
pattern matching, modules, and finally writing a minimal web
application using ReScript.
Along the way, you will learn functional programming concepts like
higher-order functions, immutability, and purity, which will help you
think about and write software differently, even when you are not using
ReScript.
Here’s what this book will cover:
Chapter1 – Language basics: expressions, binding, and control flow
Chapter2 – Functions: higher-order programming, recursion, and
purity
Chapter3 – Composite data types, pattern matching, and error
handling
Chapter4 – Records and objects
Chapter5 – Lists and arrays: map, filter, and reduce
Chapter6 – Collections: sets, maps, stacks, and queues
Chapter7 – Modular programming: modules and functors
Chapter8 – JavaScript integrations: bindings, dealing with JSON, and
more

Installing ReScript
ReScript projects are set up just like modern JavaScript projects, except
we have an extra development dependency on the rescript package.
Before we begin, make sure you have Node.js v10 or higher, and
npm. To check the version of Node.js you have, run node -v in your
terminal. If you don’t have Node.js installed, you can find installation
instructions at https://nodejs.org.
Once you’ve confirmed that you have the right version of Node.js
installed, create a new directory for your project, and run npm
install rescript@10 to install v10 of ReScript.
There will be a package.json file with the following contents
inside the project’s root directory. Add the following scripts to it:
{
...

"scripts": {
"build": "rescript",
"start": "rescript build -w"
}
}
The scripts we added in package.json are used to run the
ReScript compiler to compile our ReScript to JavaScript.
npm run build will compile all the ReScript files in the project.
npm run start will start a process that watches the project and
automatically recompiles whenever anything changes.
Next, create a bsconfig.json file inside the same directory, with
the following contents:

{
"name": "your-project-name",
"sources": [
{
"dir": "src",
"subdirs": true
}
],
"package-specs": [
{
"module": "commonjs",
"in-source": true
}
],
"suffix": ".bs.js",
"bs-dependencies": []
}

The dir field specifies which directory ReScript source files are
located, in this case under the folder src. For every ReScript file
Foo.res under src, the compiler will output a JavaScript file named
Foo.bs.js in the same location as the original source.
Now we’re ready to write some ReScript!

First ReScript Program

Source files in ReScript have the extension .res. We can write a simple
Hello World program by creating a file at src/HelloWorld.res with
the following contents:

Js.log("hello, world")

ReScript is a compiled language – this means that the ReScript files

that we write are not being run directly by the browser or Node.js. The
compiler checks to make sure our ReScript code is valid – syntax is
correct, function calls and values are the right types, etc. – and then it
compiles the ReScript files into JavaScript. The browser or Node.js will
run the JavaScript the same way they would for JavaScript we wrote by
hand.
Run the compiler using npm run build. You will see the
compiled output in src/HelloWorld.bs.js, which will have the
following contents:

console.log("hello, world");

You can run the JavaScript file using node

src/HelloWorld.bs.js to print “hello, world” to the terminal.
Since ReScript compiles to JavaScript, it can be used for both client
and server applications in a variety of environments – your browser,
Node.js, etc. For the purposes of this book, we will be executing
ReScript programs in Node.js.
As you read through the examples in the book, I encourage you to
copy the examples into your code editor or the ReScript playground at
https://rescript-lang.org/try so that you can compile and
run the programs yourself. As you experiment with ReScript for
yourself, make sure to inspect the compiled JavaScript output of your
ReScript programs to get a deeper understanding of how ReScript
works under the hood. You’ll find that the generated JavaScript code is
quite readable!
Any source code or other supplementary material referenced by the
author in this book is available to readers on GitHub
(https://github.com/Apress). For more detailed information, please
visit http://www.apress.com/source-code.
Table of Contents
Chapter 1:​ReScript Basics
Expressions, Values, and Side Effects
Compile Time and Runtime
Types, Typechecking, and Type Inference
Primitive Types and Operators
Integer and Float
Boolean
String
Unit
Printing and Debugging
Bindings
Mutation and Refs
Blocks
Block Scoping
Conditionals
Switches
Loops
Putting It All Together
Final Thoughts
Chapter 2:​Functions
Defining and Using Functions
Type Annotations
Using Standard Library Functions and Opening Modules
Higher-Order Functions
Piping
 Labeled and Optional Parameters
Currying and Partial Application
Polymorphic Functions
Pure Functions
Ignoring Return Values
Recursion
Syntax
How to Use Recursion
Final Thoughts
Chapter 3:​Composite Data Types
Tuples
Creating Tuples
Accessing Tuples
Pattern Matching with Tuples
Variants
Declaring and Constructing Variants
Pattern Matching with Variants
Exhaustiveness
Complex Patterns
Variants with Data
Recursive Data Types
Options
Pattern Matching Options
Exceptions and Error Handling
Raising Exceptions
Catching Exceptions
 Custom Exceptions
Another Way to Handle Errors:​Result
Result in Action
Defining Errors for Results
Composing Results
Final Thoughts
Chapter 4:​Records and Objects
Records
Declaring and Creating Records
Nominal Typing
Accessing Record Fields
Updating Records
Mutable Fields
Optional Fields
Destructuring Records
Pattern Matching with Records
Records and Variants
Printing Records
Records and JSON
Objects
Declaring and Creating Objects
Accessing Object Fields
Structural Typing
Mutating Objects
Printing Objects
Objects and JSON
 Objects vs.​Records
Chapter 5:​Lists and Arrays
Arrays
Array Standard Library
Note on Accessing Arrays
Higher-Order Functions for Arrays
Map
Filter
Reduce
Composing Higher-Order Functions
Higher-Order Functions in Action
Generalizing Higher-Order Functions
Lists
Building a List
Immutability and Lists
Pattern Matching with List
Higher-Order Functions with Lists
Drawbacks of Lists
Use Cases for Immutable Collections
Lists vs.​Arrays
Final Thoughts
Chapter 6:​Collections
Immutable Collections
Immutable Sets
Immutable Maps
Using Collections:​Luggage Example Revisited
 Advanced Topic:​Generic Collections
Mutable Collections
Mutable Stack
Mutable Queue
Mutable Set and Mutable Map
Hash Set and Hash Map
Advanced Topic:​Generic Hash Set/​Hash Map Keys
Dict
Which Collection Should I Use?​
Chapter 7:​Modules
Files as Modules
Defining Modules
Using Modules
Opening Modules
Destructuring a Module
Module Examples
Module Signatures
Interface Files
Defining Module Signatures
Functors
Defining and Using Functors
Extending Modules
Functors in the Standard Library
Final Thoughts
Chapter 8:​JavaScript Interoperability​
Calling JavaScript from ReScript
 Embedding Raw JavaScript in ReScript Files
Calling ReScript from JavaScript
Exporting Values from ReScript
Using ReScript Modules from JavaScript
Shared Data Types
Integers
Functions
Options
Other Data Types
Immutable Data Structures
Variants
Polymorphic Variants
Working with Null
Working with Exceptions
Catching ReScript Exceptions in JavaScript
Catching JavaScript Exceptions in ReScript
Working with JSON
Option 1:​Binding Without Types
Option 2:​Binding With Types
Option 3:​With Validation
Putting It All Together:​Simple ReScript Web App
Version 1:​Handwritten Bindings
Version 2:​Using Imported Bindings
Final Thoughts
Index
About the Author
Danny Yang
is a professional software engineer at Meta working on infrastructure
for WhatsApp. He has previously worked on Facebook Messenger,
including the web interface which was written in ReScript. His technical
interests include functional programming, compilers, and data
visualization, which he writes about on his blog at
www.yangdanny97.github.io.
About the Technical Reviewer
German Gonzalez-Morris
is a software architect/engineer working with C/C++, Java, and
different application containers, in particular with WebLogic Server. He
has developed various applications using JEE, Spring, and Python. His
areas of expertise also include OOP, Java/JEE, Python, design patterns,
algorithms, Spring Core/MVC/security, and microservices. German has
worked with performance messaging, RESTful API, and transactional
systems. For more information about him, visits
www.linkedin.com/in/german-gonzalez-morris.
© The Author(s), under exclusive license to APress Media, LLC, part of Springer
Nature 2023
D. Yang, Introducing ReScript
https://doi.org/10.1007/978-1-4842-8888-7_1

1. ReScript Basics
Danny Yang1

(1) Mountain View, CA, USA

In this chapter, we’ll dive right into the basic concepts of ReScript:
expressions, values, control flow, and binding. At the end of the chapter,
we’ll use those concepts in a simple command-line program.

Expressions, Values, and Side Effects

Expressions are the fundamental building block of ReScript programs.
In this section, we will be going over basic expressions in ReScript and
their semantics – their meaning. Just like we can learn the English
language by studying the meaning of words and sentences, we can
learn ReScript by studying the meaning of expressions.
In general, we will think about semantics like this: Evaluating an
expression performs some computation and yields a single result. The
result is a value, or something that cannot be evaluated any further –
for example, the expression 2 + 3 evaluates to 5. Additionally, the
evaluation might produce any number of side effects, or changes that
can be observed outside of the function – for example, evaluating an
expression can mutate an array, print something to the console, or
throw an exception.
In other languages, computation can be modeled as both
expressions and statements, where expressions yield a value when
evaluated and statements do not. In ReScript, there is no such thing as
statements, and every expression will yield a value if evaluated
successfully.

Compile Time and Runtime

To differentiate between things that happen when the ReScript code is
compiled and when the resulting JavaScript code is actually run, we’ll
introduce the terms compile time and runtime.
Again using 2 + 3 as an example:
At compile time, the ReScript compiler checks that 2 and 3 are valid
numbers and can be added together. Then, it outputs JavaScript code,
which in this simple case is also 2 + 3.
At runtime, the JavaScript code actually runs and 2 + 3 is evaluated
to 5.
The code snippets in this book will sometimes be followed by the
expected output of the snippet. Outputs at compile time will be labeled
as “Compiler output,” and outputs at runtime will be labeled as
“Console output.”

Types, Typechecking, and Type Inference

Just like how values in JavaScript have types like number, object, and
boolean, expressions and values in ReScript also have types. In
JavaScript, types are not very strict, and values may be interpreted as
different types depending on the context they are being used in. In
contrast, types in ReScript are more strict.
In a compile-time process called static typechecking, the compiler
checks that the types of expressions and functions in our program are
consistent with each other, allowing us to catch potential bugs without
needing to run the program.
To help the typechecker, the programmer can write down what type
each variable or function is supposed to be – this is called a type
annotation. Unlike other languages with static typechecking, type
annotations in ReScript are usually optional, thanks to a feature called
type inference which automatically detects the type of expressions or
functions based on how they are used.
 Whether or not a programmer chooses to annotate types is a trade-
off between clarity and conciseness – type annotations take time to
write, but they can help make the code easier for other people to read.
In this book, you’ll learn the names of types and how to write type
annotations, but not every example will be fully annotated.

Primitive Types and Operators

Integer and Float
Unlike JavaScript which only has a single type for numbers (number),
there are two types of numbers in ReScript: integers and floats (int
and float).
Integers in ReScript are limited to 32 bits, while floats in ReScript
are identical to JavaScript numbers.
They have different sets of arithmetic operators:
Int operators – +, -, *, /
Float operators – +., -., *., /., **
ReScript’s type system is strict, so integer arithmetic operators can
only be used on two integers, and float arithmetic operators can only be
used on two floats.
Integers may be converted to floats using float() or
Belt.Int.toFloat(); the opposite conversion can be done using
int_of_float() or Belt.Int.fromFloat().
Additionally, there are a few operations that are done using
functions instead of operators:
Js.Math.pow_int(x, y) is the equivalent of ** for integers
mod(x, y) remainder/modulo for integers
land(x, y) bitwise logical AND for integers
lor(x, y) bitwise logical OR for integers
lxor(x, y) bitwise logical XOR for integers
lnot(x) bitwise logical NOT for integers
lsl(x, y) left shift for integers
lsr(x, y) logical right shift for integers
asr(x, y) arithmetic right shift for integers
 Here are some examples of int and float arithmetic operators and
their equivalents in JavaScript:

ReScript JavaScript
1+1 1+1

1.0 +. 1.0 1.0 + 1.0

1.0 +. float(1) 1.0 + 1

2.0 ** 3.0 Math.pow(2.0, 3.0)

float(2) ** float(3) Math.pow(2, 3)

Other standard library functions for ints and floats are found in the
Belt.Int, Belt.Float, Js.Int, Js.Float, and Js.Math
modules. The latter contains many useful utilities like random
numbers, rounding, trigonometry, and more.
Integers are convenient to use when representing small numbers in
ReScript programs – they support more operations and their operators
feel more natural. However, we should always use floats to represent
very large whole numbers (such as unix timestamps) – using integer
operations on those numbers will truncate them to 32 bits!

Boolean
The boolean values true and false in ReScript are exactly the same
as booleans in JavaScript. Unlike in JavaScript, there is no such thing as
interpreting non-boolean values like numbers or strings as “truthy” and
“falsy” in ReScript – the only possible values for the bool type are
true and false. Furthermore, only boolean values may be passed to
conditionals and boolean operators, like while, if, &&, ||, etc.
Here are some common boolean operators:
Logical AND, OR, NOT: &&, ||, !
Comparison operators: >, <, >=, <=
Structural equality: ==, !=
Referential equality: ===, !==
Structural equality is a deep comparison of the values of nested
objects – two objects are structurally equal if they have the same fields
and the values of all the corresponding fields are structurally equal, and
two arrays are structurally equal if they have the same number
elements and the corresponding elements are structurally equal.
On the other hand, referential equality evaluates to true if both
sides are actually the same object.
For example:
{ "a": 1 } == { "a": 1 } evaluates to true.
{ "a": 1 } === { "a": 1 } evaluates to false.
[1, 1] == [1, 1] evaluates to true.
[1, 1] === [1, 1] evaluates to false.
x == x evaluates to true.
x === x evaluates to true.
Note that equality operators can only be used on two values that are
the same type; for example, the expression 1 == "2" is not allowed
and will result in the following typechecker error:

This has type: string

Somewhere wanted: int

String
String literals in ReScript are written with double quotes and may span
multiple lines. Strings can be concatenated using the ++ operator.
To convert other primitive values to strings, use the toString
functions in the standard library – for example, Js.Int.toString,
Js.Float.toString, etc. Here is an example of string concatenation
and conversion:

"I am " ++ Js.Int.toString(5) ++ " years old"

Here is an example of slicing a string using the standard library:

// this expression evaluates to "34"

Js.String2.slice("12345", ~from=2, ~to_=4)

ReScript supports string interpolation, although with the restriction

that interpolated expressions must all be strings. The string
concatenation example implemented using interpolation would look
like this:

`I am ${Js.Int.toString(5)} years old`

The standard library functions for strings are found in the
Js.String2 module – for the most part, these functions are exactly
the same as the JavaScript function with the same name.
In JavaScript, we might trim and split a string like this:

let s = " 1,2,3,4,5 "

let s2 = s.trim().split(",")

In ReScript, we can do the same using functions in Js.String2

(don’t worry about the arrow syntax for now, that will be explained in
the next chapter):

let s = " 1,2,3,4,5 "

let s2 = s->Js.String2.trim->Js.String2.split(",")

Unit
ReScript has a type called unit that only has one possible value, the
unit value. Unit is the name of the type, AND it is the name of the single
possible value of that type.
Just like how the two possible values for the boolean type (true and
false) can be written with the literals true and false, the single
possible value for the unit type is written with the literal ().
In JavaScript, calling a function that does not return any values and
assigning the result to a variable will make the variable equal
undefined. In ReScript, the result is modeled as the unit value.
Since the ReScript compiler compiles () to undefined, the unit
value is undefined at run time.
When the computation of an expression does not yield a useful
value, we can have it yield a unit value, and the entire expression will
have the unit type. This is common when we are primarily evaluating
an expression for its side effects.
 One example of this is the console.log function (called Js.log
in ReScript) – calling it returns a value of type unit and has the side
effect of printing to the console. Any time we would want to write a
function that doesn’t return a value in JavaScript, the ReScript
equivalent will return unit. Another example is while-loops or for-
loops. Since loops do not return a value in ReScript, they evaluate to
unit.

Printing and Debugging

ReScript allows us to call JavaScript’s console.log via the Js.log
function. This is useful for printing values and debugging our programs,
and the examples in this book will make heavy use of it.
Unlike in JavaScript where console.log takes a variable number
of arguments, ReScript’s logging functions take in a fixed number of
arguments. There are several different variants that we call depending
on how many arguments we want to log, but they all compile to
console.log.
Here are some examples:
Js.log("hello")
Js.log2("hello", "world") – This can be used to log two
values; additionally, log3 and log4 can be used to log three and
four things, respectively. Each argument can have a different type.
Js.logMany(["hello", "world"]) – This can be called with
an array to log many values at once, but each argument in the array
must be the same type.

Bindings
Bindings in ReScript allow us to associate values with names so that
they can be referenced later. They are like variable declarations in other
languages, but we don’t call them variables in ReScript because the
value can’t be changed (more on that later).
Let bindings in ReScript look similar to variable let declarations in
JavaScript. Names must start with lowercase letters:
let x = 1
let y = 2
let z = x + y
Types may be added to a binding, but they are not required. If a type
is added, the compiler checks to make sure that the value on the right
side matches the declared type. If the type is not added, then the
binding is whatever type the compiler infers the right side to have:

let w: unit = ()
let x: int = 1
let y: bool = true
let z: string = "hello"

In JavaScript, a let declaration can be updated with a new value, but

we cannot declare another variable with the same name in the same
scope. In ReScript, this is the exact opposite – we cannot update the
binding with a new value, but we can create another binding with the
same name in the same scope.
ReScript’s bindings are immutable, meaning that their values
cannot be updated, but they can be shadowed. Shadowing means
declaring a binding with the same name as an existing one – all later
usages of the name within that scope will point to the new declaration:

let x = 1
let x = 2

Shadowed bindings do not need to be the same type as other

bindings of the same name, because they are an entirely separate
declaration:

let x: int = 1
let x: string = "hello"

It’s very important to emphasize that shadowing a binding is NOT

the same as mutating a variable. Bindings are immutable, and
shadowed bindings are in fact compiled to entirely different variables
in JavaScript.
ReScript JavaScript
let x = Js.Math.random_int(0, var x = Js_math.random_int(0, 5);
5) Js.log(x) console.log(x);

let x = Js.Math.random_int(0, var x$1 = Js_math.random_int(0, 5);

5) Js.log(x) console.log(x$1);
let x = Js.Math.random_int(0, var x$2 = Js_math.random_int(0, 5);
5) Js.log(x) console.log(x$2);

Mutation and Refs

Although bindings are immutable by default, we can wrap values in a
ref, allowing them to be updated without creating a new binding.
To create a ref, just wrap an expression with ref(). The expression
will be evaluated and the result will be stored in the ref.
The ref can be bound to a name just like any other value, as shown
in the following example. The type of a ref holding a value of type 'a is
ref<'a>:

let x: ref<int> = ref(0)

Compiler output:

var x = {
contents: 0
};

To access the contents of a ref, use .contents:

let x: ref<int> = ref(0)

Js.log(x.contents)

Compiler output:

var x = {
contents: 0
};
console.log(x.contents);
 Console output:

To mutate the contents of a ref, use the := operator:

let x: ref<int> = ref(0)

x := x.contents + 1
Js.log(x.contents)

Compiler output:

var x = {
contents: 0
};
x.contents = x.contents + 1 | 0;
console.log(x.contents);

Console output:

As seen in the compiled JavaScript outputs earlier, refs are

essentially JavaScript objects with a single contents property. Be
careful not to overuse refs – if we write a program that passes around a
ref and mutates it in a bunch of different places, it will be difficult to
track those mutations and may lead to bugs.
In general, mutation should be regarded as a feature that should be
used sparingly and intentionally. In this way ReScript differs from some
languages you may be used to: immutable bindings are the default and
choosing to use mutation needs to be an explicit decision made by the
programmer. However, there are some cases where mutation makes
sense, such as when we want to write imperative loops.

Blocks
Multiple expressions can be grouped into a block, where they will be
evaluated in sequence. The result of evaluating the whole block is the
value of the last expression. Blocks are delimited by curly braces, and
the expressions within can be separated by newlines or semicolons.
Blocks must contain at least one expression or binding, and every
expression in a block except for the last one must evaluate to unit.
This expression block has type unit and evaluates to unit:

{
Js.log(1); Js.log(2); Js.log(3)
}

This expression block has type int and evaluates to 3:

{
Js.log("hello")
3
}

Blocks may be used as expressions or nested in other blocks. In this

example, the right-hand side of the binding is a block. Evaluating the
block will print “hello” and “world” and yield the final value 3, which is
what gets bound to x:

let x = {
Js.log("hello")
{
Js.log("world")
}
3
}
Js.log(x)

Console output:

Unused bindings, like those that are at the end of a block, evaluate
to unit:
let x: unit = {
let blah = 3
}

Block Scoping
Bindings are local to each block.
This example prints 3, because x is only bound to the value 4 inside
that block. It is also a good showcase of immutable bindings – the value
of x is not updated by the new binding in the nested scope, only
shadowed:

let x = 3
{
let x = 4
}
Js.log(x)

Console output:

Here’s an example which fails to compile, since the binding for y

does not exist outside of the nested scope:

let x = {
let y = Js.Math.random_int(0, 5)
y
}
let z = y

Compiler output:

The value y can't be found

Conditionals
If-expressions in ReScript do not behave like if-statements in JavaScript.
Instead, they are like ternaries – each branch is an expression and the
entire if-expression evaluates to the value of the branch corresponding
with the condition.
The semantics are pretty straightforward: if the condition evaluates
to true, then only the expression in the first branch is evaluated, and if
the condition evaluates to false, only the else branch is evaluated.
Here’s an example of if-expressions in ReScript. They compile to
ternaries in JavaScript.

ReScript JavaScript
let x = if y > 4 {
1
} else { var x = y > 4 ? 1 : 2;
2
}

If-expressions support else if syntax, which gets compiled into

nested ternaries.

ReScript JavaScript
let x = if y > 4 {
1
} else if y > 5 { var x = y > 4 ? 1 : (
2 y > 5 ? 2 : 3
} else { );
3
}

The expression in each branch of an if-expression must be the same

type. Additionally, an expression must be provided for each branch,
although we can omit the else branch entirely. If the else branch is
not provided, the entire if-expression evaluates to unit, and every other
branch must also evaluate to unit.
ReScript JavaScript
let x = if y > 4 {
() var x = (y > 4, undefined);
}

Switches
Switches in ReScript are very different from switches in JavaScript or
most other languages, to such an extent that I would say they are
similar in name only.
Although on the surface they both let us match some expression
against a number of cases and provide nice features like exhaustiveness
checking, there are a number of major differences that make ReScript’s
switches behave differently from switches in other languages:
Like conditionals, ReScript’s switches are also expressions and will
return a single value when evaluated.
There is no fall-through in the body of each case, exactly one case will
be matched, and the matching case’s body will be evaluated and
returned without evaluating any more cases.
ReScript’s switches can be used on complex data types.
Cases do not have to match on literal values; they can express more
complex conditions.
The last two points are very important – ReScript’s switches
support a powerful feature called pattern matching. Instead of only
being able to match primitive types against literal values, conditions
can be expressed as patterns, allowing cases to match complex
conditions on compound data types like tuples, lists, records, etc.
As you learn about more data types in ReScript, you’ll also learn
how to leverage pattern matching to work with them. For now, let’s see
how switches can be used on the simple data types we just covered.
When used for simple data types like integers, ReScript’s switches
can be used similarly to JavaScript’s switches. The basic syntax for a
switch is outlined in the following example. Each case begins with a
pipe |, then the value or pattern that we want to match against, then an
arrow =>, and finally the expression that we want to evaluate and
return if that case matches.
A case that is just an underscore _ is a default or wildcard which
matches everything. Cases are evaluated in order, so it’s common to see
a wildcard case at the bottom, just like we would use a default in
JavaScript switch statements:

let x = Js.Math.random_int(0, 5)
switch x {
| 0 => Js.log("zero")
| 1 => Js.log("one")
| _ => Js.log("some other number")
}

The preceding switch statement would be analogous to the

following in JavaScript. Since ReScript’s switch does not have fall-
through cases, they can be used like JavaScript switch statements with a
break at the end of each case:

switch x {
case 0:
console.log("zero");
break;
case 1:
console.log("one");
break;
default:
console.log("some other number");
}

Conditions can fall through, allowing you to use the same body and
return the same value for multiple cases:

let x = Js.Math.random_int(0, 5)
switch x {
| 0 | 1 => Js.log("zero or one")
| _ => Js.log("some other number")
}
The equivalent in JavaScript would be:

switch x {
case 0:
case 1:
console.log("zero or one");
break;
default:
console.log("some other number");
}

Like conditionals, switches in ReScript are expressions and can be

used like any other expression. For example, their result can be bound
to a variable:

let x = Js.Math.random_int(0, 5)
let y = switch x {
| 0 | 1 => true
| _ => false
}

The JavaScript equivalent would be:

var y;
switch x {
case 0:
case 1:
y = true;
break;
default:
y = false;
}

Patterns can also be used like bindings. When we use a name

instead of a literal in a pattern, it creates a binding with that name in
the body of the case:
let x = Js.Math.random_int(0, 5)
switch x {
| y => Js.log(y)
}
Be careful that the binding in the case does not accidentally shadow
another binding. For example, this switch statement that tries to check
if x and y are equal is incorrect:

let x = Js.Math.random_int(0, 5)
let y = Js.Math.random_int(0, 5)
switch x {
| y => Js.log("x == y")
| _ => Js.log("x != y")
}

It outputs the following warnings:

unused variable y.

this match case is unused.

This is because the first case is the equivalent of adding the let y
= x binding, thereby shadowing the binding for y instead of comparing
against the value of y. Therefore, the first case is always hit, not just
when x equals y.
The previous incorrect snippet is equivalent to the following:

let x = Js.Math.random_int(0, 5)
let y = Js.Math.random_int(0, 5)
switch x {
| _ => {
let y = x
Js.log("x == y")
}
}

Let’s go over how we would correctly write the switch from the
previous example.
 If we want to match against a condition that is not a literal value, we
cannot include the value in the pattern directly. Instead, we can specify
more complex conditions using the when clause in a case:

let x = Js.Math.random_int(0, 5)
let y = Js.Math.random_int(0, 5)
switch x {
| x when x == y => Js.log("x == y")
| _ => Js.log("x != y")
}

We can also check for conditions that are not simple equality, which
is not possible using a switch in JavaScript:

let x = Js.Math.random_int(0, 5)
let y = Js.Math.random_int(0, 5)
switch x {
| x when x > y => Js.log("x > y")
| _ => Js.log("x <= y")
}

The preceding condition is equivalent to the following conditional:

if x > y {
Js.log("x > y")
} else {
Js.log("x <= y")
}

Loops
Loops in ReScript have different syntax to loops in JavaScript, but they
have similar semantics. The body of each loop is an expression that
must evaluate to unit, and the entire loop is also an expression that
evaluates to unit.
For-loops in ReScript iterate between a start value and end value
(both bounds are inclusive). We can specify whether to increment or
decrement by using to or downto between the two bounds.
 This is an implementation of fizz-buzz counting up to 100 in
ReScript:

for i in 1 to 100 {
if mod(i, 15) == 0 {
Js.log("fizz buzz")
} else if mod(i, 5) == 0 {
Js.log("buzz")
} else if mod(i, 3) == 0 {
Js.log("fizz")
} else {
Js.log(i)
}
}

This one will do fizz-buzz in reverse order by counting down from

100:

for i in 100 downto 1 {

if mod(i, 15) == 0 {
Js.log("fizz buzz")
} else if mod(i, 5) == 0 {
Js.log("buzz")
} else if mod(i, 3) == 0 {
Js.log("fizz")
} else {
Js.log(i)
}
}

ReScript also has while-loops, but they differ a bit from JavaScript’s
while-loops, thanks to immutable bindings.
For example, the following loop will run forever, because the value
of x is never updated (the binding is shadowed inside the loop body):

let x = 5
while x > 0 {
let x = x - 1
}
Mutation must be done explicitly using a ref or other mutable data
type, as seen in the following example which features a loop that does
terminate:

let x = ref(5)
while x.contents > 0 {
x := x.contents - 1
}

There is no keyword to break/continue/return inside a for-loop in

ReScript, but we can break out of a while-loop by updating a mutable
condition:

let stop = ref(false)

let x = ref(5)

while !stop.contents && x.contents > 0 {

if Js.Math.random() > 0.3 {
stop := true
} else {
Js.log("Still running")
x := x.contents - 1
}
}

This is equivalent to the following in JavaScript:

var x = 5;
while x > 0 {
if (Math.random() > 0.3) {
break;
} else {
console.log("Still running");
x = x - 1;
}
}
 This all might make ReScript’s while-loops feel clunky and
cumbersome compared to other languages you’re used to, and some of
this is because loops don’t fit that well into the style of programming
that ReScript encourages.
Functional programming generally seeks to reduce side effects and
mutation, while loops require mutation and are evaluated purely for
their side effects since they do not yield a value. ReScript makes a
practical compromise here, allowing loops but requiring mutation to be
explicit. Imperative loops do have a place in ReScript, but they are less
important here than in other languages.
Some of the problems that we would use for-loops and while-loops
to solve in JavaScript can be solved in ReScript by using recursion or
higher-order functions, which you will learn about in a later chapter.

Putting It All Together

To put together some of the concepts you’ve learned in this chapter,
let’s build a simple program that takes in a year from the command line
and returns whether or not it is a leap year.
To read command-line arguments from Node.js, we would normally
use process.argv. In ReScript, we can create an external binding to
access the global process variable like this:

// src/CommandLine.res

@val external process : 'a = "process"

Js.log(`Hello, ${process["argv"][2]}`)

Console output:

> node src/CommandLine.bs.js Danny

Hello, Danny

For our leap year program, we want to interpret the command-line

argument as an integer. Arguments are represented as strings by
default, but we can convert the input to an integer using the standard
library:
// src/LeapYear.res

@val external process: 'a = "process"

let input = process["argv"][2]

let year = input->Belt.Int.fromString-
>Belt.Option.getExn
Next, we’ll use a conditional expression to determine whether the
year is a leap year or not:

let isLeapYear = if mod(year, 400) == 0 {

true
} else if mod(year, 100) == 0 {
false
} else if mod(year, 4) == 0 {
true
} else {
false
}

Finally, we’ll print the result back to the console using string
interpolation to keep things clean:

if isLeapYear {
Js.log(`${input} is a leap year`)
} else {
Js.log(`${input} is not a leap year`)
}

The complete program looks like this:

// src/LeapYear.res

@val external process: 'a = "process"

let input = process["argv"][2]

let year = input->Belt.Int.fromString-
>Belt.Option.getExn
let isLeapYear = if mod(year, 400) == 0 {
true
} else if mod(year, 100) == 0 {
false
} else if mod(year, 4) == 0 {
true
} else {
false
}

if isLeapYear {
Js.log(`${input} is a leap year`)
} else {
Js.log(`${input} is not a leap year`)
}
Run it and see the outputs for yourself:

> node src/LeapYear.bs.js 2004

2004 is a leap year

> node src/LeapYear.bs.js 2003

2003 is not a leap year

Final Thoughts
This chapter gives just a little taste of what ReScript offers: static typing
with type inference and features that support functional programming,
packaged with JavaScript-like syntax.
For readers with a JavaScript background, ReScript programs
shouldn’t look too different from JavaScript programs. In particular,
JavaScript code that doesn’t involve objects or classes should look
almost identical to the equivalent in ReScript. There are semantic
differences between ReScript and JavaScript that might take a while to
get used to, but rest assured that this language does not force you to
program in a certain way.
Although ReScript has its roots in functional programming and this
book will introduce you to functional programming using ReScript,
you’ll find that you can still use ReScript to write programs that look
and feel like JavaScript. ReScript has imperative features that you
probably know and love (such as loops, arrays, and objects) while
offering many nice features that JavaScript does not have, like null
safety and pattern matching.
As you progress through this book, you’ll learn more about
functional programming and how to effectively use features found in
ReScript to make your programs clean, concise, and bug-free.
In the examples from this chapter, we’ve already used some
functions from ReScript’s standard library without getting into too
much detail about how they work. In the upcoming chapter, we’ll dive
deeper into how to define and use functions in ReScript.
Discovering Diverse Content Through
Random Scribd Documents
jusqu’au bout cette exigence de la destinée. A quelles fins? Ils ne le
savaient ni ne cherchaient à le savoir ...
—Siméon,—dit Picrate,—puisque je l’aimais, pourquoi l’ai-je
tuée?...
Il attendait une réponse. Mais Siméon se tut. Cette parole tomba
dans le silence où ils étaient, comme une pierre dans une eau
profonde; le silence en fut strié de frémissantes ondes qui
s’espacèrent, s’élargirent, et enfin moururent.
—Siméon,—reprit Picrate,—je l’aimais trop pour ne pas la tuer!...
Et, dans le silence encore ému de ses lamentations stridentes, il
jeta ces cris, coup sur coup:
—Voilà pourquoi je l’ai tuée: je l’aimais trop!...
Et puis:
—Ah! Siméon! dis-moi pourquoi on tue parce qu’on aime!
Et puis:
—Pourquoi la haine et l’amour ont-ils pareil effet?
Siméon s’obstinait à ne pas répondre, comme si Picrate ne parlait
pas à lui, et seulement proférait, en clameurs farouches, sa
désolation. Ainsi éclate en vacarmes vains l’ardeur des nuits d’orage,
appels perdus et qui ne font que propager au loin leur frénésie.
Mais Picrate continuait:
—Après que je l’eus tuée, après que je sus qu’elle était morte,
j’éprouvai, Siméon, une sorte de joie telle qu’en donne la certitude
de posséder une femme ... Ah! quelle femme!... Désirée, convoitée
et qui se refusait ... Une sorte de joie voluptueuse et orgueilleuse,
comme d’un triomphe des sens, où l’on engage tout son être et qui
paraissait impossible!... Tourments, rages cruelles; et puis
l’indéfectible certitude!
Siméon dit:
—C’est cela: c’est cela justement. Il y a dans la mort une
certitude; tout l’attrait de la mort est là!... Une bizarre certitude,—
rudimentaire, en somme: la simple négation des hasards que la vie
comporte. Enfantillage, mais si spontané, si naturel et analogue au
reste des gamineries humaines! La vie a mille et mille inconvénients:
on la supprime, c’est le plus commode remède. Il vous vient à l’idée
tout de suite; on n’a pas à se tracasser la cervelle pour le trouver.
Les bambins qui cassent leurs joujoux l’ont inventé. Gribouille aussi
... Ah! Gribouille, Gribouille, l’essentiel Gribouille!...
»Voici deux beaux amants. Ah! comme ils s’aiment et quelles
parfaites délices ils goûtent à communier d’âme et de corps!
L’ivresse merveilleuse de leurs pâmoisons les gagne et les exalte et
les éveille à de nouveaux désirs. Chose fragile, leur amour! Il y a les
malignités du sort, les aléas du lendemain; il y a surtout cette
faiblesse lamentable de nos cœurs,—nos cœurs inconstants et
pusillanimes qui sont vite au bout de leurs voluptés ... Les beaux
amants ne veulent pas que leur ferveur décline, et, quand ils ont
atteint la félicité suprême, ils ne rêvent que de n’en point déchoir.
Faute d’oser prétendre à des joies plus magnifiques encore, ils ne
réclament que d’éterniser cette minute glorieuse.
»Éterniser, éterniser,—et la minute passe. Éterniser quelque
chose d’humain! C’est le paradoxal souhait des beaux amants. Rien
ne m’est plus, si la minute passe. Plus ne m’est rien, si passe la
minute!... Romance, aubade, sérénade.
»Oui, oui, la courtoisie des troubadours. Et mieux: l’instinct
profond de l’être. L’extase d’amour est momentanée; plaisir d’amour
ne dure qu’un instant. Mais il s’agit bien d’autre chose: la
perpétuation de l’espèce, comme disent ces darwiniens; disons: la
prolongation de l’individu par delà le temps et le temps.
»Veuille, Picrate, ne pas outre mesure t’étonner de l’importance
qu’ont, en chaque individu, les velléités amoureuses. A cet agrément
des courtes minutes, que ne sacrifie-t-on? Certes, certes!... Admets
seulement l’hérédité, qui est un fait assez plausible. Comment
n’hériterions-nous point de nos pères cette inclination vers l’acte
d’amour, duquel nous sommes nés?
»Volupté brève et projet de durer! C’est l’irrémédiable antinomie
de l’amour ... Voilà pourquoi les beaux amants s’acharnent à ne pas
laisser défaillir la minute.
 »Alors, ils vérifient bientôt qu’il n’y a pas contre la déchéance de
la minute d’autre recours que dans la mort. La plupart, il est vrai, y
renoncent. Mais tous en ont l’idée, s’ils aiment bien; et certains,
enlacés étroitement, se tuent plutôt que d’être par la vie désenlacés.
Ils disent qu’ils ne veulent pas survivre à leur félicité; ils disent qu’ils
ne veulent pas exposer au péril des lendemains leur bel amour; ils
disent qu’ils veulent éterniser la minute, l’éterniser dans la mort, qui
est seule éternelle et seule intangible au temps ... Crédules au
lyrisme de leur émoi, Picrate, ils se tuent: voilà!
»Pauvres petits!... Gribouille, pour eviter l’averse, s’est trempé
dans l’eau jusqu’aux cheveux. Les beaux amants, pour éviter une
diminution de leur extase, se plongent dans le néant. Le néant? Du
moins, ils se privent de ceci, de cela, qui était la vie,—la vie vaille
que vaille!
»Le meurtre et l’amour vont ensemble. Ils travaillent ensemble.
Le meurtre de soi, le meurtre de l’autre, ou le meurtre de tous les
deux: nuances, nuances; mais le meurtre!
»On a figuré l’amour avec un arc et des flèches. Interprétation
gentille du symbole: c’est la douce blessure que les yeux de la belle
font au cœur du galant. Un arc et des flèches pour tuer, oui! Ces
armes sont aujourd’hui surannées: donnons au symbole d’amour un
couteau de boucher, un revolver.
»Les beaux amants utilisent aussi le poison ...
Picrate écoutait Siméon. Il tâcha de conclure.
—Mais moi,—fit-il,—je n’étais pas l’amant de Marie Galande.
Alors, pourquoi l’ai-je tuée?
—Tu étais son amant par le désir, par l’imagination. Tu avais la
volonté d’être son amant. Tu étais son amant plus que moi.
—Tu étais, en réalité, son amant.
—Tais-toi,—gronda Siméon;—ce n’est pas vrai!
Mais Picrate continuait, selon de grossières logiques:
—Pourquoi n’est-ce pas toi qui l’as tuée, puisque vous vous
aimiez tous les deux? Tandis que moi ...
 Et déjà Picrate, avec sa fatuité complaisante, se déguisait en bel
amant, à part soi, quand Siméon, brutal et rieur, lui répondit:
—C’est que tu es une brute!...
Mais Picrate suivait son idée. Un scrupule lui vint: les beaux
amants meurent ensemble: or, il survivait à Marie Galande, lui.
—Siméon,—s’écria-t-il,—Siméon, j’aurais peut-être dû mourir?
Il dit cela d’une voix si piteuse, malgré l’emphase, que Siméon le
trouva ridicule et fut narquois en demandant:
—Pourquoi? Pour être un bel amant!... Tu cherches une attitude,
Picrate. Oui, tu voudrais bien dénicher quelque stratagème qui pût
orner ton personnage un peu. Je le conçois ... Il serait plus simple,
pourtant, d’y renoncer ... A ta place, il me semble que je serais
cynique, tout bonnement!
Mais Picrate se récusait:
—Non, non, j’aurais dû mourir, je le sens.
—Surtout,—répliqua Siméon,—tu aurais dû, s’il te fallait une
victime absolument, te choisir, toi, de préférence. Tu étais le seul bel
amant de l’aventure!
—Tu te railles de moi,—dit Picrate.—Tu veux encore m’humilier,
m’avilir ...
—Tu aurais tort d’être orgueilleux!
—Je n’ai pas l’intention d’être orgueilleux. Mais enfin, que dois-je
faire? Je te demande de me dire ce que je dois faire. Et toi, au lieu
de me répondre, au lieu de m’aider, tu n’as d’autre soin que de me
tourmenter davantage ... On le dirait ... Moi, cependant, je
consentais à t’obéir ... Je t’obéirai, Siméon, si tu veux avoir pitié de
moi. J’accepterais tout!... Dans l’état où je suis, il n’y a plus de
sacrifice qui me coûte. Je suis abreuvé de douleur. Si tu m’avais
conseillé de mourir, je serais mort,—tu l’as vu?
Il insista:
—Je serais mort! Tu n’avais qu’à l’ordonner.
Il poussa un soupir et, sans perdre de temps, ajouta:
—Mais je comprends bien qu’il faut vivre!
 Et Siméon faillit éclater de rire, nerveusement, lorsque Picrate
affirma, en secouant la tête:
—Il faut vivre, il faut vivre!...
Et Picrate, comme éperdu, reprit:
—Puisqu’il faut vivre, Siméon, dis-moi comment vivre! C’est trop
de sarcasmes: tu peux bien te rendre compte de ma misère. Tu es
un sage, toi. Je te conjure de m’indiquer un moyen de vivre,—toi qui
as lu les philosophes!...
Siméon sursauta. Debout, en face de Picrate, il cria, d’une voix
sifflante:
—Les philosophes, les philosophes!... Est-ce que nous n’allons
pas appeler les philosophes à la rescousse?
Il ricanait et gesticulait. Picrate, sous l’âpre moquerie, sentait sa
peau se glacer, comme si quelque bise mauvaise le harcelait. Siméon
criait:
—Les philosophes à la rescousse! On les réclame pour organiser
l’existence d’un assassin qui n’a point, à proprement parler, de
remords, mais qui trouve des difficultés pourtant à juger confortable
l’ici-bas. Holà! ceux d’Élée et d’Athènes,—et y compris les délicats
sophistes, eux surtout! habiles à démontrer que le noir est blanc
comme le blanc est noir;—ceux d’Alexandrie et ceux de Chaldée,
rêveurs et prophètes; ceux d’ailleurs: Abélard et ses camarades;
n’oublions pas Scot Erigène; n’oublions pas Roger Bacon, vu qu’il a
découvert la poudre, notamment, ni cet autre Bacon de Verulam, qui
fut un voleur mais un logicien; ni ce Jérémie Bentham qui inventa le
calcul des petits bonheurs; ni ces autres qui composèrent des
méthodes pour parvenir à la vie agréable; ni les métaphysiciens
allemands!...
»Tu es curieux de ces gens, Picrate? Mais, choisis!...
»Il y en a pour tous les goûts. En veux-tu de tristes ou de gais? Il
y en a qui te conseillent la joie; il y en a qui préconisent le désespoir.
Il y en a qui ne savent pas trop. Ces derniers ont l’inconvénient de
vous laisser un peu le bec dans l’eau; mais ils ont aussi l’avantage
d’une circonspecte prudence. Qu’en dis-tu?... Rien, rien? Tu fais la
moue? Je te comprends: tu veux des dogmatiques; ces essayistes
qui tergiversent ne sont pas du tout ce qu’il te faut, puisque tu es à
la recherche d’une éthique ...
»Alors? alors?... Décide-toi! Les tristes ou les gais? Nous avons à
ta disposition d’aimables drilles pour te prêcher un bon estomac, la
belle humeur et tout ce qui s’ensuit. Ils te démontreront, clair
comme le jour, que le monde, mon cher, est pour le mieux. Car Dieu
est bon: s’il n’était pas bon, qui le serait? Or, c’est Dieu qui a fait le
monde: si ce n’était lui, qui serait-ce? Donc, le monde est une
merveille, un excellent Dieu l’ayant fait. Quoi de plus évident?...
Écoute bien: tu n’as qu’à te laisser vivre, en ce monde parfait; cède
aux velléités de ta nature humaine. Elle t’engage à ne te point
chagriner. Ah! couronnons de lierre et de violettes nos cheveux et
profitons de ce fumet qu’ont les vieux vins, de cette affabilité qu’ont
les femmes. Tout cela en vertu d’un syllogisme avantageux autant
que péremptoire!
»Mais toi, Picrate, te voici brouillé avec la vie au point que, ces
dialectiques, tu les traites légèrement. Je le devine, je le sais. Tu dis:
«Avec de la dialectique ingénieuse, que ne prouve-t-on?...» C’est à
quoi servent, justement, les dialecticiens. Ils travaillent à installer sur
des formules honorables nos prédilections. Que n’utilises-tu ces
gens?
»Non, non! Tu refuses. Tu boudes à tes plus chers instincts. C’est
une crise. Elle passera: ensuite, tu feras comme les amis. Que
diable!... Mais, en attendant, tu repousses les complaisances de la
méthode déductive. Tu as le souci des réalités,—et foin des
théorèmes: Dieu lui-même ne t’est pas une garantie, et tu écartes
les prémisses où il figure avec son imperturbable excellence.
»Des réalités? Donc, à nous la méthode expérimentale! Un
philosophe anglais a écrit: «J’affirme que présentement, et à toute
heure du jour,—du jour et de la nuit,—tous les hommes sont
absolument heureux!...»
»Tu as bien entendu? Tous les hommes! Après cela, n’essaye pas
de t’excepter, sous le prétexte vain que tu serais ce spécial Picrate
qu’à vrai dire le philosophe anglais n’a point connu. Tu es homme:
du moment que tous les hommes sont heureux, tu es heureux. Il n’y
a point à chicaner là-dessus. «Tous les hommes sont absolument
heureux.» Un philosophe anglais l’a dit; et les Anglais ont l’esprit
positif; nul ne l’ignore. S’il l’a dit, c’est qu’il l’a vérifié.
»Je ne me souviens plus du nom de cet optimiste. S’il t’intéresse,
Picrate, je le chercherai ... Ah! le crâne optimiste!... Il m’a toujours
séduit, par sa belle intrépidité. D’autres sont timides et se contentent
d’affirmer que le bien, somme toute, l’emporte sur le mal. Nous nous
méfions de ces statistiques; et, d’ailleurs, il suffit que l’on réserve à
l’infortune un petit coin de la réalité pour qu’aussitôt nous nous y
logions. Mais «tous les hommes sont absolument heureux». Va-t’en
donc répondre à cela!... Ah! le brave cœur de philosophe! Il en
faudrait de tels à tous les carrefours. Ils vous débiteraient leurs
doctrines comme du quinquina. C’est réconfortant, c’est tonique, ça
vous remonte. On irait, le matin, causer avec eux dix minutes. On
ferait avec eux ses dix minutes d’optimisme quotidien comme on fait
des haltères ou de la gymnastique suédoise. A quelles performances
on arriverait bientôt, Picrate, et quels biceps intellectuels on
obtiendrait, quelle santé morale!...
»C’est dommage que ces optimistes ne soient pas mieux
persuasifs; c’est dommage qu’ils ne récitent que sornettes et propos
vains; c’est dommage que l’on ne puisse vanter un peu cette
existence, louer un peu cet ici-bas sans dire des bêtises, et voilà
tout, qui ne font pas illusion. Grande misère de notre état!... Car toi-
même, Picrate, avec ton fort tempérament, tu ne t’y laisses prendre
mie ...
»Eh bien! voyons les pessimistes. Si les gaillards nous déprisent
la vie un peu congrûment, tôpe là! nous aurons du dégoût pour la
vie, le cœur léger ... Oui, nous prendrons le deuil de toute joie et
trouverons quelque repos dans la certitude de n’être pas dupes.
»Ciel morne et tendu de livides nuées, glauques marais où la
lumière meurt, tocsin:—c’est le décor!...
»Giacomo Leopardi, «sombre amant de la Mort», consacra son
génie à démontrer l’infinie vanité de tout. Il mit en vers la doctrine
de l’universelle infelicità et prononça de telles paroles de néant,
qu’après les avoir lues on est plein d’amertume et d’ennui. Il disait
que le monde est un peu de fange. La maladie tourmentait son
corps et le déformait; les trente-neuf ans qu’il vécut lui furent un
quotidien supplice et son œuvre est un gémissement. Dépourvu de
beauté, il n’eut en amour que des déceptions, dont pantelaient son
cœur et son orgueil. Sa poésie maudit tout le réel et tout le possible
... Cependant il se laissa vivre et même se soigna pour se prolonger.
Dans ses poèmes, s’adressant à soi, il s’écrie: «Désespère donc pour
la dernière fois!» Il vivait dans l’attente, comme si les doux Destins
lui préparaient peut-être un dédommagement délicieux,—bien qu’il
sût et eût établi la nullité d’une telle hypothèse. Mais il n’arrivait
point à «désespérer pour la dernière fois» ... Il fallut que la Mort prît
les devants, tant se montrait le «sombre amant» peu empressé.
»L’année que Giacomo Leopardi allait mourir, le choléra sévit à
Naples. Il en fut singulièrement troublé. Peut-être la peur du fléau a-
t-elle hâté sa fin plus que ne put le faire sa philosophie ... Il mourut
un soir d’été, à l’heure où flambe le soleil bas. Il avait auprès de lui
son ami fidèle, Antonio Ranieri, et la sœur de ce jeune homme,
Paolina. Quelques instants avant la crise, il projetait des promenades
au Vésuve, des parties de campagne, que sais-je!... Et puis,
mourant, il dit à Paolina:
»—Ouvre la fenêtre, fais que je voie encore la lumière!
»Ainsi la doctrine de l’infelicità, ni la souffrance perpétuelle de la
chair et de l’esprit n’empêchèrent de vivre Giacomo Leopardi. Les
derniers mots de son agonie trahissent l’amour et le regret de la
lumière!...
»Tu me diras qu’il n’était pas un philosophe, mais un poète
lyrique. Bon! Voici notre Arthur Schopenhauer: il épilogua sur la
quadruple racine du principe de raison suffisante.
»C’était un petit homme à favoris, au museau rasé, aux yeux
perçants, au nez crochu. Un terrible petit vieux bonhomme! Il disait:
«L’essence de tout, c’est la volonté ...» Pourquoi pas? Accordons-lui
ça ... Mais prenez garde: volonté, donc désir; et le désir implique un
besoin, donc une privation, donc une souffrance.
 »Conséquemment, si la volonté est l’essence de tout, la
souffrance est au fond de tout. C’est cela même. Tocsins, tocsins;
sur la vie et sur le reste, malédiction, malédiction! L’Ecclésiaste et
Çakya-Mouni!...
»A cause de cette volonté, nous allons nous jeter à l’eau.
»Mais contre une telle logique Arthur Schopenhauer réagissait,
quant à lui. Il avait du goût pour la clarinette, dont il jouait le matin,
—tra déri déra!—et pour la bière, dont il buvait des chopes en se
régalant de saucisses grillées. Et puis, il trouvait un fameux plaisir à
injurier Hegel et ses hegeliens. Certes, il n’en concluait pas moins
que la vie est mauvaise, puisque ainsi le voulait sa philosophie. Mais,
ayant découvert des divertissements acceptables, provisoirement il
vivait et se tenait en belle humeur.
»Je te raconterai, Picrate, une histoire. C’était à Londres, il y a
quelques années. Imagine du brouillard jaune qui dégage une odeur
fade; des pianos mécaniques s’acharnent et mènent à la diable la
valse de la volonté forcenée ... Une jeune fille, une quelconque
jeune fille, blonde probablement et adonnée au rêve, lut
Schopenhauer, par hasard. Ce lui fut une révélation pathétique. Elle
connut que la souffrance est en l’âme de tout, est l’âme de tout et
geint dans l’être universel. Oui, de par ce raisonnement que je t’ai
dit: volonté, désir, besoin, privation, souffrance!... La petite Anglaise
en fut ébaubie et désolée. La logique du philosophe l’avait
convaincue tout de suite, et si parfaitement que l’idée ne lui vint
même pas de demander à d’autres dialecticiens des arguments
contraires: elle ignorait que les dialecticiens ont des logiques de
rechange à la disposition d’un chacun ... Et Schopenhauer
commentait, de la façon la plus poignante, sa théorie abstraite. A
chaque page qu’elle tournait, de ses doigts chauds de fièvre, la
petite Anglaise avait trouvé une raison nouvelle d’être sûre que la vie
ne vaut pas la peine d’être vécue.
»Elle en conçut un vif chagrin.
»Elle était poète, à ses heures; et le pessimisme se prête
excellemment au langage rythmé. Elle composa des poèmes,
déchirants et subtils, où elle reprenait pour son compte la pensée
schopenhauerienne. Elle la développa et la paraphrasa et l’illustra de
métaphores émouvantes.
»Quand elle eut assez de poèmes pour en faire un volume, elle
choisit un imprimeur et lui confia son manuscrit. Elle en corrigea les
épreuves avec un soin vigilant. Elle voulut qu’au frontispice une
vignette fût gravée, qui représentait le coin d’une rue londonienne,
d’une rue déserte et triste, nue, avec un bec de gaz pour tout
ornement. Et ce coin de rue lui plaisait, pour sa grande détresse.
»Le matin du jour où parut le recueil de ces mélancoliques
poèmes, la petite Anglaise se pendit au bec de gaz qui était le seul
ornement de ce coin de rue dont la vignette parait le frontispice du
livre. Elle attestait ainsi qu’elle avait pris au sérieux la dialectique de
son maître.
»Schopenhauer l’eût blâmée. Il jouait, lui, de la clarinette,—tra
déri déra!—mangeait des saucisses. Et, pour qu’on ne vint pas
l’accuser d’illogisme parce qu’il omettait de se pendre, il organisait
un raisonnement préservatif. Il disait: «Comme le blasphème est, en
matière religieuse, le plus éclatant hommage que l’on puisse rendre
à l’existence de Dieu, le suicide est l’affirmation la plus manifeste du
«vouloir vivre»: ah! vous estimez donc la vie grandement, que vous
vous pendez pour elle? c’est trop d’honneur que vous lui faites, en
vérité; plutôt, laissez-vous vivre, par mépris!...» Et il préludait—tra
déri déra!—très gaillardement à sa chanson matinale.
»Mais moi, je songe à la petite main de cette jeune fille
londonienne qui tournait les pages du livre désespérant ... Au fait,
est-ce que j’y songe? Et toi, Picrate, y songes-tu?... Cette jeune fille
était mal armée, la pauvrette, pour la vie. Et voilà qu’elle est morte:
qu’y pouvons-nous?... Les moralistes composent des systèmes à
l’usage de qui les voudra bien employer. Schopenhauer a travaillé
pour quelques personnes. Il n’était pas, lui, de ce groupe. Il aimait
mieux la clarinette. On n’est point forcé de se fournir chez soi, de
manger son fonds. Que diable! Il y a des marchands de vin sobres
jusqu’à ne boire que de l’eau.
Picrate soupira. Siméon se tut un instant, puis demanda:
 —Eh bien! que choisis-tu? Les pessimistes ou les optimistes?
Décide-toi. C’est une affaire de goût. Le goût, vois-tu, Picrate, le
goût! Il faut avoir du goût, premièrement: on appelle bon goût le
goût que l’on a. Mais tu hésites.
»Ah! je devine, je devine. Tu n’es pas un esprit léger, frivole. Tu
as été positiviste, en ta jeunesse. Et il en résulte que tu ne sais pas
te décider au hasard ... Pauvre Picrate, qui as écarté de ton
entendement le hasard! Que tu es dépourvu de fantaisie, Picrate!...
Je te dis, avec bonne grâce: «Choisis, Picrate!...» Et toi, tu ne sais
pas choisir. Tu réclames des motifs, hé! hé!...
»Nous recourrons à la métaphysique; s’il te plaît. Les
métaphysiciens ont énoncé des choses et des choses, concernant la
raison dernière de tout ... Ils sont menteurs, par exemple!...
»Oh! menteurs, c’est un bien gros mot. Disons qu’ils ont le
sentiment de leurs responsabilités sociales.
»Ils vous démolissent, autour d’eux, un peu tout,—le reste aussi.
Ils vous invitent à douter des opinions universelles. Ils vous
démontrent, clair comme le jour, que l’on n’a dit que des bêtises,
avant eux; ils vous démontrent encore que c’est la faute de
l’humaine raison, laquelle est un instrument pitoyable. Voici des
ruines et des ruines: ces messieurs ont passé par là.
»Une grande plaine ... Imagine, Picrate, une grande plaine, qui
va jusqu’à l’horizon. Il y avait là des tours splendides, fières de leur
isolement ... Dégringolées! De méconnaissables pierres. A peine, en
les étudiant, te sera-t-il possible d’apercevoir que ces décombres-ci
proviennent du spiritualisme, ceux-là du matérialisme et ceux-là du
panthéisme ... Ah! c’est ici que Spinoza demeurait?... Et là
Leibnitz?... Mais il fait un froid de chien, dans cette plaine que
n’abrite absolument rien. Le vent siffle et le soir tombe. Où
coucherons-nous?...
»Le bon philosophe qui t’accompagne ne veut pas que tu
t’enrhumes. Il a soin de tes poumons et de tes muqueuses nasales.
Et toi, tu geins; toi, tu as peur et tu relèves ton collet.
 »Vite, vite, avec les vieux plâtras, le bon philosophe va te rebâtir
une maisonnette. Il prend des moellons par-ci, des briques par-là,
des poutres ailleurs. Il se dépêche, à cause de ce vent! Il a pitié de
toi ... Là: entrez; couchez-vous!... Il te borde dans ton lit; pour
t’endormir, il te raconte des dialectiques assommantes. Tu n’as point
eu froid, pendant qu’après avoir démoli le philosophe rebâtissait? Il
t’apporte un chaud lait de poule.
»Tu es logé!... Tu n’es pas logé magnifiquement. Que veux-tu?
Ça vaut toujours mieux que de coucher dehors. Remercie le bon
philosophe qui t’héberge comme il peut.
»Ah! Picrate, Picrate, si les philosophes perdaient, un jour, le
sentiment de leurs responsabilités sociales, qu’est-ce que
deviendraient leurs clients? Si les philosophes n’avaient cure, au
monde, que de dire la vérité, qu’est-ce qu’ils diraient? Ils ne diraient
rien que de négatif. A quel néant n’arriveraient-ils pas? Un seul
d’entre eux suffirait à tout détruire.
»Mais on les a jadis dressés. Ils savent ce qu’il leur en coûterait
d’être véridiques imprudemment. Jadis, on a fait des exemples. On
vous brûlait, emprisonnait, torturait ces penseurs libres, libertins,
abstracteurs de quintessence, gens capables de découvrir,—par
mégarde, qui sait?—des parcelles de vérité mal consolante. Des
parcelles ou, comme disent les chimistes, des «traces». Il n’en faut
pas beaucoup pour que saute la machine considérable et tant fragile
de notre petit bonheur. On les a dressés! Et ils mentent;—ils
mentent, avec toute la circonspection désirable.
»Le souvenir de Galilée eut, Picrate, plus d’influence sur la
philosophie de Descartes que la pure et simple logique.
»Quand on cessa de brûler sur des fagots les métaphysiciens, ils
étaient sages, ils avaient pris de bonnes habitudes.
»Emmanuel Kant, bourgeois de Kœnigsberg, a composé une
Critique de la Raison pure qui ne dénigre pas seulement les dires de
tous les autres philosophes, mais encore dénigre par avance tout ce
qu’un philosophe pourra jamais aventurer; bref, il établit,
péremptoirement, que la raison n’est bonne à rien. Ensuite, au nom
d’une certaine «raison pratique», il affirma tout ce qu’il avait nié, ah!
mais, catégoriquement. Il l’affirma, comme cela, sans preuves, sans
prétextes, et démontra qu’il y aurait crime et, mieux, contradiction—
crime devant la logique!—à le vouloir démontrer un peu. A grands
coups de truelle, il restaura, réédifia la bicoque qu’il avait détruite.
Logez-vous là. Le veilleur de nuit passe, ululant sa complainte:
«Gens de la bicoque, dormez,—tout est calme!...»
»Pour achever cette Critique de la Raison pratique,—laquelle,
d’ailleurs, n’est pas du tout une critique, mais un travail de maçon
qu’on presse,—il fallait à Emmanuel Kant quelque temps. Intervalle
très dangereux, si le lecteur du précédent volume en adopte les
conclusions sans deviner qu’on les modifiera bientôt du tout au tout.
Emmanuel Kant en eut le frisson. Et c’est pourquoi il adjoignit à la
redoutable Critique de la Raison pure un chapitre où, d’avance, il
annonce, il résume la réconfortante Raison pratique.
»Il le fallait. Que diable! il le fallait!... Emmanuel Kant s’effraya
pour son lecteur. Et même il s’effraya pour lui-même. Tel qu’on le
connaît, on se figure mal ce bourgeois de Kœnigsberg signataire,
pendant plusieurs mois, d’une œuvre subversive. Il en fût tombé
malade. C’était un homme méthodique. En redingote brune et gilet
jaune, il sortait quotidiennement à cinq heures du soir, tapant; les
autres bourgeois de Kœnigsberg, quand ils le voyaient passer,
mettaient leur montre à l’heure. Il n’aimait pas le changement. A la
veste d’un jeune homme qui lui faisait de fréquentes visites, un
bouton manquait. Emmanuel Kant s’était accoutumé à cette
boutonnière oisive. Et il causait avec le jeune homme très volontiers.
Or, un jour, le jeune homme fit recoudre le bouton qui manquait à sa
veste. Emmanuel Kant, lorsqu’il le revit, s’aperçut de cette
nouveauté: il en fut troublé, déconcerté, bafouilla. Il n’était pas un
homme de changement; ses manies, je les considère comme un
hommage qu’il rendait à ses idées conservatrices. Et je pense qu’il
détestait la Critique de la Raison pure; il l’avait écrite malgré lui,
sous l’empire de son génie, et tout de suite il la biffa.
»Tiens-tu à Dieu, Picrate?... Autrefois, je le sais, non, tu n’y
tenais point. Mais aujourd’hui, dans le grand marasme où tu es, il se
pourrait que tu y revinsses: on a vu cela. Consulte sur Dieu les
philosophes. Ils vous le disloquent facilement. Sacrilège!... Oh! ne
criez pas! Ils appellent Dieu autre chose? ils prêtent ce nom flatteur
à des syllogismes, au total des possibilités, à la somme des réalités,
à n’importe quoi,—même à rien: oui, à rien, mais à rien superbifié.
Hop! et le tour est joué. Qu’est-ce que vous avez à vous plaindre
qu’on vous a défait votre Dieu?... Dieu? Le voilà. Sans barbe, à vrai
dire: spiritualisé!... méconnaissable!
»Les bons philosophes! moi, j’admire leurs façons respectueuses.
Ils casseraient tout, s’ils le voulaient ... Ils le voudraient, si l’on
n’avait eu soin de brûler leurs prédécesseurs.
»Un beau jour, il sembla que la morale chancelait sur ses bases.
La morale théorique, s’entend: car, pour la vie quotidienne, il y a les
codes et les gendarmes. Elle ne chancelait pas seulement sur ses
bases; mais on ne lui trouvait plus de bases. Quelle aventure!... Une
base, une base au moins, pour la morale, s’il vous plaît! On cherche
de tous les côtés: rien! Rien: au ciel, Dieu n’est plus qu’un syllogisme
anodin; sur terre, les gouvernements ont reçu des crocs-en-jambes;
dans l’homme,—eh! bien, dans l’homme, on remarque de l’égoïsme.
Hélas! oui, de l’égoïsme évident: et le reste est bien aléatoire.
L’égoïsme, lui, ne l’est pas. C’est juste le contraire de la morale!
Qu’importe? La morale sera fondée sur l’égoïsme, puisque l’égoïsme
seul est solide. Seulement,—disent les philosophes, et les voici qui
s’emploient de tout cœur à exposer cela,—seulement ayez la
complaisance d’observer que l’égoïsme «bien entendu» consiste à
beaucoup aimer le prochain: sans quoi le prochain ne vous aimera
pas, et le prochain vous est indispensable.—Je ferai semblant de
l’aimer!—Point! Car il n’est de comédie si réussie que la ficelle ne
s’aperçoive: aimez votre prochain réellement, et ... dans votre
intérêt, mais aimez-le!
»Cette fois encore, le tour est joué. Picrate, c’est tout le système
de ces Anglais que l’on appelle philosophes utilitaristes.

Picrate, pendant que parlait Siméon, crut voir que sa lampe

baissait. Il s’approcha, vérifia que le pétrole était épuisé. Il la voulut
remplir et d’abord l’éteignit.
Par la fenêtre, le petit jour insidieux apparut. Les carreaux
blêmirent et la désolation de l’aube naissante se devina.
Siméon dit:
—Et nous avons encore Nietzsche. A ta place, je m’établirais
Uebermensch!...
Il se tut. Picrate, qui s’apprêtait à la tâche facile de mettre du
pétrole dans sa lampe et de la rallumer, regarda le triste et pauvre
éveil de l’aube et sentit le froid l’envahir. Ses doigts tremblaient ...
Entre les buées nocturnes, un ciel verdâtre avait honte de naître.
Siméon reprit:
—Les Grecs de Périclès ont fait boire la ciguë à Socrate, qui
n’était pas bien dangereux, quant à lui. Mais il y avait alors, par la
Grèce, un tas de philosophes interlopes. Ils allaient de ville en ville,
discourant avec ingéniosité. Ils s’étaient pourvus, en Asie Mineure et
partout, dans les écoles ioniennes, éléates et autres, des plus
spécieuses doctrines, et ils les répandaient avec leur éloquence de
conférenciers agréables. Les Grecs de Périclès reconnurent le danger
que les dieux couraient, leurs dieux et leur éthique et leurs
traditions. Ils prirent, au hasard, ce philosophe de Socrate, curieux
bonhomme, et le collèrent en prison, pour faire un exemple. C’est à
peu près ainsi, plus tard, que les Juifs clouèrent au gibet Jésus,
révolutionnaire ingénu. Socrate, quand il eut avalé le poison, ne se
plaignit pas. Tandis que le froid mortel gagnait ses jambes, il parlait
encore d’un Dieu singulier, peu conforme aux dieux de l’Olympe. Un
petit nombre de disciples l’écoutaient: il pouvait raconter ce que bon
lui semblait, ainsi à huis clos. Athènes, cependant, célébrait les dieux
anciens et agissait au gré des méthodes ancestrales.
»Les philosophes se le tinrent pour dit.
Picrate avait rallumé sa lampe. Siméon criait:
—Je te défie de me citer un philosophe, digne du nom de
philosophe, dont le système, dégagé des indispensables mensonges,
ne soit une bible de néant. C’est au néant qu’ils aboutissent tous. Au
néant!... Tu réclames une certitude, Picrate! En voici une;
seulement, aie la discrétion de n’en point demander une autre. La
voici, cette seule certitude:—deux et deux font quatre.
»Qu’elle est pathétique, dans son désert universel!... Oh! je la
veux attentivement protéger. Si, par malheur, elle s’éteignait, on ne
posséderait plus, ici-bas, de certitude aucune.
»Qu’elle est pathétique ... et bête comme tout!... Deux et deux
font quatre,—mon Dieu oui: puisque j’appelle quatre deux et deux.
»Deux quoi? N’insistons pas. Deux.
»Disons plutôt: A est A. Picrate, salue ici le principe d’identité. Je
te le présente: c’est lui. D’ailleurs, il n’y a rien à en tirer. Il est stérile
absolument. Ni toi ni moi ni personne ne le persuaderait de faire des
petits. Il n’a point les idées à ça.
»Et puis? C’est tout! A est A. Si seulement A n’était point A, nous
verrions un peu ... Mais A est A. Regarde bien cet «A est A»: tu
contemples la somme des certitudes.

Picrate se lamentait comme un petit enfant qui a trop mal à ses

gencives. Il gémit:
—Siméon, je n’ai rien à faire de cet «A est A». Siméon, tu es
terrible et méchant. Tu n’as pas eu pitié de moi. Tu me laisses dans
ce néant!...
Il sanglotait et le geste de ses bras désignait vaguement l’infinité
vide. Il continua sa plainte:
—Tu as tout dévasté ... en moi ... et hors de moi ... Je veux
mourir, à présent; je ne veux plus que mourir ...
A peine eut-il prononcé ces mots de désespoir balbutiant, qu’il y
devint attentif. D’une voix nette il ajouta:
—Si je mourais?...
Siméon restait silencieux.
—Si je mourais?—reprit Picrate.—Ah! parle-moi, parle-moi. Il ne
t’est plus permis d’éluder cette question suprême que je te pose.
C’est toi qui m’as amené là. Parle!
Il fut impérieux. Siméon, brusque, répondit:
 —Meurs, s’il te convient de mourir.
—Eh! bien! je mourrai!—dit Picrate.
Une minute s’écoula sans que l’un ni l’autre fit un mouvement.
Picrate soudain s’agita:
—Tu me le conseilles?—demanda-t-il à Siméon.
—Je ne te le conseille pas,—répliqua Siméon;—je n’ai pas à te
conseiller. Cette médiocre solution n’importe guère et tu t’exagères
beaucoup la gravité de l’incident. Meurs, si tu veux. Ou bien ne
meurs pas. Tu es à moitié mort déjà. Tout le monde est à moitié
mort et meurt un peu plus sans cesse. Je ne sais pas s’il y a une
différence réelle entre l’incessant éparpillement dont les secondes
successives marquent les épisodes et le dernier éparpillement des
molécules charnelles ou mentales. Ah! si la mort était une soudaine
disparition de quelque chose, alors, Picrate, il faudrait voir!...
—Est-ce que tu crois à la vie future?
—Je te dis—continua Siméon—que, si quelque chose
disparaissait,—j’entends: si quelque chose était et puis tout à coup
n’était plus,—alors nous épiloguerions utilement sur l’opportunité de
l’aventure. Certes!... Mais il n’est pas moins hasardeux de prétendre
ceci que de prétendre cela. Et je m’abstiens d’épiloguer sur le non-
être, faute de renseignements sur l’être. Quand je te parle du néant,
c’est un mot que j’emploie pour abréger. Il n’a pas de sens par lui-
même; il désigne la négation de je ne sais quoi que serait son
contraire. Et de la mort, pareillement, je n’ai rien à te dire; pas plus
qu’un aveugle-né, ignorant du jour, ne t’expliquerait la nuit. Mais il
me semble qu’il y a, dans ce qu’on nomme «vie», assez de
décomposition perpétuelle pour qu’on ne doive pas caractériser tout
à fait autrement ce qu’on nomme «mort». Tu n’as donc jamais vu de
cadavre? Ou bien n’as-tu pensé jamais à la pourriture d’un corps
humain? Qu’est-ce que c’est que la matière? Je m’embrouille dans la
diversité de ses fermentations. Songes-y, et tu sentiras la vie tout
imprégnée de l’odeur de la mort. Au Campo Santo de Pise, une
fresque d’Orcagna—ou de quelque autre—figure cette allégorie. De
beaux seigneurs, parés d’atours très élégants, d’étoffes éclatantes et
souples, coiffés de chapeaux merveilleux, approchent, cavaliers, de
trois cercueils où des cadavres se désagrègent. Les chevaux reniflent
ou se détournent; les beaux seigneurs se bouchent le nez. Ces
beaux seigneurs et leurs chevaux me paraissent simplistes autant
que délicats. Je les voudrais voir qui se bouchent le nez et reniflent
en face de la vie comme en face de la mort. Ou bien qu’ils aient, ici
et là, bonne contenance! Il n’y a rien de vil dans la maison de
Jupiter. C’est-à-dire que, dans la maison de Jupiter, il n’y a rien qui
soit plus vil que rien.
Picrate se débattit:
—Si tu me donnes de la répugnance pour la mort comme pour la
vie, Siméon, que ferai-je?
—Tu feras, Picrate, ce que tu voudras.
—Que ferai-je? que ferai-je?—répétait Picrate.
Siméon négligea de répondre, et les gémissements de Picrate
tombèrent dans le silence.
Bientôt, Siméon remua, prit son chapeau, sa canne.
—Adieu, Picrate,—dit-il, la main tendue.
Picrate redressa la tête, qu’il avait inclinée vers le sol, et se récria
de toutes ses forces:
—Ne t’en va pas! ne t’en va pas! Je te supplie de ne pas t’en
aller. Tu ne peux pas me laisser tout seul, ainsi, dans ce désastre. Ce
serait lâche et cruel. Je ne peux pas rester ici tout seul. Tu vois bien
que j’ai peur. La police viendra; je serai pris!...
Il frissonna; sa bouche se contractait.
—Si l’on m’arrête, je suis perdu! Est-ce que tu crois qu’ils me
condamneront à mort?...
Ses doigts tremblèrent.
—J’aimerais mieux me tuer tout de suite... Réponds-moi! J’ai
peur de la guillotine...
Ses épaules furent secouées; son cou se gonfla.
—Réponds! Réponds!
—Mais non! Crime passionnel: le bagne; à peine le bagne,—
répondit Siméon, comme qui évalue tout au juste et ne veut rien
exagérer.—Peut-être même t’acquittera-t-on ...
—Je refuse! je refuse!—hurla Picrate.—Je refuse d’être acquitté.
Le bagne, oui, le bagne. C’est bien. J’irai au bagne. J’aime mieux
aller au bagne que d’être ici, dans ce désastre, dans ce désastre!...
Qu’on m’arrête! Qu’est-ce qu’ils ont à ne pas m’arrêter? Ils sont
fous, ma parole, fous!...
Picrate saisit violemment ses deux poignées et, de long en large,
dans la chambre étroite, il fit rouler son chariot, à grand bruit... Et
puis, il stoppa soudain et parut calme... Il réfléchit et, d’une voix
tranquille, annonça:
—J’ai pris ma résolution.
Siméon l’écoutait et le regardait.
—Tu peux t’en aller, Siméon. Moi, je vais me livrer à la police. Je
vais leur dire que c’est moi qui ai tué Marie Galande. Ils m’enverront
au bagne. Voilà.
Siméon dit:
—Réfléchis encore. Du moment qu’on ne t’a point arrêté jusqu’à
présent, tu peux très bien leur échapper.
—Ce n’est pas cela!...—répliqua Picrate.
—Alors?
—C’est que je ne trouve pas autre chose à faire. J’irai au bagne...
C’est que tu m’as vidé de tout espoir, de tout désir, de toute idée!...
Siméon se récusait. Picrate dit:
—Je ne songe pas à te le reprocher, Siméon. Pourquoi?... Ne
t’imagine pas que tu sois responsable du parti que je prends. Je
l’aurais pris sans toi. Plus tard, peut-être. Il n’importe! Je l’aurais pris
mal, stupidement, par instinct de bête traquée et qui a peur. De
cette façon, c’est beaucoup mieux...
Picrate bavardait, bavardait. Une sorte de sérénité singulière lui
vint, et les traits de son visage, peu à peu, se détendirent. Il sourit,
en disant:
—Au moins, c’est vrai, ce que tu m’as raconté? Il n’y a rien, n’est-
ce pas? rien, rien?
 Siméon se taisait. Picrate conclut:
—Absolument rien!... J’aime autant ça. S’il y avait la moindre
petite chose, ça m’ennuierait!... Mais rien!... Oui, A est A. Tant pis
pour «A est A»! N’est-ce pas, Siméon, que nous pouvons bien
négliger «A est A»?... J’irai au bagne. Adieu, Siméon.
Siméon voulut répliquer.
—Mon pauvre Siméon,—dit Picrate,—ne te mets pas en peine.
Mais comment peux-tu vivre, toi, dans ce désastre?... Adieu. Ou
plutôt non; pas tout de suite: nous sortirons ensemble. Tu me
conduiras, un bout de chemin. Veux-tu?...
—Qui sait—hasarda Siméon—si tu n’oublierais pas, avec le
temps, assez pour te reprendre à vivre?
Mais Picrate haussa les épaules:
—Attends-moi!...
Il s’aperçut que le jour luisait. La lumière de sa lampe semblait
une petite veilleuse. Il la souffla. Le ciel morne d’un matin pluvieux
entra dans la chambre.
 VI

ÉPILOGUE

Picrate s’apprêtait.
Il avait enlevé son veston, ouvert le col de sa chemise. A grande
eau, il se lavait. Sa cuvette était installée par terre, devant un
morceau de miroir. Ses mains, son éponge, sa tête penchée
barbotaient dans l’eau, éclaboussant le mur, le plancher, Siméon... Il
se frotta d’une serviette, avec entrain.
La fraîcheur de l’ablution lui fut agréable.
—C’est bon,—dit-il;—et ça m’étonne que le ciel ne veuille pas en
faire autant. Quelle figure!...
Il souleva le petit rideau de la fenêtre.
—Regarde-moi cette figure. On se débarbouille, que diable!
quand on est ainsi couvert de nuages, de suie, de fumée. Connais-tu
rien de plus misérable qu’un matin? Ça rechigne à naître, ça
grogne...
—Il y a—repartit Siméon—des matins sublimes. On dirait qu’ils ne
savent rien des précédents jours. Et telle est leur splendide
innocence qu’on dirait qu’ils commencent la vie et l’inaugurent. Des
matins de création, des aubes du monde, des aurores de l’ici-bas
nouveau. De vierges et naïfs matins!...
—Je ne tiens pas à y penser ...—murmura Picrate.
—Penses-y,—insistait Siméon.—De vrais matins initiaux!... C’est
comme si la vie s’était baignée aux léthéennes ondes et surgissait,
éblouissante de jeunesse, hors des abîmes oubliés. Incipit vita
nova...
—Oui, oui,—reprit Picrate;—je me rappelle. C’est dans un tel
matin rayonnant que nous apparut cette petite fille, avec le soleil à
ses cheveux blonds, Marie Galande!...
—Marie Galande!—répéta Siméon.
—Elle chantait,—continua Picrate.—Ah! l’étonnante chanson de
vie nouvelle! Une chanson légère et merveilleuse, toute pleine de bel
espoir.
Ils se turent tous deux. A son miroir, Picrate achevait sa toilette,
arrangeait ses cheveux, cirait ses moustaches. Il soupira:
—Marie Galande est morte. Je vais au bagne. Toi, que
deviendras-tu? J’ai pitié de toi.
Il voulut ranger un peu sa chambre. Ce ne fut pas une besogne
compliquée. Ses anneaux brisés, ses lacets et le stock de ses cartes
postales, qu’il assembla, firent un tas au fond d’une armoire.
—On ferme!—disait-il.—Cessation de commerce!
Il examina les murs, le lit, le plancher, le décor de son existence
passée. Il s’attendrit:
—Que c’est pauvre et laid, tout cela! Pourtant, j’ai vécu, des
années nombreuses, entre ces murs.
Il parut hésiter, comme si quelque chose le retenait qu’il avait
peine à rompre. Il pleura.
—Siméon, dis-moi pourquoi je pleure. Je n’abandonne rien que
d’affreux et de douloureux. Alors, je ne sais pas pourquoi j’ai cette
tristesse...
Et puis, il dit encore:
 —La clarinette de Schopenhauer était, sans doute, la plus
désolante musique. Imagines-tu d’autres musiques pareillement
appropriées à l’absurdité de la vie?... Il me semble que je l’entends
qui entame des romances gaies, avec des roulades, des trilles et de
prétentieux trémolos. N’est-ce pas? C’est un air sautillant, allègre et
ridicule, pour accompagner mon départ. La clarinette de
Schopenhauer rit et se moque. Ah! Siméon, Siméon, que j’ai envie
de rire, moi aussi, de rire et de me moquer!... Seulement, le courage
me fait défaut; je n’arrive pas à considérer avec détachement cette
petite aventure qui est la mienne! Je pleure sur moi.
—Il est bien naturel, Picrate,—dit Siméon,—que tu pleures sur
toi, puisque tu es toi. Mais ta douleur est un peu de la douleur
universelle; et tu pleures sur tout au monde, sans le savoir.
Picrate s’essuya les yeux, vérifia que rien ne traînait plus par sa
chambre...
—C’est pourtant bien plus vite fait de se tuer!—balbutia-t-il.—
J’aurais mieux fait de me tuer, Siméon!...
Il n’attendit pas de réponse, et, gagnant la porte:
—Allons!—dit-il.—Passe le premier.
Siméon sortit. Picrate le suivait. Au moment de fermer la porte
derrière lui, Picrate, deux secondes, tergiversa. Puis, il tira la porte
violemment et, quand elle battit en se fermant, il gémit; sa plainte
dura le même temps que le bruit de la porte dans le couloir.
Dehors, Picrate et Siméon marchèrent l’un près de l’autre. Il
bruinait. Au ciel, de grandes nuées s’échevelaient, arrachées par le
vent. La tristesse du jour se condensait en humidité froide. Tantôt
Picrate se hâtait, comme si le poussait un intense désir; et tantôt il
ralentissait l’allure de son chariot, comme si le désir l’abandonnait.
Le long du trottoir, les boutiques n’étaient pas encore ouvertes.
Seuls, les boulangers étaient à l’ouvrage. Quand on passait devant
les soupiraux de leurs caves, on sentait une odeur de pain chaud.
Siméon s’appliquait à marcher ainsi qu’il le fallait pour ne
précéder point Picrate. Il ne voulait pas le conduire, mais
l’accompagner seulement.
 Une crèmerie était de mine engageante. Picrate dit à Siméon:
—Si nous mangions un peu? Cette occasion ne se trouvera plus.
Entrons!
Ils s’installèrent. Picrate regardait, autour de lui, les murs blancs,
les jarres de lait et les œufs dans leurs corbeilles, la crémière aussi,
son tablier blanc, ses fausses manches de toile et ses mains rouges
d’être bien lavées. Une impression de confort, de placidité, de calme,
lui fut douce et l’étonna.
Un chat paresseux, à peine éveillé, vint et, le dos en voûte, frôla
nonchalamment le pied de la table. Picrate laissa pendre sa main; le
chat, câlin, s’y caressa.
—Mon pauvre Siméon,—fit Picrate,—c’est la dernière fois que le
café au lait nous est à tous les deux versé dans de si proches tasses.
J’en ai du chagrin!...
Siméon s’affligeait, à part lui.
—C’est drôle,—reprit Picrate,—que toute ta philosophie
t’abandonne depuis que j’y veux céder ... La responsabilité sociale,
Siméon?... Tu me prends pour une petite Anglaise qui est victime de
Schopenhauer? Tu as peur de ce disciple imprévu que ta
désespérance a rencontré?... Siméon, Siméon, du courage!...
A travers les carreaux, Picrate regardait les gens passer, très vite
presque tous, de pauvres gens que des besognes matinales
réclamaient. Il les voyait comme de très loin. Le spectacle de la vie
était pour lui maintenant plus étrange que de coutume. Il assistait à
la commençante journée avec détachement.
Il dit à Siméon:
—Ces gens qui passent font, tous les matins, à la même heure,
ce même chemin qu’ils font aujourd’hui. A quoi bon? C’est la
volonté, n’est-ce pas, qui les tracasse?
—Si tu veux,—répondit Siméon.
—Oui, oui: la volonté. Désir, besoin, souffrance. Comment ne se
mettent-ils pas en grève?
—Contre qui?—demanda Siméon.
 —En grève,—répliqua Picrate,—en grève contre la volonté!... Moi,
je me mets en grève contre la volonté. Je refuse de me mêler à ce
complot que fomente, avec le désir et la souffrance, la volonté. Je
m’évade. Je tire mon épingle du jeu. Là-bas, il y aura des
règlements stupides et d’affreux gardes-chiourme; ils seront les
instruments de la volonté; c’est affaire à eux: moi, j’abdique. Je ferai
ce qu’ils commanderont. Toute l’infamie retombe sur eux. Moi, je n’y
suis pour rien... Qu’ils s’arrangent! Cela n’est pas mon affaire!...
—Schopenhauer t’aurait blâmé,—dit Siméon.
Picrate reprit:
—Mais toi, quand tu te consacrais autrefois à la philologie, est-ce
que tu n’étais pas en rébellion contre la volonté? A présent même,
quand tu annihiles, à conduire de rue en rue ton fiacre et tes clients
de rencontre, ton intelligence, ton rêve et toute l’ardeur de ton
individualité, que fais-tu, Siméon, que refuser d’être complice de la
volonté?
—Oui,—répondit Siméon,—je me gaspille en pure perte, afin que
la volonté n’ait de moi rien qu’elle utilise.
Picrate s’exaltait:
—Réagissons contre la volonté!
Il développa ce thème avec emphase.
—Tu y dépenses trop d’orgueil,—observa Siméon.—Crains d’être
dupe et ne sois pas la victime de toi-même pour faire la nique à la
volonté. Cette révolte va te coûter cher. Le dédain suffit.
Picrate s’excusait:
—Je ne suis pas de nature dédaigneuse...
Dans leurs tasses, le café au lait fumait et son arôme avait du
charme. Picrate n’y fut pas indifférent. Il se chauffait les doigts à la
faïence et, les narines ouvertes, il aspirait cette tiédeur bien
odorante. Une brioche qu’il trempa dans le café au lait le régala.
Cette gourmandise le disposait à capituler.
—C’est excellent!—dit-il.
 Ensuite, il ajouta, mi-sérieux et mi-narquois, regardant Siméon
dans les yeux:
—Écoute, Siméon, si tu me trouves un motif, ou même
simplement un assez bon prétexte de vivre, je n’irai point au
bagne!... Je rentrerai chez moi. Tu comprends?
Siméon tressaillit. Éperdu, il chercha. Ses idées s’embrouillaient
et, dans leur confusion vaine, il ne trouvait rien.
—Parce que... tu conçois que je ne vais pas accepter de vivre
pour la saveur de ce café au lait!...
—Pourquoi?—demanda Siméon.
Picrate avait un air de défi. Siméon se tut...
—Eh bien?—fit Picrate.—Rien?
Après un silence, Siméon répondit avec effroi:
—Non, rien!...
—Allons-nous-en!—dit Picrate.
Ils sortirent. Dans la rue, les boutiques ouvraient. Les concierges
battaient leurs tapis. Des contrevents claquaient aux murs. Les
passants étaient plus nombreux. Ils évitaient le chariot de Picrate.
Siméon se rangeait et ne suivait pas sans difficulté Picrate, qui
lançait à grands coups son chariot.
—Réfléchis, Picrate!
Mais Picrate haussa les épaules et ne s’arrêta point.
A quelque distance, Siméon aperçut le drapeau du commissariat,
la lanterne rouge ...
—Alors, adieu, Picrate!
—Adieu, Siméon!
Ils se donnèrent une brusque poignée de main. Siméon se
détourna. Tandis qu’il s’éloignait, le bruit de roues que faisait le
chariot de Picrate l’émut péniblement. Et puis il ne discerna plus rien
dans le tumulte de la rue; et, sans savoir où il allait, il continua son
chemin.
 TABLE

PREMIÈRE PARTIE

Page
I. La rencontre 1
II. Histoire de Siméon 21
III. Picrate interrompt le récit 41
IV. Suite de l’histoire de Siméon 53
V. Histoire de Picrate 71
VI. Picrate pleure et Siméon le console 87
VII. Suite de l’histoire de Picrate 91
VIII. Suite de l’histoire de Siméon 109

DEUXIÈME PARTIE

I. Marie Galande 184

II. Les amours de Siméon 196
III. Un meurtre 259
IV. La mort du souvenir 277
 V. Picrate et Siméon 304
VI. Epilogue 354

2-0-04.—Tours, imprimerie E. Arrault et Cie.