Repository: SethMMorton/fastnumbers (language: python)

Issue:
Add support for operating on iterables
**Describe the feature or enhancement**

Add support for conversion on an iterable, either by directly adding that support to existing functions, or providing a new function e.g. `map_float` or `map_try_float`. These would behave basically like 

```python
map(try_float, some_iterable)
```

**Provide a concrete example of how the feature or enhancement will improve `fastnumbers`**

Every time a function is called in Python, there is some overhead due to memory allocations and whatnot. When operating on a large data set this overhead will start to become a sizable fraction of the net runtime. While it is true that using `map()` can mitigate this somewhat over standard for-loops or list-comprehensions, it still does not eliminate the problem.

Allowing `fastnumbers` functions to accept an iterable and then internally loop over the data and return either a list or iterator would circumvent this overhead and provide meaningful speedups for large datasets.



Discussion / hints:

Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 52bea57e..830fc2ec 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +1,18 @@
 Unreleased
 ---
 
+### Added
+- Added `map_try_real`, `map_try_float`, `map_try_int`, and `map_try_forceint`
+  to enable very fast conversions of lists or other iterables (Issues
+ [#61](https://github.com/SethMMorton/fastnumbers/issues/61) and
+ [#63](https://github.com/SethMMorton/fastnumbers/issues/63))
+
 [4.0.1] - 2023-02-05
 ---
 
 ### Fixed
 - Removed a nasty memory leak that would cause every number returned
-  from `fastnumbers` to never get freed.
+  from `fastnumbers` to never get freed
 
 [4.0.0] - 2023-02-01
 ---
diff --git a/README.rst b/README.rst
index 68881edd..549b1e0a 100644
--- a/README.rst
+++ b/README.rst
@@ -37,7 +37,7 @@ of decreasing importance as to why the module was created):
        an input *could* be converted to *int* or *float*.
     #. Provide drop-in replacements for the Python built-in ``int`` and
        ``float`` that are on par or faster with the Python equivalents
-       (see the `Timing_` section for details). These functions
+       (see the `Timing`_ section for details). These functions
        should behave *identically* to the Python built-ins except for a few
        specific corner-cases as mentioned in the
        `API documentation for those functions <https://fastnumbers.readthedocs.io/en/stable/api.html#the-built-in-replacement-functions>`_.
@@ -45,6 +45,19 @@ of decreasing importance as to why the module was created):
        - **PLEASE** read the quick start for these functions to fully
          understand the caveats before using them.
 
+**What kind of speedups can you expect?** Here are some highlights, but please
+see the `Timing`_ section for the raw data if you want details.
+
+    - Up to 2x faster conversion of strings to integers than the built-in
+      ``int()`` function
+    - Up to 5x faster conversion of strings to floats than the built-in
+      ``float()`` function (possibly greater for very long strings)
+    - Up to 10x faster handling of errors during conversion than using
+      user-side error handling
+    - On top of the above, operations on a list of strings to to convert
+      (with the ``map_try_*`` functions) is 2x faster than the equivalent
+      list comprehension.
+
 **NOTICE**: As of ``fastnumbers`` version 4.0.0, only Python >= 3.7 is
 supported.
 
@@ -77,6 +90,8 @@ Error-Handling Functions
 ++++++++++++++++++++++++
 
 - `Error-handling function API <https://fastnumbers.readthedocs.io/en/stable/api.html#the-error-handling-functions>`_
+- `Fast operations on lists and other iterables`_
+- `About the on_fail option`_
 
 ``try_float`` will be used to demonstrate the functionality of the
 ``try_*`` functions.
@@ -172,6 +187,27 @@ on if there is any fractional component of thi return value.
     >>> try_forceint(56.07)
     56
 
+Fast operations on lists and other iterables
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Each of the ``try_*`` functions have an equivalent ``map_try_*`` function
+that has an identical signiture but accepts an iterable of items to convert
+and returns a list. Using ``try_float`` as an example, the following
+are all functionally equivalent.
+
+.. code-block:: python
+
+    >>> from fastnumbers import map_try_float, try_float
+    >>> iterable = ["5", "4.5", "34567.6", "32"]
+    >>> map_try_float(iterable) == list(map(try_float, iterable))
+    True
+    >>> map_try_float(iterable) == [try_float(x) for x in iterable]
+    True
+
+The difference is that ``map_try_float`` is 2x the speed of the list
+comprehension method, and 1.5x the speed of the ``map`` method. The reason
+is that it avoids Python function call overhead on each iteration.
+
 About the ``on_fail`` option
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/docs/source/api.rst b/docs/source/api.rst
index 19b986c0..5dd1cdae 100644
--- a/docs/source/api.rst
+++ b/docs/source/api.rst
@@ -45,21 +45,41 @@ They are guaranteed to return results identical to the built-in
 
 .. autofunction:: try_real
 
+:func:`~fastnumbers.map_try_real`
++++++++++++++++++++++++++++++++++
+
+.. autofunction:: map_try_real
+
 :func:`~fastnumbers.try_float`
 ++++++++++++++++++++++++++++++
 
 .. autofunction:: try_float
 
+:func:`~fastnumbers.map_try_float`
+++++++++++++++++++++++++++++++++++
+
+.. autofunction:: map_try_float
+
 :func:`~fastnumbers.try_int`
 ++++++++++++++++++++++++++++
 
 .. autofunction:: try_int
 
+:func:`~fastnumbers.map_try_int`
+++++++++++++++++++++++++++++++++
+
+.. autofunction:: map_try_int
+
 :func:`~fastnumbers.try_forceint`
 +++++++++++++++++++++++++++++++++
 
 .. autofunction:: try_forceint
 
+:func:`~fastnumbers.map_try_forceint`
++++++++++++++++++++++++++++++++++++++
+
+.. autofunction:: map_try_forceint
+
 The "Checking" Functions
 ------------------------
 
diff --git a/docs/source/timing.rst b/docs/source/timing.rst
index 911c911b..e5b5d41e 100644
--- a/docs/source/timing.rst
+++ b/docs/source/timing.rst
@@ -10,4 +10,5 @@ Timing
     :local:
 
 Just how much faster is ``fastnumbers`` than a pure python implementation?
-Please look https://github.com/SethMMorton/fastnumbers/tree/main/profiling.
+This data has moved to
+https://github.com/SethMMorton/fastnumbers/tree/main/profiling.
diff --git a/include/fastnumbers/docstrings.hpp b/include/fastnumbers/docstrings.hpp
index de24aa4c..11ce210a 100644
--- a/include/fastnumbers/docstrings.hpp
+++ b/include/fastnumbers/docstrings.hpp
@@ -75,6 +75,7 @@ PyDoc_STRVAR(
     "--------\n"
     "check_real\n"
     "real\n"
+    "map_try_real\n"
     "\n"
     "Examples\n"
     "--------\n"
@@ -181,6 +182,7 @@ PyDoc_STRVAR(
     "--------\n"
     "check_float\n"
     "float\n"
+    "map_try_float\n"
     "\n"
     "Examples\n"
     "--------\n"
@@ -274,6 +276,7 @@ PyDoc_STRVAR(
     "try_forceint\n"
     "check_int\n"
     "int\n"
+    "map_try_int\n"
     "\n"
     "Examples\n"
     "--------\n"
@@ -312,7 +315,7 @@ PyDoc_STRVAR(
     try_forceint__doc__,
     "try_forceint(x, *, on_fail=fastnumbers.INPUT, on_type_error=fastnumbers.RAISE, "
     "allow_underscores=False)\n"
-    "Quickly convert input to an *int*, truncating if is a *float*.\n"
+    "Quickly convert input to an *int*, truncating if a *float*.\n"
     "\n"
     "Any input that is valid for the built-in *int*\n"
     "function will be converted to a *int*. An input\n"
@@ -366,6 +369,7 @@ PyDoc_STRVAR(
     "--------\n"
     "try_int\n"
     "check_intlike\n"
+    "map_try_forceint\n"
     "\n"
     "Examples\n"
     "--------\n"
@@ -763,6 +767,96 @@ PyDoc_STRVAR(
     "\n"
 );
 
+PyDoc_STRVAR(
+    map_try_real__doc__,
+    "map_try_real(x, *, inf=fastnumbers.ALLOWED, nan=fastnumbers.ALLOWED, "
+    "on_fail=fastnumbers.INPUT, on_type_error=fastnumbers.RAISE, "
+    "coerce=True, allow_underscores=False)\n"
+    "Quickly convert an iterable's contents to *int* or *float* depending on value.\n"
+    "\n"
+    "This is functionally identical to ``[try_real(x) for x in myiterable]``\n"
+    "but is twice as fast.\n"
+    "\n"
+    "All arguments are identical and behave identically to :func:`try_real`.\n"
+    "\n"
+    "Returns\n"
+    "-------\n"
+    "result : list\n"
+    "    The converted elements, in a list.\n"
+    "\n"
+    "See Also\n"
+    "--------\n"
+    "try_real\n"
+    "\n"
+);
+
+PyDoc_STRVAR(
+    map_try_float__doc__,
+    "map_try_float(x, *, inf=fastnumbers.ALLOWED, nan=fastnumbers.ALLOWED, "
+    "on_fail=fastnumbers.INPUT, on_type_error=fastnumbers.RAISE, "
+    "allow_underscores=False)\n"
+    "Quickly convert an iterable's contents to *float*.\n"
+    "\n"
+    "This is functionally identical to ``[try_float(x) for x in myiterable]``\n"
+    "but is twice as fast.\n"
+    "\n"
+    "All arguments are identical and behave identically to :func:`try_float`.\n"
+    "\n"
+    "Returns\n"
+    "-------\n"
+    "result : list\n"
+    "    The converted elements, in a list.\n"
+    "\n"
+    "See Also\n"
+    "--------\n"
+    "try_float\n"
+    "\n"
+);
+
+PyDoc_STRVAR(
+    map_try_int__doc__,
+    "map_try_int(x, *, on_fail=fastnumbers.INPUT, on_type_error=fastnumbers.RAISE, "
+    "base=10, allow_underscores=False)\n"
+    "Quickly convert an iterable's contents to *int*.\n"
+    "\n"
+    "This is functionally identical to ``[try_int(x) for x in myiterable]``\n"
+    "but is twice as fast.\n"
+    "\n"
+    "All arguments are identical and behave identically to :func:`try_int`.\n"
+    "\n"
+    "Returns\n"
+    "-------\n"
+    "result : list\n"
+    "    The converted elements, in a list.\n"
+    "\n"
+    "See Also\n"
+    "--------\n"
+    "try_int\n"
+    "\n"
+);
+
+PyDoc_STRVAR(
+    map_try_forceint__doc__,
+    "map_try_forceint(x, *, on_fail=fastnumbers.INPUT, on_type_error=fastnumbers.RAISE, "
+    "allow_underscores=False)\n"
+    "Quickly convert an iterable's contents to *int*, truncating if a *float*.\n"
+    "\n"
+    "This is functionally identical to ``[try_forceint(x) for x in myiterable]``\n"
+    "but is twice as fast.\n"
+    "\n"
+    "All arguments are identical and behave identically to :func:`try_forceint`.\n"
+    "\n"
+    "Returns\n"
+    "-------\n"
+    "result : list\n"
+    "    The converted elements, in a list.\n"
+    "\n"
+    "See Also\n"
+    "--------\n"
+    "try_forceint\n"
+    "\n"
+);
+
 PyDoc_STRVAR(
     fastnumbers_int__doc__,
     "int(x=0, *, base=10)\n"
diff --git a/include/fastnumbers/iteration.hpp b/include/fastnumbers/iteration.hpp
new file mode 100644
index 00000000..fa152254
--- /dev/null
+++ b/include/fastnumbers/iteration.hpp
@@ -0,0 +1,268 @@
+#pragma once
+
+#include <stdexcept>
+
+#include <Python.h>
+
+#include "fastnumbers/selectors.hpp"
+
+/// Custom exception class to tell the handler to just return NULL
+class just_return_null_exception : public std::runtime_error {
+public:
+    just_return_null_exception()
+        : std::runtime_error("")
+    { }
+};
+
+/**
+ * \class ListManager
+ * \brief Handles the details of creating and managing a Python list
+ */
+class ListManager {
+public:
+    /**
+     * \brief Construct the manager with a list of a fixed size
+     * \param length The initial length of the list to construct
+     */
+    explicit ListManager(const Py_ssize_t length)
+        : m_list(PyList_New(length))
+        , m_index(0)
+    {
+        if (m_list == nullptr) {
+            throw just_return_null_exception();
+        }
+    }
+
+    /**
+     * \brief Construct the manager with a list of a size based
+     *         on a hint from another object
+     * \param length The object with the length hint
+     */
+    explicit ListManager(PyObject* length_hint_base)
+        : ListManager(get_length_hint(length_hint_base))
+    { }
+
+    // Deleted
+    ListManager(const ListManager&) = delete;
+    ListManager(ListManager&&) = delete;
+    ListManager& operator=(const ListManager&) = delete;
+
+    // Default
+    ~ListManager() = default;
+
+    /**
+     * \brief Add an item to the end of the list
+     * \param item The item to add to the list
+     */
+    void append(PyObject* item)
+    {
+        // Protect against incoming NULLs.
+        if (item == nullptr) {
+            throw just_return_null_exception();
+        }
+
+        // The list may have been pre-allocated using the length hint.
+        // If so, the elements will be just populated with NULL.
+        // If the current index equals the list size, that means we are
+        // at the end of the list and we can just use append. Otherwise,
+        // we insert the object directly into the list, replacing NULL.
+        if (PyList_GET_SIZE(m_list) == m_index) {
+            if (PyList_Append(m_list, item)) {
+                Py_DECREF(m_list);
+                throw just_return_null_exception();
+            }
+        } else {
+            PyList_SET_ITEM(m_list, m_index, item);
+        }
+
+        // Increment the index of where we are currently at in the list.
+        m_index += 1;
+    }
+
+    /// Return the stored list to the user
+    PyObject* get() { return m_list; }
+
+private:
+    /// The list itself
+    PyObject* m_list;
+
+    /// The current location where we should add to the list
+    Py_ssize_t m_index;
+
+private:
+    /// Obtain the length hint from a Python object
+    static Py_ssize_t get_length_hint(PyObject* length_hint_base)
+    {
+        Py_ssize_t length_hint = PyObject_LengthHint(length_hint_base, 0);
+        if (length_hint < 0) {
+            throw just_return_null_exception();
+        }
+        return length_hint;
+    }
+};
+
+/**
+ * \class PyIterableManager
+ * \brief Makes iteration over a Python iterable with a ranged for loop possible
+ */
+template <typename Function>
+class PyIterableManager {
+public:
+    /// Constructor
+    explicit PyIterableManager(
+        PyObject* potential_iterable, PyObject*& item, Function convert
+    )
+        : m_object(potential_iterable)
+        , m_item(item)
+        , m_iterator(nullptr)
+        , m_index(0)
+        , m_seq_size(0)
+        , m_convert(convert)
+    {
+        if (PyList_Check(m_object) || PyTuple_Check(m_object)) {
+            m_seq_size = PySequence_Fast_GET_SIZE(m_object);
+        } else {
+            if ((m_iterator = PyObject_GetIter(m_object)) == nullptr) {
+                throw just_return_null_exception();
+            }
+        }
+    }
+
+    /// Destructor
+    ~PyIterableManager() { Py_XDECREF(m_iterator); }
+
+    // Deleted
+    PyIterableManager(const PyIterableManager&) = delete;
+    PyIterableManager(PyIterableManager&&) = delete;
+    PyIterableManager& operator=(const PyIterableManager&) = delete;
+
+    /**
+     * \class ItemIterator
+     * \brief An iterator over the PyIterableManager
+     */
+    class ItemIterator {
+    public:
+        // Define the iterator type
+        using iterator_category = std::input_iterator_tag;
+        using difference_type = std::ptrdiff_t;
+        using value_type = PyObject*;
+        using pointer = value_type*;
+        using reference = value_type&;
+
+        /**
+         * \brief Construct the ItemIterator and obtain the first
+         *        ViolationData if available.
+         */
+        explicit ItemIterator(PyIterableManager* parent)
+            : m_parent(parent)
+            , m_payload(m_parent != nullptr ? m_parent->next() : Sigils::ITERATOR)
+        { }
+
+        // Default other constructors/destructors
+        ItemIterator(const ItemIterator& other) = default;
+        ItemIterator(ItemIterator&&) = default;
+        ItemIterator& operator=(const ItemIterator& other) = default;
+        ~ItemIterator() = default;
+
+        /// Access the PyIterableManager data
+        reference operator*() { return m_payload; }
+
+        /// Access the PyIterableManager data as a pointer
+        pointer operator->() { return &m_payload; }
+
+        /// Increment the ItemIterator
+        ItemIterator& operator++()
+        {
+            m_payload = m_parent->next();
+            return *this;
+        }
+
+        /// Compare two ItemIterator objects for equality.
+        bool operator==(const ItemIterator& rhs) const
+        {
+            return m_payload == rhs.m_payload;
+        }
+
+        /// Compare two ItemIterator objects for inequality.
+        bool operator!=(const ItemIterator& rhs) const { return !operator==(rhs); }
+
+    private:
+        /// A pointer to the object that instantiated the iterator
+        PyIterableManager* m_parent;
+
+        /// The data returned by the parent for the current iteration
+        PyObject* m_payload;
+    };
+
+    /// Convenient name for the ItemIterator
+    typedef ItemIterator iterator;
+
+    /// Return an iterator over the PyIterableManager
+    iterator begin() { return iterator(this); };
+
+    /// The end of the iterator over the PyIterableManager
+    iterator end() { return iterator(nullptr); };
+
+private:
+    /// The object that is currently being iterated over
+    PyObject* m_object;
+
+    /// The current item being returned - needs to be a refernce to a parent
+    /// scoped object because this is used for error message.
+    PyObject*& m_item;
+
+    /// NULL if a fast sequence (e.g. list/tuple), the iterator object otherwise
+    PyObject* m_iterator;
+
+    /// The location we are in the sequence, if the input is a sequence
+    Py_ssize_t m_index;
+
+    /// The size of the sequence, if the input is a sequence
+    Py_ssize_t m_seq_size;
+
+    /// The function used to convert data
+    Function m_convert;
+
+private:
+    PyObject* next()
+    {
+        // If no iterator is stored, then the object was a fast sequence and
+        // we can access the data directly.
+        if (m_iterator == nullptr) {
+            // When at the end of the sequence, return the sigil
+            if (m_index == m_seq_size) {
+                return Sigils::ITERATOR;
+            }
+
+            // Access the data in the input sequence directly.
+            // The returned object is a borrowed reference, so we do not
+            // need to manage the reference counts.
+            m_item = PySequence_Fast_GET_ITEM(m_object, m_index);
+
+            // Before moving on, increment our internal counter.
+            m_index += 1;
+
+            // Conver the item to the correct value and return.
+            return m_convert(m_item);
+        }
+
+        // Otherwise, the object was an iterator and we use the iteration
+        // protocol to get each next item.
+        // When a nullptr is returned then it is the end of the iteration
+        // and we return return the sigil.
+        if ((m_item = PyIter_Next(m_iterator)) == nullptr) {
+            return Sigils::ITERATOR;
+        }
+
+        // Convert the item and return the value. When complete we must decrease
+        // the item reference count (because it was not returned as a borrowed
+        // reference), so some error handling must be done to ensure it happens.
+        try {
+            return m_convert(m_item);
+        } catch (...) {
+            Py_DECREF(m_item);
+            throw;
+        }
+        Py_DECREF(m_item);
+    }
+};
\ No newline at end of file
diff --git a/include/fastnumbers/selectors.hpp b/include/fastnumbers/selectors.hpp
index 5c09ca65..cc2532fb 100644
--- a/include/fastnumbers/selectors.hpp
+++ b/include/fastnumbers/selectors.hpp
@@ -34,3 +34,9 @@ struct Selectors {
     /// Selector to only allow numbers
     static PyObject* NUMBER_ONLY;
 };
+
+/// Namespace for sigils
+struct Sigils {
+    /// Used to determine when we are done with iteration
+    static PyObject* ITERATOR;
+};
diff --git a/profiling/README.md b/profiling/README.md
index ab707aff..4dd9b754 100644
--- a/profiling/README.md
+++ b/profiling/README.md
@@ -17,3 +17,6 @@ Some general observations about the results:
   slightly slower than CPython.
 - When numbers are provided (as opposed to strings), the Python built-ins
   are usually faster.
+- If you need to convert a list of data, using the `map_try_*` functions
+  is 2x faster than using `try_*` in a list comprehension, and about
+  1.5x faster than using `try_*` with `map`.
diff --git a/profiling/profile.py b/profiling/profile.py
index 76aaf578..df01d0bd 100644
--- a/profiling/profile.py
+++ b/profiling/profile.py
@@ -1,11 +1,14 @@
 #! /usr/bin/env python
 
 import copy
+import gc
 import math
 import re
 import sys
 import timeit
 
+import fastnumbers
+
 # If given an file path as an argument, cause print to write
 # to stdout and it.
 try:
@@ -54,24 +57,21 @@ class Timer(object):
         (-41053.543028758302e100, "Float"),
     )
 
-    # Formatting strings.
-    FUNCTION_CALL_FMT = "{}({!r})"
-
     def __init__(self, title):
         print("### " + title)
         print()
         self.functions = []
 
-    def add_function(self, func, label, setup="pass"):
+    def add_function(self, func, label, setup="pass", iterable=False):
         """Add a function to be timed and compared."""
-        self.functions.append((func, setup, label))
+        self.functions.append((func, setup, label, iterable))
 
     def time_functions(self, repeat=5):
         """Time all the given functions against all input then display results."""
 
         # Collect the function labels to make the header of this table.
         # Show that the units are seconds for each.
-        function_labels = [label + " (ms)" for _, _, label in self.functions]
+        function_labels = [label + " (ms)" for _, _, label, _ in self.functions]
 
         # Construct the table strings, formatted in Markdown.
         # Store each line as a string element in a list.
@@ -82,8 +82,12 @@ def time_functions(self, repeat=5):
         # For each value, time each function and collect the results.
         for value, value_label in self.THINGS_TO_TIME:
             row = []
-            for func, setup, _ in self.functions:
-                call = self.FUNCTION_CALL_FMT.format(func, value)
+            for func, setup, _, iterable in self.functions:
+                if iterable:
+                    setup += f"; iterable = [{value!r}] * 50"
+                    call = f"{func}(iterable)"
+                else:
+                    call = f"{func}({value!r})"
                 try:
                     row.append(self._timeit(call, setup, repeat))
                 except (ValueError, TypeError):
@@ -104,6 +108,7 @@ def time_functions(self, repeat=5):
         # Show the results in a table.
         print(str(table))
         print()
+        gc.collect()
 
     @staticmethod
     def mean(x):
@@ -348,6 +353,14 @@ def check_intlike_try(x):
         return a == float(x)
 
 
+def fn_listcomp(iterable, func=fastnumbers.try_float):
+    return [func(x) for x in iterable]
+
+
+def fn_map(iterable, func=fastnumbers.try_float):
+    return list(map(func, iterable))
+
+
 print(sys.version_info)
 print()
 
@@ -359,7 +372,7 @@ def check_intlike_try(x):
 timer = Timer("Timing comparison of `float` functions")
 timer.add_function("float", "builtin")
 timer.add_function("float", "fastnumbers", "from fastnumbers import float")
-timer.time_functions(repeat=50)
+timer.time_functions(repeat=100)
 
 timer = Timer("Timing comparison of `int` functions with error handling")
 timer.add_function("int_try", "try/except", "from __main__ import int_try")
@@ -423,3 +436,28 @@ def check_intlike_try(x):
     "check_intlike", "fastnumbers", "from fastnumbers import check_intlike"
 )
 timer.time_functions()
+
+
+timer = Timer(
+    "Timing comparison of `map_try_float` vs. iterating over "
+    "`try_float` for a 50 element list"
+)
+timer.add_function(
+    "fn_listcomp",
+    "[try_float(x) for x in iterable]",
+    "from __main__ import fn_listcomp",
+    iterable=True,
+)
+timer.add_function(
+    "fn_map",
+    "list(map(try_float, iterable))",
+    "from __main__ import fn_map",
+    iterable=True,
+)
+timer.add_function(
+    "map_try_float",
+    "map_try_float(iterable)",
+    "from fastnumbers import map_try_float",
+    iterable=True,
+)
+timer.time_functions()
diff --git a/profiling/results-3.10.md b/profiling/results-3.10.md
index 3bec6a10..f0f8bbf9 100644
--- a/profiling/results-3.10.md
+++ b/profiling/results-3.10.md
@@ -1,147 +1,162 @@
-sys.version_info(major=3, minor=10, micro=6, releaselevel='final', serial=0)
+sys.version_info(major=3, minor=10, micro=0, releaselevel='final', serial=0)
 
 ### Timing comparison of `int` functions
 
 | Input type        | builtin (ms)       | fastnumbers (ms)  |
 | ----------------: | -----------------: | ----------------: |
-|  Small Int String |    9.631 ± 0.476   | **7.466 ± 0.151** |
-|        Int String |   10.730 ± 0.715   | **9.469 ± 0.185** |
-| Medium Int String |   11.573 ± 0.726   | **9.414 ± 0.098** |
-|  Large Int String | **16.108 ± 0.168** |  18.211 ± 0.764   |
-|               Int |  **5.848 ± 0.814** |   6.317 ± 0.146   |
-|             Float | **15.029 ± 0.244** |  19.011 ± 0.175   |
+|  Small Int String |   10.420 ± 0.224   | **7.525 ± 0.122** |
+|        Int String |   10.276 ± 0.120   | **8.641 ± 0.115** |
+| Medium Int String |   11.127 ± 0.059   | **9.023 ± 0.507** |
+|  Large Int String | **15.196 ± 0.326** |  16.113 ± 0.073   |
+|               Int |  **4.828 ± 0.059** |   6.411 ± 0.064   |
+|             Float | **15.026 ± 0.567** |  16.651 ± 0.081   |
 
 ### Timing comparison of `float` functions
 
 | Input type         | builtin (ms)      | fastnumbers (ms)   |
 | -----------------: | ----------------: | -----------------: |
-|   Small Int String | **8.512 ± 0.565** |    9.487 ± 0.746   |
-|         Int String | **9.216 ± 0.227** |    9.715 ± 0.150   |
-|  Medium Int String |  10.486 ± 0.162   | **10.028 ± 0.087** |
-|   Large Int String |  28.977 ± 1.327   | **14.435 ± 0.182** |
-| Small Float String | **8.719 ± 0.304** |    9.946 ± 0.652   |
-|       Float String |  26.140 ± 0.447   | **11.401 ± 0.158** |
-| Large Float String |  52.146 ± 1.277   | **12.464 ± 0.450** |
-|                Int | **4.869 ± 0.045** |    9.016 ± 0.121   |
-|              Float | **4.060 ± 0.064** |    6.736 ± 0.116   |
+|   Small Int String | **6.593 ± 0.086** |    7.841 ± 0.122   |
+|         Int String | **7.314 ± 0.640** |    8.039 ± 0.152   |
+|  Medium Int String | **8.271 ± 0.110** |    8.464 ± 0.067   |
+|   Large Int String |  25.117 ± 0.379   | **12.792 ± 0.286** |
+| Small Float String | **6.918 ± 0.083** |    8.249 ± 0.073   |
+|       Float String |  21.976 ± 0.109   |  **9.695 ± 0.442** |
+| Large Float String |  44.459 ± 0.429   |  **9.978 ± 0.106** |
+|                Int | **4.156 ± 0.074** |    7.118 ± 0.073   |
+|              Float | **3.369 ± 0.048** |    6.404 ± 0.068   |
 
 ### Timing comparison of `int` functions with error handling
 
-| Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | -----------------: | -------------: | -----------------: |
-|  Non-number String |   85.344 ± 0.324   | 21.042 ± 0.058 |  **8.462 ± 0.064** |
-|   Small Int String |   13.659 ± 0.133   | 32.744 ± 0.028 |  **8.008 ± 0.069** |
-|         Int String |   14.435 ± 0.082   | 35.465 ± 0.517 | **10.396 ± 0.011** |
-|  Medium Int String |   16.305 ± 0.124   | 39.316 ± 0.349 | **10.792 ± 0.009** |
-|   Large Int String | **21.066 ± 0.370** | 53.589 ± 0.056 |   21.727 ± 3.613   |
-| Small Float String |   81.628 ± 1.191   | 23.037 ± 0.342 |  **8.465 ± 0.028** |
-|       Float String |   85.498 ± 1.389   | 29.598 ± 1.407 |  **8.565 ± 0.055** |
-| Large Float String |   92.305 ± 1.269   | 30.355 ± 0.530 |  **8.893 ± 0.391** |
-|                Int |   10.079 ± 0.025   | 50.395 ± 0.765 |  **7.146 ± 0.047** |
-|              Float | **19.626 ± 0.023** | 62.877 ± 0.125 |   20.773 ± 0.013   |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String |  83.286 ± 0.348 | 21.466 ± 0.078 |  **7.862 ± 0.033** |
+|   Small Int String |  12.922 ± 0.016 | 33.857 ± 0.015 |  **7.470 ± 0.029** |
+|         Int String |  13.737 ± 0.134 | 36.285 ± 0.081 |  **8.878 ± 0.035** |
+|  Medium Int String |  14.844 ± 0.033 | 40.039 ± 0.099 |  **9.186 ± 0.019** |
+|   Large Int String |  18.911 ± 0.132 | 53.780 ± 1.888 | **16.482 ± 0.052** |
+| Small Float String |  79.835 ± 0.289 | 24.897 ± 2.058 |  **7.800 ± 0.016** |
+|       Float String |  85.355 ± 0.348 | 28.194 ± 0.006 |  **8.250 ± 0.043** |
+| Large Float String |  88.965 ± 0.452 | 28.206 ± 0.007 |  **8.042 ± 0.030** |
+|                Int |   9.687 ± 0.683 | 50.385 ± 0.315 |  **6.835 ± 0.055** |
+|              Float |  18.710 ± 0.041 | 60.181 ± 0.017 | **17.088 ± 0.267** |
 
 ### Timing comparison of `float` functions with error handling
 
 | Input type         | try/except (ms)   | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | ----------------: | -------------: | -----------------: |
-|  Non-number String |  46.551 ± 0.177   | 23.013 ± 0.023 |  **9.349 ± 0.068** |
-|   Small Int String |  12.582 ± 0.061   | 38.585 ± 0.595 | **11.144 ± 0.011** |
-|         Int String |  13.822 ± 0.035   | 41.978 ± 0.010 | **11.210 ± 0.163** |
-|  Medium Int String |  14.820 ± 0.055   | 46.409 ± 1.863 | **12.355 ± 0.029** |
-|   Large Int String |  35.615 ± 0.499   | 80.730 ± 0.087 | **16.538 ± 0.267** |
-| Small Float String |  12.924 ± 0.055   | 37.369 ± 0.009 | **12.769 ± 1.701** |
-|       Float String |  32.907 ± 0.044   | 67.682 ± 0.014 | **13.143 ± 0.180** |
-| Large Float String |  57.393 ± 0.025   | 96.052 ± 1.335 | **13.343 ± 0.210** |
-|                Int | **8.501 ± 0.028** | 47.501 ± 0.041 |    9.819 ± 0.012   |
-|              Float |   7.616 ± 0.048   | 48.687 ± 0.032 |  **7.495 ± 0.045** |
+|  Non-number String |  43.179 ± 2.723   | 24.397 ± 0.012 |  **8.614 ± 0.038** |
+|   Small Int String |  10.175 ± 0.017   | 38.345 ± 0.226 |  **8.430 ± 0.054** |
+|         Int String |  10.795 ± 0.059   | 40.543 ± 0.005 |  **8.703 ± 0.037** |
+|  Medium Int String |  11.915 ± 0.124   | 44.903 ± 0.691 |  **9.172 ± 0.132** |
+|   Large Int String |  28.943 ± 0.084   | 72.160 ± 0.284 | **13.644 ± 0.022** |
+| Small Float String |  10.537 ± 0.074   | 37.287 ± 0.015 |  **8.935 ± 0.055** |
+|       Float String |  26.219 ± 0.007   | 62.389 ± 0.386 | **10.450 ± 0.045** |
+| Large Float String |  48.519 ± 0.026   | 89.284 ± 1.902 | **10.764 ± 0.076** |
+|                Int | **7.736 ± 0.054** | 48.937 ± 0.366 |    7.798 ± 0.053   |
+|              Float | **6.916 ± 0.021** | 48.260 ± 0.039 |    7.153 ± 0.054   |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)       | fastnumbers (ms)   |
-| -----------------: | --------------: | ---------------: | -----------------: |
-|  Non-number String |  49.292 ± 0.277 |  40.196 ± 0.057  | **10.436 ± 0.016** |
-|   Small Int String |  22.239 ± 0.079 |  32.782 ± 0.008  |  **9.033 ± 0.141** |
-|         Int String |  24.193 ± 0.035 |  35.432 ± 0.415  | **11.396 ± 0.014** |
-|  Medium Int String |  29.025 ± 0.485 |  40.538 ± 0.004  | **12.157 ± 0.175** |
-|   Large Int String |  55.918 ± 0.015 |  54.337 ± 0.829  | **21.736 ± 0.303** |
-| Small Float String |  22.084 ± 0.012 |  70.081 ± 27.353 | **13.924 ± 0.219** |
-|       Float String |  64.979 ± 2.653 |  94.541 ± 1.321  | **20.525 ± 0.792** |
-| Large Float String | 119.572 ± 1.793 | 119.674 ± 1.644  | **38.955 ± 0.608** |
-|                Int |  17.547 ± 0.044 |  53.594 ± 0.180  |  **7.856 ± 0.040** |
-|              Float |  39.578 ± 0.455 |  52.933 ± 0.403  | **21.245 ± 0.006** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  43.148 ± 1.444 |  48.827 ± 0.077 |  **9.525 ± 0.065** |
+|   Small Int String |  18.648 ± 0.010 |  36.730 ± 0.033 |  **8.601 ± 0.012** |
+|         Int String |  20.847 ± 0.014 |  38.913 ± 0.015 | **10.284 ± 0.060** |
+|  Medium Int String |  24.821 ± 1.669 |  42.951 ± 0.025 | **10.657 ± 0.016** |
+|   Large Int String |  51.047 ± 0.095 |  55.599 ± 0.029 | **17.888 ± 0.051** |
+| Small Float String |  19.108 ± 0.074 |  65.213 ± 0.219 | **10.457 ± 0.034** |
+|       Float String |  50.522 ± 0.162 |  95.450 ± 1.002 | **17.759 ± 0.072** |
+| Large Float String | 103.850 ± 0.015 | 120.071 ± 0.208 | **32.497 ± 0.021** |
+|                Int |  16.807 ± 0.126 |  53.194 ± 0.025 |  **7.420 ± 0.087** |
+|              Float |  40.472 ± 2.058 |  52.447 ± 0.094 | **17.610 ± 0.021** |
 
 ### Timing comparison of forced `int` functions with error handling
 
-| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |  131.969 ± 4.728   |  40.198 ± 0.045 |  **9.259 ± 0.022** |
-|   Small Int String |   13.700 ± 0.056   |  32.389 ± 0.023 |  **8.463 ± 0.036** |
-|         Int String |   14.463 ± 0.017   |  34.942 ± 0.016 | **10.750 ± 0.009** |
-|  Medium Int String |   16.435 ± 1.151   |  68.008 ± 0.225 | **11.229 ± 0.028** |
-|   Large Int String | **20.243 ± 0.333** | 104.271 ± 1.515 |   20.524 ± 0.025   |
-| Small Float String |   93.431 ± 1.688   |  60.968 ± 0.875 | **10.232 ± 0.045** |
-|       Float String |  133.335 ± 0.825   | 105.494 ± 0.415 | **18.650 ± 0.035** |
-| Large Float String |  178.613 ± 1.096   | 150.346 ± 0.090 | **37.636 ± 0.393** |
-|                Int |    9.432 ± 0.057   |  48.779 ± 0.914 |  **6.880 ± 0.031** |
-|              Float | **19.774 ± 0.014** |  61.374 ± 2.030 |   20.468 ± 0.007   |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 121.955 ± 1.460 |  42.623 ± 0.391 |  **8.920 ± 0.056** |
+|   Small Int String |  12.775 ± 0.053 |  33.125 ± 0.048 |  **7.864 ± 0.076** |
+|         Int String |  13.831 ± 0.053 |  37.978 ± 0.483 |  **9.717 ± 0.072** |
+|  Medium Int String |  15.348 ± 1.027 |  67.316 ± 0.288 | **10.101 ± 0.012** |
+|   Large Int String |  18.831 ± 0.042 |  99.047 ± 0.373 | **17.319 ± 0.033** |
+| Small Float String |  89.952 ± 0.376 |  60.659 ± 0.023 |  **9.176 ± 0.048** |
+|       Float String | 116.452 ± 0.716 |  97.259 ± 0.415 | **16.667 ± 0.004** |
+| Large Float String | 157.536 ± 1.256 | 138.574 ± 2.043 | **31.475 ± 0.136** |
+|                Int |   9.837 ± 0.294 |  49.607 ± 0.026 |  **6.670 ± 0.076** |
+|              Float |  18.616 ± 0.037 |  59.832 ± 0.128 | **16.839 ± 0.016** |
 
 ### Timing comparison to check if value can be converted to `int`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
 | -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  87.819 ± 1.736 | 29.586 ± 0.033 | **6.703 ± 0.042** |
-|   Small Int String |  17.920 ± 0.055 | 33.269 ± 0.734 | **6.654 ± 0.046** |
-|         Int String |  18.503 ± 0.069 | 35.133 ± 0.745 | **6.787 ± 0.046** |
-|  Medium Int String |  20.077 ± 0.273 | 38.332 ± 0.844 | **6.925 ± 0.061** |
-|   Large Int String |  25.034 ± 0.058 | 46.740 ± 0.057 | **7.142 ± 0.422** |
-| Small Float String |  79.564 ± 0.348 | 32.218 ± 0.197 | **7.447 ± 0.051** |
-|       Float String |  87.389 ± 0.101 | 37.024 ± 0.760 | **8.206 ± 0.138** |
-| Large Float String |  87.220 ± 0.083 | 36.735 ± 0.600 | **8.338 ± 0.084** |
-|                Int |  13.964 ± 0.067 | 14.274 ± 0.071 | **5.943 ± 0.028** |
-|              Float |  25.229 ± 0.285 | 13.705 ± 0.090 | **5.978 ± 0.051** |
+|  Non-number String |  82.467 ± 0.244 | 31.220 ± 0.084 | **6.184 ± 0.073** |
+|   Small Int String |  16.845 ± 0.113 | 34.291 ± 0.236 | **6.108 ± 0.047** |
+|         Int String |  17.906 ± 0.311 | 35.762 ± 0.019 | **6.315 ± 0.069** |
+|  Medium Int String |  19.060 ± 0.041 | 38.670 ± 0.418 | **6.360 ± 0.045** |
+|   Large Int String |  22.858 ± 0.027 | 46.916 ± 0.014 | **6.338 ± 0.015** |
+| Small Float String |  77.340 ± 0.210 | 33.778 ± 0.010 | **6.831 ± 0.081** |
+|       Float String |  83.426 ± 0.174 | 38.048 ± 0.011 | **7.633 ± 0.041** |
+| Large Float String |  86.156 ± 0.088 | 38.079 ± 0.017 | **7.623 ± 0.061** |
+|                Int |  12.306 ± 0.057 | 13.191 ± 0.096 | **5.366 ± 0.050** |
+|              Float |  22.221 ± 0.011 | 12.198 ± 0.032 | **5.677 ± 0.079** |
 
 ### Timing comparison to check if value can be converted to `float`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
 | -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  47.741 ± 0.184 | 32.281 ± 0.031 | **7.339 ± 0.041** |
-|   Small Int String |  16.903 ± 0.040 | 43.378 ± 3.023 | **7.731 ± 0.066** |
-|         Int String |  18.479 ± 0.126 | 42.753 ± 0.968 | **7.633 ± 0.045** |
-|  Medium Int String |  19.209 ± 0.075 | 45.565 ± 0.737 | **7.673 ± 0.065** |
-|   Large Int String |  38.828 ± 0.008 | 54.346 ± 0.360 | **7.800 ± 0.081** |
-| Small Float String |  17.452 ± 0.005 | 39.007 ± 0.104 | **8.183 ± 0.034** |
-|       Float String |  36.508 ± 0.092 | 47.560 ± 0.502 | **8.872 ± 0.068** |
-| Large Float String |  62.730 ± 1.024 | 51.882 ± 0.086 | **9.196 ± 0.044** |
-|                Int |  12.689 ± 0.060 | 15.186 ± 0.088 | **6.705 ± 0.064** |
-|              Float |  12.019 ± 0.038 | 13.328 ± 0.113 | **6.424 ± 0.049** |
+|  Non-number String |  41.736 ± 0.158 | 34.432 ± 0.181 | **6.927 ± 0.084** |
+|   Small Int String |  14.109 ± 0.085 | 42.049 ± 0.005 | **6.842 ± 0.055** |
+|         Int String |  14.773 ± 0.042 | 43.690 ± 0.138 | **7.136 ± 0.081** |
+|  Medium Int String |  15.830 ± 0.072 | 46.349 ± 0.014 | **7.097 ± 0.052** |
+|   Large Int String |  33.360 ± 0.110 | 54.715 ± 0.027 | **7.157 ± 0.067** |
+| Small Float String |  14.577 ± 0.059 | 42.176 ± 2.557 | **7.490 ± 0.058** |
+|       Float String |  30.727 ± 0.141 | 48.740 ± 0.183 | **8.310 ± 0.072** |
+| Large Float String |  53.279 ± 0.218 | 51.197 ± 0.031 | **8.337 ± 0.068** |
+|                Int |  11.177 ± 0.049 | 13.501 ± 0.220 | **6.108 ± 0.029** |
+|              Float |  10.776 ± 0.068 | 11.921 ± 0.043 | **6.220 ± 0.061** |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
 | -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  48.080 ± 0.422 | 32.689 ± 1.053 | **7.041 ± 0.053** |
-|   Small Int String |  12.951 ± 0.034 | 40.364 ± 0.285 | **7.305 ± 0.086** |
-|         Int String |  13.770 ± 0.049 | 41.131 ± 0.339 | **7.493 ± 0.052** |
-|  Medium Int String |  15.908 ± 0.397 | 45.402 ± 0.072 | **7.514 ± 0.165** |
-|   Large Int String |  34.728 ± 0.014 | 54.111 ± 1.112 | **7.417 ± 0.043** |
-| Small Float String |  13.397 ± 0.075 | 40.625 ± 2.437 | **8.128 ± 0.029** |
-|       Float String |  33.328 ± 0.035 | 48.178 ± 0.106 | **8.650 ± 0.069** |
-| Large Float String |  57.835 ± 0.006 | 50.262 ± 0.825 | **8.971 ± 0.081** |
-|                Int |   8.984 ± 0.138 | 12.015 ± 0.071 | **6.262 ± 0.018** |
-|              Float |   8.120 ± 0.025 | 10.986 ± 0.090 | **6.274 ± 0.011** |
+|  Non-number String |  42.047 ± 1.008 | 33.534 ± 0.055 | **6.963 ± 0.175** |
+|   Small Int String |  10.388 ± 0.047 | 41.865 ± 0.018 | **6.818 ± 0.035** |
+|         Int String |  11.214 ± 0.041 | 43.890 ± 0.160 | **7.183 ± 0.163** |
+|  Medium Int String |  12.415 ± 0.095 | 46.394 ± 0.071 | **7.106 ± 0.046** |
+|   Large Int String |  29.424 ± 0.041 | 54.811 ± 0.169 | **7.172 ± 0.096** |
+| Small Float String |  10.718 ± 0.030 | 40.600 ± 0.027 | **7.536 ± 0.037** |
+|       Float String |  26.583 ± 0.169 | 48.676 ± 0.050 | **8.319 ± 0.074** |
+| Large Float String |  48.837 ± 0.019 | 51.418 ± 0.295 | **8.336 ± 0.065** |
+|                Int |   7.948 ± 0.044 | 11.327 ± 0.031 | **6.146 ± 0.056** |
+|              Float |   7.163 ± 0.042 | 10.031 ± 0.094 | **6.270 ± 0.081** |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
 | -----------------: | --------------: | --------------: | ----------------: |
-|  Non-number String | 128.786 ± 1.799 |  40.152 ± 0.192 | **6.491 ± 0.060** |
-|   Small Int String |  24.634 ± 0.015 |  23.478 ± 0.017 | **6.424 ± 0.071** |
-|         Int String |  26.103 ± 0.372 |  25.953 ± 0.007 | **6.804 ± 0.094** |
-|  Medium Int String |  32.231 ± 0.017 |  28.397 ± 0.294 | **6.765 ± 0.052** |
-|   Large Int String |  63.351 ± 0.089 |  37.483 ± 0.480 | **6.728 ± 0.077** |
-| Small Float String |  99.912 ± 1.287 |  61.313 ± 0.828 | **7.505 ± 0.066** |
-|       Float String | 129.121 ± 3.041 |  97.321 ± 1.135 | **7.921 ± 0.048** |
-| Large Float String | 157.302 ± 0.920 | 126.913 ± 2.508 | **7.991 ± 0.068** |
-|                Int |  16.014 ± 0.067 |  51.582 ± 0.022 | **5.632 ± 0.030** |
-|              Float |  39.637 ± 0.012 |  81.462 ± 1.585 | **5.930 ± 0.087** |
+|  Non-number String | 122.377 ± 2.287 |  42.010 ± 0.133 | **6.125 ± 0.034** |
+|   Small Int String |  22.423 ± 0.016 |  24.684 ± 0.012 | **6.030 ± 0.042** |
+|         Int String |  23.990 ± 0.008 |  26.303 ± 0.121 | **6.257 ± 0.063** |
+|  Medium Int String |  28.451 ± 0.226 |  28.996 ± 0.053 | **6.206 ± 0.056** |
+|   Large Int String |  56.544 ± 0.205 |  37.452 ± 0.031 | **6.246 ± 0.030** |
+| Small Float String |  94.890 ± 0.344 |  62.767 ± 0.182 | **6.728 ± 0.070** |
+|       Float String | 114.992 ± 0.785 |  91.498 ± 0.227 | **7.473 ± 0.058** |
+| Large Float String | 140.728 ± 0.236 | 116.857 ± 0.175 | **7.543 ± 0.060** |
+|                Int |  14.318 ± 0.123 |  51.469 ± 0.560 | **5.345 ± 0.059** |
+|              Float |  38.331 ± 0.066 |  77.978 ± 0.136 | **5.570 ± 0.053** |
+
+### Timing comparison of `map_try_float` vs. iterating over `try_float` for a 50 element list
+
+| Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | map_try_float(iterable) (ms) |
+| -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------: |
+|  Non-number String |                      524.015 ± 1.615  |                     438.287 ± 1.311 |          **265.749 ± 0.588** |
+|   Small Int String |                      529.106 ± 1.131  |                     455.519 ± 4.760 |          **263.063 ± 0.850** |
+|         Int String |                      547.456 ± 1.906  |                     457.621 ± 0.560 |          **275.416 ± 0.202** |
+|  Medium Int String |                      580.353 ± 2.223  |                     480.623 ± 2.218 |          **297.870 ± 0.482** |
+|   Large Int String |                      798.740 ± 2.888  |                     704.378 ± 4.684 |          **523.714 ± 6.085** |
+| Small Float String |                      582.804 ± 5.197  |                     485.794 ± 0.490 |          **300.775 ± 1.616** |
+|       Float String |                      676.687 ± 35.289 |                     562.682 ± 2.027 |          **367.818 ± 3.789** |
+| Large Float String |                      668.149 ± 1.603  |                     575.859 ± 7.063 |          **383.980 ± 3.203** |
+|                Int |                      514.411 ± 5.378  |                     421.370 ± 1.443 |          **241.427 ± 0.283** |
+|              Float |                      482.791 ± 6.784  |                     391.209 ± 3.362 |          **198.089 ± 1.546** |
 
diff --git a/profiling/results-3.11.md b/profiling/results-3.11.md
index 2b699d50..6db0ffe9 100644
--- a/profiling/results-3.11.md
+++ b/profiling/results-3.11.md
@@ -2,146 +2,161 @@ sys.version_info(major=3, minor=11, micro=1, releaselevel='final', serial=0)
 
 ### Timing comparison of `int` functions
 
-| Input type        | builtin (ms)       | fastnumbers (ms)   |
-| ----------------: | -----------------: | -----------------: |
-|  Small Int String |   12.589 ± 0.696   |  **6.860 ± 0.529** |
-|        Int String |   13.447 ± 1.074   |  **9.136 ± 0.061** |
-| Medium Int String |   15.500 ± 0.163   |  **9.748 ± 0.529** |
-|  Large Int String |   22.830 ± 4.081   | **20.852 ± 0.245** |
-|               Int |    6.934 ± 0.295   |  **5.603 ± 0.066** |
-|             Float | **16.462 ± 0.030** |   19.117 ± 0.181   |
+| Input type        | builtin (ms)   | fastnumbers (ms)   |
+| ----------------: | -------------: | -----------------: |
+|  Small Int String | 12.472 ± 0.265 |  **6.927 ± 0.057** |
+|        Int String | 13.289 ± 0.069 |  **8.313 ± 0.085** |
+| Medium Int String | 15.550 ± 0.577 |  **8.847 ± 0.097** |
+|  Large Int String | 21.265 ± 0.228 | **19.443 ± 1.785** |
+|               Int |  6.899 ± 0.051 |  **5.919 ± 0.067** |
+|             Float | 16.632 ± 0.291 | **16.080 ± 0.092** |
 
 ### Timing comparison of `float` functions
 
 | Input type         | builtin (ms)      | fastnumbers (ms)   |
 | -----------------: | ----------------: | -----------------: |
-|   Small Int String | **7.164 ± 0.177** |    8.830 ± 0.175   |
-|         Int String | **7.785 ± 0.741** |    8.866 ± 0.095   |
-|  Medium Int String | **8.676 ± 0.174** |    9.381 ± 0.177   |
-|   Large Int String |  28.183 ± 0.239   | **13.801 ± 0.038** |
-| Small Float String | **7.298 ± 0.075** |    9.050 ± 0.052   |
-|       Float String |  25.474 ± 0.647   | **10.587 ± 0.187** |
-| Large Float String |  47.315 ± 0.048   | **10.735 ± 0.034** |
-|                Int | **3.403 ± 0.061** |    7.858 ± 0.033   |
-|              Float | **2.446 ± 0.055** |    5.325 ± 0.050   |
+|   Small Int String | **7.014 ± 0.381** |    7.081 ± 0.068   |
+|         Int String |   7.573 ± 0.093   |  **7.389 ± 0.054** |
+|  Medium Int String |   8.684 ± 0.223   |  **7.883 ± 0.120** |
+|   Large Int String |  28.405 ± 1.127   | **11.966 ± 0.084** |
+| Small Float String | **7.325 ± 0.084** |    7.669 ± 0.030   |
+|       Float String |  25.438 ± 0.502   |  **9.088 ± 0.053** |
+| Large Float String |  47.452 ± 0.373   |  **9.253 ± 0.041** |
+|                Int | **3.637 ± 0.865** |    6.418 ± 0.030   |
+|              Float | **2.436 ± 0.053** |    5.405 ± 0.342   |
 
 ### Timing comparison of `int` functions with error handling
 
-| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |  119.510 ± 3.464   |  23.821 ± 0.081 |  **7.627 ± 0.075** |
-|   Small Int String |   16.088 ± 0.026   |  42.784 ± 0.148 |  **7.138 ± 0.059** |
-|         Int String |   16.932 ± 0.210   |  47.846 ± 0.831 |  **9.482 ± 0.019** |
-|  Medium Int String |   19.032 ± 0.034   |  55.368 ± 0.143 | **10.059 ± 0.048** |
-|   Large Int String | **24.775 ± 0.046** |  76.420 ± 0.277 |   32.419 ± 8.462   |
-| Small Float String |  131.296 ± 23.287  |  28.426 ± 0.937 |  **7.599 ± 0.079** |
-|       Float String |  120.462 ± 0.574   |  34.981 ± 1.152 |  **8.020 ± 0.068** |
-| Large Float String |  125.589 ± 0.858   |  33.852 ± 0.464 |  **8.145 ± 0.095** |
-|                Int |    9.997 ± 0.037   |  93.293 ± 7.132 |  **5.948 ± 0.035** |
-|              Float | **19.518 ± 0.028** | 100.799 ± 0.290 |   19.546 ± 0.044   |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 116.234 ± 0.687 |  22.127 ± 0.024 |  **7.824 ± 0.020** |
+|   Small Int String |  15.910 ± 0.155 |  41.118 ± 0.011 |  **7.120 ± 0.021** |
+|         Int String |  16.778 ± 0.005 |  45.498 ± 0.196 |  **8.631 ± 0.040** |
+|  Medium Int String |  18.929 ± 0.013 |  53.859 ± 0.038 |  **9.166 ± 0.046** |
+|   Large Int String |  24.711 ± 0.005 |  74.609 ± 0.221 | **20.249 ± 1.038** |
+| Small Float String | 113.491 ± 0.497 |  25.898 ± 0.011 |  **7.929 ± 0.130** |
+|       Float String | 119.805 ± 0.135 |  32.693 ± 0.151 |  **8.200 ± 0.036** |
+| Large Float String | 124.093 ± 1.984 |  32.970 ± 1.679 |  **8.316 ± 0.462** |
+|                Int |   9.995 ± 0.014 |  91.804 ± 0.091 |  **6.095 ± 0.038** |
+|              Float |  19.606 ± 0.020 | 100.688 ± 0.205 | **16.362 ± 0.012** |
 
 ### Timing comparison of `float` functions with error handling
 
 | Input type         | try/except (ms)   | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | ----------------: | --------------: | -----------------: |
-|  Non-number String |  68.844 ± 0.336   |  27.908 ± 0.141 |  **8.245 ± 0.028** |
-|   Small Int String |  11.038 ± 0.824   |  45.968 ± 0.074 |  **9.910 ± 0.359** |
-|         Int String |  11.291 ± 0.327   |  50.655 ± 0.804 |  **9.934 ± 0.027** |
-|  Medium Int String |  12.126 ± 0.097   |  57.082 ± 0.247 | **10.385 ± 0.039** |
-|   Large Int String |  32.930 ± 1.201   |  97.150 ± 3.827 | **16.419 ± 0.410** |
-| Small Float String |  11.641 ± 0.738   |  48.032 ± 2.231 | **10.325 ± 0.063** |
-|       Float String |  29.375 ± 0.028   |  82.816 ± 1.561 | **11.818 ± 0.030** |
-| Large Float String |  51.425 ± 0.114   | 112.667 ± 4.100 | **12.009 ± 0.030** |
-|                Int | **6.304 ± 0.060** |  87.275 ± 0.285 |    8.810 ± 0.030   |
-|              Float | **5.128 ± 0.039** |  86.815 ± 1.629 |    6.371 ± 0.208   |
+|  Non-number String |  68.731 ± 0.352   |  25.852 ± 0.092 |  **8.598 ± 0.051** |
+|   Small Int String |  11.016 ± 0.012   |  45.292 ± 0.097 |  **7.904 ± 0.024** |
+|         Int String |  11.230 ± 0.014   |  48.885 ± 0.016 |  **8.325 ± 0.014** |
+|  Medium Int String |  12.707 ± 0.057   |  56.393 ± 0.032 |  **8.735 ± 0.027** |
+|   Large Int String |  32.495 ± 0.008   |  91.983 ± 0.079 | **12.969 ± 0.008** |
+| Small Float String |  10.974 ± 0.062   |  44.638 ± 0.200 |  **8.490 ± 0.009** |
+|       Float String |  29.407 ± 0.003   |  78.129 ± 0.197 |  **9.871 ± 0.040** |
+| Large Float String |  51.270 ± 0.005   | 108.739 ± 3.385 | **10.039 ± 0.012** |
+|                Int | **7.168 ± 0.029** |  85.943 ± 0.628 |    7.221 ± 0.023   |
+|              Float | **5.774 ± 0.013** |  89.423 ± 0.435 |    6.188 ± 0.035   |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)    |
-| -----------------: | --------------: | --------------: | ------------------: |
-|  Non-number String |  71.906 ± 3.020 |  50.242 ± 0.766 |  **9.042 ± 0.180**  |
-|   Small Int String |  24.549 ± 0.102 |  42.066 ± 0.324 |  **7.879 ± 0.076**  |
-|         Int String |  26.435 ± 0.046 |  46.642 ± 0.841 | **10.377 ± 0.053**  |
-|  Medium Int String |  30.269 ± 0.720 |  55.584 ± 2.802 | **11.228 ± 0.294**  |
-|   Large Int String |  59.293 ± 0.033 |  75.291 ± 0.749 | **22.167 ± 0.038**  |
-| Small Float String |  24.992 ± 0.214 |  71.503 ± 3.403 | **11.372 ± 0.032**  |
-|       Float String |  60.369 ± 0.861 | 116.867 ± 5.200 | **17.945 ± 0.056**  |
-| Large Float String | 114.538 ± 0.762 | 141.018 ± 1.215 | **47.902 ± 20.985** |
-|                Int |  21.404 ± 0.984 |  97.594 ± 5.648 |  **6.666 ± 0.034**  |
-|              Float |  43.184 ± 1.712 |  94.910 ± 1.253 | **21.164 ± 0.517**  |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  68.496 ± 0.429 |  48.313 ± 0.195 | **10.464 ± 0.738** |
+|   Small Int String |  24.562 ± 0.008 |  41.270 ± 0.007 |  **7.772 ± 0.067** |
+|         Int String |  26.334 ± 0.030 |  45.597 ± 0.085 |  **9.493 ± 0.035** |
+|  Medium Int String |  29.899 ± 0.012 |  54.034 ± 0.132 | **10.006 ± 0.028** |
+|   Large Int String |  59.243 ± 0.037 |  74.707 ± 0.225 | **20.492 ± 0.042** |
+| Small Float String |  24.889 ± 0.007 |  68.925 ± 0.080 |  **9.627 ± 0.005** |
+|       Float String |  58.652 ± 0.128 | 109.881 ± 3.986 | **16.198 ± 0.023** |
+| Large Float String | 114.415 ± 0.288 | 137.814 ± 0.664 | **31.589 ± 0.027** |
+|                Int |  20.107 ± 0.007 |  94.534 ± 0.364 |  **6.490 ± 0.028** |
+|              Float |  40.478 ± 0.011 |  89.626 ± 0.375 | **16.732 ± 0.010** |
 
 ### Timing comparison of forced `int` functions with error handling
 
-| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |  208.897 ± 17.485  |  51.073 ± 0.018 |  **8.391 ± 0.076** |
-|   Small Int String |   16.076 ± 0.019   |  42.377 ± 0.070 |  **7.480 ± 0.232** |
-|         Int String |   17.213 ± 0.379   |  49.964 ± 6.863 |  **9.760 ± 0.021** |
-|  Medium Int String |   18.960 ± 0.063   |  89.715 ± 0.437 | **12.367 ± 4.305** |
-|   Large Int String |   24.912 ± 0.356   | 132.287 ± 0.939 | **22.357 ± 0.188** |
-| Small Float String |  133.115 ± 1.589   |  81.125 ± 0.628 |  **8.810 ± 0.190** |
-|       Float String |  169.630 ± 10.755  | 125.580 ± 0.944 | **17.192 ± 0.033** |
-| Large Float String |  209.210 ± 6.064   | 173.270 ± 3.632 | **36.588 ± 0.065** |
-|                Int |    9.992 ± 0.035   |  91.783 ± 1.263 |  **5.912 ± 0.046** |
-|              Float | **19.569 ± 0.028** | 102.217 ± 2.244 |   44.126 ± 21.273  |
+| Input type         | try/except (ms) | regex (ms)       | fastnumbers (ms)   |
+| -----------------: | --------------: | ---------------: | -----------------: |
+|  Non-number String | 190.363 ± 1.261 |  45.943 ± 0.016  |  **8.649 ± 0.043** |
+|   Small Int String |  15.853 ± 0.015 |  40.585 ± 0.185  |  **7.257 ± 0.082** |
+|         Int String |  16.800 ± 0.010 |  44.827 ± 0.034  |  **9.087 ± 0.047** |
+|  Medium Int String |  18.974 ± 0.054 |  91.828 ± 12.576 |  **9.798 ± 0.119** |
+|   Large Int String |  24.802 ± 0.104 | 126.742 ± 1.043  | **20.151 ± 0.036** |
+| Small Float String | 130.671 ± 0.318 |  77.711 ± 0.305  |  **8.750 ± 0.051** |
+|       Float String | 163.009 ± 0.464 | 127.153 ± 8.906  | **15.380 ± 0.007** |
+| Large Float String | 206.238 ± 0.517 | 169.206 ± 2.326  | **30.762 ± 0.042** |
+|                Int |  10.000 ± 0.025 |  92.554 ± 1.233  |  **6.199 ± 0.112** |
+|              Float |  19.708 ± 0.145 | 101.089 ± 0.114  | **16.322 ± 0.058** |
 
 ### Timing comparison to check if value can be converted to `int`
 
-| Input type         | try/except (ms)  | regex (ms)     | fastnumbers (ms)  |
-| -----------------: | ---------------: | -------------: | ----------------: |
-|  Non-number String | 119.543 ± 4.400  | 34.629 ± 0.972 | **6.119 ± 0.052** |
-|   Small Int String |  19.274 ± 0.047  | 40.188 ± 0.272 | **5.955 ± 0.083** |
-|         Int String |  20.232 ± 0.055  | 44.502 ± 0.572 | **6.250 ± 0.048** |
-|  Medium Int String |  22.361 ± 0.041  | 50.984 ± 3.082 | **6.198 ± 0.042** |
-|   Large Int String |  28.255 ± 0.147  | 64.366 ± 0.147 | **6.203 ± 0.058** |
-| Small Float String | 119.592 ± 11.911 | 39.395 ± 0.906 | **6.762 ± 0.055** |
-|       Float String | 121.231 ± 1.776  | 46.881 ± 6.541 | **7.462 ± 0.061** |
-| Large Float String | 124.738 ± 2.045  | 45.913 ± 0.895 | **7.503 ± 0.044** |
-|                Int |  13.626 ± 1.069  | 12.640 ± 0.023 | **4.873 ± 0.060** |
-|              Float |  22.427 ± 0.030  | 11.700 ± 0.025 | **4.917 ± 0.043** |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String | 115.558 ± 0.452 | 33.347 ± 0.061 | **5.939 ± 0.064** |
+|   Small Int String |  19.045 ± 0.053 | 39.176 ± 0.026 | **5.871 ± 0.027** |
+|         Int String |  20.102 ± 0.098 | 42.590 ± 0.338 | **6.007 ± 0.061** |
+|  Medium Int String |  22.146 ± 0.003 | 48.774 ± 0.091 | **6.148 ± 0.076** |
+|   Large Int String |  28.023 ± 0.005 | 63.272 ± 0.016 | **6.111 ± 0.056** |
+| Small Float String | 112.285 ± 0.452 | 37.266 ± 0.178 | **6.753 ± 0.057** |
+|       Float String | 119.900 ± 2.970 | 43.133 ± 0.012 | **7.233 ± 0.055** |
+| Large Float String | 122.662 ± 0.681 | 43.605 ± 0.862 | **7.396 ± 0.013** |
+|                Int |  13.158 ± 0.008 | 12.655 ± 0.013 | **4.791 ± 0.037** |
+|              Float |  22.434 ± 0.006 | 11.692 ± 0.010 | **4.835 ± 0.030** |
 
 ### Timing comparison to check if value can be converted to `float`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
-| -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  70.354 ± 0.690 | 41.032 ± 0.903 | **6.819 ± 0.042** |
-|   Small Int String |  13.553 ± 0.031 | 52.209 ± 0.458 | **6.754 ± 0.039** |
-|         Int String |  14.176 ± 0.016 | 55.249 ± 0.509 | **7.148 ± 0.080** |
-|  Medium Int String |  15.293 ± 0.025 | 60.375 ± 1.780 | **7.043 ± 0.046** |
-|   Large Int String |  35.789 ± 0.229 | 76.288 ± 0.221 | **7.262 ± 0.316** |
-| Small Float String |  14.250 ± 0.204 | 50.537 ± 0.963 | **7.750 ± 0.274** |
-|       Float String |  33.230 ± 0.080 | 66.422 ± 1.252 | **8.188 ± 0.078** |
-| Large Float String |  54.882 ± 0.749 | 72.142 ± 1.444 | **8.329 ± 0.091** |
-|                Int |   8.677 ± 0.078 | 13.043 ± 0.023 | **5.614 ± 0.044** |
-|              Float |   7.930 ± 0.059 | 11.310 ± 0.034 | **5.612 ± 0.033** |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String |  68.106 ± 0.641 | 37.083 ± 0.018 |  **6.686 ± 0.033** |
+|   Small Int String |  13.525 ± 0.020 | 48.195 ± 0.104 |  **6.739 ± 0.104** |
+|         Int String |  14.203 ± 0.012 | 51.158 ± 0.057 |  **6.890 ± 0.070** |
+|  Medium Int String |  17.345 ± 0.149 | 57.941 ± 0.781 |  **6.966 ± 0.028** |
+|   Large Int String |  37.336 ± 0.928 | 72.415 ± 0.435 |  **6.977 ± 0.049** |
+| Small Float String |  13.927 ± 0.009 | 46.808 ± 0.070 |  **7.472 ± 0.027** |
+|       Float String |  32.453 ± 0.026 | 61.646 ± 0.011 | **11.891 ± 2.204** |
+| Large Float String |  58.566 ± 8.967 | 68.051 ± 0.083 |  **8.102 ± 0.051** |
+|                Int |   8.762 ± 0.044 | 13.016 ± 0.007 |  **5.490 ± 0.027** |
+|              Float |   7.932 ± 0.029 | 11.311 ± 0.022 |  **5.439 ± 0.066** |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
-| Input type         | try/except (ms)   | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | ----------------: | -------------: | -----------------: |
-|  Non-number String |  69.244 ± 0.943   | 39.047 ± 0.337 |  **6.815 ± 0.082** |
-|   Small Int String |  10.676 ± 0.021   | 49.727 ± 0.131 |  **6.770 ± 0.017** |
-|         Int String |  11.311 ± 0.017   | 52.671 ± 0.409 |  **7.387 ± 0.734** |
-|  Medium Int String |  12.423 ± 0.020   | 59.046 ± 0.218 |  **7.119 ± 0.037** |
-|   Large Int String |  32.671 ± 0.018   | 76.439 ± 1.772 | **11.275 ± 3.563** |
-| Small Float String |  11.074 ± 0.062   | 58.030 ± 5.090 |  **9.974 ± 3.195** |
-|       Float String |  30.218 ± 0.133   | 68.739 ± 2.834 | **10.777 ± 1.758** |
-| Large Float String |  54.476 ± 1.473   | 72.465 ± 0.897 |  **8.262 ± 0.060** |
-|                Int |   6.591 ± 0.022   | 10.645 ± 0.038 |  **5.681 ± 0.048** |
-|              Float | **5.451 ± 0.027** |  9.395 ± 0.089 |    5.672 ± 0.055   |
+| Input type         | try/except (ms)   | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | ----------------: | -------------: | ----------------: |
+|  Non-number String |  68.266 ± 0.435   | 36.374 ± 0.013 | **6.392 ± 0.046** |
+|   Small Int String |  10.620 ± 0.035   | 47.391 ± 0.016 | **6.398 ± 0.035** |
+|         Int String |  11.385 ± 0.170   | 50.443 ± 0.048 | **6.542 ± 0.079** |
+|  Medium Int String |  12.434 ± 0.044   | 57.003 ± 0.165 | **6.645 ± 0.060** |
+|   Large Int String |  33.067 ± 1.045   | 71.554 ± 0.149 | **6.686 ± 0.075** |
+| Small Float String |  10.985 ± 0.034   | 46.134 ± 0.022 | **7.224 ± 0.066** |
+|       Float String |  29.506 ± 0.005   | 60.984 ± 0.122 | **7.930 ± 0.046** |
+| Large Float String |  51.305 ± 0.018   | 67.360 ± 0.062 | **7.902 ± 0.085** |
+|                Int |   6.530 ± 0.012   | 10.445 ± 0.045 | **5.255 ± 0.020** |
+|              Float | **5.427 ± 0.043** |  9.136 ± 0.075 |   5.512 ± 0.007   |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
-| Input type         | try/except (ms)  | regex (ms)      | fastnumbers (ms)  |
-| -----------------: | ---------------: | --------------: | ----------------: |
-|  Non-number String | 209.075 ± 10.095 |  53.786 ± 0.939 | **5.978 ± 0.054** |
-|   Small Int String |  29.647 ± 0.506  |  30.856 ± 1.562 | **5.783 ± 0.032** |
-|         Int String |  31.054 ± 0.022  |  33.111 ± 0.045 | **6.159 ± 0.047** |
-|  Medium Int String |  36.726 ± 0.727  |  39.265 ± 0.254 | **6.095 ± 0.049** |
-|   Large Int String |  68.584 ± 0.172  |  53.585 ± 0.060 | **6.076 ± 0.035** |
-| Small Float String | 130.217 ± 5.383  |  73.901 ± 0.121 | **6.573 ± 0.077** |
-|       Float String | 154.614 ± 2.346  | 116.643 ± 3.089 | **7.216 ± 0.032** |
-| Large Float String | 180.160 ± 2.003  | 145.942 ± 4.095 | **7.316 ± 0.038** |
-|                Int |  17.891 ± 0.744  |  92.511 ± 1.872 | **4.689 ± 0.055** |
-|              Float |  39.772 ± 0.059  | 124.031 ± 0.736 | **4.673 ± 0.033** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
+| -----------------: | --------------: | --------------: | ----------------: |
+|  Non-number String | 196.881 ± 1.286 |  47.470 ± 0.145 | **5.906 ± 0.024** |
+|   Small Int String |  28.926 ± 0.127 |  28.117 ± 0.016 | **5.879 ± 0.067** |
+|         Int String |  30.733 ± 0.017 |  31.275 ± 0.011 | **5.986 ± 0.044** |
+|  Medium Int String |  35.863 ± 0.061 |  37.491 ± 0.087 | **6.151 ± 0.098** |
+|   Large Int String |  68.242 ± 0.139 |  51.875 ± 0.013 | **6.068 ± 0.030** |
+| Small Float String | 125.129 ± 0.150 |  70.659 ± 0.049 | **6.595 ± 0.022** |
+|       Float String | 151.718 ± 0.392 | 109.751 ± 0.204 | **7.193 ± 0.038** |
+| Large Float String | 181.443 ± 2.901 | 139.503 ± 0.276 | **7.326 ± 0.036** |
+|                Int |  17.530 ± 0.003 |  92.285 ± 1.465 | **4.740 ± 0.067** |
+|              Float |  39.811 ± 0.009 | 123.938 ± 0.963 | **4.705 ± 0.049** |
+
+### Timing comparison of `map_try_float` vs. iterating over `try_float` for a 50 element list
+
+| Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | map_try_float(iterable) (ms) |
+| -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------: |
+|  Non-number String |                       524.953 ± 2.530 |                    461.067 ± 0.483  |         **262.998 ± 0.226**  |
+|   Small Int String |                       502.801 ± 1.008 |                    445.925 ± 1.580  |         **242.714 ± 0.202**  |
+|         Int String |                       526.245 ± 3.073 |                    485.039 ± 0.162  |         **260.281 ± 1.538**  |
+|  Medium Int String |                       540.754 ± 3.076 |                    486.416 ± 12.681 |         **279.056 ± 0.143**  |
+|   Large Int String |                       753.758 ± 1.613 |                    688.814 ± 3.007  |         **488.477 ± 1.145**  |
+| Small Float String |                       533.173 ± 5.216 |                    464.885 ± 0.955  |         **270.109 ± 6.194**  |
+|       Float String |                       623.215 ± 4.058 |                    566.818 ± 6.747  |         **340.025 ± 2.467**  |
+| Large Float String |                       608.719 ± 1.147 |                    559.918 ± 7.374  |         **360.721 ± 28.135** |
+|                Int |                       482.215 ± 4.017 |                    422.215 ± 1.527  |         **224.294 ± 0.666**  |
+|              Float |                       415.187 ± 6.836 |                    354.330 ± 0.925  |         **170.970 ± 1.575**  |
 
diff --git a/profiling/results-3.7.md b/profiling/results-3.7.md
index d4687040..436fb312 100644
--- a/profiling/results-3.7.md
+++ b/profiling/results-3.7.md
@@ -1,147 +1,162 @@
-sys.version_info(major=3, minor=7, micro=9, releaselevel='final', serial=0)
+sys.version_info(major=3, minor=7, micro=16, releaselevel='final', serial=0)
 
 ### Timing comparison of `int` functions
 
-| Input type        | builtin (ms)       | fastnumbers (ms)   |
-| ----------------: | -----------------: | -----------------: |
-|  Small Int String |   14.186 ± 0.248   |  **7.790 ± 0.138** |
-|        Int String |   15.145 ± 0.093   | **10.171 ± 0.949** |
-| Medium Int String |   17.014 ± 0.271   | **10.367 ± 0.075** |
-|  Large Int String |   22.850 ± 0.070   | **21.071 ± 0.489** |
-|               Int |    9.258 ± 0.097   |  **6.889 ± 0.079** |
-|             Float | **19.593 ± 0.538** |   20.350 ± 0.188   |
+| Input type        | builtin (ms)   | fastnumbers (ms)   |
+| ----------------: | -------------: | -----------------: |
+|  Small Int String | 16.222 ± 0.234 |  **7.849 ± 0.065** |
+|        Int String | 17.005 ± 0.093 |  **9.467 ± 0.753** |
+| Medium Int String | 18.562 ± 0.090 |  **9.522 ± 0.118** |
+|  Large Int String | 23.544 ± 0.550 | **18.561 ± 0.118** |
+|               Int | 10.038 ± 0.097 |  **6.999 ± 0.107** |
+|             Float | 20.933 ± 0.367 | **18.227 ± 0.097** |
 
 ### Timing comparison of `float` functions
 
-| Input type         | builtin (ms)      | fastnumbers (ms)   |
-| -----------------: | ----------------: | -----------------: |
-|   Small Int String |  11.829 ± 0.092   |  **9.585 ± 0.090** |
-|         Int String |  12.384 ± 0.560   |  **9.919 ± 0.055** |
-|  Medium Int String |  13.359 ± 0.051   | **10.308 ± 0.167** |
-|   Large Int String |  35.909 ± 7.434   | **14.476 ± 0.049** |
-| Small Float String |  12.384 ± 1.176   | **10.130 ± 0.288** |
-|       Float String |  29.721 ± 0.108   | **11.757 ± 1.495** |
-| Large Float String |  52.927 ± 1.115   | **11.749 ± 0.270** |
-|                Int | **8.040 ± 0.050** |    8.839 ± 0.059   |
-|              Float |   7.213 ± 0.050   |  **6.478 ± 0.057** |
+| Input type         | builtin (ms)   | fastnumbers (ms)   |
+| -----------------: | -------------: | -----------------: |
+|   Small Int String | 13.560 ± 0.202 |  **8.632 ± 1.955** |
+|         Int String | 14.200 ± 0.510 |  **8.424 ± 0.080** |
+|  Medium Int String | 15.154 ± 0.086 |  **8.646 ± 0.075** |
+|   Large Int String | 35.950 ± 0.486 | **13.098 ± 0.027** |
+| Small Float String | 14.005 ± 0.372 |  **8.654 ± 0.040** |
+|       Float String | 32.433 ± 0.541 | **10.179 ± 1.054** |
+| Large Float String | 54.627 ± 1.123 | **10.118 ± 0.032** |
+|                Int |  9.027 ± 0.086 |  **7.652 ± 0.927** |
+|              Float |  8.302 ± 0.090 |  **7.227 ± 0.639** |
 
 ### Timing comparison of `int` functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 110.521 ± 4.610 | 26.948 ± 0.390  |  **8.470 ± 0.075** |
-|   Small Int String |  21.906 ± 0.020 | 58.548 ± 18.708 |  **8.206 ± 0.112** |
-|         Int String |  23.084 ± 0.262 | 49.424 ± 0.111  | **10.597 ± 0.018** |
-|  Medium Int String |  24.732 ± 0.006 | 55.776 ± 0.613  | **10.813 ± 0.020** |
-|   Large Int String |  31.168 ± 0.815 | 72.905 ± 0.123  | **21.539 ± 0.025** |
-| Small Float String | 105.259 ± 0.415 | 30.295 ± 0.486  |  **8.417 ± 0.052** |
-|       Float String | 111.828 ± 0.983 | 35.278 ± 0.008  |  **8.912 ± 0.101** |
-| Large Float String | 116.722 ± 0.523 | 35.528 ± 0.360  |  **8.799 ± 0.067** |
-|                Int |  16.463 ± 0.013 | 76.058 ± 0.876  |  **7.137 ± 0.052** |
-|              Float |  30.025 ± 4.226 | 87.508 ± 0.943  | **20.979 ± 0.163** |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String | 117.284 ± 2.582 | 29.122 ± 0.067 |  **8.919 ± 0.061** |
+|   Small Int String |  24.815 ± 0.006 | 50.603 ± 0.025 |  **8.262 ± 0.065** |
+|         Int String |  25.606 ± 0.081 | 54.761 ± 0.060 |  **9.776 ± 0.009** |
+|  Medium Int String |  28.436 ± 2.950 | 62.390 ± 0.107 |  **9.996 ± 0.006** |
+|   Large Int String |  32.112 ± 0.004 | 81.513 ± 0.056 | **18.929 ± 0.027** |
+| Small Float String | 113.950 ± 1.093 | 33.078 ± 0.025 |  **8.865 ± 0.019** |
+|       Float String | 122.850 ± 3.704 | 39.770 ± 0.027 |  **9.280 ± 0.048** |
+| Large Float String | 122.137 ± 1.465 | 39.770 ± 0.029 | **11.046 ± 2.521** |
+|                Int |  18.579 ± 0.014 | 78.470 ± 3.456 |  **7.307 ± 0.046** |
+|              Float |  29.663 ± 0.006 | 87.908 ± 0.931 | **18.640 ± 0.001** |
 
 ### Timing comparison of `float` functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  66.865 ± 0.461 |  30.442 ± 0.187 |  **9.101 ± 0.080** |
-|   Small Int String |  19.368 ± 0.006 |  52.993 ± 0.540 | **10.617 ± 0.009** |
-|         Int String |  19.996 ± 0.050 |  55.830 ± 0.218 | **10.883 ± 0.016** |
-|  Medium Int String |  21.070 ± 0.004 |  61.365 ± 0.508 | **11.307 ± 0.006** |
-|   Large Int String |  44.510 ± 6.144 |  94.440 ± 0.840 | **15.548 ± 0.010** |
-| Small Float String |  19.962 ± 0.537 |  52.069 ± 0.312 | **11.073 ± 0.007** |
-|       Float String |  37.684 ± 0.143 |  83.942 ± 0.360 | **12.632 ± 0.009** |
-| Large Float String |  60.153 ± 0.499 | 112.514 ± 3.484 | **12.790 ± 0.009** |
-|                Int |  14.964 ± 0.146 |  74.737 ± 0.715 |  **9.822 ± 0.119** |
-|              Float |  14.010 ± 0.011 |  74.387 ± 0.300 |  **7.404 ± 0.053** |
+|  Non-number String |  69.456 ± 0.264 |  32.747 ± 0.017 |  **9.719 ± 0.026** |
+|   Small Int String |  21.853 ± 0.003 |  57.752 ± 0.999 |  **9.072 ± 0.019** |
+|         Int String |  22.547 ± 0.005 |  63.915 ± 2.780 |  **9.293 ± 0.042** |
+|  Medium Int String |  23.640 ± 0.003 |  68.189 ± 0.047 |  **9.724 ± 0.009** |
+|   Large Int String |  44.716 ± 0.025 | 103.959 ± 0.063 | **14.032 ± 0.036** |
+| Small Float String |  22.292 ± 0.003 |  57.810 ± 1.330 | **10.809 ± 2.579** |
+|       Float String |  41.209 ± 0.070 |  93.915 ± 1.776 | **10.863 ± 0.059** |
+| Large Float String |  63.821 ± 0.059 | 123.283 ± 0.182 | **11.157 ± 0.009** |
+|                Int |  17.232 ± 0.006 |  76.113 ± 0.846 |  **8.449 ± 0.031** |
+|              Float |  16.198 ± 0.022 |  74.981 ± 0.658 |  **7.950 ± 0.071** |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  67.302 ± 1.119 |  50.590 ± 0.267 |  **9.738 ± 0.094** |
-|   Small Int String |  39.310 ± 0.044 |  46.318 ± 0.174 |  **9.477 ± 0.915** |
-|         Int String |  41.514 ± 0.088 |  49.650 ± 0.281 | **11.634 ± 0.015** |
-|  Medium Int String |  44.871 ± 0.092 |  56.371 ± 1.757 | **12.027 ± 0.009** |
-|   Large Int String |  74.584 ± 1.467 |  73.177 ± 0.378 | **22.698 ± 0.013** |
-| Small Float String |  40.815 ± 1.699 |  75.774 ± 0.180 | **12.140 ± 0.014** |
-|       Float String |  73.566 ± 2.522 | 112.994 ± 1.238 | **18.685 ± 0.013** |
-| Large Float String | 128.552 ± 0.897 | 139.712 ± 0.302 | **38.582 ± 0.709** |
-|                Int |  36.251 ± 0.242 |  81.588 ± 0.369 |  **7.689 ± 0.215** |
-|              Float |  56.887 ± 0.391 |  76.445 ± 0.460 | **23.644 ± 4.198** |
+|  Non-number String |  70.180 ± 0.902 |  55.710 ± 0.244 | **10.510 ± 0.036** |
+|   Small Int String |  43.723 ± 0.055 |  50.817 ± 0.079 |  **9.234 ± 0.045** |
+|         Int String |  46.091 ± 0.103 |  54.942 ± 0.045 | **10.853 ± 0.002** |
+|  Medium Int String |  49.237 ± 0.062 |  62.542 ± 0.028 | **11.152 ± 0.013** |
+|   Large Int String |  79.161 ± 0.110 |  81.770 ± 0.275 | **20.126 ± 0.104** |
+| Small Float String |  44.274 ± 0.022 |  82.493 ± 0.100 | **10.686 ± 0.003** |
+|       Float String |  77.809 ± 0.072 | 125.964 ± 0.080 | **17.422 ± 0.006** |
+| Large Float String | 134.166 ± 0.301 | 155.003 ± 0.284 | **32.884 ± 0.001** |
+|                Int |  40.297 ± 0.036 |  86.038 ± 0.913 |  **7.899 ± 0.051** |
+|              Float |  61.773 ± 0.237 |  83.855 ± 0.131 | **21.149 ± 2.286** |
 
 ### Timing comparison of forced `int` functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 186.441 ± 2.084 |  49.671 ± 0.291 |  **9.270 ± 0.033** |
-|   Small Int String |  21.701 ± 0.066 |  46.545 ± 2.056 |  **8.551 ± 0.195** |
-|         Int String |  22.808 ± 0.022 |  48.340 ± 0.021 | **11.144 ± 0.019** |
-|  Medium Int String |  24.827 ± 0.008 |  91.899 ± 0.621 | **11.533 ± 0.118** |
-|   Large Int String |  30.876 ± 0.246 | 130.498 ± 2.043 | **22.536 ± 0.193** |
-| Small Float String | 134.801 ± 1.360 |  84.207 ± 0.394 | **14.178 ± 0.289** |
-|       Float String | 166.256 ± 1.710 | 129.991 ± 2.359 | **18.363 ± 0.759** |
-| Large Float String | 216.890 ± 6.090 | 171.889 ± 0.626 | **40.946 ± 1.459** |
-|                Int |  17.872 ± 1.052 |  77.692 ± 1.847 |  **7.078 ± 0.066** |
-|              Float |  27.031 ± 0.014 |  90.800 ± 4.886 | **21.339 ± 0.934** |
+|  Non-number String | 192.127 ± 0.834 |  54.013 ± 0.431 |  **9.827 ± 0.018** |
+|   Small Int String |  24.817 ± 0.016 |  49.797 ± 0.050 |  **8.619 ± 0.039** |
+|         Int String |  25.558 ± 0.012 |  53.977 ± 0.019 | **10.266 ± 0.027** |
+|  Medium Int String |  27.132 ± 0.037 | 102.316 ± 0.061 | **10.581 ± 0.014** |
+|   Large Int String |  32.065 ± 0.018 | 141.521 ± 0.249 | **19.417 ± 0.033** |
+| Small Float String | 145.611 ± 0.428 |  95.307 ± 0.152 | **14.436 ± 2.521** |
+|       Float String | 180.004 ± 0.599 | 145.724 ± 0.569 | **16.546 ± 0.015** |
+| Large Float String | 222.215 ± 2.316 | 190.360 ± 0.635 | **32.100 ± 0.139** |
+|                Int |  18.950 ± 0.198 |  80.549 ± 0.845 |  **7.499 ± 0.168** |
+|              Float |  33.180 ± 3.628 |  93.286 ± 0.309 | **20.502 ± 3.959** |
 
 ### Timing comparison to check if value can be converted to `int`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
 | -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String | 110.722 ± 4.893 | 52.946 ± 4.146 | **7.081 ± 0.057** |
-|   Small Int String |  35.604 ± 0.457 | 55.293 ± 0.835 | **6.858 ± 0.013** |
-|         Int String |  33.660 ± 0.106 | 57.756 ± 0.458 | **7.178 ± 0.059** |
-|  Medium Int String |  36.716 ± 1.376 | 61.818 ± 0.250 | **7.143 ± 0.039** |
-|   Large Int String |  41.543 ± 0.027 | 73.656 ± 0.619 | **7.100 ± 0.039** |
-| Small Float String | 108.112 ± 7.347 | 57.282 ± 5.071 | **7.853 ± 0.033** |
-|       Float String | 112.621 ± 1.406 | 60.651 ± 0.174 | **8.693 ± 0.402** |
-| Large Float String | 114.817 ± 0.649 | 60.503 ± 0.025 | **8.490 ± 0.029** |
-|                Int |  29.711 ± 0.878 | 26.859 ± 0.007 | **5.636 ± 0.035** |
-|              Float |  37.428 ± 0.002 | 25.901 ± 0.005 | **5.869 ± 0.106** |
+|  Non-number String | 119.059 ± 0.170 | 57.019 ± 0.362 | **7.564 ± 0.073** |
+|   Small Int String |  39.429 ± 0.098 | 61.535 ± 0.014 | **7.524 ± 0.058** |
+|         Int String |  40.340 ± 0.020 | 65.666 ± 1.029 | **7.777 ± 0.155** |
+|  Medium Int String |  41.956 ± 0.046 | 71.127 ± 0.053 | **7.802 ± 0.050** |
+|   Large Int String |  47.462 ± 0.372 | 86.186 ± 0.142 | **7.736 ± 0.044** |
+| Small Float String | 117.070 ± 0.691 | 61.377 ± 0.147 | **8.400 ± 0.071** |
+|       Float String | 122.435 ± 0.472 | 70.768 ± 2.709 | **9.299 ± 0.062** |
+| Large Float String | 129.577 ± 0.406 | 68.758 ± 0.329 | **9.302 ± 0.024** |
+|                Int |  33.082 ± 0.210 | 30.749 ± 0.047 | **6.219 ± 0.073** |
+|              Float |  45.143 ± 0.237 | 29.429 ± 0.132 | **6.343 ± 0.116** |
 
 ### Timing comparison to check if value can be converted to `float`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
-| -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  67.044 ± 0.672 | 57.037 ± 1.025 | **7.706 ± 0.088** |
-|   Small Int String |  31.891 ± 2.469 | 63.985 ± 0.052 | **7.656 ± 0.069** |
-|         Int String |  31.273 ± 0.168 | 67.491 ± 2.249 | **8.021 ± 0.076** |
-|  Medium Int String |  32.441 ± 0.201 | 70.825 ± 0.157 | **7.970 ± 0.085** |
-|   Large Int String |  54.262 ± 1.786 | 83.828 ± 3.105 | **7.957 ± 0.107** |
-| Small Float String |  32.761 ± 2.163 | 63.740 ± 1.771 | **8.531 ± 0.117** |
-|       Float String |  49.362 ± 0.205 | 78.911 ± 3.808 | **9.646 ± 0.094** |
-| Large Float String |  74.955 ± 1.046 | 83.865 ± 0.606 | **9.300 ± 0.067** |
-|                Int |  25.516 ± 0.026 | 27.316 ± 0.006 | **6.570 ± 0.034** |
-|              Float |  25.998 ± 1.748 | 24.980 ± 0.011 | **6.590 ± 0.035** |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String |  72.147 ± 0.375 | 61.870 ± 0.398 |  **8.141 ± 0.093** |
+|   Small Int String |  37.349 ± 0.135 | 72.907 ± 0.454 |  **8.311 ± 0.073** |
+|         Int String |  38.146 ± 0.136 | 76.664 ± 0.661 |  **8.577 ± 0.032** |
+|  Medium Int String |  39.544 ± 0.071 | 82.456 ± 0.289 |  **8.573 ± 0.079** |
+|   Large Int String |  62.069 ± 0.338 | 97.940 ± 1.373 |  **8.668 ± 0.252** |
+| Small Float String |  38.082 ± 0.117 | 71.664 ± 0.689 |  **9.388 ± 0.219** |
+|       Float String |  57.922 ± 0.200 | 89.589 ± 0.301 |  **9.997 ± 0.128** |
+| Large Float String |  81.878 ± 0.205 | 96.466 ± 0.529 | **10.158 ± 0.112** |
+|                Int |  32.623 ± 0.178 | 31.090 ± 0.045 |  **6.990 ± 0.160** |
+|              Float |  31.679 ± 0.186 | 28.844 ± 0.207 |  **6.882 ± 0.106** |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
-| -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  68.250 ± 3.584 | 56.598 ± 0.598 | **7.879 ± 0.277** |
-|   Small Int String |  20.913 ± 0.144 | 66.921 ± 0.993 | **7.716 ± 0.154** |
-|         Int String |  21.603 ± 0.111 | 66.744 ± 1.185 | **7.686 ± 0.067** |
-|  Medium Int String |  21.906 ± 0.143 | 71.929 ± 4.001 | **7.738 ± 0.087** |
-|   Large Int String |  42.685 ± 0.250 | 81.850 ± 0.396 | **7.988 ± 0.690** |
-| Small Float String |  20.428 ± 0.009 | 62.688 ± 0.986 | **8.355 ± 0.066** |
-|       Float String |  38.531 ± 0.317 | 75.633 ± 0.834 | **9.036 ± 0.041** |
-| Large Float String |  60.694 ± 0.158 | 78.825 ± 0.086 | **9.165 ± 0.216** |
-|                Int |  15.534 ± 0.002 | 23.422 ± 0.387 | **6.315 ± 0.049** |
-|              Float |  14.630 ± 0.008 | 21.430 ± 0.006 | **6.582 ± 0.179** |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String |  72.886 ± 0.343 | 61.686 ± 0.199 |  **8.128 ± 0.121** |
+|   Small Int String |  23.975 ± 0.095 | 72.591 ± 0.335 |  **8.368 ± 0.131** |
+|         Int String |  25.487 ± 1.349 | 76.898 ± 2.082 |  **8.578 ± 0.101** |
+|  Medium Int String |  25.905 ± 0.069 | 82.050 ± 0.058 |  **8.529 ± 0.068** |
+|   Large Int String |  47.749 ± 0.125 | 97.240 ± 0.116 |  **8.404 ± 0.101** |
+| Small Float String |  24.601 ± 0.228 | 71.225 ± 0.080 |  **9.057 ± 0.084** |
+|       Float String |  44.197 ± 0.121 | 89.306 ± 0.246 |  **9.900 ± 0.094** |
+| Large Float String |  67.453 ± 0.170 | 95.958 ± 0.374 | **10.068 ± 0.107** |
+|                Int |  19.305 ± 0.022 | 27.000 ± 0.086 |  **6.765 ± 0.093** |
+|              Float |  18.152 ± 0.072 | 24.775 ± 0.015 |  **6.896 ± 0.132** |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
 | -----------------: | --------------: | --------------: | ----------------: |
-|  Non-number String | 179.668 ± 2.145 |  50.616 ± 0.128 | **6.854 ± 0.070** |
-|   Small Int String |  40.662 ± 0.187 |  30.886 ± 0.039 | **6.755 ± 0.135** |
-|         Int String |  42.547 ± 0.445 |  33.349 ± 0.192 | **7.145 ± 0.180** |
-|  Medium Int String |  47.565 ± 0.070 |  37.261 ± 0.006 | **6.961 ± 0.039** |
-|   Large Int String |  80.071 ± 0.384 |  48.726 ± 0.007 | **7.057 ± 0.211** |
-| Small Float String | 129.395 ± 1.054 |  80.865 ± 1.709 | **7.623 ± 0.058** |
-|       Float String | 155.662 ± 0.427 | 118.904 ± 4.248 | **8.321 ± 0.059** |
-| Large Float String | 182.865 ± 2.367 | 145.046 ± 0.389 | **8.311 ± 0.055** |
-|                Int |  31.019 ± 0.013 |  77.993 ± 0.663 | **5.584 ± 0.058** |
-|              Float |  53.975 ± 0.266 | 105.516 ± 0.273 | **5.722 ± 0.064** |
+|  Non-number String | 194.307 ± 0.564 |  59.632 ± 2.161 | **7.597 ± 0.059** |
+|   Small Int String |  50.955 ± 0.415 |  35.626 ± 0.099 | **7.564 ± 0.058** |
+|         Int String |  52.580 ± 0.131 |  39.015 ± 0.071 | **7.893 ± 0.057** |
+|  Medium Int String |  58.179 ± 0.270 |  45.268 ± 0.052 | **7.828 ± 0.068** |
+|   Large Int String |  91.144 ± 0.182 |  60.504 ± 0.425 | **7.729 ± 0.099** |
+| Small Float String | 149.155 ± 0.783 |  92.937 ± 0.059 | **8.361 ± 0.088** |
+|       Float String | 180.819 ± 2.112 | 140.772 ± 3.234 | **9.268 ± 0.131** |
+| Large Float String | 210.984 ± 3.215 | 176.550 ± 1.136 | **9.662 ± 0.071** |
+|                Int |  40.840 ± 0.012 |  86.242 ± 0.067 | **6.457 ± 0.108** |
+|              Float |  65.634 ± 0.135 | 120.329 ± 1.001 | **6.309 ± 0.060** |
+
+### Timing comparison of `map_try_float` vs. iterating over `try_float` for a 50 element list
+
+| Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | map_try_float(iterable) (ms) |
+| -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------: |
+|  Non-number String |                      652.332 ± 2.395  |                    600.443 ± 2.981  |          **281.255 ± 4.432** |
+|   Small Int String |                      614.151 ± 2.185  |                    551.352 ± 1.698  |          **244.904 ± 1.380** |
+|         Int String |                      644.272 ± 25.219 |                    567.183 ± 4.268  |          **259.058 ± 2.889** |
+|  Medium Int String |                      649.122 ± 2.362  |                    596.185 ± 5.555  |          **279.566 ± 3.240** |
+|   Large Int String |                      871.336 ± 5.950  |                    818.384 ± 1.279  |          **486.297 ± 2.119** |
+| Small Float String |                      638.322 ± 7.794  |                    573.449 ± 2.469  |          **265.707 ± 4.163** |
+|       Float String |                      714.815 ± 2.202  |                    671.790 ± 15.845 |          **342.187 ± 2.182** |
+| Large Float String |                      726.453 ± 11.171 |                    669.728 ± 2.822  |          **347.954 ± 0.216** |
+|                Int |                      577.067 ± 5.473  |                    530.852 ± 2.724  |          **220.241 ± 1.896** |
+|              Float |                      543.464 ± 4.075  |                    514.355 ± 2.143  |          **203.394 ± 2.668** |
 
diff --git a/profiling/results-3.8.md b/profiling/results-3.8.md
index 6360b540..fd73ba93 100644
--- a/profiling/results-3.8.md
+++ b/profiling/results-3.8.md
@@ -1,147 +1,162 @@
-sys.version_info(major=3, minor=8, micro=7, releaselevel='final', serial=0)
+sys.version_info(major=3, minor=8, micro=16, releaselevel='final', serial=0)
 
 ### Timing comparison of `int` functions
 
-| Input type        | builtin (ms)       | fastnumbers (ms)   |
-| ----------------: | -----------------: | -----------------: |
-|  Small Int String |   12.730 ± 0.184   |  **7.454 ± 0.066** |
-|        Int String |   13.343 ± 0.093   |  **9.933 ± 0.047** |
-| Medium Int String |   14.755 ± 1.501   | **10.131 ± 0.065** |
-|  Large Int String | **18.180 ± 0.070** |   18.253 ± 0.962   |
-|               Int |    7.435 ± 0.244   |  **6.172 ± 0.041** |
-|             Float | **17.668 ± 0.053** |   21.402 ± 2.892   |
+| Input type        | builtin (ms)   | fastnumbers (ms)   |
+| ----------------: | -------------: | -----------------: |
+|  Small Int String | 15.077 ± 0.554 |  **8.345 ± 0.216** |
+|        Int String | 16.773 ± 0.430 | **10.465 ± 0.187** |
+| Medium Int String | 18.717 ± 0.580 | **10.535 ± 0.212** |
+|  Large Int String | 24.946 ± 0.294 | **21.408 ± 0.416** |
+|               Int |  8.801 ± 0.220 |  **7.150 ± 0.250** |
+|             Float | 20.570 ± 3.143 | **19.978 ± 0.564** |
 
 ### Timing comparison of `float` functions
 
-| Input type         | builtin (ms)      | fastnumbers (ms)   |
-| -----------------: | ----------------: | -----------------: |
-|   Small Int String |  12.128 ± 0.628   |  **9.800 ± 0.203** |
-|         Int String |  12.717 ± 0.103   | **10.155 ± 0.549** |
-|  Medium Int String |  14.058 ± 0.113   | **10.416 ± 0.053** |
-|   Large Int String |  33.896 ± 0.956   | **14.643 ± 0.543** |
-| Small Float String |  12.857 ± 0.043   | **10.499 ± 0.181** |
-|       Float String |  32.188 ± 0.592   | **12.598 ± 0.094** |
-| Large Float String |  55.475 ± 0.987   | **12.794 ± 0.592** |
-|                Int | **8.732 ± 0.155** |    9.620 ± 0.144   |
-|              Float |   7.481 ± 0.145   |  **6.676 ± 0.088** |
+| Input type         | builtin (ms)   | fastnumbers (ms)   |
+| -----------------: | -------------: | -----------------: |
+|   Small Int String | 13.256 ± 0.160 |  **8.075 ± 0.166** |
+|         Int String | 13.927 ± 0.237 |  **8.467 ± 0.056** |
+|  Medium Int String | 15.156 ± 0.233 |  **8.887 ± 0.170** |
+|   Large Int String | 34.470 ± 0.585 | **14.030 ± 0.307** |
+| Small Float String | 13.668 ± 0.558 |  **8.646 ± 0.176** |
+|       Float String | 31.711 ± 0.333 | **10.138 ± 0.210** |
+| Large Float String | 54.354 ± 0.427 | **10.448 ± 0.137** |
+|                Int |  9.109 ± 0.296 |  **7.633 ± 0.148** |
+|              Float |  7.900 ± 0.366 |  **6.343 ± 0.116** |
 
 ### Timing comparison of `int` functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 110.888 ± 2.108 | 26.199 ± 0.055  |  **8.889 ± 0.019** |
-|   Small Int String |  19.847 ± 0.024 | 45.566 ± 2.212  |  **8.633 ± 0.089** |
-|         Int String |  20.747 ± 0.009 | 47.540 ± 0.045  | **11.254 ± 0.149** |
-|  Medium Int String |  21.260 ± 0.096 | 51.947 ± 0.623  | **11.643 ± 0.007** |
-|   Large Int String |  26.181 ± 0.365 | 71.502 ± 1.341  | **20.053 ± 0.514** |
-| Small Float String | 111.405 ± 2.267 | 29.582 ± 0.007  |  **8.822 ± 0.011** |
-|       Float String | 112.832 ± 2.168 | 34.062 ± 0.007  |  **9.003 ± 0.014** |
-| Large Float String | 120.336 ± 2.375 | 34.637 ± 0.538  |  **8.982 ± 0.031** |
-|                Int |  13.266 ± 0.004 | 74.868 ± 12.544 | **12.489 ± 2.175** |
-|              Float |  29.298 ± 2.650 | 86.266 ± 2.120  | **23.768 ± 1.904** |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String | 114.958 ± 0.687 | 27.917 ± 0.057 |  **8.490 ± 0.071** |
+|   Small Int String |  20.947 ± 0.052 | 46.922 ± 1.577 |  **8.281 ± 0.027** |
+|         Int String |  22.175 ± 0.061 | 50.661 ± 0.059 | **10.539 ± 0.013** |
+|  Medium Int String |  24.086 ± 0.131 | 59.014 ± 0.039 | **10.596 ± 0.692** |
+|   Large Int String |  30.111 ± 0.051 | 80.007 ± 0.063 | **21.405 ± 0.032** |
+| Small Float String | 112.306 ± 0.886 | 31.655 ± 0.027 |  **8.507 ± 0.023** |
+|       Float String | 118.067 ± 1.013 | 37.761 ± 0.042 |  **8.899 ± 0.039** |
+| Large Float String | 120.939 ± 0.155 | 38.133 ± 0.828 |  **8.855 ± 0.054** |
+|                Int |  14.492 ± 0.023 | 73.553 ± 3.772 |  **7.096 ± 0.020** |
+|              Float |  25.734 ± 0.088 | 83.458 ± 0.872 | **18.615 ± 0.026** |
 
 ### Timing comparison of `float` functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  70.751 ± 8.698 |  30.179 ± 1.103 |  **9.367 ± 0.062** |
-|   Small Int String |  19.460 ± 0.042 |  53.537 ± 0.778 | **11.219 ± 0.033** |
-|         Int String |  19.576 ± 0.009 |  56.897 ± 0.923 | **11.829 ± 0.011** |
-|  Medium Int String |  21.582 ± 0.167 |  61.248 ± 0.890 | **12.174 ± 0.024** |
-|   Large Int String |  42.487 ± 0.683 |  97.267 ± 1.224 | **17.050 ± 0.015** |
-| Small Float String |  19.632 ± 0.322 |  51.714 ± 0.708 | **12.111 ± 0.008** |
-|       Float String |  39.262 ± 0.752 |  85.373 ± 1.487 | **13.693 ± 0.008** |
-| Large Float String |  62.573 ± 0.079 | 114.056 ± 1.649 | **13.478 ± 0.104** |
-|                Int |  14.332 ± 0.031 |  69.986 ± 3.002 | **10.713 ± 0.367** |
-|              Float |  13.464 ± 0.014 |  69.146 ± 0.062 |  **7.738 ± 0.004** |
+|  Non-number String |  70.898 ± 1.697 |  31.911 ± 0.088 |  **9.424 ± 0.051** |
+|   Small Int String |  20.153 ± 0.023 |  55.668 ± 0.890 |  **8.987 ± 0.062** |
+|         Int String |  20.846 ± 0.038 |  59.150 ± 0.066 | **10.767 ± 2.523** |
+|  Medium Int String |  22.065 ± 0.050 |  67.961 ± 1.406 |  **9.890 ± 0.072** |
+|   Large Int String |  42.216 ± 0.026 | 101.521 ± 0.255 | **14.907 ± 0.011** |
+| Small Float String |  21.004 ± 0.993 |  54.557 ± 0.049 |  **9.642 ± 0.024** |
+|       Float String |  38.471 ± 0.040 |  89.116 ± 1.522 | **11.417 ± 0.605** |
+| Large Float String |  62.436 ± 2.240 | 118.666 ± 0.488 | **11.308 ± 0.033** |
+|                Int |  15.987 ± 0.834 |  72.580 ± 0.243 |  **8.386 ± 0.032** |
+|              Float |  14.092 ± 0.031 |  72.458 ± 0.898 |  **7.398 ± 0.019** |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  66.106 ± 0.906 |  47.295 ± 0.829 | **10.245 ± 0.006** |
-|   Small Int String |  34.680 ± 0.054 |  44.154 ± 1.597 |  **9.482 ± 0.004** |
-|         Int String |  36.684 ± 0.595 |  47.816 ± 1.794 | **12.480 ± 0.500** |
-|  Medium Int String |  40.420 ± 0.601 |  54.676 ± 2.252 | **12.219 ± 0.011** |
-|   Large Int String |  71.460 ± 0.935 |  70.553 ± 2.034 | **21.439 ± 0.014** |
-| Small Float String |  34.389 ± 0.520 |  73.655 ± 1.037 | **13.372 ± 0.243** |
-|       Float String |  70.123 ± 1.163 | 112.252 ± 1.398 | **20.727 ± 0.393** |
-| Large Float String | 129.285 ± 1.095 | 140.052 ± 0.325 | **40.601 ± 0.085** |
-|                Int |  29.827 ± 0.519 |  74.714 ± 2.484 |  **7.556 ± 0.012** |
-|              Float |  51.868 ± 0.042 |  73.311 ± 0.451 | **22.674 ± 0.108** |
+|  Non-number String |  76.335 ± 3.516 |  57.077 ± 0.690 | **11.037 ± 0.201** |
+|   Small Int String |  39.471 ± 0.086 |  50.956 ± 1.454 |  **9.710 ± 0.008** |
+|         Int String |  42.974 ± 0.902 |  56.823 ± 4.918 | **12.194 ± 0.026** |
+|  Medium Int String |  46.618 ± 0.698 |  63.485 ± 0.958 | **12.319 ± 0.091** |
+|   Large Int String |  77.581 ± 1.352 |  87.257 ± 2.181 | **23.510 ± 0.023** |
+| Small Float String |  40.790 ± 1.031 |  86.856 ± 0.346 | **11.466 ± 0.165** |
+|       Float String |  76.360 ± 0.880 | 130.134 ± 2.084 | **19.835 ± 1.002** |
+| Large Float String | 134.289 ± 2.282 | 161.117 ± 1.947 | **35.029 ± 0.601** |
+|                Int |  35.632 ± 0.619 |  83.551 ± 1.432 |  **7.946 ± 0.018** |
+|              Float |  60.414 ± 3.635 |  81.779 ± 1.402 | **20.270 ± 0.027** |
 
 ### Timing comparison of forced `int` functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)       | fastnumbers (ms)   |
-| -----------------: | --------------: | ---------------: | -----------------: |
-|  Non-number String | 177.131 ± 2.119 |  48.813 ± 0.300  |  **9.375 ± 0.019** |
-|   Small Int String |  19.265 ± 0.006 |  44.503 ± 3.029  |  **8.922 ± 0.004** |
-|         Int String |  20.755 ± 0.005 |  49.112 ± 0.412  | **11.512 ± 0.106** |
-|  Medium Int String |  21.270 ± 0.096 |  89.518 ± 1.242  | **12.191 ± 0.050** |
-|   Large Int String |  26.013 ± 0.007 | 131.097 ± 9.542  | **20.358 ± 0.031** |
-| Small Float String | 129.235 ± 1.141 |  80.439 ± 2.077  | **14.826 ± 0.009** |
-|       Float String | 171.361 ± 3.261 | 151.193 ± 25.174 | **20.896 ± 0.185** |
-| Large Float String | 214.887 ± 4.584 | 177.821 ± 4.828  | **42.449 ± 4.578** |
-|                Int |  13.700 ± 0.005 |  69.204 ± 0.058  |  **7.183 ± 0.033** |
-|              Float |  25.247 ± 0.022 |  80.713 ± 1.155  | **22.774 ± 0.304** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 197.868 ± 2.028 |  53.780 ± 0.045 | **10.222 ± 0.040** |
+|   Small Int String |  23.936 ± 1.762 |  50.161 ± 0.280 |  **8.983 ± 0.053** |
+|         Int String |  23.525 ± 0.024 |  53.968 ± 0.942 | **11.864 ± 0.031** |
+|  Medium Int String |  26.346 ± 0.050 | 101.485 ± 1.534 | **11.544 ± 0.844** |
+|   Large Int String |  31.979 ± 0.022 | 145.965 ± 4.408 | **23.796 ± 0.874** |
+| Small Float String | 147.575 ± 3.638 |  93.141 ± 1.469 | **14.279 ± 0.065** |
+|       Float String | 181.961 ± 4.433 | 144.822 ± 1.821 | **18.450 ± 0.168** |
+| Large Float String | 228.627 ± 3.781 | 192.266 ± 0.720 | **34.483 ± 0.042** |
+|                Int |  15.395 ± 0.049 |  76.981 ± 0.628 |  **7.438 ± 0.045** |
+|              Float |  27.310 ± 0.050 |  90.789 ± 1.041 | **19.583 ± 0.064** |
 
 ### Timing comparison to check if value can be converted to `int`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
 | -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String | 114.661 ± 1.215 | 49.919 ± 1.429 | **7.014 ± 0.053** |
-|   Small Int String |  29.961 ± 0.186 | 52.985 ± 2.409 | **7.122 ± 0.100** |
-|         Int String |  30.869 ± 0.052 | 55.649 ± 0.943 | **7.545 ± 0.047** |
-|  Medium Int String |  32.032 ± 0.238 | 60.471 ± 1.687 | **7.404 ± 0.157** |
-|   Large Int String |  36.726 ± 0.045 | 71.843 ± 1.947 | **7.385 ± 0.048** |
-| Small Float String | 109.212 ± 2.871 | 55.673 ± 1.208 | **8.436 ± 0.122** |
-|       Float String | 123.935 ± 1.338 | 61.109 ± 1.439 | **8.811 ± 0.017** |
-| Large Float String | 117.221 ± 1.827 | 60.288 ± 1.207 | **9.261 ± 0.047** |
-|                Int |  25.544 ± 0.054 | 24.007 ± 0.061 | **6.143 ± 0.020** |
-|              Float |  36.979 ± 0.134 | 22.762 ± 0.018 | **6.617 ± 0.090** |
+|  Non-number String | 124.939 ± 1.549 | 55.419 ± 1.100 | **7.648 ± 0.040** |
+|   Small Int String |  37.235 ± 0.488 | 60.094 ± 0.863 | **7.373 ± 0.033** |
+|         Int String |  38.007 ± 0.934 | 62.413 ± 0.932 | **7.884 ± 0.021** |
+|  Medium Int String |  39.795 ± 0.604 | 67.864 ± 1.041 | **8.273 ± 0.544** |
+|   Large Int String |  46.004 ± 0.618 | 83.338 ± 1.696 | **7.825 ± 0.136** |
+| Small Float String | 120.866 ± 1.672 | 58.071 ± 0.649 | **8.232 ± 0.025** |
+|       Float String | 126.829 ± 1.027 | 66.735 ± 0.387 | **8.995 ± 0.132** |
+| Large Float String | 138.810 ± 9.851 | 66.793 ± 1.497 | **9.064 ± 0.115** |
+|                Int |  29.090 ± 0.015 | 24.730 ± 0.044 | **6.197 ± 0.039** |
+|              Float |  41.104 ± 0.814 | 23.791 ± 0.331 | **6.601 ± 0.080** |
 
 ### Timing comparison to check if value can be converted to `float`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
 | -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  70.067 ± 1.201 | 55.434 ± 1.117 | **8.225 ± 0.034** |
-|   Small Int String |  30.417 ± 0.013 | 61.630 ± 1.561 | **7.950 ± 0.051** |
-|         Int String |  30.453 ± 0.348 | 64.639 ± 2.905 | **8.275 ± 0.017** |
-|  Medium Int String |  32.233 ± 0.566 | 69.451 ± 1.637 | **8.626 ± 0.005** |
-|   Large Int String |  53.524 ± 0.890 | 80.674 ± 1.647 | **8.405 ± 0.133** |
-| Small Float String |  30.925 ± 0.056 | 60.978 ± 0.859 | **8.546 ± 0.020** |
-|       Float String |  52.656 ± 3.021 | 78.660 ± 1.274 | **9.716 ± 0.021** |
-| Large Float String |  76.718 ± 2.023 | 79.064 ± 2.076 | **9.798 ± 0.010** |
-|                Int |  24.224 ± 0.016 | 22.936 ± 0.008 | **6.507 ± 0.039** |
-|              Float |  24.162 ± 0.564 | 21.357 ± 0.043 | **6.761 ± 0.034** |
+|  Non-number String |  77.118 ± 2.864 | 58.986 ± 1.272 | **8.302 ± 0.067** |
+|   Small Int String |  34.970 ± 0.161 | 68.465 ± 0.648 | **8.303 ± 0.010** |
+|         Int String |  36.414 ± 0.047 | 71.673 ± 1.514 | **8.604 ± 0.041** |
+|  Medium Int String |  37.057 ± 0.052 | 78.172 ± 1.229 | **8.509 ± 0.039** |
+|   Large Int String |  59.387 ± 0.991 | 92.400 ± 1.004 | **8.862 ± 0.021** |
+| Small Float String |  35.726 ± 0.669 | 69.647 ± 1.633 | **9.404 ± 0.085** |
+|       Float String |  55.903 ± 0.335 | 83.468 ± 0.981 | **9.666 ± 0.099** |
+| Large Float String |  80.127 ± 0.793 | 90.141 ± 1.391 | **9.724 ± 0.060** |
+|                Int |  29.588 ± 0.044 | 25.555 ± 0.984 | **7.307 ± 0.065** |
+|              Float |  28.786 ± 0.265 | 23.063 ± 0.267 | **7.348 ± 0.057** |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
-| -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  66.447 ± 0.292 | 52.414 ± 1.822 | **7.448 ± 0.030** |
-|   Small Int String |  19.648 ± 0.288 | 61.143 ± 0.632 | **7.618 ± 0.062** |
-|         Int String |  20.017 ± 0.007 | 66.307 ± 5.601 | **8.571 ± 0.809** |
-|  Medium Int String |  22.139 ± 0.053 | 69.420 ± 1.079 | **8.168 ± 0.067** |
-|   Large Int String |  43.621 ± 0.040 | 80.505 ± 1.017 | **7.761 ± 0.035** |
-| Small Float String |  19.807 ± 0.251 | 60.539 ± 1.596 | **8.196 ± 0.031** |
-|       Float String |  38.855 ± 0.097 | 74.068 ± 1.164 | **8.954 ± 0.094** |
-| Large Float String |  63.789 ± 1.272 | 78.092 ± 0.584 | **9.132 ± 0.077** |
-|                Int |  14.503 ± 0.031 | 19.901 ± 0.027 | **6.271 ± 0.016** |
-|              Float |  13.670 ± 0.237 | 18.868 ± 0.510 | **6.564 ± 0.012** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
+| -----------------: | --------------: | --------------: | ----------------: |
+|  Non-number String |  75.314 ± 1.498 | 57.221 ± 0.937  | **7.785 ± 0.055** |
+|   Small Int String |  22.180 ± 0.365 | 66.847 ± 1.149  | **7.952 ± 0.079** |
+|         Int String |  22.667 ± 0.020 | 70.751 ± 1.605  | **8.254 ± 0.078** |
+|  Medium Int String |  23.940 ± 0.056 | 77.050 ± 1.300  | **8.263 ± 0.157** |
+|   Large Int String |  45.489 ± 0.031 | 99.726 ± 10.363 | **8.230 ± 0.030** |
+| Small Float String |  22.321 ± 0.036 | 65.425 ± 1.027  | **8.993 ± 0.084** |
+|       Float String |  41.991 ± 0.918 | 82.014 ± 1.363  | **9.703 ± 0.150** |
+| Large Float String |  65.827 ± 0.074 | 88.154 ± 0.903  | **9.886 ± 0.057** |
+|                Int |  17.653 ± 0.034 | 22.491 ± 0.174  | **6.754 ± 0.029** |
+|              Float |  15.447 ± 0.043 | 19.723 ± 0.026  | **6.837 ± 0.084** |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
-| -----------------: | --------------: | --------------: | ----------------: |
-|  Non-number String | 174.255 ± 3.376 |  47.925 ± 0.285 | **6.958 ± 0.030** |
-|   Small Int String |  38.187 ± 0.543 |  30.375 ± 0.008 | **6.796 ± 0.030** |
-|         Int String |  42.139 ± 3.555 |  33.888 ± 0.172 | **7.547 ± 0.036** |
-|  Medium Int String |  45.751 ± 0.138 |  37.241 ± 0.526 | **7.039 ± 0.065** |
-|   Large Int String |  76.780 ± 0.337 |  50.521 ± 0.785 | **6.943 ± 0.016** |
-| Small Float String | 131.403 ± 2.628 |  78.397 ± 1.509 | **7.772 ± 0.035** |
-|       Float String | 156.915 ± 2.271 | 118.703 ± 2.614 | **8.666 ± 0.023** |
-| Large Float String | 188.136 ± 3.973 | 148.394 ± 2.881 | **8.659 ± 0.050** |
-|                Int |  26.778 ± 0.045 |  69.914 ± 0.988 | **5.703 ± 0.026** |
-|              Float |  51.406 ± 0.266 |  97.251 ± 1.374 | **5.838 ± 0.020** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 197.228 ± 2.818 |  56.134 ± 0.789 |  **7.267 ± 0.036** |
+|   Small Int String |  44.298 ± 0.687 |  35.911 ± 0.567 |  **7.271 ± 0.020** |
+|         Int String |  44.941 ± 0.067 |  39.392 ± 0.609 | **10.607 ± 5.100** |
+|  Medium Int String |  51.820 ± 0.177 |  45.129 ± 0.174 |  **7.546 ± 0.019** |
+|   Large Int String |  84.164 ± 0.120 |  60.725 ± 0.912 |  **7.526 ± 0.013** |
+| Small Float String | 147.687 ± 2.451 |  91.247 ± 1.929 |  **8.392 ± 0.054** |
+|       Float String | 172.404 ± 2.478 | 135.899 ± 1.812 |  **8.829 ± 0.134** |
+| Large Float String | 203.461 ± 3.547 | 168.054 ± 3.164 |  **8.838 ± 0.225** |
+|                Int |  30.535 ± 1.005 |  76.894 ± 0.619 |  **6.085 ± 0.009** |
+|              Float |  54.348 ± 0.269 | 107.730 ± 1.184 |  **6.256 ± 0.065** |
+
+### Timing comparison of `map_try_float` vs. iterating over `try_float` for a 50 element list
+
+| Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | map_try_float(iterable) (ms) |
+| -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------: |
+|  Non-number String |                      625.158 ± 2.060  |                    521.393 ± 3.049  |          **285.822 ± 3.357** |
+|   Small Int String |                      570.145 ± 13.045 |                    465.285 ± 3.015  |          **244.780 ± 4.710** |
+|         Int String |                      577.579 ± 1.349  |                    478.350 ± 1.060  |          **259.877 ± 0.729** |
+|  Medium Int String |                      599.520 ± 1.062  |                    500.178 ± 1.968  |          **276.347 ± 1.080** |
+|   Large Int String |                      862.283 ± 1.749  |                    752.639 ± 1.950  |          **491.864 ± 1.035** |
+| Small Float String |                      585.507 ± 1.918  |                    486.918 ± 1.184  |          **264.531 ± 0.842** |
+|       Float String |                      661.683 ± 1.255  |                    572.532 ± 13.393 |          **362.430 ± 1.168** |
+| Large Float String |                      723.021 ± 5.716  |                    613.001 ± 7.232  |          **371.401 ± 5.565** |
+|                Int |                      563.963 ± 3.278  |                    456.702 ± 5.501  |          **219.925 ± 0.769** |
+|              Float |                      501.868 ± 6.730  |                    400.935 ± 4.421  |          **168.092 ± 0.835** |
 
diff --git a/profiling/results-3.9.md b/profiling/results-3.9.md
index 7ac5d57e..315a431e 100644
--- a/profiling/results-3.9.md
+++ b/profiling/results-3.9.md
@@ -1,147 +1,162 @@
-sys.version_info(major=3, minor=9, micro=1, releaselevel='final', serial=0)
+sys.version_info(major=3, minor=9, micro=16, releaselevel='final', serial=0)
 
 ### Timing comparison of `int` functions
 
-| Input type        | builtin (ms)       | fastnumbers (ms)   |
-| ----------------: | -----------------: | -----------------: |
-|  Small Int String |   12.593 ± 0.248   |  **7.914 ± 0.441** |
-|        Int String |   13.992 ± 0.188   | **10.547 ± 0.130** |
-| Medium Int String |   16.081 ± 0.933   | **10.798 ± 0.156** |
-|  Large Int String |   20.625 ± 0.423   | **20.528 ± 0.482** |
-|               Int |    7.456 ± 0.086   |  **6.754 ± 0.101** |
-|             Float | **17.618 ± 0.245** |   20.509 ± 0.342   |
+| Input type        | builtin (ms)   | fastnumbers (ms)   |
+| ----------------: | -------------: | -----------------: |
+|  Small Int String | 13.934 ± 0.370 |  **7.587 ± 0.134** |
+|        Int String | 15.408 ± 0.333 |  **9.525 ± 0.240** |
+| Medium Int String | 17.534 ± 0.618 |  **9.531 ± 0.029** |
+|  Large Int String | 23.312 ± 0.428 | **20.367 ± 0.400** |
+|               Int |  7.326 ± 0.183 |  **6.355 ± 0.105** |
+|             Float | 18.079 ± 0.362 | **17.528 ± 0.632** |
 
 ### Timing comparison of `float` functions
 
-| Input type         | builtin (ms)      | fastnumbers (ms)   |
-| -----------------: | ----------------: | -----------------: |
-|   Small Int String |  12.346 ± 0.181   |  **9.970 ± 0.154** |
-|         Int String |  13.045 ± 0.369   | **10.372 ± 0.202** |
-|  Medium Int String |  14.447 ± 0.172   | **10.655 ± 0.165** |
-|   Large Int String |  34.842 ± 0.483   | **15.100 ± 0.127** |
-| Small Float String |  12.745 ± 0.199   | **10.717 ± 0.589** |
-|       Float String |  32.362 ± 0.544   | **12.314 ± 0.430** |
-| Large Float String |  55.314 ± 0.748   | **12.370 ± 0.131** |
-|                Int | **8.269 ± 0.468** |    9.181 ± 0.139   |
-|              Float |   7.166 ± 0.084   |  **6.925 ± 1.448** |
+| Input type         | builtin (ms)   | fastnumbers (ms)   |
+| -----------------: | -------------: | -----------------: |
+|   Small Int String | 13.111 ± 0.216 |  **7.819 ± 0.186** |
+|         Int String | 13.369 ± 0.185 |  **8.137 ± 0.633** |
+|  Medium Int String | 14.359 ± 0.213 |  **8.507 ± 0.212** |
+|   Large Int String | 35.528 ± 0.575 | **12.754 ± 0.137** |
+| Small Float String | 13.197 ± 0.171 |  **8.394 ± 0.188** |
+|       Float String | 31.817 ± 0.418 |  **9.924 ± 0.197** |
+| Large Float String | 55.035 ± 0.586 | **10.086 ± 0.160** |
+|                Int |  8.225 ± 0.162 |  **7.300 ± 0.039** |
+|              Float |  6.725 ± 0.144 |  **5.961 ± 0.179** |
 
 ### Timing comparison of `int` functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String | 113.282 ± 2.178 | 28.338 ± 0.103 |  **8.585 ± 0.133** |
-|   Small Int String |  18.880 ± 0.010 | 49.447 ± 0.530 |  **8.270 ± 0.052** |
-|         Int String |  20.351 ± 0.763 | 53.191 ± 0.911 | **10.739 ± 0.015** |
-|  Medium Int String |  22.308 ± 1.526 | 59.030 ± 0.929 | **11.239 ± 0.164** |
-|   Large Int String |  26.523 ± 0.236 | 75.934 ± 0.082 | **20.858 ± 0.070** |
-| Small Float String | 101.350 ± 1.587 | 32.187 ± 0.499 |  **9.069 ± 0.014** |
-|       Float String | 123.328 ± 0.383 | 38.582 ± 0.300 |  **9.553 ± 0.022** |
-| Large Float String | 119.014 ± 1.791 | 36.978 ± 0.542 |  **9.031 ± 0.008** |
-|                Int |  13.046 ± 0.124 | 71.464 ± 3.671 |  **7.964 ± 0.517** |
-|              Float |  26.833 ± 0.331 | 82.255 ± 2.104 | **23.186 ± 0.193** |
+|  Non-number String | 112.138 ± 0.337 | 28.500 ± 0.078 |  **8.184 ± 0.038** |
+|   Small Int String |  19.820 ± 0.043 | 45.596 ± 0.803 |  **7.746 ± 0.045** |
+|         Int String |  21.088 ± 0.080 | 49.780 ± 0.109 |  **9.666 ± 0.131** |
+|  Medium Int String |  23.029 ± 0.040 | 58.033 ± 0.450 | **10.030 ± 0.785** |
+|   Large Int String |  28.983 ± 0.042 | 78.683 ± 0.377 | **20.343 ± 0.014** |
+| Small Float String | 109.583 ± 0.855 | 32.178 ± 0.025 |  **8.175 ± 0.026** |
+|       Float String | 118.698 ± 0.867 | 38.231 ± 0.040 |  **8.623 ± 0.037** |
+| Large Float String | 122.048 ± 0.498 | 38.586 ± 0.733 |  **8.574 ± 0.049** |
+|                Int |  13.257 ± 0.023 | 70.646 ± 1.041 |  **6.600 ± 0.037** |
+|              Float |  23.997 ± 0.054 | 78.606 ± 1.979 | **17.673 ± 0.026** |
 
 ### Timing comparison of `float` functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  63.457 ± 0.217 |  32.312 ± 0.097 |  **9.439 ± 0.039** |
-|   Small Int String |  18.933 ± 0.203 |  54.598 ± 3.398 | **11.018 ± 0.010** |
-|         Int String |  18.883 ± 0.006 |  56.796 ± 2.269 | **11.612 ± 0.010** |
-|  Medium Int String |  20.686 ± 0.031 |  61.178 ± 1.864 | **11.651 ± 0.006** |
-|   Large Int String |  41.133 ± 0.011 |  96.650 ± 3.003 | **16.260 ± 0.025** |
-| Small Float String |  18.666 ± 0.013 |  49.794 ± 0.746 | **12.010 ± 0.009** |
-|       Float String |  38.494 ± 0.561 |  86.937 ± 0.727 | **13.328 ± 0.217** |
-| Large Float String |  61.532 ± 0.015 | 115.315 ± 3.365 | **13.405 ± 0.060** |
-|                Int |  13.837 ± 0.026 |  65.023 ± 0.919 | **10.488 ± 0.015** |
-|              Float |  12.811 ± 0.255 |  67.340 ± 4.061 |  **9.297 ± 2.210** |
+|  Non-number String |  69.349 ± 0.412 |  31.347 ± 0.053 |  **8.882 ± 0.075** |
+|   Small Int String |  19.012 ± 0.045 |  54.319 ± 1.713 |  **8.853 ± 0.109** |
+|         Int String |  19.653 ± 0.040 |  58.261 ± 2.993 |  **9.264 ± 0.127** |
+|  Medium Int String |  20.715 ± 0.028 |  64.443 ± 0.022 |  **9.875 ± 0.802** |
+|   Large Int String |  43.553 ± 0.805 | 100.982 ± 0.104 | **13.742 ± 0.053** |
+| Small Float String |  19.462 ± 0.027 |  52.864 ± 0.757 |  **9.471 ± 0.044** |
+|       Float String |  38.205 ± 0.056 |  87.234 ± 0.763 | **10.937 ± 0.090** |
+| Large Float String |  61.056 ± 0.724 | 116.075 ± 0.436 | **11.134 ± 0.037** |
+|                Int |  14.195 ± 0.025 |  73.170 ± 0.712 |  **8.019 ± 0.048** |
+|              Float |  12.610 ± 0.033 |  71.197 ± 0.184 |  **6.800 ± 0.039** |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  69.576 ± 8.552 |  48.195 ± 0.448 | **10.047 ± 0.012** |
-|   Small Int String |  33.381 ± 0.179 |  46.644 ± 0.130 |  **8.828 ± 0.051** |
-|         Int String |  34.312 ± 0.029 |  52.759 ± 0.572 | **12.017 ± 0.023** |
-|  Medium Int String |  47.312 ± 8.377 |  61.891 ± 1.043 | **12.847 ± 0.022** |
-|   Large Int String |  70.102 ± 0.612 |  76.042 ± 0.778 | **21.787 ± 0.072** |
-| Small Float String |  33.033 ± 0.027 |  74.887 ± 3.416 | **12.688 ± 0.010** |
-|       Float String |  70.756 ± 4.574 | 114.817 ± 1.407 | **19.573 ± 0.010** |
-| Large Float String | 126.242 ± 0.647 | 145.267 ± 3.663 | **40.787 ± 0.566** |
-|                Int |  28.990 ± 0.074 |  69.509 ± 0.643 |  **7.437 ± 0.017** |
-|              Float |  51.889 ± 0.062 |  67.726 ± 0.117 | **22.826 ± 0.082** |
+|  Non-number String |  70.396 ± 1.091 |  53.650 ± 0.214 |  **9.383 ± 0.030** |
+|   Small Int String |  33.039 ± 0.042 |  45.666 ± 0.035 |  **8.505 ± 0.052** |
+|         Int String |  35.838 ± 0.831 |  50.091 ± 0.075 | **10.481 ± 0.025** |
+|  Medium Int String |  39.513 ± 0.111 |  58.148 ± 0.088 | **10.601 ± 0.015** |
+|   Large Int String |  78.320 ± 0.723 |  78.697 ± 0.032 | **21.439 ± 0.052** |
+| Small Float String |  33.411 ± 0.055 |  78.993 ± 0.815 | **10.433 ± 0.064** |
+|       Float String |  75.468 ± 0.095 | 118.692 ± 0.788 | **17.033 ± 0.046** |
+| Large Float String | 130.374 ± 0.720 | 151.338 ± 7.239 | **32.915 ± 1.054** |
+|                Int |  30.454 ± 1.499 |  72.440 ± 0.053 |  **7.057 ± 0.014** |
+|              Float |  50.635 ± 0.050 |  72.454 ± 1.933 | **17.935 ± 0.026** |
 
 ### Timing comparison of forced `int` functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 172.662 ± 2.171 |  46.588 ± 0.041 |  **9.413 ± 0.040** |
-|   Small Int String |  19.126 ± 0.338 |  46.695 ± 1.698 |  **8.909 ± 0.530** |
-|         Int String |  20.797 ± 0.238 |  50.297 ± 0.791 | **11.261 ± 0.009** |
-|  Medium Int String |  21.675 ± 0.157 |  89.442 ± 0.190 | **11.666 ± 0.012** |
-|   Large Int String |  26.574 ± 0.015 | 127.667 ± 0.937 | **21.386 ± 0.006** |
-| Small Float String | 125.611 ± 0.717 |  83.287 ± 4.168 | **14.638 ± 5.906** |
-|       Float String | 176.213 ± 6.931 | 131.219 ± 2.238 | **18.761 ± 0.009** |
-| Large Float String | 215.600 ± 4.576 | 175.560 ± 2.711 | **39.680 ± 0.434** |
-|                Int |  13.061 ± 0.027 |  66.012 ± 0.072 |  **7.223 ± 0.051** |
-|              Float |  23.827 ± 0.254 |  76.009 ± 0.825 | **23.477 ± 4.494** |
+|  Non-number String | 183.655 ± 6.067 |  48.094 ± 0.135 |  **9.583 ± 0.023** |
+|   Small Int String |  21.705 ± 0.168 |  45.240 ± 0.077 |  **8.576 ± 0.186** |
+|         Int String |  22.396 ± 0.045 |  49.029 ± 0.782 | **10.534 ± 0.024** |
+|  Medium Int String |  24.460 ± 0.027 |  96.415 ± 3.426 | **11.022 ± 0.014** |
+|   Large Int String |  32.248 ± 0.659 | 144.217 ± 5.532 | **22.437 ± 0.352** |
+| Small Float String | 144.885 ± 2.399 |  84.433 ± 1.425 | **10.191 ± 0.843** |
+|       Float String | 186.585 ± 2.031 | 143.518 ± 2.153 | **17.262 ± 0.037** |
+| Large Float String | 234.846 ± 2.232 | 191.686 ± 3.329 | **35.359 ± 2.694** |
+|                Int |  14.079 ± 0.044 |  71.516 ± 0.093 |  **6.808 ± 0.024** |
+|              Float |  25.501 ± 0.023 |  84.014 ± 0.545 | **18.509 ± 0.192** |
 
 ### Timing comparison to check if value can be converted to `int`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
 | -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String | 108.364 ± 1.407 | 43.367 ± 0.035 | **7.053 ± 0.040** |
-|   Small Int String |  26.890 ± 0.441 | 51.432 ± 2.656 | **7.471 ± 0.029** |
-|         Int String |  28.267 ± 0.522 | 52.019 ± 0.167 | **7.556 ± 0.060** |
-|  Medium Int String |  28.778 ± 0.069 | 54.932 ± 0.404 | **7.225 ± 0.046** |
-|   Large Int String |  33.605 ± 0.056 | 70.005 ± 2.097 | **7.319 ± 0.124** |
-| Small Float String | 101.619 ± 1.371 | 47.796 ± 0.775 | **8.112 ± 0.023** |
-|       Float String | 112.443 ± 1.773 | 52.576 ± 0.025 | **8.581 ± 0.020** |
-| Large Float String | 116.919 ± 0.845 | 54.079 ± 1.947 | **8.990 ± 0.048** |
-|                Int |  20.050 ± 0.365 | 21.579 ± 0.005 | **5.650 ± 0.027** |
-|              Float |  30.338 ± 0.020 | 20.427 ± 0.014 | **5.875 ± 0.037** |
+|  Non-number String | 120.317 ± 0.427 | 49.834 ± 2.098 | **6.893 ± 0.035** |
+|   Small Int String |  29.925 ± 0.057 | 51.704 ± 0.453 | **6.842 ± 0.059** |
+|         Int String |  31.527 ± 0.049 | 55.322 ± 0.229 | **7.230 ± 0.048** |
+|  Medium Int String |  33.640 ± 1.070 | 61.465 ± 0.936 | **7.158 ± 0.031** |
+|   Large Int String |  39.966 ± 0.056 | 76.597 ± 1.458 | **7.084 ± 0.052** |
+| Small Float String | 117.130 ± 0.205 | 56.432 ± 2.375 | **7.693 ± 0.018** |
+|       Float String | 125.993 ± 0.642 | 60.797 ± 0.626 | **8.442 ± 0.027** |
+| Large Float String | 129.002 ± 0.948 | 60.929 ± 1.452 | **8.474 ± 0.106** |
+|                Int |  23.212 ± 0.786 | 24.172 ± 0.136 | **5.700 ± 0.050** |
+|              Float |  34.258 ± 0.033 | 25.132 ± 2.906 | **5.833 ± 0.037** |
 
 ### Timing comparison to check if value can be converted to `float`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
 | -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String |  62.413 ± 0.843 | 47.293 ± 0.042 | **7.975 ± 0.038** |
-|   Small Int String |  26.279 ± 0.005 | 57.323 ± 0.810 | **7.861 ± 0.026** |
-|         Int String |  26.804 ± 0.389 | 63.788 ± 3.379 | **8.652 ± 0.180** |
-|  Medium Int String |  28.135 ± 0.006 | 67.880 ± 2.493 | **8.369 ± 0.031** |
-|   Large Int String |  50.123 ± 0.725 | 77.206 ± 0.682 | **8.239 ± 0.033** |
-| Small Float String |  26.503 ± 0.380 | 56.502 ± 0.931 | **8.642 ± 0.068** |
-|       Float String |  47.032 ± 2.534 | 70.667 ± 0.914 | **9.228 ± 0.016** |
-| Large Float String |  69.682 ± 0.434 | 73.521 ± 0.039 | **9.291 ± 0.042** |
-|                Int |  20.431 ± 0.030 | 22.568 ± 0.372 | **6.595 ± 0.120** |
-|              Float |  19.404 ± 0.026 | 19.850 ± 0.003 | **6.463 ± 0.062** |
+|  Non-number String |  74.816 ± 1.514 | 54.070 ± 0.949 | **7.739 ± 0.098** |
+|   Small Int String |  29.062 ± 0.032 | 62.434 ± 0.141 | **7.720 ± 0.056** |
+|         Int String |  29.924 ± 0.020 | 65.960 ± 0.884 | **8.079 ± 0.087** |
+|  Medium Int String |  31.283 ± 0.110 | 73.014 ± 1.073 | **8.027 ± 0.050** |
+|   Large Int String |  56.448 ± 2.305 | 87.975 ± 0.176 | **7.915 ± 0.029** |
+| Small Float String |  29.655 ± 0.140 | 61.216 ± 0.113 | **8.895 ± 0.828** |
+|       Float String |  51.253 ± 0.270 | 77.765 ± 0.164 | **9.282 ± 0.025** |
+| Large Float String |  76.127 ± 0.961 | 84.602 ± 0.134 | **9.292 ± 0.052** |
+|                Int |  24.090 ± 0.037 | 24.635 ± 0.066 | **6.881 ± 0.024** |
+|              Float |  22.408 ± 0.041 | 22.157 ± 0.746 | **6.285 ± 0.067** |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  62.700 ± 2.415 | 47.693 ± 0.448  |  **7.654 ± 0.067** |
-|   Small Int String |  18.768 ± 0.024 | 57.541 ± 2.481  |  **8.121 ± 0.285** |
-|         Int String |  20.091 ± 0.017 | 60.349 ± 0.058  |  **8.399 ± 0.104** |
-|  Medium Int String |  21.361 ± 0.120 | 63.463 ± 0.883  |  **7.972 ± 0.025** |
-|   Large Int String |  42.285 ± 0.751 | 82.013 ± 3.395  |  **8.439 ± 0.019** |
-| Small Float String |  20.607 ± 0.066 | 58.581 ± 0.248  |  **9.694 ± 0.449** |
-|       Float String |  42.608 ± 0.548 | 72.007 ± 1.249  |  **9.772 ± 0.040** |
-| Large Float String |  64.745 ± 2.167 | 93.079 ± 11.397 | **10.517 ± 0.027** |
-|                Int |  15.962 ± 0.042 | 21.281 ± 0.018  |  **6.939 ± 0.054** |
-|              Float |  14.370 ± 0.139 | 18.610 ± 0.010  |  **6.893 ± 0.039** |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
+| -----------------: | --------------: | -------------: | ----------------: |
+|  Non-number String |  73.598 ± 0.119 | 51.486 ± 0.095 | **7.698 ± 0.110** |
+|   Small Int String |  20.861 ± 0.023 | 60.508 ± 0.805 | **7.480 ± 0.017** |
+|         Int String |  21.584 ± 0.075 | 63.462 ± 0.087 | **7.822 ± 0.030** |
+|  Medium Int String |  22.686 ± 0.023 | 71.683 ± 2.169 | **7.795 ± 0.023** |
+|   Large Int String |  45.468 ± 0.145 | 85.413 ± 0.180 | **7.771 ± 0.080** |
+| Small Float String |  21.437 ± 0.093 | 59.056 ± 0.849 | **8.374 ± 0.053** |
+|       Float String |  41.328 ± 0.091 | 75.060 ± 0.132 | **9.208 ± 0.137** |
+| Large Float String |  65.741 ± 0.576 | 81.926 ± 0.163 | **9.228 ± 0.056** |
+|                Int |  15.734 ± 0.028 | 20.235 ± 0.029 | **6.547 ± 0.043** |
+|              Float |  13.965 ± 0.027 | 18.732 ± 0.826 | **6.287 ± 0.066** |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
 | -----------------: | --------------: | --------------: | ----------------: |
-|  Non-number String | 176.388 ± 5.146 |  47.721 ± 0.665 | **6.952 ± 0.107** |
-|   Small Int String |  36.671 ± 0.131 |  31.345 ± 0.148 | **7.069 ± 0.009** |
-|         Int String |  38.811 ± 0.543 |  33.323 ± 0.562 | **9.177 ± 3.960** |
-|  Medium Int String |  45.133 ± 0.185 |  38.554 ± 0.021 | **7.352 ± 0.025** |
-|   Large Int String |  78.121 ± 0.124 |  50.196 ± 0.022 | **7.092 ± 0.026** |
-| Small Float String | 128.708 ± 3.183 |  78.251 ± 3.168 | **7.931 ± 0.044** |
-|       Float String | 157.215 ± 3.267 | 120.111 ± 2.452 | **8.544 ± 0.186** |
-| Large Float String | 182.948 ± 2.852 | 149.855 ± 4.554 | **8.850 ± 0.069** |
-|                Int |  26.646 ± 0.444 |  65.726 ± 0.545 | **5.852 ± 0.037** |
-|              Float |  51.737 ± 0.760 |  95.225 ± 0.323 | **5.854 ± 0.106** |
+|  Non-number String | 192.697 ± 0.318 |  47.930 ± 0.107 | **6.810 ± 0.016** |
+|   Small Int String |  40.588 ± 0.210 |  31.694 ± 0.050 | **6.859 ± 0.046** |
+|         Int String |  42.696 ± 0.184 |  35.260 ± 0.835 | **7.202 ± 0.032** |
+|  Medium Int String |  51.946 ± 4.483 |  42.604 ± 0.637 | **7.153 ± 0.039** |
+|   Large Int String |  90.527 ± 0.743 |  56.966 ± 0.184 | **7.141 ± 0.045** |
+| Small Float String | 141.470 ± 1.108 |  81.856 ± 1.357 | **7.723 ± 0.139** |
+|       Float String | 171.346 ± 2.006 | 127.129 ± 1.115 | **8.708 ± 0.031** |
+| Large Float String | 201.622 ± 2.004 | 160.668 ± 2.859 | **8.414 ± 0.077** |
+|                Int |  28.605 ± 0.803 |  73.405 ± 0.150 | **5.529 ± 0.027** |
+|              Float |  53.006 ± 0.093 | 112.248 ± 0.474 | **5.585 ± 0.014** |
+
+### Timing comparison of `map_try_float` vs. iterating over `try_float` for a 50 element list
+
+| Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | map_try_float(iterable) (ms) |
+| -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------: |
+|  Non-number String |                      600.867 ± 2.618  |                    499.744 ± 5.433  |         **269.688 ± 3.212**  |
+|   Small Int String |                      594.952 ± 9.212  |                    489.232 ± 0.696  |         **270.918 ± 10.541** |
+|         Int String |                      605.785 ± 2.051  |                    488.885 ± 12.781 |         **264.311 ± 1.780**  |
+|  Medium Int String |                      581.671 ± 1.428  |                    484.751 ± 0.665  |         **282.492 ± 1.311**  |
+|   Large Int String |                      800.175 ± 1.346  |                    701.576 ± 2.600  |         **484.354 ± 1.615**  |
+| Small Float String |                      578.116 ± 2.350  |                    487.157 ± 12.704 |         **298.143 ± 2.384**  |
+|       Float String |                      710.853 ± 6.761  |                    597.494 ± 2.271  |         **373.294 ± 4.058**  |
+| Large Float String |                      706.124 ± 4.584  |                    603.460 ± 2.657  |         **380.390 ± 4.439**  |
+|                Int |                      555.378 ± 14.460 |                    463.203 ± 10.879 |         **237.247 ± 2.456**  |
+|              Float |                      479.725 ± 1.414  |                    391.447 ± 6.573  |         **177.232 ± 2.944**  |
 
diff --git a/src/cpp/fastnumbers.cpp b/src/cpp/fastnumbers.cpp
index 4eb926a6..60641e75 100644
--- a/src/cpp/fastnumbers.cpp
+++ b/src/cpp/fastnumbers.cpp
@@ -11,6 +11,7 @@
 #include "fastnumbers/argparse.hpp"
 #include "fastnumbers/docstrings.hpp"
 #include "fastnumbers/implementation.hpp"
+#include "fastnumbers/iteration.hpp"
 #include "fastnumbers/parser/numeric.hpp"
 #include "fastnumbers/selectors.hpp"
 #include "fastnumbers/user_options.hpp"
@@ -62,6 +63,8 @@ static inline PyObject* convert_exception(PyObject* obj, const std::string& s)
 static inline PyObject* handle_exceptions(PyObject* input)
 try {
     throw;
+} catch (const just_return_null_exception&) {
+    return nullptr;
 } catch (const fastnumbers_exception& e) {
     return e.raise_value_error();
 } catch (const std::exception& e) {
@@ -236,6 +239,33 @@ static inline void validate_consider(const PyObject* selector)
     }
 }
 
+/**
+ * \brief Iterate over the elements of a collection and convert each one
+ * \param input The given input object that should be iterable
+ * \param item The reference to a PyObject* that will use to hold the input's
+ *             items - this is used for possible error reporting
+ * \param convert A function accepting a single argument that performs the conversion
+ * \return A new python list containing the converted results, or NULL on error
+ */
+template <typename Function>
+static PyObject*
+iterate_python_object(PyObject* input, PyObject*& item, Function convert)
+{
+    // Create a python list into which to store the return values
+    ListManager list_manager(input);
+
+    // The helper for iterating over the Python iterable
+    PyIterableManager iter_manager(input, item, convert);
+
+    // For each element in the Python iterable, convert it and append to the list
+    for (auto& value : iter_manager) {
+        list_manager.append(value);
+    }
+
+    // Return the list to the user
+    return list_manager.get();
+}
+
 /**
  * \brief Quickly convert to an int or float, depending on value, with error handling
  */
@@ -1040,6 +1070,178 @@ static PyObject* fastnumbers_real(
     }
 }
 
+static PyObject* fastnumbers_map_try_real(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
+{
+    PyObject* input = nullptr;
+    PyObject* inf = Selectors::ALLOWED;
+    PyObject* nan = Selectors::ALLOWED;
+    PyObject* on_fail = Selectors::INPUT;
+    PyObject* on_type_error = Selectors::RAISE;
+    int coerce = true;
+    int allow_underscores = false;
+
+    // Read the function argument
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("map_try_real", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$inf", false, &inf,
+                           "$nan", false, &nan,
+                           "$on_fail", false, &on_fail,
+                           "$on_type_error", false, &on_type_error,
+                           "$coerce", true, &coerce,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
+
+    // Execute main logic in a try-block to convert C++ exceptions
+    PyObject* item = nullptr;
+    try {
+        validate_not_disallow(inf);
+        validate_not_disallow(nan);
+        validate_not_allow_disallow_str_only_num_only(on_fail);
+        validate_not_allow_disallow_str_only_num_only(on_type_error);
+        auto convert = [&](PyObject* x) -> PyObject* {
+            return float_conv_impl(
+                x,
+                on_fail,
+                on_type_error,
+                inf,
+                nan,
+                UserType::REAL,
+                allow_underscores,
+                coerce
+            );
+        };
+        return iterate_python_object(input, item, convert);
+    } catch (...) {
+        return handle_exceptions(item != nullptr ? item : input);
+    }
+}
+
+static PyObject* fastnumbers_map_try_float(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
+{
+    PyObject* input = nullptr;
+    PyObject* inf = Selectors::ALLOWED;
+    PyObject* nan = Selectors::ALLOWED;
+    PyObject* on_fail = Selectors::INPUT;
+    PyObject* on_type_error = Selectors::RAISE;
+    int allow_underscores = false;
+
+    // Read the function arguments
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("map_try_float", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$inf", false, &inf,
+                           "$nan", false, &nan,
+                           "$on_fail", false, &on_fail,
+                           "$on_type_error", false, &on_type_error,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
+
+    // Execute main logic in a try-block to convert C++ exceptions
+    PyObject* item = nullptr;
+    try {
+        validate_not_disallow(inf);
+        validate_not_disallow(nan);
+        validate_not_allow_disallow_str_only_num_only(on_fail);
+        validate_not_allow_disallow_str_only_num_only(on_type_error);
+        auto convert = [&](PyObject* x) -> PyObject* {
+            return float_conv_impl(
+                x, on_fail, on_type_error, inf, nan, UserType::FLOAT, allow_underscores
+            );
+        };
+        return iterate_python_object(input, item, convert);
+    } catch (...) {
+        return handle_exceptions(item != nullptr ? item : input);
+    }
+}
+
+static PyObject* fastnumbers_map_try_int(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
+{
+    PyObject* input = nullptr;
+    PyObject* on_fail = Selectors::INPUT;
+    PyObject* on_type_error = Selectors::RAISE;
+    PyObject* pybase = nullptr;
+    int allow_underscores = false;
+
+    // Read the function arguments
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("map_try_int", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$on_fail", false, &on_fail,
+                           "$on_type_error", false, &on_type_error,
+                           "$base", false, &pybase,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
+
+    // Execute main logic in a try-block to convert C++ exceptions
+    PyObject* item = nullptr;
+    try {
+        validate_not_allow_disallow_str_only_num_only(on_fail);
+        validate_not_allow_disallow_str_only_num_only(on_type_error);
+        const int base = assess_integer_base_input(pybase);
+        auto convert = [&](PyObject* x) -> PyObject* {
+            return int_conv_impl(
+                x, on_fail, on_type_error, UserType::INT, allow_underscores, base
+            );
+        };
+        return iterate_python_object(input, item, convert);
+    } catch (...) {
+        return handle_exceptions(item != nullptr ? item : input);
+    }
+}
+
+static PyObject* fastnumbers_map_try_forceint(
+    PyObject* self, PyObject* const* args, Py_ssize_t len_args, PyObject* kwnames
+)
+{
+    PyObject* input = nullptr;
+    PyObject* on_fail = Selectors::INPUT;
+    PyObject* on_type_error = Selectors::RAISE;
+    int allow_underscores = false;
+
+    // Read the function arguments
+    FN_PREPARE_ARGPARSER;
+    // clang-format off
+    if (fn_parse_arguments("map_try_forceint", args, len_args, kwnames,
+                           "x", false,  &input,
+                           "$on_fail", false, &on_fail,
+                           "$on_type_error", false, &on_type_error,
+                           "$allow_underscores", true, &allow_underscores,
+                           nullptr, false, nullptr
+        )) return nullptr;
+    // clang-format on
+
+    // Execute main logic in a try-block to convert C++ exceptions
+    PyObject* item = nullptr;
+    try {
+        validate_not_allow_disallow_str_only_num_only(on_fail);
+        validate_not_allow_disallow_str_only_num_only(on_type_error);
+        auto convert = [&](PyObject* x) -> PyObject* {
+            return int_conv_impl(
+                x, on_fail, on_type_error, UserType::FORCEINT, allow_underscores
+            );
+        };
+        return iterate_python_object(input, item, convert);
+    } catch (...) {
+        return handle_exceptions(item != nullptr ? item : input);
+    }
+}
+
 // Define the methods contained in this module
 static PyMethodDef FastnumbersMethods[] = {
     { "try_real",
@@ -1119,6 +1321,22 @@ static PyMethodDef FastnumbersMethods[] = {
       (PyCFunction)fastnumbers_real,
       METH_FASTCALL | METH_KEYWORDS,
       fastnumbers_real__doc__ },
+    { "map_try_real",
+      (PyCFunction)fastnumbers_map_try_real,
+      METH_FASTCALL | METH_KEYWORDS,
+      map_try_real__doc__ },
+    { "map_try_float",
+      (PyCFunction)fastnumbers_map_try_float,
+      METH_FASTCALL | METH_KEYWORDS,
+      map_try_float__doc__ },
+    { "map_try_int",
+      (PyCFunction)fastnumbers_map_try_int,
+      METH_FASTCALL | METH_KEYWORDS,
+      map_try_int__doc__ },
+    { "map_try_forceint",
+      (PyCFunction)fastnumbers_map_try_forceint,
+      METH_FASTCALL | METH_KEYWORDS,
+      map_try_forceint__doc__ },
     { nullptr, nullptr, 0, nullptr } /* Sentinel */
 };
 
@@ -1145,6 +1363,7 @@ PyObject* Selectors::RAISE = nullptr;
 PyObject* Selectors::STRING_ONLY = nullptr;
 PyObject* Selectors::NUMBER_ONLY = nullptr;
 PyObject* NumericParser::PYTHON_ZERO = nullptr;
+PyObject* Sigils::ITERATOR = nullptr;
 
 // Actually create the module object itself
 PyMODINIT_FUNC PyInit_fastnumbers()
@@ -1171,6 +1390,9 @@ PyMODINIT_FUNC PyInit_fastnumbers()
     PyModule_AddObject(m, "STRING_ONLY", Selectors::STRING_ONLY);
     PyModule_AddObject(m, "NUMBER_ONLY", Selectors::NUMBER_ONLY);
 
+    // Sigils
+    Sigils::ITERATOR = PyObject_New(PyObject, &PyBaseObject_Type);
+
     // Constants cached for internal use
     PyObject* pos_inf_str = PyBytes_FromString("+infinity");
     PyObject* neg_inf_str = PyBytes_FromString("-infinity");
diff --git a/src/fastnumbers/__init__.py b/src/fastnumbers/__init__.py
index a7abda4c..f9f7843d 100644
--- a/src/fastnumbers/__init__.py
+++ b/src/fastnumbers/__init__.py
@@ -20,6 +20,10 @@
     isint,
     isintlike,
     isreal,
+    map_try_float,
+    map_try_forceint,
+    map_try_int,
+    map_try_real,
     query_type,
     real,
     try_float,
@@ -50,6 +54,10 @@
     "isint",
     "isintlike",
     "isreal",
+    "map_try_float",
+    "map_try_forceint",
+    "map_try_int",
+    "map_try_real",
     "query_type",
     "real",
     "try_float",
diff --git a/src/fastnumbers/fastnumbers.pyi b/src/fastnumbers/fastnumbers.pyi
index 722103ba..8e23800c 100644
--- a/src/fastnumbers/fastnumbers.pyi
+++ b/src/fastnumbers/fastnumbers.pyi
@@ -2,6 +2,8 @@ from builtins import float as pyfloat, int as pyint
 from typing import (
     Any,
     Callable,
+    Iterable,
+    List,
     NewType,
     Optional,
     Sequence,
@@ -2580,6 +2582,2524 @@ def try_forceint(
     allow_underscores: bool = False,
 ) -> Union[TransformType, TransformType2, pyint]: ...
 
+# Try real mapping
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: ALLOWED_T = ALLOWED,
+    nan: ALLOWED_T = ALLOWED,
+    on_fail: RAISE_T,
+    on_type_error: RAISE_T = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Default2,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyint, pyfloat]]: ...
+@overload
+def map_try_real(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    coerce: bool = True,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, Nan, pyint, pyfloat]]: ...
+
+# Try float mapping
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: ALLOWED_T = ALLOWED,
+    nan: ALLOWED_T = ALLOWED,
+    on_fail: RAISE_T,
+    on_type_error: RAISE_T = RAISE,
+    allow_underscores: bool = False,
+) -> List[pyfloat]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Union[ALLOWED_T, INPUT_T, RAISE_T] = ALLOWED,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Nan,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Inf,
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[FastInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, Inf, Nan, pyfloat]]: ...
+@overload
+def map_try_float(
+    x: Iterable[AnyInputType],
+    *,
+    inf: Callable[[FastInputType], Inf],
+    nan: Callable[[FastInputType], Nan],
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, Inf, Nan, pyfloat]]: ...
+
+# Try int mapping
+@overload
+def map_try_int(
+    x: Iterable[FastInputType],
+    *,
+    on_fail: RAISE_T,
+    on_type_error: RAISE_T = RAISE,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[pyint]: ...
+@overload
+def map_try_int(
+    x: Iterable[FastInputType],
+    *,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: RAISE_T = RAISE,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[FastInputType],
+    *,
+    on_fail: Default,
+    on_type_error: RAISE_T = RAISE,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[Default, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[FastInputType],
+    *,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: RAISE_T = RAISE,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Default,
+    on_type_error: Default2,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, pyint]]: ...
+@overload
+def map_try_int(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    base: Union[HasIndex, pyint] = 10,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, pyint]]: ...
+
+# Try forceint mapping
+@overload
+def map_try_forceint(
+    x: Iterable[FastInputType],
+    *,
+    on_fail: RAISE_T,
+    on_type_error: RAISE_T = RAISE,
+    allow_underscores: bool = False,
+) -> List[pyint]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[FastInputType],
+    *,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: RAISE_T = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[FastInputType],
+    *,
+    on_fail: Default,
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[Default, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[FastInputType],
+    *,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Union[INPUT_T, RAISE_T] = RAISE,
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, Default, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Union[INPUT_T, RAISE_T] = INPUT,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[FastInputType, TransformType, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Default,
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, Default, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Default,
+    on_type_error: Default2,
+    allow_underscores: bool = False,
+) -> List[Union[Default, Default2, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Default,
+    on_type_error: Callable[[AnyInputType], TransformType],
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: INPUT_T,
+    allow_underscores: bool = False,
+) -> List[Union[AnyInputType, TransformType, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Default,
+    allow_underscores: bool = False,
+) -> List[Union[Default, TransformType, pyint]]: ...
+@overload
+def map_try_forceint(
+    x: Iterable[AnyInputType],
+    *,
+    on_fail: Callable[[FastInputType], TransformType],
+    on_type_error: Callable[[AnyInputType], TransformType2],
+    allow_underscores: bool = False,
+) -> List[Union[TransformType, TransformType2, pyint]]: ...
+
 # Fast real
 @overload
 def fast_real(


Test patch:
diff --git a/tests/test_fastnumbers.py b/tests/test_fastnumbers.py
index a2bcf2d7..c92613f7 100644
--- a/tests/test_fastnumbers.py
+++ b/tests/test_fastnumbers.py
@@ -95,6 +95,60 @@ def __call__(
         ...
 
 
+class MapTryReal(Protocol):
+    def __call__(
+        self,
+        x: Iterable[Any],
+        *,
+        inf: Any = fastnumbers.ALLOWED,
+        nan: Any = fastnumbers.ALLOWED,
+        on_fail: Any = fastnumbers.INPUT,
+        on_type_error: Any = fastnumbers.RAISE,
+        coerce: bool = True,
+        allow_underscores: bool = False,
+    ) -> List[Any]:
+        ...
+
+
+class MapTryFloat(Protocol):
+    def __call__(
+        self,
+        x: Iterable[Any],
+        *,
+        inf: Any = fastnumbers.ALLOWED,
+        nan: Any = fastnumbers.ALLOWED,
+        on_fail: Any = fastnumbers.INPUT,
+        on_type_error: Any = fastnumbers.RAISE,
+        allow_underscores: bool = False,
+    ) -> List[Any]:
+        ...
+
+
+class MapTryInt(Protocol):
+    def __call__(
+        self,
+        x: Iterable[Any],
+        *,
+        on_fail: Any = fastnumbers.INPUT,
+        on_type_error: Any = fastnumbers.RAISE,
+        base: int = 0,
+        allow_underscores: bool = False,
+    ) -> List[Any]:
+        ...
+
+
+class MapTryForceInt(Protocol):
+    def __call__(
+        self,
+        x: Iterable[Any],
+        *,
+        on_fail: Any = fastnumbers.INPUT,
+        on_type_error: Any = fastnumbers.RAISE,
+        allow_underscores: bool = False,
+    ) -> List[Any]:
+        ...
+
+
 class CheckReal(Protocol):
     def __call__(
         self,
@@ -150,6 +204,7 @@ def __call__(self, x: Any = 0.0, *, coerce: bool = True) -> Union[int, float]:
 
 
 ConversionFuncs = Union[TryReal, TryFloat, TryInt, TryForceInt]
+MappingConversionFuncs = Union[MapTryReal, MapTryFloat, MapTryInt, MapTryForceInt]
 IdentificationFuncs = Union[CheckReal, CheckFloat, CheckInt, CheckIntLike]
 
 # Predefine Unicode digits, numbers, and not those.
@@ -238,6 +293,16 @@ def base_n(
     return "-" + val if neg else val
 
 
+def capture_result(  # type: ignore [no-untyped-def]
+    func: Union[ConversionFuncs, MappingConversionFuncs], *args, **kwargs
+) -> Any:
+    """Execute a function, and either return the result or the exception message"""
+    try:
+        return func(*args, **kwargs)
+    except Exception as e:
+        return str(e).replace("map_try", "try")  # normalize error message
+
+
 class DumbFloatClass(object):
     def __float__(self) -> NoReturn:
         raise ValueError("something here might go wrong")
@@ -418,14 +483,8 @@ def test_old_to_new_conversion_equivalence(
         self, old_func: ConversionFuncs, new_func: ConversionFuncs, x: Any
     ) -> None:
         for value in (x, (x, x)):
-            try:
-                old_result = old_func(value)
-            except Exception as e:
-                old_result = str(e)
-            try:
-                new_result = new_func(value)
-            except Exception as e:
-                new_result = str(e)
+            old_result = capture_result(old_func, value)
+            new_result = capture_result(new_func, value)
             if old_result != old_result and new_result != new_result:
                 assert math.isnan(old_result) and math.isnan(new_result)
             else:
@@ -1490,3 +1549,113 @@ def test_containers_returns_container_type(
     ) -> None:
         assert fastnumbers.query_type(x) is type(x)
         assert fastnumbers.query_type(x, allowed_types=(float, int, str)) is None
+
+
+class TestMappingFunctions:
+    """Ensure that mapping functions operate on iterables"""
+
+    @given(lists(floats() | integers() | text(max_size=50), min_size=1, max_size=50))
+    @parametrize(
+        "nomapper, mapper",
+        [
+            (fastnumbers.try_real, fastnumbers.map_try_real),
+            (fastnumbers.try_float, fastnumbers.map_try_float),
+            (fastnumbers.try_int, fastnumbers.map_try_int),
+            (fastnumbers.try_forceint, fastnumbers.map_try_forceint),
+        ],
+    )
+    @parametrize(
+        "kwargs",
+        [
+            {},
+            {"inf": fastnumbers.RAISE},
+            {"nan": fastnumbers.RAISE},
+            {"on_fail": fastnumbers.RAISE},
+            {"base": 16},
+            {"coerce": True},
+        ],
+    )
+    def test_mapping_non_mapping_behave_the_same(
+        self,
+        nomapper: ConversionFuncs,
+        mapper: MappingConversionFuncs,
+        kwargs: Dict[str, Any],
+        x: List[Union[float, int, str]],
+    ) -> None:
+        nomapper = partial(nomapper, **kwargs)
+        mapper = partial(mapper, **kwargs)
+        nonmapping = capture_result(lambda y: list(map(nomapper, y)), x)  # type: ignore
+        mapping = capture_result(mapper, x)
+        if nonmapping != nonmapping and mapping != mapping:
+            assert math.isnan(nonmapping) and math.isnan(mapping)
+        else:
+            assert nonmapping == mapping
+
+    @parametrize(
+        "nomapper, mapper",
+        [
+            (fastnumbers.try_real, fastnumbers.map_try_real),
+            (fastnumbers.try_float, fastnumbers.map_try_float),
+            (fastnumbers.try_int, fastnumbers.map_try_int),
+            (fastnumbers.try_forceint, fastnumbers.map_try_forceint),
+        ],
+    )
+    def test_mapping_non_mapping_behave_the_same_with_invalid_types(
+        self, nomapper: ConversionFuncs, mapper: MappingConversionFuncs
+    ) -> None:
+        x = ["7", "5", None]
+        nonmapping = capture_result(lambda y: list(map(nomapper, y)), x)  # type: ignore
+        mapping = capture_result(mapper, x)
+        assert nonmapping == mapping
+
+    @parametrize(
+        "func",
+        [
+            fastnumbers.map_try_real,
+            fastnumbers.map_try_float,
+            fastnumbers.map_try_int,
+            fastnumbers.map_try_forceint,
+        ],
+    )
+    @parametrize(
+        "iterable_gen",
+        [
+            lambda: ["6", "4", "590"],
+            lambda: ("6", "4", "590"),
+            lambda: {"6", "4", "590"},
+            lambda: iter(["6", "4", "590"]),
+            lambda: (x for x in ["6", "4", "590"]),
+        ],
+    )
+    def test_mapping_handles_any_iterable(
+        self, func: MappingConversionFuncs, iterable_gen: Callable[[], Iterable[Any]]
+    ) -> None:
+        expected = [4, 6, 590]
+        result = sorted(func(iterable_gen()))  # sorted needed b/c of set
+        assert result == expected
+
+    @parametrize(
+        "func",
+        [
+            fastnumbers.map_try_real,
+            fastnumbers.map_try_float,
+            fastnumbers.map_try_int,
+            fastnumbers.map_try_forceint,
+        ],
+    )
+    @parametrize(
+        "iterable_gen",
+        [
+            lambda: [],
+            lambda: (),
+            lambda: set(),
+            lambda: iter([]),
+            lambda: (x for x in []),  # type: ignore [var-annotated]
+        ],
+    )
+    def test_mapping_handles_empty_iterable(
+        self, func: MappingConversionFuncs, iterable_gen: Callable[[], Iterable[Any]]
+    ) -> None:
+        expected: List[Any] = []
+        result = func(iterable_gen())
+        assert result == expected