PP 1 - Introduction to Haskell

A list of reflective questions to ask yourself Antifragile Availability bias Black Swan Bottlenecks Cause and Effect Compound Interest Confirmation Bias Create momentum to make progress Emergence Environment Design Every field has some core principles and ideas upon which all other derive Evolution Excellence is mundane Fail Fast So You Can Fix Early Feedback Loop First instinct fallacy Force multiplier Free Rider Problem Friction Gall's Law Hanlon's Razor Haskell Hickam's Dictum Hindsight Bias How to Acquire Mental Models Increase your leverage to become more productive Innovation Multiplier Inversion Leverage Local maxima vs. Global maxima Mario Marketing Mental Models Metcalfe's Law Minimize time getting into position, just go Mise en place Network Effects Not making time for yourself first leads to burnout Occam's Razor Opportunity Cost Overton windows Perverse Incentive Positive Sum Post Hoc Ergo Propter Hoc Fallacy PP 1 - Introduction to Haskell PP 2 - Types and classes PP 3 - Functions and lists PP 4 - Recursion PP 5 - Higher-order functions PP 6 - Declaring types and type classes Premature Optimization Reciprocity Regression to the Mean Sharpen the saw Sherlock Holmes and Mental Models Signal vs. Noise Skin in the Game Stop being ungrateful of having so little life, and be grateful that you were given any at all Survivorship bias Take on the role before you can assume the role The Barbell Strategy The Diderot Effect The Dunning-Kruger Effect The Feature-Positive Effect The Ivy Lee Method for daily planning The Law of Inertia The Lindy Effect The Map Is Not The Territory The Mere-Exposure Effect The Pareto Principle The Pauli Exclusion Principle The Pratfall Effect The QEC method The Red Queen Effect Theory of Constraints To catch a second wind, you have to stay in the game long enough Using notes to advance in life Via Negativa Wittgenstein's Ruler Working on vs. working in Your second brain should actively grow and compound Zero Sum

Learning goals

To be able to explain the notion of a function in the functional programming paradigm in a precise way
To understand the central points in the history of functional programming
To be able to install the Glasgow Haskell compiler and use it with a simple programming environment
To be able to write simple definitions in Haskell
To be able to edit, load and use simple Haskell scripts
To understand and be able to apply simple aspects of Haskell syntax: Definitions, comments, the layout rule and where declarations in definitions

Haskell

Run and debug fast

Use ghci filename.hs to start with a file loaded.
When in ghci, here are some useful commands:

:load file.hs
:reload or :r
:set editor <name> to set editor to name
:edit <name> to edit script name
:edit to edit current script
:show modules
:show imports
:type <expr> to show type of expression expr
:? for help
:quit

Conventions

Function and arguments begins with a lower-case letter. Capital letters are for types.
List arguments usually have an s suffix. E.g. xs, ns, nss.

Useful functions

Haskell has library functions. Many functions are useful on lists. Imagine the lists have elements. x represents a number.

Select first element of list: head []
Remove the first element from a list: tail [].
Select the nth element of a list: [] !! x
Select the first nth element of a list: take x []
Remove first n elements from a list: drop x []
Calculate length of list: length []
Calculate sum of list of numbers: sum []
Calculate product of a list of numbers: product []
Append two lists: [] ++ []
Reverse a list: reverse []

Functions

Function application is denoted using space.
Multiplication is denoted using *.
E.g. call f with parameters a and b: f a b
Function calls have higher priority than any other operator.
f a + b means (f a) + b.

A function can be a total function or a Partial function.

Math	Haskell
$f(x)$	`f x`
$f(x,y)$	`f x y`
$f(g(x))$	`f (g x )`
$f(x,g(y))$	`f x (g y)`
$f(x)g(y)$	`f x * g y`

The Layout Rule

In a sequence of definitions, each definition must begin in precisely the same column.
Meaning, it works on indentation. So you don’t need to explicitly define groupings of definitions.

Outgoing links: Haskell, Partial function