fix typos

Events/EventDuration.hs

@@ -17,9 +17,9 @@ import GHC.RTS.Events hiding (Event, GCIdle, GCWork)
 import qualified GHC.RTS.Events as GHC
 
 -------------------------------------------------------------------------------
--- This datastructure is a duration-based representation of the event
--- loginformation where thread-runs and GCs are explicitly represented
--- by a single constructor identifying their start and end points.
+-- This data structure is a duration-based representation of the eventlog
+-- information where thread-runs and GCs are explicitly represented by a
+-- single constructor identifying their start and end points.
 
 data EventDuration
   = ThreadRun {-#UNPACK#-}!ThreadId

GUI/App.hs

@@ -9,6 +9,6 @@ module GUI.App (initApp) where
 -------------------------------------------------------------------------------
 
 -- | Initialize application
--- Perform application initialization for non-Mac OS X platforms
+-- Perform application initialization for non-macOS platforms
 initApp :: IO ()
 initApp = return ()

GUI/DataFiles.hs

@@ -21,7 +21,7 @@ uiFile = "threadscope.ui"
 logoFile :: FilePath
 logoFile = "threadscope.png"
 
--- | Textual representaion of the UI file
+-- | Textual representation of the UI file
 ui :: Q Exp
 ui = [| TE.decodeUtf8 $(makeRelativeToProject uiFile >>= embedFile) |]
 

GUI/Timeline.hs

@@ -331,7 +331,7 @@ viewRangeToTimeRange view (x, x') = do
     return (xv, xv')
 
 -------------------------------------------------------------------------------
--- Update the internal state and the timemline view after changing which
+-- Update the internal state and the timeline view after changing which
 -- traces are displayed, or the order of traces.
 
 queueRedrawTimelines :: TimelineState -> IO ()

GUI/Timeline/Render.hs

@@ -170,7 +170,7 @@ drawSelection vp@ViewParameters{height} (RangeSelection x x') = do
 -------------------------------------------------------------------------------
 
 -- We currently have two different way of converting from logical units
--- (ie timestamps in micro-seconds) to device units (ie pixels):
+-- (i.e. timestamps in micro-seconds) to device units (i.e. pixels):
 --   * the first is to set the cairo context to the appropriate scale
 --   * the second is to do the conversion ourself
 --
@@ -450,7 +450,7 @@ showTrace _ TraceActivity =
   "Activity"
 showTrace _ TraceGroup{} = error "Render.showTrace"
 
--- | Calcaulate the maximal Y value for a graph-like trace, or Nothing.
+-- | Calculate the maximal Y value for a graph-like trace, or Nothing.
 traceMaxSpark :: Double -> Double -> Double -> Trace -> Maybe Double
 traceMaxSpark maxS _ _ TraceCreationHEC{}   = Just $ maxS * 1000
 traceMaxSpark maxS _ _ TraceConversionHEC{} = Just $ maxS * 1000

GUI/Timeline/Render/Constants.hs

@@ -18,7 +18,7 @@ ox = 10
 firstTraceY :: Int
 firstTraceY = 13
 
--- Gap betweem traces in the timeline view
+-- Gap between traces in the timeline view
 
 tracePad :: Int
 tracePad = 20

GUI/Timeline/Ticks.hs

@@ -86,7 +86,7 @@ renderXScaleArea ViewParameters{width, scaleValue, hadjValue, xScaleAreaHeight}
 data XScaleMode = XScaleTime | XScaleLog Double Double deriving Eq
 
 -- | Render the X (vertical) scale: render X axis and call ticks rendering.
--- TODO: refactor common parts with renderVRulers, in particlar to expose
+-- TODO: refactor common parts with renderVRulers, in particular to expose
 -- that ruler positions match tick positions.
 renderXScale :: Double -> Double -> Timestamp -> Int
              -> (Int -> Int) -> XScaleMode

papers/haskell_symposium_2009/sumEuler/SumEuler1.hs

@@ -1,5 +1,5 @@
 -------------------------------------------------------------------------------
--- This demonstrates that f `par` (f + e) does not result in parallelsim.
+-- This demonstrates that f `par` (f + e) does not result in parallelism.
 
 module Main
 where

tests/ParFib.hs

@@ -9,15 +9,15 @@ import Control.Parallel
 import System.Mem
 
 -------------------------------------------------------------------------------
--- A purely sequential implementaiton of fib.
+-- A purely sequential implementation of fib.
 
 seqFib :: Int -> Integer
 seqFib 0 = 1
 seqFib 1 = 1
 seqFib n = seqFib (n-1) + seqFib (n-2)
 
 -------------------------------------------------------------------------------
--- A thresh-hold value below which the parallel implementation of fib
+-- A threshold value below which the parallel implementation of fib
 -- reverts to sequential implementation.
 
 threshHold :: Int