functionalthreading 1.0.0__tar.gz → 1.0.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functionalthreading
-Version: 1.0.0
+Version: 1.0.1
 Summary: Concurrent functional programming with thread-based parallelism
 Author-email: Richard Tong <richytong@gmail.com>
 License-Expression: Unlicense
@@ -270,8 +270,8 @@ chain(
 ```
 
 
-### tmap(argument, func)
-### tmap(func)
+### tmap(argument, function)
+### tmap(function)
 Map a function concurrently across each element of an 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.
@@ -288,8 +288,8 @@ squared = my_mapping_func([1, 2, 3])
 ```
 
 
-### tforeach(argument, func)
-### tforeach(func)
+### tforeach(argument, function)
+### tforeach(function)
 Execute a callback concurrently for each element of an 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,8 +306,8 @@ my_foreach_func([1, 2, 3])
 ```
 
 
-### tfilter(argument, func)
-### tfilter(func)
+### tfilter(argument, function)
+### tfilter(function)
 Concurrently filter an 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.
@@ -330,8 +330,36 @@ odd_numbers = filter_odds([1, 2, 3, 4, 5])
 ```
 
 
-### tflatmap(argument, func)
-### tflatmap(func)
+### reduce(argument, function, /[, initial])
+### reduce(function, /[, initial])
+Reduce an 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.
+
+```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 an 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.1}/README.md

@@ -255,8 +255,8 @@ chain(
 ```
 
 
-### tmap(argument, func)
-### tmap(func)
+### tmap(argument, function)
+### tmap(function)
 Map a function concurrently across each element of an 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.
@@ -273,8 +273,8 @@ squared = my_mapping_func([1, 2, 3])
 ```
 
 
-### tforeach(argument, func)
-### tforeach(func)
+### tforeach(argument, function)
+### tforeach(function)
 Execute a callback concurrently for each element of an 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,8 +291,8 @@ my_foreach_func([1, 2, 3])
 ```
 
 
-### tfilter(argument, func)
-### tfilter(func)
+### tfilter(argument, function)
+### tfilter(function)
 Concurrently filter an 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.
@@ -315,8 +315,36 @@ odd_numbers = filter_odds([1, 2, 3, 4, 5])
 ```
 
 
-### tflatmap(argument, func)
-### tflatmap(func)
+### reduce(argument, function, /[, initial])
+### reduce(function, /[, initial])
+Reduce an 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.
+
+```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 an 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.1}/functionalthreading.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functionalthreading
-Version: 1.0.0
+Version: 1.0.1
 Summary: Concurrent functional programming with thread-based parallelism
 Author-email: Richard Tong <richytong@gmail.com>
 License-Expression: Unlicense
@@ -270,8 +270,8 @@ chain(
 ```
 
 
-### tmap(argument, func)
-### tmap(func)
+### tmap(argument, function)
+### tmap(function)
 Map a function concurrently across each element of an 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.
@@ -288,8 +288,8 @@ squared = my_mapping_func([1, 2, 3])
 ```
 
 
-### tforeach(argument, func)
-### tforeach(func)
+### tforeach(argument, function)
+### tforeach(function)
 Execute a callback concurrently for each element of an 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,8 +306,8 @@ my_foreach_func([1, 2, 3])
 ```
 
 
-### tfilter(argument, func)
-### tfilter(func)
+### tfilter(argument, function)
+### tfilter(function)
 Concurrently filter an 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.
@@ -330,8 +330,36 @@ odd_numbers = filter_odds([1, 2, 3, 4, 5])
 ```
 
 
-### tflatmap(argument, func)
-### tflatmap(func)
+### reduce(argument, function, /[, initial])
+### reduce(function, /[, initial])
+Reduce an 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.
+
+```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 an 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.1}/pyproject.toml

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