functionalthreading 1.0.0__tar.gz → 1.0.2__tar.gz

{functionalthreading-1.0.0 → functionalthreading-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functionalthreading
-Version: 1.0.0
+Version: 1.0.2
 Summary: Concurrent functional programming with thread-based parallelism
 Author-email: Richard Tong <richytong@gmail.com>
 License-Expression: Unlicense
@@ -270,11 +270,11 @@ chain(
 ```
 
 
-### tmap(argument, func)
-### tmap(func)
-Map a function concurrently across each element of an list or tuple.
+### tmap(argument, function)
+### tmap(function)
+Map a function concurrently across each element of a list or tuple.
 
-A mapper is a function that specifies a single element of an list or tuple and returns a corresponding element of the resulting list or tuple. Each mapper invocation happens in a separate thread.
+A mapper is a function that specifies a single element of a list or tuple and returns a corresponding element of the resulting list or tuple. Each mapper invocation happens in a separate thread.
 
 ```python
 squared = tmap([1, 2, 3], lambda n: n ** 2)
@@ -288,9 +288,9 @@ squared = my_mapping_func([1, 2, 3])
 ```
 
 
-### tforeach(argument, func)
-### tforeach(func)
-Execute a callback concurrently for each element of an list or tuple.
+### tforeach(argument, function)
+### tforeach(function)
+Execute a callback concurrently for each element of a list or tuple.
 
 A callback is a function that does not necessarily specify a value or return. Each callback invocation happens in a separate thread.
 
@@ -306,11 +306,11 @@ my_foreach_func([1, 2, 3])
 ```
 
 
-### tfilter(argument, func)
-### tfilter(func)
-Concurrently filter an list or tuple.
+### tfilter(argument, function)
+### tfilter(function)
+Concurrently filter a list or tuple.
 
-A predicate is a function that specifies an element of an list or tuple and returns a boolean value. Elements corresponding to predicate invocations that return `False` are filtered out of the resulting list or tuple, while elements corresponding to predicate invocationsn that return `True` are retained. Each predicate invocation happens in a separate thread.
+A predicate is a function that specifies an element of a list or tuple and returns a boolean value. Elements corresponding to predicate invocations that return `False` are filtered out of the resulting list or tuple, while elements corresponding to predicate invocationsn that return `True` are retained. Each predicate invocation happens in a separate thread.
 
 ```python
 def is_odd(n):
@@ -330,9 +330,37 @@ odd_numbers = filter_odds([1, 2, 3, 4, 5])
 ```
 
 
-### tflatmap(argument, func)
-### tflatmap(func)
-Apply a flatmapper concurrently to each element of an list or tuple, concatenating the results.
+### reduce(argument, function, /[, initial])
+### reduce(function, /[, initial])
+Reduce a list or tuple to a single value (accumulator).
+
+A reducer is a function that specifies an accumulator and a given element of a list or tuple, and returns an accumulator. Each reducer invocation happens sequentially.
+
+```python
+# add is a reducer
+def add(a, b):
+    return a + b
+
+sum = reduce([1, 2, 3, 4, 5], add)
+```
+
+If an initial value is provided, it is treated as the starting value for the accumulator.
+
+```python
+sum = reduce([1, 2, 3, 4, 5], add, 10)
+```
+
+If the list or tuple argument is omitted, returns a function of the reducer and initial value that expects the argument.
+
+```python
+reducing_func = reduce(add, 10)
+sum = reducing_func([1, 2, 3, 4, 5])
+```
+
+
+### tflatmap(argument, function)
+### tflatmap(function)
+Apply a flatmapper concurrently to each element of a list or tuple, concatenating the results.
 
 A flatmapper is a function that specifies an element of the list or tuple, and returns a list, tuple, or single element. A returned list or tuple is concatenated onto the resulting list or tuple, while a returned single element is appended. Each flatmapper invocation happens in a separate thread.
 

{functionalthreading-1.0.0 → functionalthreading-1.0.2}/README.md

@@ -255,11 +255,11 @@ chain(
 ```
 
 
-### tmap(argument, func)
-### tmap(func)
-Map a function concurrently across each element of an list or tuple.
+### tmap(argument, function)
+### tmap(function)
+Map a function concurrently across each element of a list or tuple.
 
-A mapper is a function that specifies a single element of an list or tuple and returns a corresponding element of the resulting list or tuple. Each mapper invocation happens in a separate thread.
+A mapper is a function that specifies a single element of a list or tuple and returns a corresponding element of the resulting list or tuple. Each mapper invocation happens in a separate thread.
 
 ```python
 squared = tmap([1, 2, 3], lambda n: n ** 2)
@@ -273,9 +273,9 @@ squared = my_mapping_func([1, 2, 3])
 ```
 
 
-### tforeach(argument, func)
-### tforeach(func)
-Execute a callback concurrently for each element of an list or tuple.
+### tforeach(argument, function)
+### tforeach(function)
+Execute a callback concurrently for each element of a list or tuple.
 
 A callback is a function that does not necessarily specify a value or return. Each callback invocation happens in a separate thread.
 
@@ -291,11 +291,11 @@ my_foreach_func([1, 2, 3])
 ```
 
 
-### tfilter(argument, func)
-### tfilter(func)
-Concurrently filter an list or tuple.
+### tfilter(argument, function)
+### tfilter(function)
+Concurrently filter a list or tuple.
 
-A predicate is a function that specifies an element of an list or tuple and returns a boolean value. Elements corresponding to predicate invocations that return `False` are filtered out of the resulting list or tuple, while elements corresponding to predicate invocationsn that return `True` are retained. Each predicate invocation happens in a separate thread.
+A predicate is a function that specifies an element of a list or tuple and returns a boolean value. Elements corresponding to predicate invocations that return `False` are filtered out of the resulting list or tuple, while elements corresponding to predicate invocationsn that return `True` are retained. Each predicate invocation happens in a separate thread.
 
 ```python
 def is_odd(n):
@@ -315,9 +315,37 @@ odd_numbers = filter_odds([1, 2, 3, 4, 5])
 ```
 
 
-### tflatmap(argument, func)
-### tflatmap(func)
-Apply a flatmapper concurrently to each element of an list or tuple, concatenating the results.
+### reduce(argument, function, /[, initial])
+### reduce(function, /[, initial])
+Reduce a list or tuple to a single value (accumulator).
+
+A reducer is a function that specifies an accumulator and a given element of a list or tuple, and returns an accumulator. Each reducer invocation happens sequentially.
+
+```python
+# add is a reducer
+def add(a, b):
+    return a + b
+
+sum = reduce([1, 2, 3, 4, 5], add)
+```
+
+If an initial value is provided, it is treated as the starting value for the accumulator.
+
+```python
+sum = reduce([1, 2, 3, 4, 5], add, 10)
+```
+
+If the list or tuple argument is omitted, returns a function of the reducer and initial value that expects the argument.
+
+```python
+reducing_func = reduce(add, 10)
+sum = reducing_func([1, 2, 3, 4, 5])
+```
+
+
+### tflatmap(argument, function)
+### tflatmap(function)
+Apply a flatmapper concurrently to each element of a list or tuple, concatenating the results.
 
 A flatmapper is a function that specifies an element of the list or tuple, and returns a list, tuple, or single element. A returned list or tuple is concatenated onto the resulting list or tuple, while a returned single element is appended. Each flatmapper invocation happens in a separate thread.
 

{functionalthreading-1.0.0 → functionalthreading-1.0.2}/functionalthreading/functions/__init__.py

@@ -112,9 +112,9 @@ def _tmap(argument, func):
     return result
 
 def tmap(*args):
-    """Map a function concurrently across each element of an list or tuple.
+    """Map a function concurrently across each element of a list or tuple.
 
-    A mapper is a function that specifies a single element of an list or tuple and returns a corresponding element of the resulting list or tuple. Each mapper invocation happens in a separate thread.
+    A mapper is a function that specifies a single element of a list or tuple and returns a corresponding element of the resulting list or tuple. Each mapper invocation happens in a separate thread.
 
     ```python
     squared = tmap([1, 2, 3], lambda n: n ** 2)
@@ -147,7 +147,7 @@ def _tforeach(argument, func):
     return None
 
 def tforeach(*args):
-    """Execute a callback concurrently for each element of an list or tuple.
+    """Execute a callback concurrently for each element of a list or tuple.
 
     A callback is a function that does not necessarily specify a value or return. Each callback invocation happens in a separate thread.
 
@@ -190,9 +190,9 @@ def _tfilter(argument, func):
     return result
 
 def tfilter(*args):
-    """Concurrently filter an list or tuple.
+    """Concurrently filter a list or tuple.
 
-    A predicate is a function that specifies an element of an list or tuple and returns a boolean value. Elements corresponding to predicate invocations that return `False` are filtered out of the resulting list or tuple, while elements corresponding to predicate invocationsn that return `True` are retained. Each predicate invocation happens in a separate thread.
+    A predicate is a function that specifies an element of a list or tuple and returns a boolean value. Elements corresponding to predicate invocations that return `False` are filtered out of the resulting list or tuple, while elements corresponding to predicate invocationsn that return `True` are retained. Each predicate invocation happens in a separate thread.
 
     ```python
     def is_odd(n):
@@ -217,9 +217,9 @@ def tfilter(*args):
     return _tfilter(*args)
 
 def reduce(*args):
-    """Reduce an list or tuple to a single value (accumulator).
+    """Reduce a list or tuple to a single value (accumulator).
 
-    A reducer is a function that specifies an accumulator and a given element of an list or tuple, and returns an accumulator. Each reducer invocation happens sequentially.
+    A reducer is a function that specifies an accumulator and a given element of a list or tuple, and returns an accumulator. Each reducer invocation happens sequentially.
 
     ```python
     # add is a reducer
@@ -273,7 +273,7 @@ def _tflatmap(argument, func):
     return result
 
 def tflatmap(*args):
-    """Apply a flatmapper concurrently to each element of an list or tuple, concatenating the results.
+    """Apply a flatmapper concurrently to each element of a list or tuple, concatenating the results.
 
     A flatmapper is a function that specifies an element of the list or tuple, and returns a list, tuple, or single element. A returned list or tuple is concatenated onto the resulting list or tuple, while a returned single element is appended. Each flatmapper invocation happens in a separate thread.
 

{functionalthreading-1.0.0 → functionalthreading-1.0.2}/functionalthreading.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functionalthreading
-Version: 1.0.0
+Version: 1.0.2
 Summary: Concurrent functional programming with thread-based parallelism
 Author-email: Richard Tong <richytong@gmail.com>
 License-Expression: Unlicense
@@ -270,11 +270,11 @@ chain(
 ```
 
 
-### tmap(argument, func)
-### tmap(func)
-Map a function concurrently across each element of an list or tuple.
+### tmap(argument, function)
+### tmap(function)
+Map a function concurrently across each element of a list or tuple.
 
-A mapper is a function that specifies a single element of an list or tuple and returns a corresponding element of the resulting list or tuple. Each mapper invocation happens in a separate thread.
+A mapper is a function that specifies a single element of a list or tuple and returns a corresponding element of the resulting list or tuple. Each mapper invocation happens in a separate thread.
 
 ```python
 squared = tmap([1, 2, 3], lambda n: n ** 2)
@@ -288,9 +288,9 @@ squared = my_mapping_func([1, 2, 3])
 ```
 
 
-### tforeach(argument, func)
-### tforeach(func)
-Execute a callback concurrently for each element of an list or tuple.
+### tforeach(argument, function)
+### tforeach(function)
+Execute a callback concurrently for each element of a list or tuple.
 
 A callback is a function that does not necessarily specify a value or return. Each callback invocation happens in a separate thread.
 
@@ -306,11 +306,11 @@ my_foreach_func([1, 2, 3])
 ```
 
 
-### tfilter(argument, func)
-### tfilter(func)
-Concurrently filter an list or tuple.
+### tfilter(argument, function)
+### tfilter(function)
+Concurrently filter a list or tuple.
 
-A predicate is a function that specifies an element of an list or tuple and returns a boolean value. Elements corresponding to predicate invocations that return `False` are filtered out of the resulting list or tuple, while elements corresponding to predicate invocationsn that return `True` are retained. Each predicate invocation happens in a separate thread.
+A predicate is a function that specifies an element of a list or tuple and returns a boolean value. Elements corresponding to predicate invocations that return `False` are filtered out of the resulting list or tuple, while elements corresponding to predicate invocationsn that return `True` are retained. Each predicate invocation happens in a separate thread.
 
 ```python
 def is_odd(n):
@@ -330,9 +330,37 @@ odd_numbers = filter_odds([1, 2, 3, 4, 5])
 ```
 
 
-### tflatmap(argument, func)
-### tflatmap(func)
-Apply a flatmapper concurrently to each element of an list or tuple, concatenating the results.
+### reduce(argument, function, /[, initial])
+### reduce(function, /[, initial])
+Reduce a list or tuple to a single value (accumulator).
+
+A reducer is a function that specifies an accumulator and a given element of a list or tuple, and returns an accumulator. Each reducer invocation happens sequentially.
+
+```python
+# add is a reducer
+def add(a, b):
+    return a + b
+
+sum = reduce([1, 2, 3, 4, 5], add)
+```
+
+If an initial value is provided, it is treated as the starting value for the accumulator.
+
+```python
+sum = reduce([1, 2, 3, 4, 5], add, 10)
+```
+
+If the list or tuple argument is omitted, returns a function of the reducer and initial value that expects the argument.
+
+```python
+reducing_func = reduce(add, 10)
+sum = reducing_func([1, 2, 3, 4, 5])
+```
+
+
+### tflatmap(argument, function)
+### tflatmap(function)
+Apply a flatmapper concurrently to each element of a list or tuple, concatenating the results.
 
 A flatmapper is a function that specifies an element of the list or tuple, and returns a list, tuple, or single element. A returned list or tuple is concatenated onto the resulting list or tuple, while a returned single element is appended. Each flatmapper invocation happens in a separate thread.
 

{functionalthreading-1.0.0 → functionalthreading-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "functionalthreading"
-version = "1.0.0"
+version = "1.0.2"
 authors = [
   { name="Richard Tong", email="richytong@gmail.com" },
 ]