Fixes in Julia Manual

doc/manual/calling-c-and-fortran-code.rst

@@ -65,7 +65,7 @@ function from the standard C library::
  Int32
 
 ``clock`` takes no arguments and returns an ``Int32``. One common gotcha
-is that a 1-tuple must be written with with a trailing comma. For
+is that a 1-tuple must be written with a trailing comma. For
 example, to call the ``getenv`` function to get a pointer to the value
 of an environment variable, one makes a call like this::
 
@@ -339,7 +339,7 @@ Any operation that throws an error is probably currently unimplemented
 and should be posted as a bug so that it can be resolved.
 
 If the pointer of interest is a plain-data array (bitstype or immutable), the
-function ``pointer_to_array(ptr,dims,[own])`` may be more more useful. The final
+function ``pointer_to_array(ptr,dims,[own])`` may be more useful. The final
 parameter should be true if Julia should "take ownership" of the underlying
 buffer and call ``free(ptr)`` when the returned ``Array`` object is finalized.
 If the ``own`` parameter is omitted or false, the caller must ensure the

doc/manual/control-flow.rst

@@ -210,7 +210,7 @@ The reasoning is that ``a && b`` must be ``false`` if ``a`` is
 ``false``, regardless of the value of ``b``, and likewise, the value of
 ``a || b`` must be true if ``a`` is ``true``, regardless of the value of
 ``b``. Both ``&&`` and ``||`` associate to the right, but ``&&`` has
-higher precedence than than ``||`` does. It's easy to experiment with
+higher precedence than ``||`` does. It's easy to experiment with
 this behavior::
 
  julia> t(x) = (println(x); true)

doc/manual/faq.rst

@@ -23,7 +23,7 @@ collector runs; you can force this to happen with ``gc()``.
 How can I modify the declaration of a type/immutable in my session?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Perhaps you've defined a type and and then realize you need to add a
+Perhaps you've defined a type and then realize you need to add a
 new field. If you try this at the REPL, you get the error::
 
  ERROR: invalid redefinition of constant MyType

doc/manual/functions.rst

@@ -129,7 +129,7 @@ Operators Are Functions
 In Julia, most operators are just functions with support for special
 syntax. The exceptions are operators with special evaluation semantics
 like ``&&`` and ``||``. These operators cannot be functions since
-:ref:`short circuit evaluation <man-short-circuit-evaluation>` requires that
+:ref:`short-circuit evaluation <man-short-circuit-evaluation>` requires that
 their operands are not evaluated before evaluation of the operator.
 Accordingly, you can also apply them using parenthesized argument lists,
 just as you would any other function::

doc/manual/introduction.rst

@@ -86,7 +86,7 @@ and efficiency in a single language. In addition to the above, some
 advantages of Julia over comparable systems include:
 
 - Free and open source (`MIT
- licensed <https://github.com/JuliaLang/julia/blob/master/LICENSE>`_)
+ licensed <https://github.com/JuliaLang/julia/blob/master/LICENSE.md>`_)
 - User-defined types are as fast and compact as built-ins
 - No need to vectorize code for performance; devectorized code is fast
 - Designed for parallelism and distributed computation

doc/manual/methods.rst

@@ -27,7 +27,7 @@ addition to their number, and more than a single method definition may
 be provided. When a function is applied to a particular tuple of
 arguments, the most specific method applicable to those arguments is
 applied. Thus, the overall behavior of a function is a patchwork of the
-behaviors of its various method defintions. If the patchwork is well
+behaviors of its various method definitions. If the patchwork is well
 designed, even though the implementations of the methods may be quite
 different, the outward behavior of the function will appear seamless and
 consistent.

doc/manual/parallel-computing.rst

@@ -225,7 +225,7 @@ Parallel Map and Loops
 ----------------------
 
 Fortunately, many useful parallel computations do not require data
-movement. A common example is a monte carlo simulation, where multiple
+movement. A common example is a Monte Carlo simulation, where multiple
 processes can handle independent simulation trials simultaneously. We
 can use ``@spawn`` to flip coins on two processes. First, write the
 following function in ``count_heads.jl``::

doc/manual/types.rst

@@ -553,7 +553,7 @@ encountered in static parametric type systems can be relatively easily
 handled.
 
 All declared types (the ``DataType`` variety) can be parameterized, with
-the same syntax in each case. We will discuss them in in the following
+the same syntax in each case. We will discuss them in the following
 order: first, parametric composite types, then parametric abstract
 types, and finally parametric bits types.