OOFP 2025-26

Enumerated type

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

Enumerated type #

An enumerated type is a finite set of alternative values.

Example. A playing card can have one of four suits: Clubs, Diamonds, Hearts or Spades.

In the first assignment, we modeled these values as four characters 'C', 'D', 'H' or 'S'. This solution is unsatisfying, because the type Char allows other letters. Instead, we could declare an enumerated type (for instance named Suit) with 4 possible values (Clubs, Diamonds, Hearts and Spades).

Linear recursion

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

Linear recursion #

Definition. A recursive function/method is linear recursive if it performs at most one recursive call each time it is executed.

Hint. In an imperative language (like Java), a linear recursive algorithm can easily be transformed into an iterative one (i.e. an algorithm that uses only loops).

Haskell does not admit loops, so linear recursion is the standard way to perform simple iterations (although list comprehensions can be used instead in certain cases). Accordingly, in this section, we will mostly use Haskell as an illustration.

Object

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

Object #

An object groups data in a meaningful way.

A simple example: JSON #

Here is a JSON object (in Javascript syntax) that describes the city of Florence:

{
  name: "Florence",
  zipCode: 50100
}

A JSON object may contain other objects, as well as arrays (of values, objects or arrays). For instance:

{
  name: "Alice",
  age: 26,
  birthPlace: {
    name: "Florence",
    zipCode: 50100
  },
  jobs: [
    {
      employer: "Kolping",
      start: 2021,
      end: 2022
    },
    {
      employer : "Eurac",
      start: 2023
    }
  ]
}

In JSON:

Organization

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

Organization #

The course consists of:

20 lectures (40 hours), and
10 labs (20 hours).

Julien Corman will teach the lectures and labs.

Schedule #

Lectures #

By default, lectures are scheduled on:

Tuesday 15:30 - 17:30
Thursday 10:30 - 12:30

Hint. Lectures can be followed via Teams (e.g. for students sitting at the back of the class), by joining the corresponding meeting (in the “Lectures” channel of this course’s Team).

Paradigm

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

Paradigm #

A programming paradigm is a way to write programs. Paradigms include:

imperative programming,

object-oriented programming,

functional programming,

logical programming,

etc.

Programming languages are often categorized based on the paradigms that they support.

Disclaimer. The boundaries of a paradigm are not always clear, and can be subjective. For this reason, we will (cautiously) borrow descriptions from Wikipedia.

Imperative programming #

Languages #

The most widely used programming languages are imperative.

Set, list, tuple

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

Set, list, tuple #

Set #

A set can be (informally) viewed as a collection of elements with no duplicate and in no specific order.

Examples.

$\{2,5\}$ and $\{5,2\}$ are the same set,

$\{2,5,2\}$ is not a set.

Power set #

Definition. The power set $\mathcal{P}(X)$ of a set $X$ is the set of all subsets of $X$.

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`

Type variable

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

Type variable #

A type variable stands for an underspecified type.

Example. Consider a function half that maps a list to its first half (say rounded down if the list has odd length).

The implementation of this function is identical for:

a list of strings,

a list of integers,

a list of Boolean values,

etc.

A type variable lets us declare such a function

in Haskell:
half :: [a] -> [a]    -- `a` is a type variable here
or in Java:
/* will be revealed later */

In Haskell #

Syntax. In Haskell, a type variable starts with a lowercase letter (like a regular variable).

Assignment 1

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

Assignment 1: higher-order functions and linear recursion #

Hint. In this assignment, you can often take advantage of the native higher-order functions that we have encountered: filter, map, all, any, etc.

Exercise 1: utility functions #

Implement the functions below by completing the function stubs in the file Src/Utility.hs.

Hint. Some of these functions can be used to implement others.

Hint. Feel free to create additional (auxiliary) functions to simplify your implementation.

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`

Class and instance

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

Class and instance #

A class can be viewed as a blueprint for a set of similar objects.

Terminology. An object that follows this blueprint is called an instance of the class.

Example. Consider the two following objects (in pseudocode):
{
  name: "Florence",
  zipCode: 50100,
  region: "Tuscany"
}
$\qquad$
{
  name: "Rome",
  zipCode: 00100,
  region: "Lazio"
}
Each of these objects describes a city, and they share the same keys (name, zipCode and region).

Compile time vs runtime error

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

Compile time vs runtime error #

Definition. In (pre)compiled languages (like Java, C/C++, C#, Haskell, Python, Go, Rust, etc.):

A compile time error prevents a program from compiling. It can be thought of as a “syntactic” error.

A runtime error (also called a bug) occurs during the execution of a program. It may depend on the input of the program.

Note. An IDE can identify some compile time errors (and highlight them), without even attempting to compile the program.

Intermediate result

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

Recursion and intermediate result #

In some cases, we need recursive calls to return more information than what the function should compute.

Example. We want to implement a function
longestWord :: String -> Int
that maps a string to the length of its longest word.

For simplicity, we will assume that words are separated by a blank space (noted ' ' in Haskell).
For instance,
longestWord "Hi there"
should evaluate to 5.

Recall that a string in Haskell is an array of characters.

Material

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

Course material #

Lectures #

This website contains the lecture material.

Additional readings are listed in the dedicated section. We emphasize that these are optional (the course is self-contained).

Assignments #

Assignments will be released via Codeboard.
Details are provided in the dedicated section.

Passing by value or by reference

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

Passing by value or by reference #

Definition. Imperative languages differ in the way arguments are passed to methods/functions. Two common strategies are:

passing by value: the method receives as input a copy of each argument.

passing by reference: the method receives as input a reference to each argument (which lets the method modify the originals).

Example. Consider the following program (in pseudocode):
myInteger = 0
myMethod(myInteger)
print(myInteger)

myMethod(argument){
  argument += 1
}
If the argument is passed by value, then the program prints 0.

If the argument is passed by reference, then the program prints 1.

In Java #

Java (and many other programming languages, like C, Python, Javascript, etc.) passes arguments by value.

Pattern matching

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

Pattern matching #

Pattern matching is a traditional feature of functional languages. It pairs well with sum types (which we will see later).

Pattern matching is no longer exclusive to functional languages: several imperative languages now support it to some extent (natively or via libraries). This includes:

C# (since 2020),
Java (since 2021),
PHP (since 2021),
Python (since 2021)
Rust (since its first release in 2015).

in Haskell #

A pattern is a syntactic expression that can match certain values.

Product type

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

Product type #

A product type can be viewed as a simplistic class, and its values as simplistic objects.

in Haskell #

Declaration #

Syntax. A product type can be declared as

Anonymous function

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

Anonymous function #

We have seen in the dedicated section that a function can be written anonymously, as a lambda expression.

Anonymous functions are a traditional feature of functional languages (like Haskell). But they have also been integrated to a variety of imperative languages, for instance:

Python (since 1994),
Javascript (since its initial release in 1995),
C# (since 2007)
C++ (since 2011)
Java (since 2014)
Rust (since its initial release in 2015)

In Haskell #

Syntax. “$\lambda x.$” in Haskell is written \x ->

Assignment 2

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

Assignment 2: functional patterns #

Exercise 1: utility functions #

Implement the functions below by completing the function stubs in the file Src/Utility.hs.

Hint. Some of these functions can be used to implement others.

Hint. Feel free to create additional (auxiliary) functions to simplify your implementation.

`lastMatch` #

Implement the function

lastMatch :: (a -> Bool) -> [a] -> Maybe a

such that lastMatch f xs is:

Just x if x is the last element of the list xs for which f x is True, or
Nothing if there is no such x.

For instance,

Bound

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

Bound #

In some scenarios, a regular type variable may be too generic.

Example. We may want to write an algorithm where the input can have any numeric type (integer, float, etc.).

A type variable in this case is too generic, because it can also stand for a non-numeric type (e.g. string, Boolean value, a function type, etc.).

In Haskell #

Example. The following function does not compile, because the operation + is not defined for arbitrary types.

Currying

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

Currying #

Functional programs traditionally define functions in curried form (for a definition, we refer to the dedicated section).

In Haskell #

Syntax #

A Haskell function can (in theory) take a tuple as argument.

Example.

power :: (Int, Int) -> Int
power (x,y) = x^y

However, functions in curried form are usually preferred, because they are more versatile.

Example. The function above in curried form can be written:
power :: Int -> (Int -> Int)
power = \x -> (\y -> x^y)
or equivalently:

Function

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

Function #

A function $f\colon X \to Y$ maps each element $x$ of its domain $X$ to an element $f(x)$ of its codomain $Y$.

Terminology. A function is also called a map.

Examples.

$\ $the function $f\colon \mathbb{Z} \to \mathbb{N}$ defined by

$\qquad f(x) = x^2$

$\qquad$maps each integer to its squared value.
$\qquad$For instance,

$\qquad f(3) = 9$

$\ $the function $g\colon \mathbb{N} \to \mathcal{P}(\mathbb{N})$ defined by

$\qquad g(x) = \{y \mid y \in \mathbb{N},\ y < x\}$

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`

Reading path

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

Reading path #

This page lists the topics covered during each lecture. It will be updated after a lecture.

Advice. If you miss a lecture, make sure to read the sections that we covered (and do the related exercises) before the next lecture. Otherwise you may fall behind.

Warning. On this website, the material is grouped in thematic chapters, to ease your revisions for the exam. These chapters do not always reflect the order of the lectures.

Sum type

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

Sum type #

A sum type represents several alternative types.

in Haskell #

Syntax. A sum type in Haskell is declared as
data <sum type name> = <type 1> | ... | <type n>

Example. In the following declarations:

Point is a product type, and
Shape is a sum type.

-- a point in the Euclidean plane, represented by its coordinates
data Point = PointC Float Float

-- a shape, defined as either a triangle or a rectangle
data Shape = TriangleC Point Point Point | RectangleC Point Point Point Point

Note. in Haskell, an enumerated type is a sum type.

Typing

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

Typing #

A typing system restricts the values that can be used in certain contexts.

Example. In Java, the following instruction is incorrect, because the variable x has type int, whereas the value "Hi" is a string.
int x = "Hi";
This line of code would generate a compile-time error.

Terminology. In this example, int is called a type annotation.

Static vs dynamic typing #

Static typing #

Definition. A programming language is statically typed if type checks are performed at compile time.

Accumulator and tail recursion

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

Accumulator and tail recursion #

Tail recursion #

Definition. A function/method is tail-recursive if it is:

linear recursive, and

does not perform any operation after a recursive call.

Example. The following function is tail-recursive

-- `True` iff the input string ends with an `s`
endsWithS :: String -> Bool
endsWithS [] = False               -- first base case
endsWithS ['s'] = True             -- second base case
endsWithS (_ : cs) = endsWithS cs  -- inductive case

Example. The function sum seen earlier (and reproduced here) is not tail-recursive, because the addition (Line 3) is performed after termination of the recursive call.

Boolean condition

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

Boolean condition #

Pattern matching has limitations.

Examples. No pattern can match:

integers greater than 2,

odd integers,

etc.

For more expressive conditions, programming language usually rely on Boolean expressions.

In Haskell #

Boolean expression #

We have seen how to define a Boolean operator (precisely, the Boolean operator “AND”) with patterns in Haskell.

This is not necessary: Haskell provides native implementations, similar to their counterparts in Java (and many programming languages). They include:

Evaluation

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

Evaluation #

Evaluation for this course is based on:

a written exam, and
5 to 6 assignments with oral presentations.

The assignments are optional.

Marking scheme #

An assignment counts only if your mark for this assignment is superior to your mark at the written exam.
If this is the case, then the assignment counts for 5% of your final mark.

Example. For the marks reported on the right:

Pipeline

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

Pipeline #

We will see in this section how functional languages provide a convenient syntax to compose functions that modify lists.

This lets us apply a sequence of operations (filter, transform, aggregate, etc.) to a stream of incoming data, analogously to Unix-like pipes. This style of programming also pairs well with functors and monads, which we will see in later sections.

Thanks to lazy evaluation, each operation in the pipeline can start feeding partial results to the next one, even if it has not finished processing its input list.

Prerequisites

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

Prerequisites #

Students are expected to have completed the Computer Programming course (INF/01 76203).

Consequence. The following topics are not covered in this course:

variables, assignments, variable scope,

basic data types (int, char, boolean, etc.).

expression evaluation,

conditional statements (“if/then/else”) and loops,

methods/functions,

arrays,

basic syntax of Java,

etc.

Hint. If you have not completed this course, you can ask for office hours to get help on these topics.

Pure function

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

Pure function #

Functional languages like Haskell favor pure functions, which behave like mathematical functions.

In imperative code, their adoption varies by language and community. For instance, pure functions are not idiomatic in C, but common in languages like Java, JavaScript, Python or Rust.

Side effect #

Definition. A method/function has a side effect if it modifies a resource (variable, object, array, etc.) that is defined outside of its scope.

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.

Functor

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

Functor #

The notion of functor comes from a branch of mathematics called category theory.

For programmers, a functor can be viewed as a generic type that implements a certain function (called fmap in Haskell), while respecting certain constraints.

In Haskell #

Definition. Functor in Haskell is a type class.

A type t that belongs to this class must:

be a generic type (with a single type variable), and

implement the function
fmap :: (Functor t) => (a -> b) -> t a -> t b

Terminology. The function fmap lifts a function

Generic type

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

Generic type #

In Haskell #

Syntax #

We have already seen how to define a product type or a sum type.

Example. As we have seen earlier, the type of lists of integers can be defined as follows:
data IntList = Nil | Cons Int IntList
Similarly, the type of lists of Booleans can be defined as
data BoolList = Nil | Cons Bool BoolList
To make this more generic, we can use a type variable instead of the concrete type (Int or Bool here).

Monad

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

Monad #

Like functors, monads come from category theory.

For programmers, a monad can be viewed as a functor that implements additional functions, while respecting certain constraints.

Monads serve a variety of purposes in functional programs. This includes (among other) writing to a log, or reading data.

In this section, we will only focus on two of the simplest monads, namely the type of lists and the option type (as we did for functors).

Office hours

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

Office hours #

You can ask for office hours to get help with:

prerequisites for this course,
an assignment,
a notion seen during a lecture,
etc.

These appointments must be scheduled via email or Teams.

Additional content #

Office hours can also be organized on demand for a group of students, on any of the following topics:

hierarchical file system,
git,
using a terminal,
text editors and IDEs (landscape and usage).

This content is optional. It is meant to help you interact with a computer, so that your learning experience does not get impaired by technological obstacles.

Content

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

Content of the course #

This is a programming course for beginners, with an emphasis on:

(class-based) object-oriented programming and

functional programming.

Programming languages #

We will use:

Haskell at the beginning of this course, for a short introduction to functional programming, and
Java during the rest of the course, for object-oriented and more general techniques.

Note. Many notions seen in this course are not specific to Haskell or Java. Accordingly, some sections may use pseudocode for conciseness.

List comprehension

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

List comprehension #

Pure functional programming does not admit loops.

In particular, this is the case of Haskell. So iteration in Haskell is primarily achieved via recursive functions.

Besides, Haskell provides an alternative syntax for a limited form of iteration, called list comprehensions.

List comprehensions are also available in Python (with a slightly different syntax) since the release of Python 2 (in 2000).

Syntax #

We have already seen set comprehensions.

Option type

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

Option type #

We introduce an important generic sum type, available in many languages, under a variety of names (Maybe, Option, optional, Optional, Nullable, etc.)

We will see in the dedicated sections that such a type can also be made a functor, and (perhaps most importantly) a monad. For now, we will use it without these extra features.

Motivation #

Problem. A programming language may not have a type that exactly fits the domain of a function that we want to implement.

A few higher-order functions

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

A few higher-order functions #

We introduce a few convenient higher-order functions.

In Haskell #

`filter` #

The function filter retains elements of a list that satisfy a certain condition.

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 ().

Call stack

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

Call stack #

During the execution of a program, the call stack keeps track of ongoing function/method calls:

when a function/method is called, a frame is pushed on top of the stack: the frame stores information about the execution of the function/method (current value of variables, …),

when the execution of the call terminates, the frame is popped from the stack, and control is passed back to the calling function/method (whose frame is now on top of the stack).

Additional resources

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

Additional resources #

This course is self-contained, meaning that no extra reading is required.
We list here optional resources that may help you complement it, or provide a different perspective.

A reading list for this course is available in the catalogue of the Unibz’s library. All books can be accessed via the library (either physically or digitally).

Among these books, we highlight the following five.

Introductory textbooks #

Java #

Java : the complete reference (11th edition) by Herbert Schildt McGraw-Hill Education, 2019

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 : [])

Software

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

Recommended software #

Lectures #

No particular software is required for the lectures.

The exercises can be solved using web applications, for instance:

the Haskell playground and
the Java playground.

However, a proper code editor may be more comfortable.

Assignments #

For the assignments, you will need an IDE for Haskell and Java (possibly the same one). We provide detailed instructions below.

Before these, we briefly explain what a package manager is, why it can be useful, and how to install and use one.

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

This page will be released after the dedicated lecture.

OOFP 2025-26

Enumerated type

Enumerated type #

Linear recursion

Linear recursion #

Object

Object #

A simple example: JSON #

Organization

Organization #

Schedule #

Lectures #

Paradigm

Paradigm #

Imperative programming #

Languages #

Set, list, tuple

Set, list, tuple #

Set #

Power set #

Tokens

Tokens #

Type variable

Type variable #

In Haskell #

Assignment 1

Assignment 1: higher-order functions and linear recursion #

Exercise 1: utility functions #

Base types

Base types #

Class and instance

Class and instance #

Compile time vs runtime error

Compile time vs runtime error #

Intermediate result

Recursion and intermediate result #

Material

Course material #

Lectures #

Assignments #

Passing by value or by reference

Passing by value or by reference #

In Java #

Pattern matching

Pattern matching #

in Haskell #

Product type

Product type #

in Haskell #

Declaration #

Anonymous function

Anonymous function #

In Haskell #

Assignment 2

Assignment 2: functional patterns #

Exercise 1: utility functions #

lastMatch #

Bound

Bound #

In Haskell #

Currying

Currying #

In Haskell #

Syntax #

Function

Function #

Native functions

Native functions #

Reading path

Reading path #

Sum type

Sum type #

in Haskell #

Typing

Typing #

Static vs dynamic typing #

Static typing #

Accumulator and tail recursion

Accumulator and tail recursion #

Tail recursion #

`lastMatch` #

`filter` #

The function `main` #