Removed deprecated datatypes file

Basis types are described within 'stdtypes.txt'.
Fixed typos and references mistakes.

Author: shorodilov

src/appx/precedence.txt

@@ -27,12 +27,12 @@ same precedence (use left-to-right precedence).
 +------------------------+----------------------------------------------------+
 | ``await x``            | Await expression                                   |
 +------------------------+----------------------------------------------------+
-| ``**``                 | Exponentiation[#]_                                 |
+| ``**``                 | Exponentiation [#]_                                |
 +------------------------+----------------------------------------------------+
 | ``+x``, ``-x``, ``~x`` | Positive, negative, bitwise NOT                    |
 +------------------------+----------------------------------------------------+
 | ``*``, ``@``, ``/``,   | Multiplication, matrix multiplication, division,   |
-| ``//``, ``%``          | floor division, remainder[#]_                      |
+| ``//``, ``%``          | floor division, remainder [#]_                     |
 +------------------------+----------------------------------------------------+
 | ``+``, ``-``           | Addition and subtraction                           |
 +------------------------+----------------------------------------------------+

src/appx/printf.txt

@@ -8,10 +8,10 @@
 
 String objects have one unique built-in operation: the ``%`` operator (modulo).
 This is also known as the string *formatting* or *interpolation* operator
-:cite:`docs-python:printf-style`. Given ``format % values`` (where *format* is
-a string), ``%`` conversion specifications in *format* are replaced with zero
-or more elements of *values*. If *format* requires a single argument, *values*
-may be a single non-tuple object.
+:cite:`docs-python:printf-formatting`. Given ``format % values`` (where
+*format* is a string), ``%`` conversion specifications in *format* are replaced
+with zero or more elements of *values*. If *format* requires a single argument,
+*values* may be a single non-tuple object.
 
 The conversion flag characters are:
 
@@ -57,7 +57,7 @@ The conversion types are:
 +------------+----------------------------------------------------------------+
 | ``'g'``    | Floating point format. Uses lowercase exponential format if    |
 |            | exponent is less that -4 or not less than precision, decimal   |
-|            | format overwise.                                               |
+|            | format otherwise.                                              |
 | ``'G'``    |                                                                |
 +------------+----------------------------------------------------------------+
 | ``'c'``    | Single character (accepts integer or single character string)  |

src/basics/datatypes.txt

@@ -7,7 +7,6 @@
 
     variables
     syntax
-    datatypes
     stdtypes
     controlflow
     functions

src/basics/index.txt

@@ -12,7 +12,7 @@ Numeric types
 
 There are 3 distinct numeric types: *integers*, *floating point numbers*, and
 *complex numbers*. In addition, Booleans are a subtype of integers. Integers
-have unlimited precision. Floating point numbers are usually implemented usign
+have unlimited precision. Floating point numbers are usually implemented using
 ``double`` in C. Complex numbers have a real and imaginary part, which are each
 a floating point number.
 
@@ -127,7 +127,7 @@ They may be constructed in several ways:
 - using a pair of square brackets to denote the empty list: ``[]``
 - using square brackets, separating items with commas: ``[a]``, ``[a, b, c]``
 - using a list comprehension: ``[x for x in iterable]``
-- using the type constuctor: ``list()`` or ``list(iterable)``
+- using the type constructor: ``list()`` or ``list(iterable)``
 
 Tuples
 ------
@@ -185,7 +185,7 @@ types results in inequality, and ordering comparison across these types raises
 
 Sequences compare lexicographically using comparison of corresponding elements.
 The built-in containers typically assume identical objects are equal to
-themselves. Lexicographical comparison between buit-in collections works as
+themselves. Lexicographical comparison between built-in collections works as
 follows:
 
 -  For two collections to compare equal, they must be of the same type, have
@@ -207,16 +207,16 @@ Mutable sequence types
 +--------------------+--------------------------------------------------------+
 | ``del s[i:j]``     | same as ``s[i:j] = []``                                |
 +--------------------+--------------------------------------------------------+
-| ``s[i:j:k] = t``   | the elements of *s* are replaced by those of *t*[#]_   |
+| ``s[i:j:k] = t``   | the elements of *s* are replaced by those of *t* [#]_  |
 +--------------------+--------------------------------------------------------+
 | ``del s[i:j:k]``   | removes the elements of ``s[i:j:k]`` from the list     |
 +--------------------+--------------------------------------------------------+
 | ``s.append(x)``    | appends *x* to the end of the sequence; the same as    |
 |                    | ``s[len(s):len(s)] = [x]``                             |
 +--------------------+--------------------------------------------------------+
-| ``s.clear()``      | removes all items from *s* (``del s[:]``)[#3.3]_       |
+| ``s.clear()``      | removes all items from *s* (``del s[:]``)[#new]_       |
 +--------------------+--------------------------------------------------------+
-| ``s.copy()``       | creates a shallow copy of *s* (``s[:]``)[#3.3]_        |
+| ``s.copy()``       | creates a shallow copy of *s* (``s[:]``)[#new]_        |
 +--------------------+--------------------------------------------------------+
 | ``s.extend(t)``    | extends *s* with the contents of *t*                   |
 | ``s += t``         |                                                        |
@@ -233,7 +233,7 @@ Mutable sequence types
 +--------------------+--------------------------------------------------------+
 
 .. [#]    *t* must have the same length as the slice it is replacing
-.. [#3.3] new in Python version 3.3
+.. [#new] new in Python version 3.3
 
 Text sequence type
 ==================
@@ -316,8 +316,8 @@ Dictionaries can be created by several means:
 
 - Use braces to denote the empty dictionary: ``{}``
 - Use a comma-separated list of ``key: value`` pairs with braces:
-  ``{'first_name': 'Serhii', 'last_name': 'Horodilov', 'age': 34}
-- Use a dict comprehension: `{x: x ** 2 for x in range(10)}``
+  ``{'first_name': 'Serhii', 'last_name': 'Horodilov', 'age': 34}``
+- Use a dict comprehension: ``{x: x ** 2 for x in range(10)}``
 - Use the type constructor: ``dict()``, ``dict([('key', 100)])``,
   ``dict(key=100)``
 

src/basics/stdtypes.txt

@@ -25,6 +25,8 @@
         appx/software_list
         appx/code_edit
         appx/env_path
+        appx/precedence
+        appx/printf
 
 .. rubric:: References
 

src/index.txt

@@ -58,7 +58,7 @@ @misc{docs-python:operator-precedence
     url = {https://docs.python.org/3/reference/expressions.html#operator-precedence},
 }
 
-@misc{docs-python:printf-formating,
+@misc{docs-python:printf-formatting,
     title = "{Python Documentation}",
     url = {https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting},
 }