Document i16

python · JukkaL · Jun 23, 2023 · Apr 19, 2023 · Apr 19, 2023 · Apr 19, 2023
commit de7b9a58a4cf7a991c984e567ea8897451e9852c
diff --git a/mypyc/doc/float_operations.rst b/mypyc/doc/float_operations.rst
@@ -14,6 +14,7 @@ Construction
 * ``float(x: int)``
 * ``float(x: i64)``
 * ``float(x: i32)``
+* ``float(x: i16)``
 * ``float(x: str)``
 * ``float(x: float)`` (no-op)
 
@@ -28,8 +29,9 @@ Functions
 ---------
 
 * ``int(f)``
-* ``i32(f)`` (convert to ``i32``)
-* ``i64(f)`` (convert to ``i64``)
+* ``i64(f)`` (convert to 64-bit signed integer)
+* ``i32(f)`` (convert to 32-bit signed integer)
+* ``i16(f)`` (convert to 16-bit signed integer)
 * ``abs(f)``
 * ``math.sin(f)``
 * ``math.cos(f)``

diff --git a/mypyc/doc/int_operations.rst b/mypyc/doc/int_operations.rst
@@ -8,14 +8,16 @@ Mypyc supports these integer types:
 * ``int`` (arbitrary-precision integer)
 * ``i64`` (64-bit signed integer)
 * ``i32`` (32-bit signed integer)
+* ``i16`` (16-bit signed integer)
 
-``i64`` and ``i32`` are *native integer types* and must be imported
+``i64``, ``i32`` and ``i16`` are *native integer types* and must be imported
 from the ``mypy_extensions`` module. ``int`` corresponds to the Python
 ``int`` type, but uses a more efficient runtime representation (tagged
-pointer). Native integer types are value types. All integer types have
-optimized primitive operations, but the native integer types are more
-efficient than ``int``, since they don't require range or bounds
-checks.
+pointer). Native integer types are value types.
+
+All integer types have optimized primitive operations, but the native
+integer types are more efficient than ``int``, since they don't
+require range or bounds checks.
 
 Operations on integers that are listed here have fast, optimized
 implementations. Other integer operations use generic implementations
@@ -31,6 +33,7 @@ Construction
 * ``int(x: float)``
 * ``int(x: i64)``
 * ``int(x: i32)``
+* ``int(x: i16)``
 * ``int(x: str)``
 * ``int(x: str, base: int)``
 * ``int(x: int)`` (no-op)
@@ -40,6 +43,7 @@ Construction
 * ``i64(x: int)``
 * ``i64(x: float)``
 * ``i64(x: i32)``
+* ``i64(x: i16)``
 * ``i64(x: str)``
 * ``i64(x: str, base: int)``
 * ``i64(x: i64)`` (no-op)
@@ -49,10 +53,21 @@ Construction
 * ``i32(x: int)``
 * ``i32(x: float)``
 * ``i32(x: i64)`` (truncate)
+* ``i32(x: i16)``
 * ``i32(x: str)``
 * ``i32(x: str, base: int)``
 * ``i32(x: i32)`` (no-op)
 
+``i16`` type:
+
+* ``i16(x: int)``
+* ``i16(x: float)``
+* ``i16(x: i64)`` (truncate)
+* ``i16(x: i32)`` (truncate)
+* ``i16(x: str)``
+* ``i16(x: str, base: int)``
+* ``i16(x: i16)`` (no-op)
+
 Conversions from ``int`` to a native integer type raise
 ``OverflowError`` if the value is too large or small. Conversions from
 a wider native integer type to a narrower one truncate the value and never

diff --git a/mypyc/doc/using_type_annotations.rst b/mypyc/doc/using_type_annotations.rst
@@ -32,6 +32,7 @@ implementations:
 * ``int`` (:ref:`native operations <int-ops>`)
 * ``i64`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
 * ``i32`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
+* ``i16`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
 * ``float`` (:ref:`native operations <float-ops>`)
 * ``bool`` (:ref:`native operations <bool-ops>`)
 * ``str`` (:ref:`native operations <str-ops>`)
@@ -342,13 +343,14 @@ Examples::
 Native integer types
 --------------------
 
-You can use the native integer types ``i64`` (64-bit signed integer)
-and ``i32`` (32-bit signed integer) if you know that integer values
-will always fit within fixed bounds. These types are faster than the
-arbitrary-precision ``int`` type, since they don't require overflow
-checks on operations. ``i32`` may also use less memory than ``int``
-values. The types are imported from the ``mypy_extensions`` module
-(installed via ``pip install mypy_extensions``).
+You can use the native integer types ``i64`` (64-bit signed integer),
+``i32`` (32-bit signed integer), and ``i16`` (16-bit signed integer)
+if you know that integer values will always fit within fixed
+bounds. These types are faster than the arbitrary-precision ``int``
+type, since they don't require overflow checks on operations. ``i32``
+and ``i16`` may also use less memory than ``int`` values. The types
+are imported from the ``mypy_extensions`` module (installed via ``pip
+install mypy_extensions``).
 
 Example::