[Kaleidoscope] Tiny typo fixes

[robin850]

Summary

Hello,

Just fixes for "lets" references which should certainly be "let's" in the Kaleidoscope tutorial.

Off topic : just wanted to say thank you for this amazing piece of software and the really great documentation ! <3

Have a nice day !

[SjoerdMeijer]

Looks good to me.
Just checking, do you have commit access?

[robin850]

No, I don't have commit access at all 😊

[SjoerdMeijer]

Then the obvious next question is: do you want me to commit it on your behalf?

[robin850]

Yeah, why not ! :-) (If it's not too time consuming for you, obviously)

[SjoerdMeijer]

Done: see message/link above. Thanks.

docs/tutorial/LangImpl02.rst

 `Operator-Precedence
 Parsing <http://en.wikipedia.org/wiki/Operator-precedence_parser>`_ to
 parse the Kaleidoscope language (the latter for binary expressions and
-the former for everything else). Before we get to parsing though, lets
+the former for everything else). Before we get to parsing though, let's
 talk about the output of the parser: the Abstract Syntax Tree.
 
 The Abstract Syntax Tree (AST)

 Full Code Listing
 =================
 
-Here is the complete code listing for our running example. Because this 
+Here is the complete code listing for our running example. Because this
 uses the LLVM libraries, we need to link them in. To do this, we use the
 `llvm-config <http://llvm.org/cmds/llvm-config.html>`_ tool to inform
 our makefile/command line about which options to use:

docs/tutorial/LangImpl03.rst

 Code generation for prototypes and functions must handle a number of
 details, which make their code less beautiful than expression code
 generation, but allows us to illustrate some important points. First,
-lets talk about code generation for prototypes: they are used both for
+let's talk about code generation for prototypes: they are used both for
 function bodies and external function declarations. The code starts
 with:
 

docs/tutorial/LangImpl04.rst

 experiment with passes from the command line, so you can see if they do
 anything.
 
-Now that we have reasonable code coming out of our front-end, lets talk
+Now that we have reasonable code coming out of our front-end, let's talk
 about executing it!
 
 Adding a JIT Compiler

 ``InitializeModuleAndPassManager``) is still open and waiting for new code to be
 added.
 
-With just these two changes, lets see how Kaleidoscope works now!
+With just these two changes, let's see how Kaleidoscope works now!
 
 ::
 

 the JIT and open a new module. In HandleExtern, we just need to add one line to
 add the prototype to FunctionProtos.
 
-With these changes made, lets try our REPL again (I removed the dump of the
+With these changes made, let's try our REPL again (I removed the dump of the
 anonymous functions this time, you should get the idea by now :) :
 
 ::

docs/tutorial/LangImpl05.rst

 it shows how easy it is to "grow" a language over time, incrementally
 extending it as new ideas are discovered.
 
-Before we get going on "how" we add this extension, lets talk about
+Before we get going on "how" we add this extension, let's talk about
 "what" we want. The basic idea is that we want to be able to write this
 sort of thing:
 

 Kaleidoscope allows side-effects, this behavior is important to nail
 down.
 
-Now that we know what we "want", lets break this down into its
+Now that we know what we "want", let's break this down into its
 constituent pieces.
 
 Lexer Extensions for If/Then/Else

 introduce new concepts. All of the code above has been thoroughly
 described in previous chapters.
 
-To motivate the code we want to produce, lets take a look at a simple
+To motivate the code we want to produce, let's take a look at a simple
 example. Consider:
 
 ::

 Phi nodes directly, if convenient. In this case, it is really
 easy to generate the Phi node, so we choose to do it directly.
 
-Okay, enough of the motivation and overview, lets generate code!
+Okay, enough of the motivation and overview, let's generate code!
 
 Code Generation for If/Then/Else
 --------------------------------

 =====================
 
 Now that we know how to add basic control flow constructs to the
-language, we have the tools to add more powerful things. Lets add
+language, we have the tools to add more powerful things. Let's add
 something more aggressive, a 'for' expression:
 
 ::

 to return, we'll just define the loop as always returning 0.0. In the
 future when we have mutable variables, it will get more useful.
 
-As before, lets talk about the changes that we need to Kaleidoscope to
+As before, let's talk about the changes that we need to Kaleidoscope to
 support this.
 
 Lexer Extensions for the 'for' Loop

     }
 
 This loop contains all the same constructs we saw before: a phi node,
-several expressions, and some basic blocks. Lets see how this fits
+several expressions, and some basic blocks. Let's see how this fits
 together.
 
 Code Generation for the 'for' Loop

docs/tutorial/LangImpl06.rst

 Now we have useful user-defined binary operators. This builds a lot on
 the previous framework we built for other operators. Adding unary
 operators is a bit more challenging, because we don't have any framework
-for it yet - lets see what it takes.
+for it yet - let's see what it takes.
 
 User-defined Unary Operators
 ============================