[commit: ghc] master: Typos (ffa8d22)

[git at git.haskell.org]

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

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

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

commit ffa8d223a938981dedda5ee99088f35ef7cd52a4
Author: Krzysztof Gogolewski <krz.gogolewski at gmail.com>
Date:   Fri Sep 20 22:23:49 2013 +0200

    Typos


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

ffa8d223a938981dedda5ee99088f35ef7cd52a4
 compiler/llvmGen/LlvmCodeGen/CodeGen.hs |    4 ++--
 compiler/typecheck/TcHsType.lhs         |    2 +-
 compiler/typecheck/TcSimplify.lhs       |    2 +-
 docs/users_guide/glasgow_exts.xml       |   10 +++++-----
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/llvmGen/LlvmCodeGen/CodeGen.hs b/compiler/llvmGen/LlvmCodeGen/CodeGen.hs
index def9e2b..33107c0 100644
--- a/compiler/llvmGen/LlvmCodeGen/CodeGen.hs
+++ b/compiler/llvmGen/LlvmCodeGen/CodeGen.hs
@@ -1007,7 +1007,7 @@ genMachOp _ op [x] = case op of
                  w | w > toWidth -> sameConv' reduce
                  _w              -> return x'
         
-        panicOp = panic $ "LLVM.CodeGen.genMachOp: non unary op encourntered"
+        panicOp = panic $ "LLVM.CodeGen.genMachOp: non unary op encountered"
                        ++ "with one argument! (" ++ show op ++ ")"
 
 -- Handle GlobalRegs pointers
@@ -1252,7 +1252,7 @@ genMachOp_slow opt op [x, y] = case op of
                 else
                     panic $ "isSMulOK: Not bit type! (" ++ showSDoc dflags (ppr word) ++ ")"
 
-        panicOp = panic $ "LLVM.CodeGen.genMachOp_slow: unary op encourntered"
+        panicOp = panic $ "LLVM.CodeGen.genMachOp_slow: unary op encountered"
                        ++ "with two arguments! (" ++ show op ++ ")"
 
 -- More then two expression, invalid!
diff --git a/compiler/typecheck/TcHsType.lhs b/compiler/typecheck/TcHsType.lhs
index 64f5faf..38a4f2b 100644
--- a/compiler/typecheck/TcHsType.lhs
+++ b/compiler/typecheck/TcHsType.lhs
@@ -884,7 +884,7 @@ as if $(..blah..) :: forall k. k.
 
 In the e1 example, the context of the splice fixes kappa to *.  But
 in the e2 example, we'll desugar the type, zonking the kind unification
-variables as we go.  When we encournter the unconstrained kappa, we
+variables as we go.  When we encounter the unconstrained kappa, we
 want to default it to '*', not to AnyK.
 
 
diff --git a/compiler/typecheck/TcSimplify.lhs b/compiler/typecheck/TcSimplify.lhs
index 0ffda04..ca29111 100644
--- a/compiler/typecheck/TcSimplify.lhs
+++ b/compiler/typecheck/TcSimplify.lhs
@@ -220,7 +220,7 @@ simplifyInfer _top_lvl apply_mr name_taus wanteds
   | isEmptyWC wanteds
   = do { gbl_tvs <- tcGetGlobalTyVars
        ; qtkvs <- quantifyTyVars gbl_tvs (tyVarsOfTypes (map snd name_taus))
-       ; traceTc "simplifyInfer: emtpy WC" (ppr name_taus $$ ppr qtkvs) 
+       ; traceTc "simplifyInfer: empty WC" (ppr name_taus $$ ppr qtkvs) 
        ; return (qtkvs, [], False, emptyTcEvBinds) }
 
   | otherwise
diff --git a/docs/users_guide/glasgow_exts.xml b/docs/users_guide/glasgow_exts.xml
index 4390f53..eb8e4d9 100644
--- a/docs/users_guide/glasgow_exts.xml
+++ b/docs/users_guide/glasgow_exts.xml
@@ -430,7 +430,7 @@ Indeed, the bindings can even be recursive.
 	  <listitem><para> <literal>&quot;foo&quot;&num;</literal> has type <literal>Addr&num;</literal></para> </listitem>
 	  <listitem><para> <literal>3&num;</literal> has type <literal>Int&num;</literal>. In general,
 	  any Haskell integer lexeme followed by a <literal>&num;</literal> is an <literal>Int&num;</literal> literal, e.g.
-            <literal>-0x3A&num;</literal> as well as <literal>32&num;</literal></para>.</listitem>
+            <literal>-0x3A&num;</literal> as well as <literal>32&num;</literal>.</para></listitem>
 	  <listitem><para> <literal>3&num;&num;</literal> has type <literal>Word&num;</literal>. In general,
 	  any non-negative Haskell integer lexeme followed by <literal>&num;&num;</literal>
 	      is a <literal>Word&num;</literal>. </para> </listitem>
@@ -441,7 +441,7 @@ Indeed, the bindings can even be recursive.
    </sect2>
 
     <sect2 id="negative-literals">
-      <title>Negative Literals</title>
+      <title>Negative literals</title>
       <para>
           The literal <literal>-123</literal> is, according to
           Haskell98 and Haskell 2010, desugared as
@@ -465,11 +465,11 @@ Indeed, the bindings can even be recursive.
       <para>
           Haskell 2010 and Haskell 98 define floating literals with
           the syntax <literal>1.2e6</literal>. These literals have the
-          type <literal>Fractional a => Fractional</literal>.
+          type <literal>Fractional a => a</literal>.
       </para>
 
       <para>
-         The language extension <option>-XNumLiterals</option> allows
+         The language extension <option>-XNumDecimals</option> allows
          you to also use the floating literal syntax for instances of
          <literal>Integral</literal>, and have values like
          <literal>(1.2e6 :: Num a => a)</literal>
@@ -1743,7 +1743,7 @@ absurd x = case x of {}      -- (B)
 We much prefer (B). Why? Because GHC can figure out that <literal>(True :~: False)</literal>
 is an empty type. So (B) has no partiality and GHC should be able to compile with
 <option>-fwarn-incomplete-patterns</option>.  (Though the pattern match checking is not
-yet clever enough to do that.
+yet clever enough to do that.)
 On the other hand (A) looks dangerous, and GHC doesn't check to make
 sure that, in fact, the function can never get called.
 </para>