[commit: ghc] master: Typos in manual and comments (b1aede6)

[git at git.haskell.org]

Repository : ssh://git@git.haskell.org/ghc

On branch  : master
Link       : http://ghc.haskell.org/trac/ghc/changeset/b1aede61350a9c0a33c6d034de93a249c000a84c/ghc

>---------------------------------------------------------------

commit b1aede61350a9c0a33c6d034de93a249c000a84c
Author: Gabor Greif <ggreif at gmail.com>
Date:   Tue May 2 13:25:33 2017 +0200

    Typos in manual and comments


>---------------------------------------------------------------

b1aede61350a9c0a33c6d034de93a249c000a84c
 compiler/coreSyn/CoreSubst.hs     | 2 +-
 compiler/rename/RnEnv.hs          | 2 +-
 compiler/simplStg/StgCse.hs       | 2 +-
 docs/users_guide/glasgow_exts.rst | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/coreSyn/CoreSubst.hs b/compiler/coreSyn/CoreSubst.hs
index 640c7f1..919d9e8 100644
--- a/compiler/coreSyn/CoreSubst.hs
+++ b/compiler/coreSyn/CoreSubst.hs
@@ -723,7 +723,7 @@ The functions that substitute over IdInfo must be pretty lazy, because
 they are knot-tied by substRecBndrs.
 
 One case in point was Trac #10627 in which a rule for a function 'f'
-referred to 'f' (at a differnet type) on the RHS.  But instead of just
+referred to 'f' (at a different type) on the RHS.  But instead of just
 substituting in the rhs of the rule, we were calling simpleOptExpr, which
 looked at the idInfo for 'f'; result <<loop>>.
 
diff --git a/compiler/rename/RnEnv.hs b/compiler/rename/RnEnv.hs
index 3aa9472..570c6c0 100644
--- a/compiler/rename/RnEnv.hs
+++ b/compiler/rename/RnEnv.hs
@@ -609,7 +609,7 @@ TH we might use the same TH NameU in two different name spaces.
 eg (Trac #7241):
    $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])
 Here we generate a type constructor and data constructor with the same
-unique, but differnt name spaces.
+unique, but different name spaces.
 
 It'd be nicer to rule this out in extendGlobalRdrEnvRn, but that would
 mean looking up the OccName in every name-space, just in case, and that
diff --git a/compiler/simplStg/StgCse.hs b/compiler/simplStg/StgCse.hs
index ec4b188..6bd6adc 100644
--- a/compiler/simplStg/StgCse.hs
+++ b/compiler/simplStg/StgCse.hs
@@ -26,7 +26,7 @@ which produces this Core:
     bar :: forall a. a -> (Either Int a, Either Bool a)
     bar @a x = (Right @Int @a x, Right @Bool @a x)
 
-where the two components of the tuple are differnt terms, and cannot be
+where the two components of the tuple are different terms, and cannot be
 commoned up (easily). On the STG level we have
 
     bar [x] = let c1 = Right [x]
diff --git a/docs/users_guide/glasgow_exts.rst b/docs/users_guide/glasgow_exts.rst
index 0a09c7c..6e394e7 100644
--- a/docs/users_guide/glasgow_exts.rst
+++ b/docs/users_guide/glasgow_exts.rst
@@ -7196,7 +7196,7 @@ precisely the same as type given in the instance head. For example: ::
     instance Eq (Elem [e]) => Collects [e] where
       -- Choose one of the following alternatives:
       type Elem [e] = e       -- OK
-      type Elem [x] = x       -- BAD; '[x]' is differnet to '[e]' from head
+      type Elem [x] = x       -- BAD; '[x]' is different to '[e]' from head
       type Elem x   = x       -- BAD; 'x' is different to '[e]'
       type Elem [Maybe x] = x -- BAD: '[Maybe x]' is different to '[e]'