Functional Programming Practice Exam

Question 1 Functional Programming

How does reduce work in functional programming?

reduce (also called fold) combines all elements of a collection into a single value using an accumulator function and an initial value.
Example: [1, 2, 3].reduce((acc, x) => acc + x, 0) returns 6.
It's the most powerful of map/filter/reduce — both map and filter can be implemented using reduce. A stream is a lazy, possibly infinite sequence. streamFrom n = n : streamFrom (n+1) is an infinite stream. Streams enable processing of unbounded data with bounded memory via take, map, and filter. They are the backbone of Rx-style reactive programming. MaybeT m a is a monad transformer that adds Maybe short-circuiting to an underlying monad m. do { x <- ma; y <- mb; return (x + y) } yields Nothing if either step yields Nothing, even if ma performs effects. A currying transforms a function that takes multiple arguments into a sequence of functions, each taking a single argument. Example:
const add = a => b => a + b;
add(2)(3); // 5
Named after mathematician Haskell Curry. In Haskell, all functions are automatically curried.

Question 2 Functional Programming

What is an interpreter in the Free monad sense?

|> (Elixir, F#): left-to-right data flow. x |> f(y) is f(x, y)
. (Haskell): right-to-left function composition. f . g is \x -> f (g x)

Pipes are data-focused; composition builds functions. F# has both: |> and >>. A term is in WHNF when its outermost structure is not a redex: either a constructor, lambda, or partial application. In Haskell, let x = 1 + 2 : l leaves x in WHNF even though the addition isn't done. Full evaluation to NF is sometimes called "NF" or "spine normal form." Either.map(f, Left(e)) returns Left(e) unchanged. Only the Right branch is transformed. Combined with flatMap, errors propagate through the entire chain without explicit checks. An interpreter is a function interp :: Free f a -> m a that walks the free-monad tree, folding each layer with a natural transformation. The same Free program can have a real-world interpreter (IO) and a test interpreter (pure values), enabling effect testing without mocks.

Question 3 Functional Programming

What is immutability's effect on concurrency?

Unfold (also called anamorphism) is the dual of fold — it builds a data structure from a seed value. While fold collapses a structure, unfold generates one.
Example: generating a list from 1 to n:
unfold(1, x => x > n ? null : [x, x+1])
produces [1, 2, 3, ..., n]. It's useful for generating sequences and streams. Immutable data is automatically thread-safe: no lock is needed because no thread can mutate shared state. This eliminates a whole class of bugs (data races, deadlocks). It is the central reason Erlang, Clojure, and Haskell scale to massive concurrency. Haskell uses the IO monad to handle side effects while maintaining purity. Side-effectful operations return IO a types. The do notation provides imperative-looking syntax:
do { name <- getLine; putStrLn ("Hello " ++ name) }
Pure code is strictly separated from effectful code at the type level, enforced by the compiler. The Y combinator enables anonymous recursion in lambda calculus: Y f = f (Y f). It computes the least fixed point of f, i.e. x = f x. Foundational for defining recursive functions without named bindings, and central to denotational semantics.

Question 4 Functional Programming

What is the EitherT monad transformer?

Many persistent vectors (including Clojure's) are implemented as tries with branching factor 32. Updating element i requires copying only O(log32 n) nodes along the path — effectively O(1) for vectors up to billions of elements. data Person = Person { name :: String, age :: Int } defines a record with field accessors automatically. name p extracts the name; p { age = 30 } updates the age (returning a new record). Records improve readability over positional constructors. Function composition combines two or more functions to create a new function where the output of one becomes the input of the next. Notation: (f ∘ g)(x) = f(g(x))
Example:
const compose = (f, g) => x => f(g(x));
const addOneThenDouble = compose(double, addOne);
It reads right to left. Piping is left-to-right composition. EitherT e m a lifts Either e over monad m, allowing error handling inside effectful code. Common in production Haskell: ExceptT String IO User chains IO with explicit error propagation through throwError and catchError.

Question 5 Functional Programming

What is bind (>>=) in Haskell?

The Writer monad appends to a log on every bind, but does not explicitly thread the log value. For long-running computations, the log can grow unbounded in memory. Solutions: streaming writers (one log line at a time), effects-based logging (MTL style), or a custom monad transformer. SKI calculus is a minimal combinator calculus with three primitives: S, K, and I (identity). It is computationally equivalent to lambda calculus but has no variables or lambdas. Useful for studying evaluation strategies without alpha-conversion. bind chains a monadic computation: m >>= k takes a monadic value m :: M a and a function k :: a -> M b, returning M b. It is the fundamental sequencing operation — return alone only wraps, while bind actually threads values through. The List monad represents non-deterministic computation: a list is a set of possible results. [1,2] >>= \x -> [x, -x] produces [1,-1,2,-2]. It is the basis of list comprehensions in Haskell and underlies generator-style enumeration in other languages.

Question 6 Functional Programming

What is the IO monad?

The IO monad encapsulates side effects (file I/O, console output, network calls) in a pure functional context. In Haskell, all side effects must be wrapped in the IO monad:
main :: IO ()
main = putStrLn "Hello"
This keeps the type system honest — you can tell from a function's type whether it performs side effects. Erlang models concurrency as lightweight isolated processes with message passing. Each process has its own heap, GC, and mailbox. There is no shared memory. spawn creates a process, ! sends a message, receive receives. Crash isolation is built in. Memoization is an optimization technique that caches the results of expensive function calls and returns the cached result for the same inputs. It works best with pure functions (guaranteed same output for same input).
Example: const memo = fn => { const cache = {}; return (...args) => cache[args] ??= fn(...args); }; A traversal is an optic that focuses on zero or more elements at once, like every element of a list. traverse :: Applicative f => (a -> f b) -> s -> f (t b). Traversals are the most general optic: lenses and prisms are special cases.

Question 7 Functional Programming

What is a difference list?

A difference list is a list represented as a function from a list to a list: type DList a = [a] -> [a]. Append becomes function composition: dl1 <> dl2 = dl1 . dl2, giving O(1) append. Useful in logic programming (Prolog) and Haskell's Show instance for performance. An interpreter is a function interp :: Free f a -> m a that walks the free-monad tree, folding each layer with a natural transformation. The same Free program can have a real-world interpreter (IO) and a test interpreter (pure values), enabling effect testing without mocks. The IO monad encapsulates side effects (file I/O, console output, network calls) in a pure functional context. In Haskell, all side effects must be wrapped in the IO monad:
main :: IO ()
main = putStrLn "Hello"
This keeps the type system honest — you can tell from a function's type whether it performs side effects. The Writer monad accumulates a log or telemetry alongside a computed value. Writer w a carries (a, w), where w is a monoid (so logs can be combined associatively). Common uses: logging, profiling, collecting errors.

Question 8 Functional Programming

What is Idris?

Immutable data is automatically thread-safe: no lock is needed because no thread can mutate shared state. This eliminates a whole class of bugs (data races, deadlocks). It is the central reason Erlang, Clojure, and Haskell scale to massive concurrency. Idris is a dependently-typed functional language with syntax like Haskell. It supports full dependent types, totality checking, and tactics-based theorem proving. It targets compilation to native code, JavaScript, and C, making it practical for systems where types carry significant information. filter takes a predicate function (returns true/false) and returns a new collection containing only elements for which the predicate returns true.
Example: [1, 2, 3, 4].filter(x => x % 2 === 0) returns [2, 4].
The original collection is not modified. A phantom type is a type parameter that does not appear in the constructor: data Token a = Token String — the a is phantom. Phantom types encode extra type-level information (e.g. Token "user" vs Token "admin") without runtime cost.

Question 9 Functional Programming

What is a Church encoding?

Partial application fixes some arguments of a function, producing a new function with fewer parameters. Unlike currying, it can fix multiple arguments at once. Example:
const multiply = (a, b) => a * b;
const double = multiply.bind(null, 2);
double(5); // 10 Lexical scoping (static scoping) means a variable's scope is determined by its position in the source code, not by the runtime call stack. Inner functions can access variables from their enclosing functions. This is the foundation of closures and is used in most modern languages including JavaScript, Python, and Haskell.

Y: Y f = (\x -> f (x x)) (\x -> f (x x)) — works in lazy languages like Haskell
Z: Z f = (\x -> f (\y -> x x y)) (\x -> f (\y -> x x y)) — works in strict languages because it wraps the recursive call in a thunk

A Church encoding represents data as higher-order functions. Church Bool = forall a. a -> a -> a; True = \t _ -> t. Church numerals: n = \f x -> iterate f x applied n times. It's a way to express all of computation using only lambdas.

Question 10 Functional Programming

What is immutability?

Eta expansion is the inverse of eta reduction: it wraps a function with a lambda to make its behavior explicit. map reverse might be eta-expanded to \xs -> map reverse xs when you need to make a type signature check or delay evaluation.

reduce: applies a single transformation during fold
transduce: composes multiple transformations then applies them during a single fold

transduce avoids intermediate collections when chaining many operations, dramatically improving performance. Algebraic data types (ADTs) are composite types formed by combining other types. Two main kinds:

Sum types (tagged unions): a value is one of several variants — Either<A, B>, enum
Product types: a value contains all fields — struct, tuple, record

Used extensively in Haskell, Rust, Scala, and ML family languages. Immutability means that once a data structure is created, it cannot be changed. Instead of modifying data, you create new copies with the desired changes. Benefits include:

Easier reasoning about code
Thread safety without locks
Simpler debugging and testing

Example: const newArr = [...arr, newItem]; instead of arr.push(newItem);

Question 11 Functional Programming

What is the Ord type class?

Eq provides (==) and (/=) for equality comparison. Any type with a meaningful notion of equality can be an Eq instance. Eq is a superclass of Ord, so any ordered type must also be equatable. For any functor F, mapping the identity function over it must yield the same structure: F.map(x => x, fa) ≡ fa. If map(id) changes anything, the type is not a lawful functor. Ord provides (<), (<=), (>), (>=), compare, and uses min/max. It requires Eq as a superclass. Ordering must be total: compare a b yields LT, EQ, or GT exactly. An Endomorphism is a function from a type to itself: type Endo a = a -> a. With composition, all Endo a form a monoid. They enable efficient repeated transformation, e.g. foldMap Endo [f,g,h] gives a single composed function.

How does reduce work in functional programming?

What is an interpreter in the Free monad sense?

What is immutability's effect on concurrency?

What is the EitherT monad transformer?

What is bind (>>=) in Haskell?

What is the IO monad?

What is a difference list?

What is Idris?

What is a Church encoding?

What is immutability?

What is the Ord type class?

What is the difference between Foldable and Functor?

What is eager (strict) evaluation?

What is the Applicative composition law?

What is beta reduction?

What is a cofree comonad?

What is a Natural Number object?

What is kind in Haskell?

What is a function monoid?

What is the difference between Elixir's |> and Haskell's . ?

What is a type class (Haskell)?

How does filter work in functional programming?

What is the Writer monad's logging problem?

What is a rose tree?

What is a trie in persistent data structures?

What is the difference between map and flatMap?

What is a setter?

What is a Scott encoding?

What is a prism?

What is Erlang's process model?

What is the "let it crash" philosophy?

What is functional programming?

What is a finger tree?

What is a fold operation?

What are persistent data structures?

What is the difference between join and bind?

What is a contravariant functor?

How does Clojure handle immutability?

What is the Functor type class?

What is a software transactional memory (STM)?

What is lambda calculus?

What is a natural transformation?

What is the difference between data and newtype?

What is a thunk leak?

What is the S combinator?

What is the difference between mapcat and flatMap?

What is type inference?

What is lexical scoping?

What is a phantom type?

What are transducers in Clojure?