Fixup templates

Author: NelosG

hw1/src/HW1/T1.hs

@@ -1,26 +1,30 @@
 module HW1.T1
-       ( Day (..),
-       nextDay,
-       afterDays,
-       isWeekend,
-       daysToParty
-       ) where
+  ( Day (..)
+  , afterDays
+  , daysToParty
+  , isWeekend
+  , nextDay
+  ) where
 
 import GHC.Natural (Natural)
 
-data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday deriving Show
+data Day =
+    Monday
+  | Tuesday
+  | Wednesday
+  | Thursday
+  | Friday
+  | Saturday
+  | Sunday
 
 -- | Returns the day that follows the day of the week given as input.
 nextDay :: Day -> Day
 
-
 -- | Returns the day of the week after a given number of days has passed.
 afterDays :: Natural -> Day -> Day
 
 -- | Checks if the day is on the weekend.
 isWeekend :: Day -> Bool
 
-
-
--- | Computes the number of days until the next Friday.
+-- | Computes the number of days until Friday.
 daysToParty :: Day -> Natural

hw1/src/HW1/T2.hs

@@ -1,48 +1,40 @@
 module HW1.T2
-       ( N(..),
-       nplus,
-       nmult,
-       nsub,
-       ncmp,
-       nFromNatural,
-       nToNum,
-       --advanced (comment if don't want to do andvanced)
-       nEven,
-       nOdd,
-       ndiv,
-       nmod
-       ) where
+  ( N (..)
+  , nFromNatural
+  , nToNum
+  , ncmp
+  , nmult
+  , nplus
+  , nsub
+    -- * Advanced
+  , nEven
+  , nOdd
+  , ndiv
+  , nmod
+  ) where
 
 import GHC.Natural (Natural)
 
-data N = Z | S N deriving Show
-
+data N =
+    Z
+  | S N
 
 nplus :: N -> N -> N        -- addition
 
-
 nmult :: N -> N -> N        -- multiplication
 
-
 nsub :: N -> N -> Maybe N   -- subtraction     (Nothing if result is negative)
 
-
-
 ncmp :: N -> N -> Ordering  -- comparison      (Do not derive Ord)
 
-
-
 nFromNatural :: Natural -> N
 
 nToNum :: Num a => N -> a
 
-
--- Advanced
+-- | Advanced
 
 nEven, nOdd :: N -> Bool    -- parity checking
 
-
 ndiv :: N -> N -> N         -- integer division
 
-
 nmod :: N -> N -> N         -- modulo operation

hw1/src/HW1/T3.hs

@@ -1,33 +1,44 @@
 module HW1.T3
-       ( Tree (..),
-       tsize,
-       tdepth,
-       tmember,
-       tinsert,
-       tFromList
-       ) where
+  ( Tree (..)
+  , tFromList
+  , tdepth
+  , tinsert
+  , tmember
+  , tsize
+  ) where
+
+import GHC.Generics
+
+-- The Meta field must store additional information about the subtree that can be accessed in constant time, for example its size. You can use Int, (Int, Int), or a custom data structure:
+-- 
+-- type Meta = Int         -- OK
+-- data Meta = M Int Int   -- OK
+
+data Tree a
+  = Leaf
+  | Branch
+    Meta 
+    (Tree a)
+    a
+    (Tree a)
 
-data Tree a = Leaf | Branch (Int, Int) (Tree a) a (Tree a) deriving Show
 
 -- | Size of the tree, O(1).
 tsize :: Tree a -> Int
 
 -- | Depth of the tree.
 tdepth :: Tree a -> Int
 
-
 -- | Check if the element is in the tree, O(log n)
 tmember :: Ord a => a -> Tree a -> Bool
 
-
--- | Build a tree from a list, O(n log n)
-tFromList :: Ord a => [a] -> Tree a
-
-
-
 -- | Insert an element into the tree, O(log n)
 tinsert :: Ord a => a -> Tree a -> Tree a
 
--- support functions
+-- | Build a tree from a list, O(n log n)
+tFromList :: Ord a => [a] -> Tree a
 
-mkBranch :: Tree a -> a -> Tree a -> Tree a
+-- Tip 1: in order to maintain the CachedSize invariant, define a helper function:
+-- 
+-- mkBranch :: Tree a -> a -> Tree a -> Tree a
+-- Tip 2: the Balanced invariant is the hardest to maintain, so implement it last. Search for “tree rotation”.

hw1/src/HW1/T4.hs

@@ -1,10 +1,10 @@
 module HW1.T4
-       ( tfoldr
-       ) where
+  ( tfoldr
+  ) where
 
-import HW1.T3 ( Tree(..) )
+import HW1.T3 (Tree (Branch, Leaf))
 
 tfoldr :: (a -> b -> b) -> b -> Tree a -> b
 
--- treeToList :: Tree a -> [a]    -- output list is sorted
--- treeToList = tfoldr (:) []
+treeToList :: Tree a -> [a]    -- output list is sorted
+treeToList = tfoldr (:) []

hw1/src/HW1/T5.hs

@@ -1,22 +1,10 @@
 module HW1.T5
-       ( splitOn,
-       joinWith
-       ) where
+  ( joinWith
+  , splitOn
+  ) where
 
-import Data.List.NonEmpty ( NonEmpty(..) )
+import Data.List.NonEmpty (NonEmpty ((:|)))
 
 splitOn :: Eq a => a -> [a] -> NonEmpty [a]
 
-
--- ghci> splitOn '/' "path/to/file"
--- ["path", "to", "file"]
-
--- ghci> splitOn '/' "path/with/trailing/slash/"
--- ["path", "with", "trailing", "slash", ""]
-
 joinWith :: a -> NonEmpty [a] -> [a]
-
--- (joinWith sep . splitOn sep)  ≡  id
-
--- ghci> "import " ++ joinWith '.' ("Data" :| "List" : "NonEmpty" : [])
--- "import Data.List.NonEmpty"

hw1/src/HW1/T6.hs

@@ -1,22 +1,8 @@
 module HW1.T6
-       ( mcat,
-       epart
-       ) where
-
+  ( epart
+  , mcat
+  ) where
 
 mcat :: Monoid a => [Maybe a] -> a
 
--- using foldable
-
--- ghci> mcat [Just "mo", Nothing, Nothing, Just "no", Just "id"]
--- "monoid"
-
--- ghci> Data.Monoid.getSum $ mcat [Nothing, Just 2, Nothing, Just 40]
--- 42
-
--- | Concat all Either's to array
-
 epart :: (Monoid a, Monoid b) => [Either a b] -> (a, b)
-
--- ghci> epart [Left (Sum 3), Right [1,2,3], Left (Sum 5), Right [4,5]]
--- (Sum {getSum = 8},[1,2,3,4,5])

hw1/src/HW1/T7.hs

@@ -1,41 +1,38 @@
 module HW1.T7
-       ( ListPlus(..),
-       Inclusive(..),
-       DotString(..),
-       Fun(..)
-       ) where
--- Define the following data type and a lawful Semigroup instance for it
-
-data ListPlus a = a :+ ListPlus a | Last a deriving Show
+  ( DotString (..)
+  , Fun (..)
+  , Inclusive (..)
+  , ListPlus (..)
+  ) where
+
+data ListPlus a = 
+  a :+ ListPlus a
+  | Last a       
 infixr 5 :+
 
 instance Semigroup (ListPlus a) where
+  ...
 
-
-data Inclusive a b = This a | That b | Both a b deriving Show
+data Inclusive a b = 
+  This a 
+  | That b 
+  | Both a b
 
 instance (Semigroup a, Semigroup b) => Semigroup (Inclusive a b) where
+  ...
 
-
-
-newtype DotString = DS String deriving Show
+newtype DotString = DS String
 
 instance Semigroup DotString where
-
--- ghci> DS "person" <> DS "address" <> DS "city"
--- DS "person.address.city"
-
--- Implement a Monoid instance for it
-
--- mempty <> a  ≡  a
--- a <> mempty  ≡  a
+  ...
 
 instance Monoid DotString where
+  ...
 
-
--- Implement lawful Semigroup and Monoid instances for it
 newtype Fun a = F (a -> a)
 
 instance Semigroup (Fun a) where
+  ...
 
 instance Monoid (Fun a) where
+  ...