Basic syntax of Haskell on OOFP 2025-26

Tokens

Mon, 01 Jan 0001 00:00:00 +0000

Tokens #

Syntax. Here are syntactic constraints on basic elements of a Haskell program:

meaning syntax examples

variable name starts with a lower case letter x, xs, f, remainder, maxValue

function name starts with a lower case letter square, applyBoolOp

type starts with an upper case letter Integer, Char, Bool

type variable starts with a lower case letter a, type, baseType

constructor starts with a capital letter Cons, CityC, True

meaning	syntax	examples
variable name	starts with a lower case letter	`x`, `xs`, `f`, `remainder`, `maxValue`
function name	starts with a lower case letter	`square`, `applyBoolOp`
type	starts with an upper case letter	`Integer`, `Char`, `Bool`
type variable	starts with a lower case letter	`a`, `type`, `baseType`
constructor	starts with a capital letter	`Cons`, `CityC`, `True`

Base types

Mon, 01 Jan 0001 00:00:00 +0000

Base types #

A base type in Haskell intuitively represents a set of values (like in Java, and many other languages).

Here are a few native base types:

type	meaning	syntax of constants in Haskell
`Char`	a Unicode character, like `b`, `B`, `5`, `_` or `\t`.	`'b'`, `'B'`, `'5'`, `'_'` or `'\t'` (single quotes)
`String`	a sequence of Unicode characters, like `banana` or `f?#\t5`	`"banana"` or `"f?#\t5"` (double quotes)
`Bool`	a Boolean value	`True` or `False`
`Integer`	an arbitrary integer (i.e. an element of $\mathbb{Z}$)	`-42`, `0` or `3`
`Int`	an integer within a certain range, from $- 2^{63}$ to $2^{63} -1$ (i.e. 64 bits) by default.	`-42`, `0` or `3`
`Float`	a 32 bits floating-point number	`-42`, `4472`, `4472.0` or `4472.1357`

Native functions

Mon, 01 Jan 0001 00:00:00 +0000

Native functions #

Syntax. Many native functions/operators (e.g. over numbers or Boolean values) have the same syntax in Haskell and Java. This includes equality (==), sum (+), product (*), etc.

We highlight below a few cases where the two syntaxes differ:

meaning syntax in Haskell example syntax in Java example

inequality /= x /= 2 != x != 2

negation (NOT) not not x ! !x

disjunction (OR) || x || y || (lazy evaluation) or
| (full evaluation) x || y or
x | y

conjunction (AND) && x && y && (lazy evaluation) or
& (full evaluation) x && y or
x & y

meaning	syntax in Haskell	example	syntax in Java	example
inequality	`/=`	`x /= 2`	`!=`	`x != 2`
negation (NOT)	`not`	`not x`	`!`	`!x`
disjunction (OR)	`\|\|`	`x \|\| y`	`\|\|` (lazy evaluation) or `\|` (full evaluation)	`x \|\| y` or `x \| y`
conjunction (AND)	`&&`	`x && y`	`&&` (lazy evaluation) or `&` (full evaluation)	`x && y` or `x & y`

Tuple

Mon, 01 Jan 0001 00:00:00 +0000

Tuple #

Syntax. A tuple in Haskell is written in parentheses.

Example. The pair $(\mathit{banana}, 5)$ is written
("banana", 5)

Syntax. The type of a tuple is written in parentheses (like the tuple itself).

Examples.

Haskell tuple Possible type

(5,3) (Int, Int)

("banana", 5) (String, Int)

("banana", 5, "tomato") (String, Int, String)

Haskell tuple	Possible type
`(5,3)`	`(Int, Int)`
`("banana", 5)`	`(String, Int)`
`("banana", 5, "tomato")`	`(String, Int, String)`

Function

Mon, 01 Jan 0001 00:00:00 +0000

Function #

Function definition #

Syntax. A function in Haskell is defined analogously to a mathematical function, with the symbol =.

Example. The function $f(x) = 2x$ is written:
f x = 2 * x

Warning. As opposed to Java (and C/C++, C#, Javascript, Python, etc.), the symbol = in Haskell does not assign a value to a variable.

Syntax. Note that $f(x)$ is written f x, without parentheses. This also holds when applying a function to a constant.

Program

Mon, 01 Jan 0001 00:00:00 +0000

Program #

File #

A simple Haskell program is written in a file with the extension .hs. For instance, MyProgram.hs.

Content #

Functions #

A Haskell program primarily consists of function definitions.

Hint. The order of function definitions in a program is irrelevant.

The function `main` #

To make a program executable, one of its functions must be the entry point. By default, this function is called main, and has type IO ().

List

Mon, 01 Jan 0001 00:00:00 +0000

List #

Recursive form #

Lists in Haskell are recursive.

Definition (finite list in Haskell).

[] is the empty list,

if x is an element and xs a list, then x : xs is a list.

In addition, all elements in a list must have the same type. If this type is a, then the list has type [a].

Example. The Haskell list

$\qquad$5 : (2 : [])

Basic syntax of Haskell on OOFP 2025-26

Tokens

Tokens #

Base types

Base types #

Native functions

Native functions #

Tuple

Tuple #

Function

Function #

Function definition #

Program

Program #

File #

Content #

Functions #

The function main #

List

List #

Recursive form #

The function `main` #