Linting, haddocking

src/Dodge/Layout/Tree/Polymorphic.hs

@@ -15,7 +15,7 @@ import Data.Tree
 import Control.Monad.State
 import System.Random
 
-{-
+{- |
 Creates a linear tree.
 Safe.
 -}
@@ -23,7 +23,7 @@ treeFromPost :: [a] -> a -> Tree a
 treeFromPost []     y = Node y []
 treeFromPost (x:xs) y = Node x [treeFromPost xs y]
 
-{-
+{- |
 Creates a tree with one trunk branch, 
 input as a list, that ends in another tree.
 -}
@@ -34,7 +34,7 @@ treeFromTrunk
 treeFromTrunk [] t     = t
 treeFromTrunk (x:xs) t = Node x [treeFromTrunk xs t]
 
-{-
+{- |
 Applies a function to the root of a tree.
 -}
 applyToRoot :: (a -> a) -> Tree a -> Tree a
@@ -42,7 +42,7 @@ applyToRoot f (Node t ts) = Node (f t) ts
 
 treeSize = length . flatten
 
-{-
+{- |
 Applies a function to a specific node determined by a list of indices.
 Unsafe (partial function).
 -}
@@ -52,7 +52,7 @@ applyToNode (i:is) f (Node x xs) = Node x (ys ++ [applyToNode is f z] ++ zs)
   where
     (ys, z:zs) = splitAt i xs
 
-{-
+{- |
 Applies a function to the first node along a trunk that satisfies a given property.
 -}
 applyToSubTrunkBy :: (a -> Bool) -> (Tree a -> Tree a) -> Tree a -> Tree a
@@ -64,62 +64,65 @@ applyToSubTrunkBy _ _ t = t
 zipTree :: Tree a -> Tree b -> Tree (a,b)
 zipTree (Node x xs) (Node y ys) = Node (x,y) $ zipWith zipTree xs ys
 
-{-
+{- |
 Makes each node into its child number, i.e. the index it has 
 in the list of children of its parent.
 -}
 treeChildNums :: Tree a -> Tree Int
-treeChildNums t = setRoot 0 t
+treeChildNums = setRoot 0
   where 
     setRoot :: Int -> Tree a -> Tree Int
     setRoot i (Node x xs) = Node i (zipWith setRoot [0..] xs)
 
-{-
+{- |
 Makes each node into its path, i.e. the list of indices that, 
 when followed from the root, lead to the node.
 -}
 treePaths :: Tree a -> Tree [a]
-treePaths (Node x xs) = fmap (x :) $ Node [] (map treePaths xs)
+treePaths (Node x xs) = (x :) <$> Node [] (map treePaths xs)
 
-{-
+{- |
 Picks a random path in the tree.
 Uniform probability that the path leads to any specific node.
 -}
 randomPath :: RandomGen g => Tree a -> State g [Int]
 randomPath = takeOne . flatten . treePaths . treeChildNums
 
-{-
-Apply a function to a node picked uniformly at random.
+{- |
+Apply a function to the value of a node; 
+the node is picked uniformly at random.
 -}
 applyToRandomNode :: RandomGen g => (a -> a) -> Tree a -> State g (Tree a)
 applyToRandomNode f t = do
     p <- randomPath t
     return $ applyToNode p f t
 
-{-
+{- |
 Add a forest to the end of a tree (along the trunk).
 -}
 addToTrunk :: Tree a -> [Tree a] -> Tree a
 addToTrunk (Node x []) f = Node x f
 addToTrunk (Node x (t:ts)) f = Node x (addToTrunk t f : ts)
 
-{-
+{- |
 Find the depth of a tree along the trunk.
 -}
 trunkDepth :: Tree a -> Int
 trunkDepth (Node _ []) = 0
 trunkDepth (Node _ (x:xs)) = trunkDepth x + 1
 
-{-
+{- |
 Split a tree at a given point along its trunk.
 -}
-splitTrunkAt :: Int -> Tree a -> (Tree a, [Tree a])
+splitTrunkAt 
+    :: Int      -- ^ Split depth
+    -> Tree a -> (Tree a, [Tree a])
 splitTrunkAt 0 (Node x xs) = (Node x [],xs)
 splitTrunkAt i (Node y (x:xs)) = 
-    let (t, ts) = (splitTrunkAt (i-1) x)
-    in  (Node y (t : xs) , ts)
+    let (t, ts) = splitTrunkAt (i-1) x
+    in (Node y (t : xs) , ts)
 
-{-
+{- |
 Split a tree at a random point along its trunk.
 -}
 splitTrunk :: RandomGen g => Tree a -> State g (Tree a, [Tree a])