Haskell Functors Explained: fmap and Type Constructors Tutorial

Haskell provides several built-in parameterized types: lists use [a] syntax with type parameters in brackets, tuples use (a,b,c) syntax with type parameters in parentheses, and the functional arrow (->) serves as a type constructor taking two type arguments. The Maybe type (Maybe a) represents optional values with Nothing (no value) and Just a (value present), while the Either type (Either a b) represents sum types with Left a (error case) and Right b (success case), commonly used for error handling where Right wraps successful results and Left wraps error information.

The Maybe type (representing optional values) is isomorphic to the sum of unit and a type. It has two constructors: Nothing (corresponding to the left unit) and Just a (corresponding to the right a). This shows how algebraic manipulation of types directly translates to concrete data structure definitions in programming languages like Haskell.

Algebraic data types (ADTs) in Haskell are a powerful mechanism for defining custom data structures by combining multiple data constructors, each potentially carrying associated fields of various types; unlike conventional object-oriented classes, ADTs use pattern matching to deconstruct values and handle different cases explicitly, enabling robust error handling through types like Maybe (which represents optional values) and recursive structures like lists and trees, while Haskell's type system ensures compile-time correctness by making illegal states unrepresentable.

This section covers two fundamental algebraic data types in Haskell. The Maybe type represents optional values with constructors Nothing and Just a, enabling safe handling of partial functions. The Either type provides error handling with Left a and Right b constructors. Both types are used to define total functions that handle edge cases gracefully. The maybe and either functions serve as destructors for pattern matching on these types, allowing programmers to extract values safely without explicit case analysis.

ADTs solve fundamental data modeling challenges by replacing ad hoc solutions like nulls and separate fields. When representing optional data (like payment methods), ADTs ensure by construction that you have exactly the right amount of data for whichever case applies—no too little, no too much. Unlike inheritance which is open to new subclasses at deployment time, ADTs are closed by design, meaning you know all possible cases at compile time. This enables compiler-checked exhaustiveness in pattern matching. The Option type demonstrates parametric polymorphism applied to ADTs, providing a reusable null replacement with Some and None constructors. The Result type extends this by separating success and failure into distinct generic parameters, enabling better composition than monolithic ADTs.

Type classes define interfaces that multiple types can implement. The Eq type class defines types supporting equality testing. Types implement either (==) or (/=), with the compiler providing defaults for the other. Custom types can be made instances by implementing required methods. The Ord type class extends Eq with ordering support, using compare to return Ordering (LT, EQ, GT).

Type classes in Haskell define interfaces (like 'Eq' for equality) that types can implement. An 'instance' declaration shows how a specific type implements a type class. For example, 'instance Eq Shape where ...' shows how Shape implements equality.

Type classes in Haskell are collections of types supporting the same methods. The EQ class provides equality (==) and inequality (/=) operators. The Ordered class adds comparison operators (<, <=, >, >=) and min/max, requiring types to be instances of EQ first. The Show class converts values to strings via 'show', while Read parses strings to values via 'read'. The Numeric class provides basic arithmetic (+, -, *, negate, abs, signum) but excludes division. The Integral class extends Numeric for whole numbers, adding integer division (div) and modular arithmetic (mod). The Fractional class extends Numeric for floating point numbers, adding floating point division (/) and reciprocation (recip). The Enum class supports sequentially ordered types with the '..' operator. Only 'data' and 'newtype' declarations can be made into type class instances.

Las type classes son conjuntos de tipos de datos que siguen ciertas condiciones y permiten usar operaciones específicas. Por ejemplo, 'Num' incluye todos los tipos numéricos (Int, Float, Double), 'Eq' incluye tipos que pueden ser comparados por igualdad, y 'Ord' incluye tipos que pueden ser ordenados. Las type classes permiten definir funciones genéricas que funcionan para múltiples tipos. La jerarquía es: 'Show' (todos los tipos pueden mostrarse), luego 'Eq', luego 'Ord', y finalmente 'Num'. 'Num' incluye 'Integral' (enteros) y 'Fractional' (fraccionarios).

Type classes in Haskell define interfaces that types can implement. A type class specifies method signatures that types must provide to be members. Built-in classes include Eq (equality), Ord (ordering), Show (string conversion), and Read (parsing from strings). User-defined types can become members by providing implementations for required methods, enabling generic programming across different data types.

This comprehensive section covers higher-order functions, currying, and complex list processing in Haskell. The instructor explains currying as the process of transforming a function that takes multiple arguments into a sequence of functions that each take one argument. The instructor demonstrates this with 'take', which takes two arguments (a number and a list) but can be partially applied to create a function that takes only one argument. The instructor demonstrates combining partial application and composition to create complex functions, such as creating a function that doubles a number and then adds one. The instructor covers the 'map' function, which applies a given function to each element of a list and returns a new list with the results. The instructor demonstrates this with examples like mapping 'length' over a list of strings to get a list of numbers, and mapping 'even' over a list of numbers to get a list of booleans. The instructor also covers the 'filter' function, which selects elements from a list that satisfy a given condition (predicate function). The instructor demonstrates combining 'filter' with function composition to create more complex filtering conditions. The instructor creates a data structure for representing movies using tuples, with components for title, duration, country, and a boolean indicating if it's a good movie. The instructor demonstrates calculating the total duration of a movie marathon by extracting the duration from each movie, mapping this function over the list, and summing the results.

In Haskell, functions are first-class citizens that can accept and return other functions, making them higher-order functions; every function technically takes only one argument and returns one value, which enables currying—where functions can be partially applied by calling them with fewer arguments than expected, returning new functions that wait for the remaining parameters. This paradigm allows powerful abstractions like map, filter, and zip, which separate computation patterns from specific implementations, enabling concise and reusable code.

First-class functions can be passed as arguments, returned from functions, assigned to variables, and stored in data structures. Higher-order functions either accept other functions as arguments or return new functions, enabling powerful patterns like memoization, debouncing, and specialized function creation. Function composition combines multiple functions into a single function executing them sequentially, applying arguments from right to left. Currying transforms functions taking multiple arguments into sequences of single-argument functions. Partial application fixes some arguments, returning specialized functions. Together, these techniques enable building complex transformations from simple building blocks, reducing boilerplate and improving code clarity.

A higher-order function takes another function as an argument or returns a function as its result. Currying transforms a function that takes multiple arguments into a sequence of functions, each taking a single argument. This enables partial application of arguments. For example, a function that adds two numbers can be curried so that you can pass one number first and get back a function that expects the second number. These techniques help reduce code duplication and create reusable code patterns.

The map function can be implemented using reduce by maintaining an accumulator array and pushing transformed elements. Filter can be implemented by checking a predicate and deciding whether to include each element. Currying transforms a function taking multiple arguments into a sequence of single-argument functions. When called with fewer arguments than expected, it returns a new function accepting remaining arguments. Implementation uses the function.length property to track expected arguments and recursively returns new functions until all arguments are provided. This enables partial application, allowing arguments to be passed incrementally.