Why learn Haskell? Haskell 101. Chapter 1.

Before we learn any syntax or anything. Let's first explore the most important question to learn anything.

That is to learn why learn Haskell?

Let's explore what makes Haskell worth learning and what makes it unique.

1. Pure Functional Programming:

This is the most important point.

Haskell is purely functional programming, which means it treats computation as the evaluation of mathematical functions. Pure functional programming means that functions are pure, having two main properties:

1. They always produce the same output for the same input
2. More predictable code which has no side effects like modifying global state

Let's see what it means:

In imperative languages, functions can often have side effects, which can lead to unexpected behaviour. In Haskell, functions are predictable.

Example:

//function add(x: number, y: number): number
add :: Int -> Int -> Int

//const add = (x, y) => x + y;
add x y = x + y

later we will understand keywords and syntax i.e :: . For now just try to get the gist.

 Int -> Int -> Int means:

• The function takes two Int parameters
• It returns an Int
• The arrow (->) is used to separate parameter types and the return type

1. we don't need parentheses around the parameters.
2. we don't use an arrow or the return keyword
3. The sign = is used to define the function body.

For easy explanation we will compare Haskell to Typescript:

1. Type system:
2. Similarities: Both Haskell & Typescript are statically typed, meaning types are checked at compile time
3. Difference: Haskell's type system is more powerful & expressive
4. Function Syntax:
5. Haskell's syntax are more concise. Params are listed after the function name, separated by spaces.
6. Typescript uses Javascript functions syntax with added type annotations.
7. Curring:

• In Haskell currying is automatic

  addFive :: Int -> Int
  addFive = add 5

• Typescript, you need to manually implement curried function.

const addFive = (y: number): number => add(5, y);

What is Currying?

The names comes from Haskell Curry, a mathematician and logician.

Currying is a technique in functional programming where a function that takes multiple arguments is transformed into a sequence of functions, each taking single arguments.

Currying is a way of structuring functions that makes them more flexible.

Let's use a real world analogy:

Imagine you have a coffee machine that makes different types of coffee drinks.

• A non-curried version would be like a machine where you input all ingredients at once (coffee, milk, sugar) and get your drink.

function makeCoffee(coffee, milk, sugar) {
 return `coffee: ${coffee} + ${milk} milk ${sugar} sugar.`;
}

const coffee = makeCoffee("Espresso", "100ml", "1 spoon");

Your coffee is: Espresso with 100ml milk and 1 spoon sugar.

• A curried version would be like a machine where you:

1. first choose the type of coffee
2. then decide on the amount of milk
3. then finally decide on sugar

function makeCoffee(coffee) {
 return function(milk) {
  return function(sugar) {
   return `coffee: ${coffee} + ${milk} milk & ${sugar} sugar.`;
  };
 };
}

const espressoWithMilk = makeCoffee("Espresso")("100ml");
const finalCoffee = espressoWithMilk("1 spoon");
console.log(finalCoffee);

Output: coffee: Espresso with 100ml milk and 1 spoon sugar.

Here a curried version is more specialized than the non curried one.

Key points to take away:

1. In curried version, instead of taking all arguments at once, the function takes one argument & return a new function that takes new argument.
2. This allow us to partially apply function. For example:

 ****************  non curried function *************
function add(a, b) {
  return a + b;
}
console.log(add(2, 3)); // Outputs: 5


 **************** curried function ****************

function add(a) {
  return function(b) {
    return a + b;
  }
}
console.log(add(2)(3));  // Outputs: 5

const addTwo = add(2);  // This creates a new function
console.log(addTwo(3));  // Outputs: 5
console.log(addTwo(4));  // Outputs: 6

In Haskell, this currying is automatic. Every function is curried by default:

add :: Int -> Int -> Int
add x y = x + y

addTwo :: Int -> Int
addTwo = add 2

main = do
  print(add 2 3)     -- Outputs: 5
  print(addTwo 3)    -- Outputs: 5

Currying breaks down a function that takes multiple arguments into a series of function, each taking a single argument which make your code more flexible and easier to reuse.

2. Concurrency & Easier Parallel Programming.

1. Because the pure function don't have any side effects and always produce the same output for the same input, they can be easily parallelized without worrying about shared mutable state.
2. Immutability: Data in Haskell is immutable by default, which means once a value is created, it can't be changed.
3. This functional nature makes it easier to write parallel code compared to imperative languages.
4. These properties makes it safer to run operations in parallel because you don't have to worry about different threads interfering with each other's data or producing inconsistent results.
5. Thus makes it easier to write concurrent & parallel programs.

import Control.Parallel.Strategies

// type signature of our function
parallelMap :: (a -> b) -> [a] -> [b]

parallelMap f xs = map f xs `using` parList rseq

-- Usage
result = parallelMap (\x -> x * x) [1..1000000]

1. Here parallelMap function
2. takes
3. function that goes from a to b
4. tales a list of a
5. returns a new list [b], where each element of a has been transformed by the function.
6. We will discuss this syntax at the end if you don't understand.

3. Strong static typing.

-- Define a func that takes two integers and returns their sum
addIntegers :: Integer -> Integer -> Integer
addIntegers x y = x + y

-- Define a function that takes two floating-point numbers and returns their sum
addFloats :: Float -> Float -> Float
addFloats x y = x + y

4. Mathematical foundations:

Haskell was designed with strong mathematical principles in mind. Learning haskell can help develop a more mathematical way of thinking about programming problems.

1. Complex ideas can often be expressed very concisely.
2. Focusing on what things are, rather than sequences of steps( declarative vs imperative)
3. Has powerful abstractions that can model complex systems elegantly.
4. Using function composition to build complex behaviours from simple parts.

5. Lazy Evaluation:

Allows us to define potentially infinite computation & data structures, but only compute the parts you actually use. This can lead to more efficient programs & allow for elegant solutions to certain problems.

-- A function that prints a message and returns a value
expensiveFunction :: Int -> Int
expensiveFunction x =
trace ("Computing expensive function for " ++ show x) (x * 1000)
 where trace = Debug.Trace.trace -- For demonstration purposes

-- A lazy list of expensive computations
lazyList :: [Int]
lazyList = map expensiveFunction [1..]

main :: IO ()
main = do
  putStrLn "Defining lazyList..."
  putStrLn "Taking the second element:"
  print (lazyList !! 1)
  putStrLn "Taking the first element:"
  print (head lazyList)
  putStrLn "Program finished."



Defining lazyList... 
Taking the second element: 
Computing expensive function for 2 2000 
Taking the first element: 
Computing expensive function for 1 1000 
Program finished.

1. Delayed computation:
2. when we defined lazylist, nothing was actually computed, the list is more like a recipe than a computed results.
3. Compute only what's needed:
4. when we asked for 2nd element, it only computed that element (& the 1st element, which it had skip over). It didn't compute the entire infinite list.

Breaking down the codes:

For examples provided earlier in this notes, we will discuss it here for clearly understanding.

Type signature:

::

It's read as has type of or is of type. This symbol is a fundamental part of Haskell's syntax for explicitly declaring the types of expression, functions or variables.

Let's break it down with some examples:

• For variables:

x :: Int
x = 5

declares that x has type of Int & then assigns the value 5

For functions

add :: Int -> Int -> Int
add x y = x + y

declares that add is a function that takes two Int parameters and returns Int

Since we also learnt what is currying this same statement could be written as

add :: Int -> (Int -> Int)
add x y = x + y

Int -> Int -> Int vs a -> b

Last Int and the b is always the retun type

1. In Int -> Int -> Int, the last Int is the final return type
2. In a -> b, b is the return type.
3. a -> b -> c, where c would be the final return type.

import Control.Parallel.Strategies

parallelMap :: (a -> b) -> [a] -> [b]
parallelMap f xs = map f xs `using` parList rseq

-- Usage
result = parallelMap (\x -> x * x) [1..1000000]

Dissecting it:

1. Why did we use (a -> b) -> [a] ->[b] instead of a -> b -> [a] -> [b]?
2. In hasklel, -> is a right associative. This means that a -> b -> c is interpreted as a -> (b -> c).
3. If we wrote a -> b -> [a] -> [b], it'd mean a function that takes four arguments:a, b, & a list of a and returns a list of b. This is not what we want for a map function.
4. Let's use an analogy of T-shirt customization service. Your service does two things:
5. Takes a design function like
6. add a logo
7. change color
8. It applies this design to a batch of plain T-shirts.

type PlainShirt = String
type CustomShirt = String

customizeBatch :: (PlainShirt -> CustomShirt) -> [PlainShirt] -> [CustomShirt]
customizeBatch designFunc shirts = map designFunc shirts

-- Example design functions
addLogo :: PlainShirt -> CustomShirt
addLogo shirt = shirt ++ " with Logo"

changeColor :: PlainShirt -> CustomShirt
changeColor shirt = "Blue " ++ shirt

-- Usage
plainShirts = ["T-Shirt", "Polo", "Tank Top"]
withLogo = customizeBatch addLogo plainShirts
colorChanged = customizeBatch changeColor plainShirts

main = do
  print withLogo   -- ["T-Shirt with Logo","Polo with Logo","Tank Top with Logo"]
  print colorChanged -- ["Blue T-Shirt","Blue Polo","Blue Tank Top"]

1. (PlainShirt -> CustomShirt) is our design function. It's in parentheses because it's one complete thing. A func that knows how to customize one shirt.
2. [Plainshirt] is your batch of plain shirts
3. [CustomShirt] is your resulting batch of customized shirts.
4. The func (customizeBatch designFunc shirts = map designFunc shirts)
5. takes
6. a design fucntion (a -> b) i.e goes from a to b
7. a list of plain shirts
8. returns a list of customized shirts.
9. Key points:
10. The parentheses in (a -> b) indicate that this is one argument that happens to be a function.
11. This function is then applied to each element in the list [a].
12. The result is a new list [b] where each element has been transformed by the function.

#Haskell #functionalProgramming #CSCE550