Skip to content

Haskell Flashcards (Basics)

Haskell Basics — Flashcards

30 flashcards covering core Haskell concepts. Tap a card to reveal the answer.

Additional Flashcard Topics

  • Pure Functions: no side effects; same input always produces same output. This makes reasoning and testing trivial but requires monads for I/O.

  • Lazy Evaluation: expressions are evaluated only when needed. Infinite data structures are possible: ones = 1 : ones. Strictness annotations (seq, !) force evaluation.

  • Type Classes: ad-hoc polymorphism. Eq, Ord, Show, Read, Num are standard type classes. Custom type classes define interfaces for new types.

  • Algebraic Data Types: data Shape = Circle Double | Rectangle Double Double. Sum types (OR) and product types (AND). Pattern matching exhaustively handles all constructors.

  • Monads: IO, Maybe, List, State. >>= (bind) chains effectful computations. do notation provides imperative-looking syntax for monadic code.

  • Higher-Order Functions: functions that take or return functions. map, filter, foldr are the building blocks of functional programming.

Intuition

Haskell is a purely functional language where expressions are evaluated lazily (on demand) and functions have no side effects. The type system is your most powerful tool, if the types align, the program is very likely correct. Type classes provide ad-hoc polymorphism (like interfaces in OOP), and monads sequence effectful computations while keeping the language pure. Currying means every function takes one argument and returns a function waiting for the next. Haskell’s type system is the most powerful among mainstream languages, enabling correctness guarantees that few other languages can match.

Common Pitfalls

  • Infinite recursion: Writing a base case that never triggers, the function recurses forever, building up the stack until it overflows. Always ensure the base case is reachable.
  • Off-by-one in infinite lists: Defining [1..] produces an infinite list, this is fine if consumed lazily but can hang if forced into a strict context (e.g., length [1..] never terminates).
  • Type class ambiguity: When a function uses a type class that has multiple instances for a type, Haskell cannot infer which one to use, add a type annotation to resolve the ambiguity.
  • Forgetting strictness: Lazy evaluation can cause space leaks. Use seq, BangPatternsor strict data types to control when evaluation happens.
  • Confusing = with ==: = is assignment (in let/where); == is equality comparison (from Eq class). Using one instead of the other causes parse errors.

Cross-References

  • Types and Functions: Deep dive into currying, higher-order functions, and type classes.
  • Pattern Matching: Structural pattern matching on algebraic data types.
  • Monads and Functors: Monad transformers and effect management covered in the flashcards.
  • Rust Traits: Rust’s trait system provides similar type-level abstractions to Haskell’s type classes.

Advanced Content

This section provides detailed coverage of advanced concepts, including full derivations, proofs, and extended examples.

Derivations and Proofs

Complete mathematical derivations and proofs are provided where appropriate. Each step is explained to ensure understanding of the underlying reasoning.

Extended Examples

Advanced examples demonstrate the application of concepts to complex problems. These examples go beyond standard exam questions to develop deeper understanding.

Research Connections

This material connects to current research and advanced applications in the field. Understanding these connections provides context for the study material.

Prerequisites

Ensure you have mastered the prerequisite material before attempting this advanced content.