50 Haskell Interview Questions and Answers

Haskell is a purely functional programming language that features strong static typing, lazy evaluation, and immutability by default.

Functions in Haskell are defined using equations, e.g., 'add x y = x + y'. The type signature is optional but recommended: 'add :: Int -> Int -> Int'.

Pattern matching is a way of deconstructing values to use their components, allowing functions to behave differently based on the input patterns.

Lazy evaluation means expressions are only evaluated when their results are needed, allowing for efficient handling of infinite data structures and improved performance.

Types are labels for values, while typeclasses are interfaces defining behavior. For example, Int is a type, and Num is a typeclass for numeric operations.

Lists in Haskell are created using square brackets, e.g., [1,2,3]. They can also be created using range notation like [1..10] or list comprehensions.

'=' is used for definition/assignment, while '==' is used for equality comparison. For example, 'x = 5' defines x, while 'x == 5' checks if x equals 5.

IO in Haskell is handled through monads, specifically the IO monad, which safely separates pure functions from operations with side effects.

Guards are boolean expressions used to test properties of values and control program flow, similar to if-then-else but more readable.

Maybe is a type for values that might not exist, with constructors Just a (for present values) and Nothing (for absent values), helping handle potential failures safely.

Recursion is a fundamental concept where functions call themselves to solve problems. It's especially important in Haskell as there are no traditional loops.

Single-line comments start with -- and multi-line comments are enclosed between {- and -}.

The $ operator is used for function application without parentheses, with lower precedence than normal application. It helps reduce code clutter.

Lists are concatenated using the ++ operator, e.g., [1,2] ++ [3,4] results in [1,2,3,4].

A higher-order function is one that takes functions as arguments or returns functions as results. Common examples include map, filter, and fold.

The State monad represents computations that carry state through a sequence of operations. It's useful for maintaining mutable state in a pure functional way, with get and put operations for state manipulation.

To implement a custom typeclass, use the 'class' keyword to define the typeclass and 'instance' to provide implementations. Example: 'class MyShow a where myShow :: a -> String'.

Functors are types that implement fmap, allowing function application over wrapped values. They must satisfy identity and composition laws: fmap id = id and fmap (f . g) = fmap f . fmap g.

Applicative functors extend functors with pure and <*> operations, allowing application of wrapped functions to wrapped values and sequential composition of effects.

Monad transformers combine multiple monads into a single monad, allowing composition of different effects. Common examples include StateT, ReaderT, and ExceptT.

Lenses are composable abstractions for accessing and modifying parts of immutable data structures, making it easier to work with nested records and complex data types.

foldl performs left-associated reduction (from left to right), while foldr performs right-associated reduction. They differ in evaluation order and stack usage.

Type inference uses the Hindley-Milner algorithm to automatically determine types of expressions without explicit annotations, while maintaining type safety.

Generalized Algebraic Data Types allow for more precise type constraints on constructors, enabling type-safe operations that would be impossible with regular ADTs.

Type families are functions on types, allowing type-level programming and associated type relationships. They're useful for type-safe computations and generic programming.

Exceptions in Haskell are handled using Either, Maybe, or ExceptT for pure code, and catch/throw in IO monad for impure operations.

The Reader monad represents computations that need access to a shared environment, avoiding explicit parameter passing through deep call chains.

Lazy I/O allows reading files lazily but can lead to resource management issues. Better alternatives include strict I/O or streaming libraries like conduit.

Phantom types are type parameters that don't appear in the data constructor, used for adding compile-time constraints and improving type safety.

Concurrent Haskell uses lightweight threads (forkIO), STM for atomic operations, and MVars/TVars for communication between threads, all with functional guarantees.

Free monads provide a way to separate program description from interpretation, enabling flexible composition of domain-specific languages and better separation of concerns in large applications.

Rank-n types allow for polymorphic functions to be passed as arguments where the caller can't specify the types. They're useful for encoding higher-rank polymorphism and creating more flexible abstractions.

The GHC runtime uses thunks to implement lazy evaluation, with sophisticated mechanisms for sharing, blackholing to prevent infinite loops, and garbage collection of evaluated thunks.

Type-level computations use type families, data kinds, and promoted datatypes to perform calculations at compile time, enabling static guarantees and complex generic programming.

Category theory provides the mathematical foundation for Haskell's abstractions like functors, monads, and arrows, helping define lawful and composable interfaces.

Optimization involves understanding strictness annotations, RULES pragmas, fusion, worker/wrapper transformation, and GHC's rewrite rules for performance tuning.

Arrows generalize functions and monads, providing a unified interface for computation. They're useful for stream processing, circuit description, and parser combinators.

Dependent types allow types to depend on values. While Haskell doesn't directly support them, they can be emulated using singletons, GADTs, and type families.

STM provides atomic, composable transactions for concurrent programming, using TVars for shared state and ensuring consistency through optimistic execution and rollback.

Type roles (nominal, representational, phantom) control how type parameters behave with respect to coercion, ensuring type safety with newtypes and generic programming.

Type families provide functions on types with explicit equations, while functional dependencies specify relationships between type variables in multi-parameter type classes.

GHC's typechecker uses constraint solving, unification, and sophisticated inference algorithms to verify program correctness and resolve complex type-level computations.

Bidirectional pattern synonyms provide custom patterns with both pattern matching and construction capabilities, allowing abstraction over data representation.

Impredicative polymorphism allows instantiating quantified types with polymorphic types, which is challenging for type inference and requires special compiler support.

Effect systems can be implemented using free monads, extensible effects, or capability-based approaches to track and compose computational effects statically.

Relation algebras provide mathematical foundations for database queries, graph algorithms, and program verification through categorical abstractions.

Linear types ensure resources are used exactly once, enabling safe resource management, optimization opportunities, and better reasoning about memory usage.

Lazy pattern matching involves creating thunks for unevaluated patterns and managing evaluation order to maintain lazy semantics while ensuring pattern match completeness.

Type-level proofs use GADTs, type families, and constraint kinds to encode and verify program properties at compile time through the type system.

Purely functional data structures use techniques like path copying, structural sharing, and amortization to achieve efficiency while maintaining immutability.