OSlash 2.0.0__tar.gz → 3.0.0__tar.gz

oslash-3.0.0/.github/dependabot.yml

@@ -0,0 +1,22 @@
+version: 2
+updates:
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    commit-message:
+      prefix: "chore"
+
+  - package-ecosystem: "pre-commit"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    commit-message:
+      prefix: "chore"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    commit-message:
+      prefix: "chore"

{oslash-2.0.0 → oslash-3.0.0}/.github/workflows/ci.yml

@@ -10,8 +10,8 @@ jobs:
   pre-commit:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: '3.12'
       - name: Install uv
@@ -28,10 +28,10 @@ jobs:
         os: [ubuntu-latest, macos-latest, windows-latest]
         python-version: ['3.12', '3.13', '3.14']
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -45,7 +45,7 @@ jobs:
         run: uv run pytest --cov=oslash --cov-report=xml --cov-report=term
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v7
         if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
         with:
           file: ./coverage.xml
@@ -54,7 +54,7 @@ jobs:
   type-check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
 
       - name: Install uv
         uses: astral-sh/setup-uv@v7

oslash-3.0.0/.github/workflows/conventional-pr-title.yml

@@ -0,0 +1,27 @@
+name: conventional-pr-title
+
+on:
+  pull_request:
+    types: [opened, edited, synchronize, reopened]
+    branches: [master]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v6
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          types: |
+            feat
+            fix
+            chore
+            docs
+            style
+            refactor
+            perf
+            test
+            ci
+            build
+            revert

{oslash-2.0.0 → oslash-3.0.0}/.github/workflows/python-publish.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
 
       - name: Install uv
         uses: astral-sh/setup-uv@v7

{oslash-2.0.0 → oslash-3.0.0}/.github/workflows/release-please.yml

@@ -13,7 +13,7 @@ jobs:
   release-please:
     runs-on: ubuntu-latest
     steps:
-      - uses: googleapis/release-please-action@v4
+      - uses: googleapis/release-please-action@v5
         id: release
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
@@ -21,7 +21,7 @@ jobs:
       # Publish to PyPI when a release is created
       - name: Checkout code
         if: ${{ steps.release.outputs.release_created }}
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Install uv
         if: ${{ steps.release.outputs.release_created }}

{oslash-2.0.0 → oslash-3.0.0}/.pre-commit-config.yaml

@@ -1,10 +1,11 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.5
+    rev: v0.17.4
     hooks:
       - id: ruff
         args: [--fix]
       - id: ruff-format
+        types_or: [python, pyi]
 
   - repo: local
     hooks:
@@ -16,7 +17,7 @@ repos:
         pass_filenames: false
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer

oslash-3.0.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "3.0.0"
+}

{oslash-2.0.0 → oslash-3.0.0}/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [3.0.0](https://github.com/dbrattli/OSlash/compare/oslash-v2.0.0...oslash-v3.0.0) (2026-11-12)
+
+
+### ⚠ BREAKING CHANGES
+
+* align functor and writer factory typing contracts ([#74](https://github.com/dbrattli/OSlash/issues/74))
+* correct public typing contracts ([#67](https://github.com/dbrattli/OSlash/issues/67))
+
+### Features
+
+* add error-accumulating validation ([#68](https://github.com/dbrattli/OSlash/issues/68)) ([cec0c6b](https://github.com/dbrattli/OSlash/commit/cec0c6bcfa1be30dca627e2b031b12b7a53df149))
+
+
+### Bug Fixes
+
+* align functor and writer factory typing contracts ([#74](https://github.com/dbrattli/OSlash/issues/74)) ([f7c7790](https://github.com/dbrattli/OSlash/commit/f7c7790d8f277106726b008c7564e73b5bcf47cd))
+* correct public typing contracts ([#67](https://github.com/dbrattli/OSlash/issues/67)) ([bae0e4d](https://github.com/dbrattli/OSlash/commit/bae0e4da0aa6182f1451b61ed3833aa9cfe4b851))
+* preserve file input when mapping IO actions ([#50](https://github.com/dbrattli/OSlash/issues/50)) ([18000ca](https://github.com/dbrattli/OSlash/commit/18000ca6977fe0e4d8ab3f0a339caa502480f2d4))
+
+
+### Documentation
+
+* align Reader tutorial and API descriptions with current interfaces ([#51](https://github.com/dbrattli/OSlash/issues/51)) ([ce7a93c](https://github.com/dbrattli/OSlash/commit/ce7a93c3e934868ae5d56fb92a0e6031b568b5bf))
+
 ## [2.0.0](https://github.com/dbrattli/OSlash/compare/oslash-v1.0.0...oslash-v2.0.0) (2025-11-17)
 
 

{oslash-2.0.0 → oslash-3.0.0}/CLAUDE.md

@@ -51,8 +51,8 @@ Located in [oslash/typing/](oslash/typing/), these define the "laws" of function
 
 ```python
 @runtime_checkable
-class Functor[T](Protocol):
-    def map[U](self, fn: Callable[[T], U]) -> Functor[U]:
+class Functor[T, U, Result](Protocol):
+    def map(self, fn: Callable[[T], U], /) -> Result:
         """Transform values inside the container."""
         ...
 ```
@@ -65,13 +65,13 @@ class Functor[T](Protocol):
 
 ```python
 @runtime_checkable
-class Applicative[T](Protocol):
-    def apply[U](self, something: Applicative[Callable[[T], U]]) -> Applicative[U]:
+class Applicative[T, Arg, Result](Protocol):
+    def apply(self, something: Arg, /) -> Result:
         """Apply a wrapped function to wrapped values."""
         ...
 
     @classmethod
-    def pure(cls, value: T) -> Self:
+    def pure(cls, value: T, /) -> Applicative[T, Arg, Result]:
         """Wrap a pure value."""
         ...
 ```
@@ -82,13 +82,13 @@ class Applicative[T](Protocol):
 
 ```python
 @runtime_checkable
-class Monad[T](Protocol):
-    def bind[U](self, fn: Callable[[T], Monad[U]]) -> Monad[U]:
+class Monad[T, Result](Protocol):
+    def bind(self, fn: Callable[[T], Result], /) -> Result:
         """Chain computations that produce wrapped values."""
         ...
 
     @classmethod
-    def unit(cls, value: T) -> Self:
+    def unit(cls, value: T, /) -> Monad[T, Result]:
         """Wrap a pure value."""
         ...
 ```
@@ -294,12 +294,12 @@ def compose[T](*funcs: Callable[[T], T]) -> Callable[[T], T]:
 
 identity: Callable[[T], T] = compose()
 
-def fmap[T, U](func: Callable[[T], U], functor: Functor[T]) -> Functor[U]:
-    """Flipped version of map for partial application."""
-    return functor.map(func)
+def fmap[A, B, C](f: Callable[[B], C], g: Callable[[A], B]) -> Callable[[A], C]:
+    """Map a function over a function (function composition)."""
+    return compose(f, g)
 ```
 
-**Note**: Uses 7 `@overload` signatures to provide perfect type inference for 0-7 arguments.
+**Note**: Uses 7 `@overload` signatures for 0-6 arguments.
 
 #### [basic.py](oslash/util/basic.py) - Basic Utilities
 
@@ -328,10 +328,10 @@ succ: Callable[[ChurchNumeral[T]], ChurchNumeral[T]] = ...
 ### [Kleisli Composition](oslash/monadic.py)
 
 ```python
-def compose[A, B, C](
-    f: Callable[[B], Monad[C]],
-    g: Callable[[A], Monad[B]]
-) -> Callable[[A], Monad[C]]:
+def compose[A, B, Result](
+    f: Callable[[B], Result],
+    g: Callable[[A], Monad[B, Result]]
+) -> Callable[[A], Result]:
     """Compose monadic functions."""
     return lambda x: g(x).bind(f)
 ```
@@ -385,7 +385,9 @@ Continuation: TypeAlias = Callable[[T], R]  # T, R must be defined elsewhere
 
 ### When `Any` is Acceptable
 
-We minimize `Any` usage (<10 instances), but it's justified when:
+Keep `Any` at dynamic implementation boundaries and expose precise public types.
+The `apply` overloads, for example, describe unary and two-argument callables
+while their shared implementation accepts both shapes.
 
 1. **Higher-kinded types aren't supported**:
 
@@ -394,21 +396,23 @@ We minimize `Any` usage (<10 instances), but it's justified when:
    type ListSelector[T] = Callable[[T, List[T]], Any]  # Any: Return type varies
    ```
 
-2. **Partial application creates ambiguity**:
+2. **Partial application across callable arities**:
 
    ```python
-   # Partially applied function has complex intermediate type
-   result = partial(func, arg1)  # type: ignore  # Partial: Complex type inference
+   # Public overloads return either U or Callable[[Next], U].
+   # Only the shared implementation handles Callable[..., Any].
+   result = apply_callable(func, arg1)
    ```
 
-3. **Protocol limitations**:
+3. **Protocol implementation boundaries**:
 
    ```python
-   # Protocol can't express "returns same type as receiver"
-   def copy(self) -> Any:  # Any: Protocol limitation, actual type is Self
+   # Keep a type-erased implementation behind precise overloads.
+   def apply(self: Identity[Callable[..., Any]], something: Identity[Any]) -> Identity[Any]:
+       ...
    ```
 
-**Always add inline comment** explaining why:
+Document why `Any` is needed at its implementation boundary:
 
 ```python
 value: Any  # Any: [Brief explanation of why static types insufficient]
@@ -579,14 +583,9 @@ pythonVersion = "3.12"
 3. **Protocol implementation**:
 
    ```python
-   # Ensure all protocol methods are implemented
-   class MyMonad[T](Monad[T]):
-       def bind[U](self, fn: Callable[[T], Monad[U]]) -> Monad[U]:
-           ...  # Must implement
-
-       @classmethod
-       def unit(cls, value: T) -> Self:
-           ...  # Must implement
+   # Check the public structural contract from caller code.
+   value: Monad[int, Identity[str]] = Identity(1)
+   result: Identity[str] = value.bind(lambda x: Identity(str(x)))
    ```
 
 ### Linting and Formatting
@@ -841,8 +840,8 @@ OSlash uses **Protocol** instead of **ABC** for type definitions. Here's why:
 
 ```python
 @runtime_checkable
-class Functor[T](Protocol):
-    def map[U](self, fn: Callable[[T], U]) -> Functor[U]: ...
+class Functor[T, U, Result](Protocol):
+    def map(self, fn: Callable[[T], U], /) -> Result: ...
 
 # Any class with a map method is a Functor - no inheritance needed
 class MyClass[T]:

{oslash-2.0.0 → oslash-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: oslash
-Version: 2.0.0
+Version: 3.0.0
 Summary: Functional library for Functors, Applicatives, and Monads in Python 3.12+
 Project-URL: Homepage, https://github.com/dbrattli/oslash
 Project-URL: Repository, https://github.com/dbrattli/oslash
@@ -56,8 +56,8 @@ Description-Content-Type: text/markdown
 
 OSlash (Ø) is a library for learning and understanding functional programming in Python 3.12+. It re-implements
 concepts from [Learn You a Haskell for Great Good!](http://learnyouahaskell.com/) using Python with modern type annotations. OSlash unifies
-functional and object-oriented paradigms by grouping related functions within classes. Objects are never used
-for storing values or mutable data; data exists only within function closures.
+functional and object-oriented paradigms by grouping related functions within classes. Most monads store wrapped
+values or computations on their instances; the immutable linked list stores its elements within function closures.
 
 ## ✨ What's New in 1.0
 
@@ -71,7 +71,7 @@ for storing values or mutable data; data exists only within function closures.
 **Type Safety**: OSlash is fully type-checked with Pyright in strict mode, providing excellent IDE support and catching errors at development time. It leverages Python 3.12's PEP 695 type parameter syntax for clean, ergonomic generic types.
 
 OSlash is intended to be a tutorial. For practical functional programming in Python in production environments you
-should use [Expression](https://github.com/dbrattli/Expression) instead.
+should consider using [Expression](https://github.com/dbrattli/Expression) instead.
 
 ## Install
 
@@ -85,7 +85,7 @@ uv add oslash
 
 The project currently contains implementations for:
 
-## Abstract Base Classes
+## Protocols
 
 - **[Functor](https://github.com/dbrattli/OSlash/wiki/Functors,-Applicatives,-And-Monads-In-Pictures#functors)**, for stuff that can be mapped
 - **[Applicative](https://github.com/dbrattli/OSlash/wiki/Functors,-Applicatives,-And-Monads-In-Pictures#applicatives)**, for callable stuff
@@ -104,11 +104,63 @@ The project currently contains implementations for:
 - **State**, for stateful computations of stuff
 - **Cont**, for continuation of stuff
 
+## Validation
+
+`Validation` is an applicative for independent checks. `Either` stops at the first
+`Left`, while `Validation.apply` collects errors in argument order. Convert an
+`Either` with `Validation.from_either`; a `Left` becomes a singleton OSlash `List`.
+
+```python
+from oslash import Left, List, Validation, or_else
+
+name = Validation.from_either(Left("name is missing"))
+age = Validation.from_either(Left("age is invalid"))
+result = Validation.pure(lambda name, age: (name, age)).apply(name).apply(age)
+assert result.to_either() == Left(List(["name is missing", "age is invalid"]))
+```
+
+Use `or_else(first, fallback)` for a choice between two `Either` results. It
+keeps the first `Right`; if that fails, it returns the fallback, including its
+error when both fail. Both arguments are evaluated before the call.
+
+## Typing
+
+The concrete classes keep the wrapped result type through `map`, `bind`, and `apply`.
+The structural protocols describe a particular operation and its result container:
+
+```python
+from collections.abc import Callable
+from oslash import Identity
+from oslash.typing import Applicative, Functor, Monad
+
+functor: Functor[int, str, Identity[str]] = Identity(1)
+mapped: Identity[str] = functor.map(str)
+
+monad: Monad[int, Identity[str]] = Identity(1)
+result: Identity[str] = monad.bind(lambda value: Identity(str(value)))
+
+fn: Callable[[int], str] = str
+applicative: Applicative[Callable[[int], str], Identity[int], Identity[str]] = Identity(fn)
+applied: Identity[str] = applicative.apply(Identity(1))
+```
+
+`Monad` now takes the input value type and the concrete bind result type.
+`Applicative` takes the wrapped function type, argument container type, and result container type.
+`Functor[T, U, Result]` takes the input value type, mapped value type, and output container type.
+This replaces the previous `Functor[T]` protocol, which only supported same-type mappings.
+
+`Writer.map` maps the value and keeps its log. Use `Writer.map_with_log` to transform both.
+`Writer.unit(value)` uses a string log; for another log type, pass `empty_log` or use `Writer.create`.
+Factories expose `WriterFactory[Log]`: their `unit(value)` always uses the configured log identity
+and does not accept `empty_log`. For example, `Writer.create("IntWriter", int).unit(1)` returns
+`Writer[int, int]`. Annotate instances as `Writer[T, Log]`, rather than using a dynamic factory
+name such as `StringWriter` as a type. Import `WriterFactory` from `oslash.writer` when needed.
+`apply` has typed overloads for unary and two-argument functions; applying the first argument of a
+two-argument function returns a wrapped one-argument function.
+
 ## Monadic functions
 
 - **>>**, for sequencing monadic actions
-- **lift**, for mapping a function over monadic values
-- **join**, for removing one level of monadic structure
 - **compose**, for composing monadic functions
 
 ## Utility functions

{oslash-2.0.0 → oslash-3.0.0}/README.md

@@ -7,8 +7,8 @@
 
 OSlash (Ø) is a library for learning and understanding functional programming in Python 3.12+. It re-implements
 concepts from [Learn You a Haskell for Great Good!](http://learnyouahaskell.com/) using Python with modern type annotations. OSlash unifies
-functional and object-oriented paradigms by grouping related functions within classes. Objects are never used
-for storing values or mutable data; data exists only within function closures.
+functional and object-oriented paradigms by grouping related functions within classes. Most monads store wrapped
+values or computations on their instances; the immutable linked list stores its elements within function closures.
 
 ## ✨ What's New in 1.0
 
@@ -22,7 +22,7 @@ for storing values or mutable data; data exists only within function closures.
 **Type Safety**: OSlash is fully type-checked with Pyright in strict mode, providing excellent IDE support and catching errors at development time. It leverages Python 3.12's PEP 695 type parameter syntax for clean, ergonomic generic types.
 
 OSlash is intended to be a tutorial. For practical functional programming in Python in production environments you
-should use [Expression](https://github.com/dbrattli/Expression) instead.
+should consider using [Expression](https://github.com/dbrattli/Expression) instead.
 
 ## Install
 
@@ -36,7 +36,7 @@ uv add oslash
 
 The project currently contains implementations for:
 
-## Abstract Base Classes
+## Protocols
 
 - **[Functor](https://github.com/dbrattli/OSlash/wiki/Functors,-Applicatives,-And-Monads-In-Pictures#functors)**, for stuff that can be mapped
 - **[Applicative](https://github.com/dbrattli/OSlash/wiki/Functors,-Applicatives,-And-Monads-In-Pictures#applicatives)**, for callable stuff
@@ -55,11 +55,63 @@ The project currently contains implementations for:
 - **State**, for stateful computations of stuff
 - **Cont**, for continuation of stuff
 
+## Validation
+
+`Validation` is an applicative for independent checks. `Either` stops at the first
+`Left`, while `Validation.apply` collects errors in argument order. Convert an
+`Either` with `Validation.from_either`; a `Left` becomes a singleton OSlash `List`.
+
+```python
+from oslash import Left, List, Validation, or_else
+
+name = Validation.from_either(Left("name is missing"))
+age = Validation.from_either(Left("age is invalid"))
+result = Validation.pure(lambda name, age: (name, age)).apply(name).apply(age)
+assert result.to_either() == Left(List(["name is missing", "age is invalid"]))
+```
+
+Use `or_else(first, fallback)` for a choice between two `Either` results. It
+keeps the first `Right`; if that fails, it returns the fallback, including its
+error when both fail. Both arguments are evaluated before the call.
+
+## Typing
+
+The concrete classes keep the wrapped result type through `map`, `bind`, and `apply`.
+The structural protocols describe a particular operation and its result container:
+
+```python
+from collections.abc import Callable
+from oslash import Identity
+from oslash.typing import Applicative, Functor, Monad
+
+functor: Functor[int, str, Identity[str]] = Identity(1)
+mapped: Identity[str] = functor.map(str)
+
+monad: Monad[int, Identity[str]] = Identity(1)
+result: Identity[str] = monad.bind(lambda value: Identity(str(value)))
+
+fn: Callable[[int], str] = str
+applicative: Applicative[Callable[[int], str], Identity[int], Identity[str]] = Identity(fn)
+applied: Identity[str] = applicative.apply(Identity(1))
+```
+
+`Monad` now takes the input value type and the concrete bind result type.
+`Applicative` takes the wrapped function type, argument container type, and result container type.
+`Functor[T, U, Result]` takes the input value type, mapped value type, and output container type.
+This replaces the previous `Functor[T]` protocol, which only supported same-type mappings.
+
+`Writer.map` maps the value and keeps its log. Use `Writer.map_with_log` to transform both.
+`Writer.unit(value)` uses a string log; for another log type, pass `empty_log` or use `Writer.create`.
+Factories expose `WriterFactory[Log]`: their `unit(value)` always uses the configured log identity
+and does not accept `empty_log`. For example, `Writer.create("IntWriter", int).unit(1)` returns
+`Writer[int, int]`. Annotate instances as `Writer[T, Log]`, rather than using a dynamic factory
+name such as `StringWriter` as a type. Import `WriterFactory` from `oslash.writer` when needed.
+`apply` has typed overloads for unary and two-argument functions; applying the first argument of a
+two-argument function returns a wrapped one-argument function.
+
 ## Monadic functions
 
 - **>>**, for sequencing monadic actions
-- **lift**, for mapping a function over monadic values
-- **join**, for removing one level of monadic structure
 - **compose**, for composing monadic functions
 
 ## Utility functions

oslash-3.0.0/examples/hello.py

@@ -0,0 +1,28 @@
+"""Hello example using bind."""
+
+from oslash import get_line, put_line
+
+main = put_line("What is your name?") | (
+    lambda _: (
+        get_line()
+        | (
+            lambda name: (
+                put_line("What is your age?")
+                | (
+                    lambda _: (
+                        get_line()
+                        | (
+                            lambda age: (
+                                put_line("Hello " + name + "!") | (lambda _: put_line("You are " + age + " years old"))
+                            )
+                        )
+                    )
+                )
+            )
+        )
+    )
+)
+
+if __name__ == "__main__":
+    # print(main)
+    main()

{oslash-2.0.0 → oslash-3.0.0}/notebooks/Reader.ipynb

@@ -10,7 +10,7 @@
     "\n",
     "The Reader is just a fancy name for a wrapped function, so this monad could also be called the Function monad, or perhaps the Callable monad. Reader is all about composing wrapped functions.\n",
     "\n",
-    "This [IPython](http://ipython.org) notebook uses the [OSlash](https://github.com/dbrattli/OSlash) library for Python 3.4, aka Ø. You can install Ø using:\n",
+    "This [IPython](http://ipython.org) notebook uses the [OSlash](https://github.com/dbrattli/OSlash) library for Python 3.12+, aka Ø. You can install Ø using:\n",
     "\n",
     "```bash\n",
     "> pip3 install oslash\n",
@@ -115,7 +115,7 @@
    "source": [
     "## Bind\n",
     "\n",
-    "You can bind a Reader to a monadic function using the pipe `|` operator (The bind operator is called `>>=` in Haskell). A monadic function is a function that takes a value and returns a monad, and in this case it returns a new Reader monad:"
+    "You can bind a Reader to a monadic function using `.bind()` (The bind operator is called `>>=` in Haskell). A monadic function is a function that takes a value and returns a monad, and in this case it returns a new Reader monad:"
    ]
   },
   {
@@ -139,7 +139,7 @@
    "source": [
     "r = Reader(lambda name: f\"Hi {name}!\")\n",
     "\n",
-    "b = r | (lambda x: unit(x.replace(\"Hi\", \"Hello\")))\n",
+    "b = r.bind(lambda x: unit(x.replace(\"Hi\", \"Hello\")))\n",
     "b(\"Dag\")"
    ]
   },
@@ -149,7 +149,7 @@
    "source": [
     "## Applicative\n",
     "\n",
-    "Apply (`*`) is a beefed up `map`. It takes a Reader that has a function in it and another Reader, and extracts that function from the first Reader and then maps it over the second one (basically composes the two functions)."
+    "Apply (`.apply()`) is a beefed up `map`. It takes a Reader that has a function in it and another Reader, and extracts that function from the first Reader and then maps it over the second one (basically composes the two functions)."
    ]
   },
   {
@@ -173,7 +173,7 @@
    "source": [
     "r = Reader(lambda name: f\"Hi {name}!\")\n",
     "\n",
-    "a = Reader.pure(lambda x: x + \"!!!\") * r\n",
+    "a = Reader.pure(lambda x: x + \"!!!\").apply(r)\n",
     "a(\"Dag\")"
    ]
   },
@@ -228,7 +228,7 @@
     }
    ],
    "source": [
-    "r = ask() | (lambda x: unit(f\"Hi {x}!\"))\n",
+    "r = ask().bind(lambda x: unit(f\"Hi {x}!\"))\n",
     "r(\"Dag\")"
    ]
   },
@@ -295,15 +295,15 @@
     "\n",
     "\n",
     "def hello():\n",
-    "    return ask() | (lambda name: unit(\"Hello, \" + name + \"!\"))\n",
+    "    return ask().bind(lambda name: unit(\"Hello, \" + name + \"!\"))\n",
     "\n",
     "\n",
     "def bye():\n",
-    "    return ask() | (lambda name: unit(\"Bye, \" + name + \"!\"))\n",
+    "    return ask().bind(lambda name: unit(\"Bye, \" + name + \"!\"))\n",
     "\n",
     "\n",
     "def convo():\n",
-    "    return hello() | (lambda c1: bye() | (lambda c2: unit(f\"{c1} {c2}\")))\n",
+    "    return hello().bind(lambda c1: bye().bind(lambda c2: unit(f\"{c1} {c2}\")))\n",
     "\n",
     "\n",
     "r = convo()\n",

{oslash-2.0.0 → oslash-3.0.0}/oslash/__init__.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 # Monads
 from .cont import Cont
 from .do import do, guard, let
-from .either import Either, Left, Right
+from .either import Either, Left, Right, or_else
 from .identity import Identity
 from .ioaction import IO, Get, Put, ReadFile, Return, get_line, put_line, read_file
 from .list import List
@@ -23,10 +23,11 @@ from .state import State
 # Protocols
 from .typing import Applicative, Functor, Monad, Monoid
 from .util import Unit, compose, fmap, identity, indent
+from .validation import Validation
 from .writer import MonadWriter, StringWriter, Writer
 
 # Version will be managed by release-please
-__version__ = "2.0.0"
+__version__ = "3.0.0"
 
 __all__ = [
     "IO",
@@ -54,6 +55,7 @@ __all__ = [
     "State",
     "StringWriter",
     "Unit",
+    "Validation",
     "Writer",
     "compose",
     "do",
@@ -64,6 +66,7 @@ __all__ = [
     "indent",
     "let",
     "monadic_compose",
+    "or_else",
     "put_line",
     "read_file",
 ]