An assortment of typos

d7729c75 · Gabor Greif · 6c794c31 · d7729c75 · d7729c75 · d7729c75
Commit d7729c75 authored Dec 08, 2015 by Gabor Greif 💬
--- a/compiler/basicTypes/Var.hs
+++ b/compiler/basicTypes/Var.hs
@@ -196,7 +196,7 @@ symbols will appear in the linker symbol table.

 However, note that this use of "exported" is quite different to the
 export list on a Haskell module.  Setting the ExportFlag on an Id does
-/not/ mean that if you import the module (in Haskell source code you
+/not/ mean that if you import the module (in Haskell source code) you
 will see this Id.  Of course, things that appear in the export list
 of the source Haskell module do indeed have their ExportFlag set.
 But many other things, such as dictionary functions, are kept alive

--- a/compiler/deSugar/DsBinds.hs
+++ b/compiler/deSugar/DsBinds.hs
@@ -521,7 +521,7 @@ Here `tm` is the monomorphic binding for `rhs`.
 With `Strict`, we want to force `tm`, but NOT `fm` or `gm`.
 Alas, `tm` isn't in scope in the `in <body>` part.

-The simplest thing is to return it in the polymoprhic
+The simplest thing is to return it in the polymorphic
 tuple `t`, thus:

  let t = /\a. letrec tm = rhs[fm,gm]

--- a/compiler/hsSyn/HsBinds.hs
+++ b/compiler/hsSyn/HsBinds.hs
@@ -305,7 +305,7 @@ you were defining) appears in the abe_poly field of the
 abs_exports. The bindings in abs_binds are for fresh, local, Ids with
 a *monomorphic* Id.

-If there is a group of mutually recursive (see Note [Polymoprhic
+If there is a group of mutually recursive (see Note [Polymorphic
 recursion]) functions without type signatures, we get one AbsBinds
 with the monomorphic versions of the bindings in abs_binds, and one
 element of abe_exports for each variable bound in the mutually
@@ -319,7 +319,7 @@ After type checking we get
                                  , abe_mono = g :: a -> a }]
            , abs_binds = { (f,g) = (\x -> x, f) }

-Note [Polymoprhic recursion]
+Note [Polymorphic recursion]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider
   Rec { f x = ...(g ef)...
@@ -348,7 +348,7 @@ up with
       ; AbsBinds { ...for g ... } }

 This approach allows both f and to call each other
-polymoprhically, even though only g has a signature.
+polymorphically, even though only g has a signature.

 We get an AbsBinds that encompasses multiple source-program
 bindings only when

--- a/compiler/main/HscMain.hs
+++ b/compiler/main/HscMain.hs
@@ -798,7 +798,7 @@ hscFileFrontEnd mod_summary = do
 -- Note [Safe Haskell Inference]
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- Safe Haskell does Safe inference on modules that don't have any specific
-- safe haskell mode flag. The basic aproach to this is:
+-- safe haskell mode flag. The basic approach to this is:
 --   * When deciding if we need to do a Safe language check, treat
 --     an unmarked module as having -XSafe mode specified.
 --   * For checks, don't throw errors but return them to the caller.

--- a/compiler/typecheck/TcRnTypes.hs
+++ b/compiler/typecheck/TcRnTypes.hs
@@ -1142,7 +1142,7 @@ data TcIdSigInfo
 data TcIdSigBndr   -- See Note [Complete and partial type signatures]
  = CompleteSig    -- A complete signature with no wildards,
                   -- so the complete polymorphic type is known.
-        TcId          -- The polymoprhic Id with that type
+        TcId          -- The polymorphic Id with that type

  | PartialSig     -- A partial type signature (i.e. includes one or more
                   -- wildcards). In this case it doesn't make sense to give

--- a/libraries/base/System/Environment.hs
+++ b/libraries/base/System/Environment.hs
@@ -299,7 +299,7 @@ putEnv keyvalue = do
  -- IMPORTANT: Do not free `s` after calling putenv!
  --
  -- According to SUSv2, the string passed to putenv becomes part of the
-  -- enviroment.
+  -- environment.
  throwErrnoIf_ (/= 0) "putenv" (c_putenv s)

 foreign import ccall unsafe "putenv" c_putenv :: CString -> IO CInt

--- a/testsuite/tests/typecheck/should_compile/tc191.hs
+++ b/testsuite/tests/typecheck/should_compile/tc191.hs
@@ -19,7 +19,7 @@ geq :: Data a => a -> a -> Bool
 geq x y = geq' x y
  where
 --    This type signature no longer works, because it is
--    insufficiently polymoprhic.
+--    insufficiently polymorphic.
 --    geq' :: forall a b. (Data a, Data b) => a -> b -> Bool
    geq' :: GenericQ (GenericQ Bool)
    geq' x y =     (toConstr x == toConstr y)