Make exports explicit

src/Arithmetic.hs

@@ -1,4 +1,16 @@
-module Arithmetic where
+module Arithmetic
+  ( isPrime,
+    myGCD,
+    coprime,
+    totient,
+    primeFactors,
+    primeFactorsMult,
+    primesR,
+    goldbach,
+    goldbachList,
+    multiplicativeInverse,
+  )
+where
 
 import Control.Arrow ((&&&))
 import qualified Control.Monad as M

src/BinaryTrees.hs

@@ -1,4 +1,4 @@
-module BinaryTrees where
+module BinaryTrees (cbalTree, symmetric, construct, symCbalTrees, hbalTree) where
 
 import BinaryTree (Tree (..))
 

src/BinaryTrees2.hs

@@ -1,6 +1,22 @@
 {-# OPTIONS -Wno-incomplete-uni-patterns -Wno-incomplete-patterns #-}
 
-module BinaryTrees2 where
+module BinaryTrees2
+  ( countLeaves,
+    leaves,
+    internals,
+    atLevel,
+    completeBinaryTree,
+    layout,
+    layout2,
+    stringToTree,
+    treeToString,
+    treeToPreorder,
+    treeToInorder,
+    preInTree,
+    tree2ds,
+    ds2tree,
+  )
+where
 
 import BinaryTree (Tree (..))
 import Control.Applicative ((<|>))

src/Lists.hs

@@ -3,7 +3,20 @@
 
 {-# OPTIONS -Wno-incomplete-patterns #-}
 
-module Lists where
+module Lists
+  ( NestedList (..),
+    myLast,
+    myButLast,
+    elementAt,
+    myLength,
+    myReverse,
+    isPalindrome,
+    flatten,
+    compress,
+    pack,
+    encode,
+  )
+where
 
 import Control.Arrow ((&&&))
 import Control.Monad ((<=<))

src/Lists2.hs

@@ -2,7 +2,18 @@
 
 {-# OPTIONS -Wno-incomplete-uni-patterns #-}
 
-module Lists2 where
+module Lists2
+  ( encodeModified,
+    decodeModified,
+    dupli,
+    repli,
+    dropEvery,
+    split,
+    slice,
+    rotate,
+    removeAt,
+  )
+where
 
 import qualified Control.Monad as M
 import qualified Data.List as L

src/Lists3.hs

@@ -1,6 +1,22 @@
 {-# OPTIONS -Wno-incomplete-uni-patterns #-}
 
-module Lists3 where
+module Lists3
+  ( insertAt,
+    range,
+    rndSelect,
+    diffSelect,
+    rndPerm',
+    rndPerm,
+    combinations,
+    group3,
+    group,
+    lsort,
+    lfsort,
+    fibonacci,
+    mmult,
+    fibonacci',
+  )
+where
 
 import qualified Control.Monad as M
 import Data.Array.IO (IOArray)

src/Logic.hs

@@ -1,7 +1,20 @@
 {-# LANGUAGE DerivingStrategies #-}
 {-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}
 
-module Logic where
+module Logic
+  ( and',
+    or',
+    nand',
+    nor',
+    xor',
+    impl',
+    equ',
+    table,
+    tablen,
+    gray,
+    huffman,
+  )
+where
 
 import qualified Control.Monad as M
 import qualified Data.Bifunctor as Bf

src/Misc.hs

@@ -1,4 +1,4 @@
-module Misc where
+module Misc (queens, knightsTour, knightsTo, closedKnights) where
 
 import qualified Control.Monad as M
 import qualified Data.Ix as Ix

src/Monads.hs

@@ -1,6 +1,13 @@
 {-# LANGUAGE DerivingStrategies #-}
 
-module Monads where
+module Monads
+  ( Operator (..),
+    Element (..),
+    randomWalkPaths,
+    collatz,
+    calculatePostfix,
+  )
+where
 
 import qualified Control.Monad as M
 import qualified Control.Monad.Identity as Id

src/MultiwayTrees.hs

@@ -1,6 +1,16 @@
 {-# LANGUAGE DerivingStrategies #-}
 
-module MultiwayTrees where
+module MultiwayTrees
+  ( Tree (..),
+    nnodes,
+    stringToTree,
+    treeToString,
+    ipl,
+    bottomUp,
+    treeToLisp,
+    lispToTree,
+  )
+where
 
 import Control.Applicative ((<|>))
 import qualified Control.Applicative as A
@@ -12,43 +22,6 @@ import qualified Parser as P
 data Tree a = Node a [Tree a]
   deriving stock (Eq, Show)
 
-tree4 :: Tree Char
-tree4 = Node 'b' [Node 'd' [], Node 'e' []]
-
-tree5 :: Tree Char
-tree5 =
-  Node
-    'a'
-    [ Node
-        'f'
-        [ Node 'g' []
-        ],
-      Node 'c' [],
-      Node
-        'b'
-        [ Node 'd' [],
-          Node 'e' []
-        ]
-    ]
-
-{-
-tree5:
-           ┌──┐
- ┌─────────┤a ├────────┐
- │         └─┬┘        │
- │           │         │
- │           │         │
-┌┴─┐       ┌─┴┐       ┌┴─┐
-│f │       │c │  ┌────┤b ├─────┐
-└┬─┘       └──┘  │    └──┘     │
- │               │             │
- │               │             │
-┌┴─┐           ┌─┴┐           ┌┴─┐
-│g │           │d │           │e │
-└──┘           └──┘           └──┘
-
--}
-
 -- Problem 70B: (*) Check whether a given term represents a multiway tree.
 -- ANSWER: Creating an invalid tree is not possible in Haskell.
 

src/Parser.hs

@@ -3,7 +3,7 @@
 
 {-# OPTIONS -Wno-incomplete-patterns #-}
 
-module Parser where
+module Parser (Parser (..), parse, letter, open, close, comma, space) where
 
 import Control.Applicative (Alternative, empty, (<|>))
 import qualified Control.Applicative as A

test/MonadsSpec.hs

@@ -1,7 +1,5 @@
 module MonadsSpec (spec) where
 
--- import Debug.Trace
-
 import qualified Control.Monad as M
 import qualified Data.Char as C
 import Monads

test/MultiwayTreesSpec.hs

@@ -11,6 +11,43 @@ import Test.Hspec
 import Test.Hspec.QuickCheck
 import Test.QuickCheck
 
+tree4 :: Tree Char
+tree4 = Node 'b' [Node 'd' [], Node 'e' []]
+
+tree5 :: Tree Char
+tree5 =
+  Node
+    'a'
+    [ Node
+        'f'
+        [ Node 'g' []
+        ],
+      Node 'c' [],
+      Node
+        'b'
+        [ Node 'd' [],
+          Node 'e' []
+        ]
+    ]
+
+{-
+tree5:
+           ┌──┐
+ ┌─────────┤a ├────────┐
+ │         └─┬┘        │
+ │           │         │
+ │           │         │
+┌┴─┐       ┌─┴┐       ┌┴─┐
+│f │       │c │  ┌────┤b ├─────┐
+└┬─┘       └──┘  │    └──┘     │
+ │               │             │
+ │               │             │
+┌┴─┐           ┌─┴┐           ┌┴─┐
+│g │           │d │           │e │
+└──┘           └──┘           └──┘
+
+-}
+
 t1 :: Tree Char
 t1 =
   Node