Coding/Learn/haskell/haskell modules imports
Learn Haskell & Pure Functional Programming
01.Introduction to Haskell & GHC
02.Syntax, Comments & Program Layout
03.Basic Types & Immutability
04.Arithmetic, Precedence & Infix Functions
05.Strings, Lists & the Cons Operator (:)
06.Booleans, Equality & Logical Operators
07.Conditional Expressions (if then else)
08.Function Guards (| condition = result)
09.Pattern Matching on Functions
10.Case Expressions (case of)
11.Local Bindings with let ... in
12.Auxiliary Bindings with where Clauses
13.Function Signatures & Referential Transparency
14.Currying & Partial Function Application
15.Anonymous Lambda Expressions (\x -> expr)
16.Higher-Order Functions: map, filter, foldl & foldr
17.Function Composition (.) & Application ($)
18.Recursion Patterns & Tail Recursion
19.Tuples & Pair Operations (fst, snd)
20.List Functions: head, tail, take, drop & null
21.Arithmetic Sequences & List Ranges
22.List Comprehensions
23.Zipping & Combining Lists (zip, zipWith)
24.Lazy Evaluation & Infinite Streams
25.Type Inference & Type Variables
26.Standard Typeclasses: Eq, Ord, Show & Num
27.Defining Custom Typeclasses & Instances
28.Type Synonyms (type) & newtype Wrappers
29.Algebraic Data Types (data ADT)
30.Record Syntax & Named Fields
31.The Maybe Type & Null Safety
32.The Either Type for Detailed Errors
33.Pattern Matching on Maybe & Either
34.Domain Errors & Validation Pipelines
35.Recursive Data Structures: Binary Trees
36.Strictness, seq & Bang Patterns (!)
37.The Functor Typeclass & fmap (<$>)
38.Applicative Functors: pure & (<*>)
39.The Monad Typeclass & Bind Operator (>>=)
40.Do Notation & Monadic Desugaring
41.The Three Monad Laws
42.Monadic Utilities: sequence, mapM, forM & when
43.The IO Monad & Pure/Impure Separation
44.File I/O: Reading & Writing Files
45.Modules, Exports & Qualified Imports
46.Monad Transformers: Reader, Writer & State
47.Concurrency, forkIO & MVars
48.Property-Based Testing with QuickCheck
49.Unit Testing & Test Suites (HUnit / Hspec)
50.Monadic Parsing & Parser Combinators
51.Production Architecture: Cabal & Stack
52.Comprehensive Functional Practice Challenges
53.Final Knowledge Assessment Quiz
54.Capstone Project: Domain Expression Evaluator & AST Engine
55.Verified Haskell Developer Certificate
Course Certificate0%

Complete all lessons to earn

LearnModules, Exports & Qualified Imports
45 / 55 0%
Lesson 45 of 55
9 mins read

Modules, Exports & Qualified Imports

PreviousNext Lesson
In Plain English

Haskell code is organized into modules. Use module Name (exportedFunctions) where to declare modules, and import qualified Data.Map as Map to avoid name clashes.

Deep Dive: How It Works

Module Header: module Geometry.Sphere (volume, area) where.

Explicit Imports: import Data.List (sort, nub) brings only specified functions into scope.

Qualified Imports: import qualified Data.Map as Map requires calling Map.lookup and Map.insert, preventing collisions with Prelude.lookup.

PointCore Rules to Remember

Point star
Explicit Export Lists: Control your public API by exposing only intended functions and types.
Point star
Qualified Imports: Avoid symbol name collisions across libraries with import qualified ... as.

Live Interactive Example

Hit Run Code to see it live
Explicit and Qualified Imports
Python 3.12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Output Console
Click "Run Code" to view the rendered output.
How it works: nub removes duplicates; Map.lookup performs a key-value search.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Remove Duplicates with nub

  • PointImport `Data.List (nub)` and apply to `[1, 1, 2, 3, 3]`.
  • PointPrint `"Unique: "` followed by its `show` string.
1
2
3
4
5
6
7
8
Sandbox Output
Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.

PreviousNext Lesson
Overview100 SheetLearnCertificates