Merge pull request #1609 from pyx/fix-doc-typo

Documentation improvement

docs/contrib/sequences.rst

@@ -55,7 +55,7 @@ This results in the sequence ``[0 1 1 2 3 5 8 13 21 34 ...]``.
 seq
 ===
 
-Usage: ``(seq [n] (* n n)``
+Usage: ``(seq [n] (* n n))``
 
 Creates a sequence defined in terms of ``n``.
 

docs/language/api.rst

@@ -233,7 +233,7 @@ as the user enters *k*.
 
 .. code-block:: clj
 
-    (while True (if (= "k" (raw-input "? "))
+    (while True (if (= "k" (input "? "))
                   (break)
                   (print "Try again")))
 
@@ -296,7 +296,7 @@ As shown below, only the first matching result block is executed.
     ...  (cond [(< value 5) (print "value is smaller than 5")]
     ...        [(= value 5) (print "value is equal to 5")]
     ...        [(> value 5) (print "value is greater than 5")]
-    ...	       [True (print "value is something that it should not be")]))
+    ...        [True (print "value is something that it should not be")]))
 
     => (check-value 6)
     value is greater than 5
@@ -487,11 +487,11 @@ Parameters may have the following keywords in front of them:
         => (defn total-value [value &optional [value-added-tax 10]]
         ...  (+ (/ (* value value-added-tax) 100) value))
 
-	=> (total-value 100)
+        => (total-value 100)
         110.0
 
-    	=> (total-value 100 1)
-	101.0
+        => (total-value 100 1)
+        101.0
 
 &kwargs
     Parameter will contain 0 or more keyword arguments.
@@ -525,7 +525,7 @@ Parameters may have the following keywords in front of them:
 
         => (defn zig-zag-sum [&rest numbers]
              (setv odd-numbers (list-comp x [x numbers] (odd? x))
-	           even-numbers (list-comp x [x numbers] (even? x)))
+                   even-numbers (list-comp x [x numbers] (even? x)))
              (- (sum odd-numbers) (sum even-numbers)))
 
         => (zig-zag-sum)
@@ -1115,8 +1115,8 @@ that ``import`` can be used.
     ;; import sys as systest
     (import [tests.resources [kwtest function-with-a-dash]]
             [os.path [exists
-	              isdir :as dir?
-		      isfile :as file?]]
+                      isdir :as dir?
+                      isfile :as file?]]
             [sys :as systest])
 
     ;; Import all module functions into current namespace
@@ -1398,7 +1398,7 @@ repexpr]])``, but a less error-prone approach is to change the definition of
     (defmacro foo [n]
       `(do
         (require mymodule)
-        (mymodule.repexpr ~n (raw-input "Gimme some input: "))))
+        (mymodule.repexpr ~n (input "Gimme some input: "))))
 
 It's wise to use ``(require mymodule)`` here rather than ``(require [mymodule
 [repexpr]])`` to avoid accidentally shadowing a function named ``repexpr`` in
@@ -1856,7 +1856,7 @@ will be 4 (``1+1 + 1+1``).
     => (addition 1 1)
     4
     => (with-decorator inc2-decorator inc-decorator
-    ...	 (defn addition [a b] (+ a b)))
+    ...  (defn addition [a b] (+ a b)))
     => (addition 1 1)
     8
 

docs/language/core.rst

@@ -652,7 +652,7 @@ calling ``(f val-in-result val-in-latter)``.
 
 .. code-block:: hy
 
-    => (merge-with (fn [x y] (+ x y)) {"a" 10 "b" 20} {"a" 1 "c" 30})
+    => (merge-with + {"a" 10 "b" 20} {"a" 1 "c" 30})
     {u'a': 11L, u'c': 30L, u'b': 20L}
 
 
@@ -1201,9 +1201,9 @@ if *from-file* ends before a complete expression can be parsed.
     4
     => (import io)
     => (setv buffer (io.StringIO "(+ 2 2)\n(- 2 1)"))
-    => (eval (read :from_file buffer))
+    => (eval (read :from-file buffer))
     4
-    => (eval (read :from_file buffer))
+    => (eval (read :from-file buffer))
     1
 
     => (with [f (open "example.hy" "w")]

docs/language/internals.rst

@@ -323,13 +323,13 @@ Will turn into::
     else:
         _temp_name_here = False
 
-    print _temp_name_here
+    print(_temp_name_here)
 
 
 OK, that was a bit of a lie, since we actually turn that statement
 into::
 
-    print True if True else False
+    print(True if True else False)
 
 By forcing things into an ``ast.expr`` if we can, but the general idea holds.
 
@@ -412,10 +412,11 @@ so our re-written ``nif`` would look like:
 
    (defmacro nif [expr pos-form zero-form neg-form]
      (with-gensyms [g]
-       `(setv [~g ~expr])
-       `(cond [(pos? ~g) ~pos-form]
-              [(zero? ~g) ~zero-form]
-              [(neg? ~g) ~neg-form])))
+       `(do
+          (setv ~g ~expr)
+          (cond [(pos? ~g) ~pos-form]
+                [(zero? ~g) ~zero-form]
+                [(neg? ~g) ~neg-form]))))
 
 Finally, though we can make a new macro that does all this for us. :ref:`defmacro/g!`
 will take all symbols that begin with ``g!`` and automatically call ``gensym`` with the

docs/tutorial.rst

@@ -120,7 +120,7 @@ This is the basic premise of Lisp. Lisp stands for "list
 processing"; this means that the structure of the program is
 actually lists of lists.  (If you're familiar with Python lists,
 imagine the entire same structure as above but with square brackets
-instead, any you'll be able to see the structure above as both a
+instead, and you'll be able to see the structure above as both a
 program and a data structure.)  This is easier to understand with more
 examples, so let's write a simple Python program, test it, and then
 show the equivalent Hy program::