Haskell in a Nutshell

Introduction

If you’ve ever been told you “think TOO functionally”, your dorky enough to enjoy Haskell.

Haskell is a purely functional, statically typed language that introduced concepts that modern programming languages like Rust, Scala, and Kotlin have borrowed.

(Borrowed? Stole? Were inspired by???? ….. :) )

Haskell is known for its mathematical purity, laziness (lazy evaluation, not developer laziness), and strong type system.

The History of Haskell

Haskell was born in 1990, created by a committee of academics and researchers who wanted a better, standardized functional programming language.

(Sometimes committee’s DO do cool things.. )

Why Was Haskell Created?

Functional programming languages existed, but they were fragmented and inconsistent.
Researchers wanted a pure functional language where side effects were controlled.
It needed a strong type system to eliminate entire categories of bugs.

Key Innovations of Haskell

✅ Purely Functional → Everything in Haskell is a function—no side effects!
✅ Lazy Evaluation → Computations only happen when needed, improving efficiency.
✅ Strong Static Typing → Haskell’s type system catches errors at compile time.
✅ Monads → Introduced a structured way to handle I/O and side effects.
✅ Pattern Matching → A powerful alternative to traditional conditional logic.

Further Reading:
Haskell Wikipedia
The History of Haskell

Haskell’s Influence on Modern Languages

Feature	Haskell	Modern Equivalent
Purely Functional	✅ Yes	❌ Mostly No (Except Elm, PureScript)
Lazy Evaluation	✅ Yes	✅ Python (Generators), Scala (Lazy Collections)
Strong Static Typing	✅ Yes	✅ Rust, Scala, Kotlin
Pattern Matching	✅ Yes	✅ Swift, Rust, Scala
Monads for Side Effects	✅ Yes	❌ Most languages don’t have explicit monads
Higher-Order Functions	✅ Yes	✅ Python, JavaScript, C#

💡 Verdict: Haskell introduced functional programming features that have now been adopted by many modern languages.

Haskell Syntax Table

Concept	Haskell Code	Equivalent in Python / Java
Hello World	`main = putStrLn "Hello, World!"`	`print("Hello, World!")` / `System.out.println("Hello, World!");`
Variables	`x = 42`	`x = 42` / `int x = 42;`
Loops	`mapM_ print [1..10]`	`for i in range(1, 11):` / `for (int i=1; i<=10; i++)`
Conditionals	`if x > 5 then "High" else "Low"`	`if x > 5: print('High')` / `if (x > 5) { System.out.println('High'); }`
Functions	`square x = x * x`	`def square(x): return x * x` / `int square(int x) { return x * x; }`
Lists	`[1,2,3,4,5]`	`[1, 2, 3, 4, 5]`
Recursion	`factorial 0 = 1; factorial n = n * factorial (n-1)`	`def factorial(n): return 1 if n == 0 else n * factorial(n - 1)`

Haskell Code Examples

1. Hello, World!

1
main = putStrLn "Hello, World!"

2. Declaring Variables

1
x = 42

3. If-Else Statement

1
if x > 10 then putStrLn "X is greater than 10" else putStrLn "X is 10 or less"

4. List Processing (Map Example)

1
map (*2) [1,2,3,4,5]  -- Doubles every element in the list

5. Function Definition

1
square x = x * x

6. Lists and List Comprehension

1
evens = [x | x <- [1..10], even x]

7. Recursion (Factorial)

1
2
factorial 0 = 1
factorial n = n * factorial (n - 1)

8. Lambda Functions

1
addOne = \x -> x + 1

9. Pattern Matching

1
2
3
describeList [] = "Empty list"
describeList [x] = "One element"
describeList _ = "Multiple elements"

10. Monads and I/O Example

1
2
3
4
main = do
    putStrLn "Enter your name:"
    name <- getLine
    putStrLn ("Hello, " ++ name ++ "!")

Why is Haskell Still Relevant?

✅ It’s widely used in academia, research, and specialized applications.
✅ It influenced modern functional languages like Rust, Scala, and Elm.
✅ It’s one of the most mathematically pure programming languages ever designed.

💡 Want to Try Haskell? Check out these online interpreters:

Key Takeaways

Haskell is a purely functional language that influenced many modern programming languages.
It introduced concepts like lazy evaluation, monads, and pattern matching.
If you want to truly understand functional programming, Haskell is a must-learn language.