Merge pull request #420 from jagerman/doc-typos

Fix minor documentation spelling mistakes

docs/advanced.rst

@@ -540,7 +540,7 @@ pybind11 provides a few convenience macros such as
 in the preprocessor (which has no concept of types), they *will* get confused
 by commas in a template argument such as ``PYBIND11_OVERLOAD(MyReturnValue<T1,
 T2>, myFunc)``. In this case, the preprocessor assumes that the comma indicates
-the beginnning of the next parameter. Use a ``typedef`` to bind the template to
+the beginning of the next parameter. Use a ``typedef`` to bind the template to
 another name and use it in the macro to avoid this problem.
 
 
@@ -670,7 +670,7 @@ functions:
         .def_readwrite("contents", &MyClass::contents);
 
 In this case, properties can be read and written in their entirety. However, an
-``append`` operaton involving such a list type has no effect:
+``append`` operation involving such a list type has no effect:
 
 .. code-block:: pycon
 
@@ -1524,7 +1524,7 @@ or ``py::array::f_style``.
     void f(py::array_t<double, py::array::c_style | py::array::forcecast> array);
 
 The ``py::array::forcecast`` argument is the default value of the second
-template paramenter, and it ensures that non-conforming arguments are converted
+template parameter, and it ensures that non-conforming arguments are converted
 into an array satisfying the specified requirements instead of trying the next
 function overload.
 

docs/faq.rst

@@ -121,7 +121,7 @@ can be compiled independently from another. Following this approach will
 2. enable parallel builds (if desired).
 
 3. allow for faster incremental builds. For instance, when a single class
-   definiton is changed, only a subset of the binding code will generally need
+   definition is changed, only a subset of the binding code will generally need
    to be recompiled.
 
 How can I create smaller binaries?
@@ -131,7 +131,7 @@ To do its job, pybind11 extensively relies on a programming technique known as
 *template metaprogramming*, which is a way of performing computation at compile
 time using type information. Template metaprogamming usually instantiates code
 involving significant numbers of deeply nested types that are either completely
-removed or reduced to just a few instrutions during the compiler's optimization
+removed or reduced to just a few instructions during the compiler's optimization
 phase. However, due to the nested nature of these types, the resulting symbol
 names in the compiled extension library can be extremely long. For instance,
 the included test suite contains the following symbol: