refactor: avoid name shadowing/unnecessary imports

4 files changed, 75 insertions, 69 deletions

diff --git a/src/Taskell/Data/Task.hs b/src/Taskell/Data/Task.hs
index f8dd1df..d60b6dd 100644
--- a/src/Taskell/Data/Task.hs
+++ b/src/Taskell/Data/Task.hs
@@ -4,20 +4,22 @@ module Taskell.Data.Task where
 
 import ClassyPrelude
 
-import Control.Lens (ix, makeLenses, (%~), (&), (.~), (?~), (^.), (^?))
+import Control.Lens ((%~), (&), (.~), (?~), (^.), (^?), ix, makeLenses)
 
-import           Data.Sequence        as S (adjust', deleteAt, (|>), insertAt)
-import           Data.Text            (strip)
-import           Data.Time.Zones      (TZ)
-import           Taskell.Data.Date    (Due (..), inputToTime)
+import Data.Sequence as S ((|>), adjust', deleteAt, insertAt)
+import Data.Text (strip)
+import Data.Time.Zones (TZ)
+import Taskell.Data.Date (Due(..), inputToTime)
 import qualified Taskell.Data.Subtask as ST (Subtask, Update, complete, duplicate, name)
 
-data Task = Task
-    { _name        :: Text
-    , _description :: Maybe Text
-    , _subtasks    :: Seq ST.Subtask
-    , _due         :: Maybe Due
-    } deriving (Show, Eq)
+data Task =
+    Task
+        { _name :: Text
+        , _description :: Maybe Text
+        , _subtasks :: Seq ST.Subtask
+        , _due :: Maybe Due
+        }
+    deriving (Show, Eq)
 
 type Update = Task -> Task
 
@@ -43,7 +45,7 @@ setDescription text =
 
 maybeAppend :: Text -> Maybe Text -> Maybe Text
 maybeAppend text (Just current) = Just (concat [current, "\n", text])
-maybeAppend text Nothing        = Just text
+maybeAppend text Nothing = Just text
 
 appendDescription :: Text -> Update
 appendDescription text =
@@ -64,8 +66,7 @@ getSubtask :: Int -> Task -> Maybe ST.Subtask
 getSubtask idx = (^? subtasks . ix idx)
 
 addSubtaskAtIndex :: Int -> ST.Subtask -> Update
-addSubtaskAtIndex index subtask =
-    subtasks %~ S.insertAt index subtask
+addSubtaskAtIndex idx subtask = subtasks %~ S.insertAt idx subtask
 
 addSubtask :: ST.Subtask -> Update
 addSubtask subtask = subtasks %~ (|> subtask)
diff --git a/src/Taskell/Events/Actions/Modal/Detail.hs b/src/Taskell/Events/Actions/Modal/Detail.hs
index 4258756..7b9775d 100644
--- a/src/Taskell/Events/Actions/Modal/Detail.hs
+++ b/src/Taskell/Events/Actions/Modal/Detail.hs
@@ -7,15 +7,14 @@ module Taskell.Events.Actions.Modal.Detail
 
 import ClassyPrelude
 
-import           Graphics.Vty.Input.Events
-import           Taskell.Events.Actions.Types      as A (ActionType (..))
-import           Taskell.Events.State              (clearDate, normalMode, quit, store, undo, write)
-import           Taskell.Events.State.Modal.Detail as Detail
-import           Taskell.Events.State.Types
-import           Taskell.Events.State.Types.Mode   (DetailItem (..), DetailMode (..))
-import           Taskell.IO.Keyboard.Types         (Actions)
-import           Taskell.Events.State.Modal.Detail (getCurrentSubtask)
-import qualified Taskell.UI.Draw.Field             as F (event)
+import Graphics.Vty.Input.Events
+import Taskell.Events.Actions.Types as A (ActionType(..))
+import Taskell.Events.State (clearDate, normalMode, quit, store, undo, write)
+import Taskell.Events.State.Modal.Detail as Detail
+import Taskell.Events.State.Types
+import Taskell.Events.State.Types.Mode (DetailItem(..), DetailMode(..))
+import Taskell.IO.Keyboard.Types (Actions)
+import qualified Taskell.UI.Draw.Field as F (event)
 
 events :: Actions
 events
@@ -40,27 +39,26 @@ events
 
 normal :: Event -> Stateful
 normal (EvKey KEsc _) = normalMode
-normal _              = pure
+normal _ = pure
 
 insert :: Event -> Stateful
 insert (EvKey KEsc _) s = do
     item <- getCurrentItem s
     case item of
         DetailDescription -> (write =<<) $ finishDescription s
-        DetailDate        -> showDetail s
-        (DetailItem _)    -> (write =<<) . (showDetail =<<) $ finishSubtask s
+        DetailDate -> showDetail s
+        (DetailItem _) -> (write =<<) . (showDetail =<<) $ finishSubtask s
 insert (EvKey KEnter _) s = do
     item <- getCurrentItem s
     case item of
         DetailDescription -> (write =<<) $ finishDescription s
         DetailDate -> (write =<<) $ finishDue s
-        (DetailItem _) ->
-             (Detail.newBelow =<<) . (write =<<)  $ finishSubtask s
+        (DetailItem _) -> (Detail.newBelow =<<) . (write =<<) $ finishSubtask s
 insert e s = updateField (F.event e) s
 
 event :: Event -> Stateful
 event e s = do
     m <- getCurrentMode s
     case m of
-        DetailNormal     -> normal e s
+        DetailNormal -> normal e s
         (DetailInsert _) -> insert e s
diff --git a/src/Taskell/Events/Actions/Modal/Help.hs b/src/Taskell/Events/Actions/Modal/Help.hs
index b77bca5..40b7365 100644
--- a/src/Taskell/Events/Actions/Modal/Help.hs
+++ b/src/Taskell/Events/Actions/Modal/Help.hs
@@ -1,14 +1,12 @@
 {-# LANGUAGE OverloadedLists #-}
 
 module Taskell.Events.Actions.Modal.Help
-  ( event,
-    events,
-  )
-where
+    ( event
+    , events
+    ) where
 
-import ClassyPrelude
 import Graphics.Vty.Input.Events
-import Taskell.Events.Actions.Types as A (ActionType (..))
+import Taskell.Events.Actions.Types as A (ActionType(..))
 import Taskell.Events.State
 import Taskell.Events.State.Modal.Help (moveHelpMenuDown, moveHelpMenuUp)
 import Taskell.Events.State.Types (Stateful)
@@ -16,12 +14,12 @@ import Taskell.IO.Keyboard.Types (Actions)
 
 events :: Actions
 events =
-  [ (A.Quit, quit),
-    (A.MoveUp, moveHelpMenuUp),
-    (A.Next, moveHelpMenuUp),
-    (A.MoveDown, moveHelpMenuDown),
-    (A.Previous, moveHelpMenuDown)
-  ]
+    [ (A.Quit, quit)
+    , (A.MoveUp, moveHelpMenuUp)
+    , (A.Next, moveHelpMenuUp)
+    , (A.MoveDown, moveHelpMenuDown)
+    , (A.Previous, moveHelpMenuDown)
+    ]
 
 event :: Event -> Stateful
 event _ = normalMode
diff --git a/src/Taskell/Events/State/Modal/Detail.hs b/src/Taskell/Events/State/Modal/Detail.hs
index de3f5c9..393c3c0 100644
--- a/src/Taskell/Events/State/Modal/Detail.hs
+++ b/src/Taskell/Events/State/Modal/Detail.hs
@@ -29,33 +29,42 @@ import ClassyPrelude
 
 import Control.Lens ((&), (.~), (^.))
 
-import           Taskell.Data.Date               (timeToDisplay)
-import qualified Taskell.Data.Seq                as S
-import qualified Taskell.Data.Subtask            as ST (blank, name, toggle)
-import           Taskell.Data.Task               (Task, addSubtask, countSubtasks, description, due,
-                                                  getSubtask, removeSubtask, setDescription, setDue,
-                                                  subtasks, updateSubtask, addSubtaskAtIndex)
-import           Taskell.Events.State            (getCurrentTask, setCurrentTask, store)
-import           Taskell.Events.State.Types      (State, Stateful, mode, time, timeZone)
-import           Taskell.Events.State.Types.Mode (DetailItem (..), DetailMode (..),
-                                                  ModalType (Detail), Mode (Modal))
-import           Taskell.UI.Draw.Field           (Field, blankField, getText, textToField)
+import Taskell.Data.Date (timeToDisplay)
+import qualified Taskell.Data.Seq as S
+import qualified Taskell.Data.Subtask as ST (blank, name, toggle)
+import Taskell.Data.Task
+    ( Task
+    , addSubtask
+    , addSubtaskAtIndex
+    , countSubtasks
+    , description
+    , due
+    , getSubtask
+    , removeSubtask
+    , setDescription
+    , setDue
+    , subtasks
+    , updateSubtask
+    )
+import Taskell.Events.State (getCurrentTask, setCurrentTask, store)
+import Taskell.Events.State.Types (State, Stateful, mode, time, timeZone)
+import Taskell.Events.State.Types.Mode
+    ( DetailItem(..)
+    , DetailMode(..)
+    , ModalType(Detail)
+    , Mode(Modal)
+    )
+import Taskell.UI.Draw.Field (Field, blankField, getText, textToField)
 
 newAbove :: Stateful
 newAbove state = do
-  index <- getCurrentSubtask state
-  store state
-    >>= newItemAtIndex index
-    >>= subTaskAtIndex index
-    >>= insertMode
+    idx <- getCurrentSubtask state
+    store state >>= newItemAtIndex idx >>= subTaskAtIndex idx >>= insertMode
 
 newBelow :: Stateful
 newBelow state = do
-  index <- (+1) <$> getCurrentSubtask state
-  store state
-    >>= newItemAtIndex index
-    >>= subTaskAtIndex index
-    >>= insertMode
+    idx <- (+ 1) <$> getCurrentSubtask state
+    store state >>= newItemAtIndex idx >>= subTaskAtIndex idx >>= insertMode
 
 updateField :: (Field -> Field) -> Stateful
 updateField fieldEvent s =
@@ -99,25 +108,25 @@ getCurrentSubtask :: State -> Maybe Int
 getCurrentSubtask state =
     case state ^. mode of
         Modal (Detail (DetailItem i) _) -> Just i
-        _                               -> Nothing
+        _ -> Nothing
 
 getCurrentItem :: State -> Maybe DetailItem
 getCurrentItem state =
     case state ^. mode of
         Modal (Detail item _) -> Just item
-        _                     -> Nothing
+        _ -> Nothing
 
 getCurrentMode :: State -> Maybe DetailMode
 getCurrentMode state =
     case state ^. mode of
         Modal (Detail _ m) -> Just m
-        _                  -> Nothing
+        _ -> Nothing
 
 getField :: State -> Maybe Field
 getField state =
     case state ^. mode of
         Modal (Detail _ (DetailInsert f)) -> Just f
-        _                                 -> Nothing
+        _ -> Nothing
 
 setComplete :: Stateful
 setComplete state = do
@@ -161,8 +170,8 @@ newItem state = do
     setCurrentTask task state
 
 newItemAtIndex :: Int -> Stateful
-newItemAtIndex index state = do
-    task <- addSubtaskAtIndex index ST.blank <$> getCurrentTask state
+newItemAtIndex idx state = do
+    task <- addSubtaskAtIndex idx ST.blank <$> getCurrentTask state
     setCurrentTask task state
 
 -- list navigation
@@ -178,7 +187,7 @@ previousSubtask :: Stateful
 previousSubtask = changeSubtask (-1)
 
 subTaskAtIndex :: Int -> Stateful
-subTaskAtIndex index state = setIndex state index
+subTaskAtIndex idx state = setIndex state idx
 
 lastSubtask :: Stateful
 lastSubtask state = lastIndex state >>= setIndex state