OCaml: The Basics

Integers are values of type int.

According to the Int module: "Integers are Sys.int_size bits wide and use two's complement representation. All operations are taken modulo 2^Sys.int_size. They do not fail on overflow."

According to the documentation for Sys.int_size, it's an int that represents the "[s]ize of int, in bits. It is 31 (resp. 63) when using OCaml on a 32-bit (resp. 64-bit) platform."¹

Literals are as usual (2, -345, and so on).² and usual operators are available:³

Pretty standard stuff.

Floating-point numbers are values of type float.

According to the Float module: "OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-point operations never raise an exception on overflow, underflow, division by zero, etc. Instead, special IEEE numbers are returned as appropriate, such as infinity for 1.0 /. 0.0, neg_infinity for -1.0 /. 0.0, and nan ('not a number') for 0.0 /. 0.0. These special numbers then propagate through floating-point computations as expected: for instance, 1.0 /. infinity is 0.0, basic arithmetic operations (+., -., *., /.) with nan as an argument return nan, …"

Short version: floating-point numbers are standard.

Literal as usual (2., -345.67, and so on).⁴ and the usual operators (among others) are available:

Remark. You've undoubtedly noticed at this point that we have different arithmetic operations for integers and floating points (e.g., + vs. +.). This has to do with the "really strongly typed" discussion in the previous set of notes. Expressions are typed, and they have their types in perpetuity. And (+) is a function⁵ ──a valid expression──and so it has a type, and it has that type in perpetuity. No function overloading, ever. So, yes, we need two addition functions.⁶

Boolean values are of type bool.

In OCaml, the two boolean literals are true and false. And the usual operators:

We'll also note here that OCaml has all the usual comparison operators:

Yes, equality is written with a single equals symbol. Yes, this means you can write confusing stuff like:

let foo = 1 = 2

No further comments.

Aside. But wait, hold on, what just happened. Didn't we just make a big hubbub about how an expression has it's type in perpetuity? Don't I need a different equality/inequality for integers and floats? Turns out: no. OCaml comparison operators a polymorphic. Exactly what this means will be a topic of later discussion, but in typically forward-reference you-get-the-gist fashion, the idea the type of all these comparison operators is:

'a -> 'a -> bool

which we read this as: for any type t, this function can be applied to two t values to get a bool.

And, how does this work? Once we learn more about parametric polymorphism, we might even be inclined to ask: how can this possibly work?⁷ Well, it's mostly magic, particularly when it comes to inequalities. Actually, polymorphic inequalities are a form of hidden function overloading.⁸ Which, yeah, not great.⁹ Folks have been discussing removing polymorphic comparison for years. I don't expect it'll ever disappear, and the truth is that it's really freakin' convenient (until it's not). We'll be using these comparison operators frequently, and not thinking about it too hard.

Strings are values of type string.

According to the String module: "A string s of length n is an indexable and immutable sequence of n bytes. For historical reasons these bytes are referred to as characters."

String literals are as usual ("foo", "bar", and so on).¹⁰

According to the Char module: "Characters are the elements of string and bytes values. Characters represent bytes, that is an integer in the range
[ 0x00 ; 0xFF ]."

Character literals are as usual ('b', 'a', 'r', and so on).¹¹

The only real operations we have are concatenation (^) and indexing (s.[i], where s is a string and i is an int).

More pretty standard stuff.

Aside. Except that string are one of the most complicated data types out there when you really get into it. There are thousands of languages and hundreds of writing systems¹² all of whose basic elements need to be shoved into sequences of bytes if we want to use these languages for, say, variable names. With logographic writing systems, for example, doing basic things like determining word/morpheme boundaries becomes a whole lot more interesting. In a majority of introductory CS settings these details don't matter. But "language" is in the name of this course, so the nitty-gritty of strings matters more to us than in other areas.

That said, we're gonna ignore most of these details. We'll be working in English, which has a constant-sized alphabet, and we're gonna assume ASCII-encoding, no unicode, no emojis (bummer).

One last point: strings are decidedly not the same thing as lists of characters in OCaml. We haven't discussed lists yet so this point in fact be pointless, but we'll find that they're represented completely differently, are thus we'll work with them completely differently.

The humble unit. The literal () is of type unit. That's all there is to it.

What's the point? We've already established OCaml is a functional PL and that's that. But also that's not it, because there are plenty of things we can/will often do in OCaml that are not functional, e.g., printing and asserting.

let _ = print_endline "Testing arithmetic..."
let _ = assert (1 + 1 = 2)

print_endline is a function that writes to stdout. There isn't really a value that we can naturally associate with the result of printing. We see it, but from the perspective of the program, nothing happened. In these "nothing happened" scenarios, we still need a type. This is why the type of print_endline is:

string -> unit

It takes a string (prints it to stdout, unbeknownst to the program itself) and then gives back (), basically as a placeholder to satisfy the type system.

Every literal we described above is an expression. We think of this as essentially the base case of our recursive definition.

Syntax. For example 1 and true and 3.45 and "six seven" are all well-formed expressions.

Semantics. Every literal has a corresponding value. For example, 12 has the value \(12\). We will usually distinguish between the a literal and its value by the font we use, except in the case of Boolean values, for which we use \(\top\) for the true Boolean value an \(\bot\) for the false Boolean value.

Typing. Every literal has the type described in its corresponding section. For example, 12 has the type int.

Syntax. If \(e_1\), \(e_2\), and \(e_3\) are well-formed expressions, then so is \(\texttt{if} \ e_1 \ \texttt{then} \ e_2 \texttt{else} \ texttt{e_3}\).

We begin with conditionals. And as was hinted in our previous notes, this means specifying three things: syntax, typing and semantics. In what follows we'll specify these things informally, and put alongside the informal specification the formal ones as well as a sneak peak of what's to come in the second part of the course.

A quick reminder that OCaml is an expression based language. If-expressions are our first marked departure from the status quo of imperative languages which generally have if-statements. The difference between an expression and a statement is important, but somewhat subtle, and the kind of thing that we hope you appreciate coming out of this course. In broad strokes, a statement is an imperative; it describes a thing to do. Conditional statements are compound imperatives: given two imperatives, determine what to do based on the value of a boolean expression. In python we'd write something like:

if condition_to_check:
    # do something
    ...
else:
    # do something else
    ...

An expression is a syntactic object that we evaluate to get a value. So the first major point: statements don't have values. Only expressions have values. What a lot of folks don't know is that Python also has if-expressions:

foo = then_expr if cond_to_check else else_expr

We won't spend this much time on the later constructs but I think this highlights two major points that get us into the expression-based mindset:

• It doesn't make sense to drop the else-case of an if-expression. If the thing needs to evaluate to a value and the condition is false, we still need to give back something to evaluate.