punctional 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

punctional/__init__.py

@@ -13,7 +13,7 @@ from .string import ToUpper, ToLower, Contains
 from .list_filters import Map, FilterList, Reduce
 from .monads import Option, Some, Nothing, Result, Ok, Error, some, try_result
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 
 __all__ = [
     # Core

punctional-0.1.1.dist-info/METADATA

@@ -0,0 +1,426 @@
+Metadata-Version: 2.4
+Name: punctional
+Version: 0.1.1
+Summary: A functional programming framework for Python — composable filters, method chaining, and expressive data pipelines with Option and Result monads.
+Project-URL: Homepage, https://github.com/peghaz/punctional
+Project-URL: Repository, https://github.com/peghaz/punctional
+Project-URL: Documentation, https://github.com/peghaz/punctional#readme
+Project-URL: Issues, https://github.com/peghaz/punctional/issues
+Author-email: Mehdi Peghaz <peghaz@example.com>
+License: MIT
+License-File: LICENSE
+Keywords: composition,data-pipeline,filters,functional-programming,method-chaining,monads,option,pipe-operator,result
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Punctional
+
+> Functional programming for Python — monads, composable filters, and expressive data pipelines.
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+## What is Punctional?
+
+**Punctional** brings robust functional programming patterns to Python. It provides:
+
+- **Monads** for safe error handling and null-safety (`Option`, `Result`)
+- **Composable filters** that chain with the pipe (`|`) operator
+- **Functional wrappers** for native types enabling method chaining
+
+No dependencies. Pure Python. Type-safe.
+
+## Installation
+
+```bash
+pip install punctional
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/peghaz/punctional.git
+cd punctional
+pip install -e .
+```
+
+---
+
+## Core Features
+
+### 1. Option Monad — Safe Null Handling
+
+The `Option` type represents a value that may or may not exist. Use `Some` to wrap a value and `Nothing` to represent absence — eliminating `None` checks and `AttributeError` exceptions.
+
+```python
+from punctional import Some, Nothing, some
+
+# Wrap existing values
+user_name = Some("Alice")
+print(user_name.map(str.upper))         # Some('ALICE')
+print(user_name.get_or_else("Unknown")) # 'Alice'
+
+# Handle missing values safely
+missing = Nothing()
+print(missing.map(str.upper))           # Nothing
+print(missing.get_or_else("Unknown"))   # 'Unknown'
+
+# Auto-convert from potentially None values
+def find_user(user_id):
+    return {"alice": "Alice"}.get(user_id)
+
+result = some(find_user("bob"))  # Nothing (because get returns None)
+result = some(find_user("alice"))  # Some('Alice')
+```
+
+**Option Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `map(f)` | Transform the value if present |
+| `flat_map(f)` / `bind(f)` | Chain operations that return `Option` |
+| `filter(predicate)` | Return `Nothing` if predicate fails |
+| `get_or_else(default)` | Get value or return default |
+| `get_or_none()` | Get value or `None` |
+| `or_else(alternative)` | Return alternative `Option` if `Nothing` |
+| `is_some()` / `is_nothing()` | Check presence |
+
+**Chaining with Option:**
+
+```python
+from punctional import Some, Nothing
+
+def parse_int(s: str) -> Option[int]:
+    try:
+        return Some(int(s))
+    except ValueError:
+        return Nothing()
+
+def double(x: int) -> Option[int]:
+    return Some(x * 2)
+
+# Chain operations safely
+result = Some("42").flat_map(parse_int).flat_map(double)  # Some(84)
+result = Some("abc").flat_map(parse_int).flat_map(double) # Nothing
+```
+
+---
+
+### 2. Result Monad — Explicit Error Handling
+
+The `Result` type represents either success (`Ok`) or failure (`Error`). Unlike exceptions, errors are explicit in the type signature and must be handled.
+
+```python
+from punctional import Ok, Error, try_result
+
+# Explicit success and failure
+success = Ok(42)
+failure = Error("Something went wrong")
+
+print(success.map(lambda x: x * 2))  # Ok(84)
+print(failure.map(lambda x: x * 2))  # Error('Something went wrong')
+
+print(success.get_or_else(0))  # 42
+print(failure.get_or_else(0))  # 0
+```
+
+**Wrapping exceptions with `try_result`:**
+
+```python
+from punctional import try_result
+
+def divide(a, b):
+    return a / b
+
+result = try_result(lambda: divide(10, 2))  # Ok(5.0)
+result = try_result(lambda: divide(10, 0))  # Error(ZeroDivisionError(...))
+
+# With custom error handler
+result = try_result(
+    lambda: divide(10, 0),
+    error_handler=lambda e: f"Division failed: {e}"
+)  # Error('Division failed: division by zero')
+```
+
+**Result Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `map(f)` | Transform success value |
+| `map_error(f)` | Transform error value |
+| `flat_map(f)` / `bind(f)` | Chain operations returning `Result` |
+| `get_or_else(default)` | Get value or default |
+| `is_ok()` / `is_error()` | Check success/failure |
+| `to_option()` | Convert to `Option` (discards error info) |
+
+**Railway-oriented programming:**
+
+```python
+from punctional import Result, Ok, Error
+
+def validate_age(age: int) -> Result[int, str]:
+    if age < 0:
+        return Error("Age cannot be negative")
+    if age > 150:
+        return Error("Age seems unrealistic")
+    return Ok(age)
+
+def validate_name(name: str) -> Result[str, str]:
+    if not name.strip():
+        return Error("Name cannot be empty")
+    return Ok(name.strip())
+
+# Chain validations
+age_result = validate_age(25).map(lambda a: f"Age: {a}")     # Ok('Age: 25')
+age_result = validate_age(-5).map(lambda a: f"Age: {a}")     # Error('Age cannot be negative')
+```
+
+---
+
+### 3. Pipe Operator & Filters
+
+Chain transformations using the `|` operator for readable, left-to-right data flow.
+
+```python
+from punctional import fint, fstr, ffloat, Add, Mult, Sub, Div, ToUpper
+
+# Arithmetic chaining
+result = fint(10) | Add(5) | Mult(2) | Sub(3)  # (10 + 5) * 2 - 3 = 27
+
+# String transformations
+text = fstr("hello") | ToUpper() | Add(" WORLD!")  # 'HELLO WORLD!'
+
+# Float operations
+value = ffloat(10.0) | Div(4) | Mult(2)  # 5.0
+```
+
+**Functional Wrappers:**
+
+| Function | Type | Description |
+|----------|------|-------------|
+| `fint(x)` | `FunctionalInt` | Enables piping for integers |
+| `ffloat(x)` | `FunctionalFloat` | Enables piping for floats |
+| `fstr(x)` | `FunctionalStr` | Enables piping for strings |
+
+---
+
+### 4. Built-in Filters
+
+**Arithmetic:**
+```python
+from punctional import fint, Add, Sub, Mult, Div
+
+fint(10) | Add(5)   # 15
+fint(10) | Sub(3)   # 7
+fint(10) | Mult(2)  # 20
+fint(10) | Div(4)   # 2.5
+```
+
+**Comparison:**
+```python
+from punctional import fint, GreaterThan, LessThan, Equals
+
+fint(42) | GreaterThan(10)  # True
+fint(5) | LessThan(10)      # True
+fint(42) | Equals(42)       # True
+```
+
+**Logical:**
+```python
+from punctional import fint, AndFilter, OrFilter, NotFilter, GreaterThan, LessThan
+
+# All conditions must pass
+fint(42) | AndFilter(GreaterThan(10), LessThan(100))  # True
+
+# At least one condition must pass
+fint(5) | OrFilter(LessThan(3), GreaterThan(3))  # True
+
+# Negate a condition
+fint(5) | NotFilter(Equals(0))  # True
+```
+
+**String:**
+```python
+from punctional import fstr, ToUpper, ToLower, Contains, Mult
+
+fstr("hello") | ToUpper()               # 'HELLO'
+fstr("WORLD") | ToLower()               # 'world'
+fstr("hello world") | Contains("world") # True
+fstr("ha") | Mult(3)                    # 'hahaha'
+```
+
+**List Operations:**
+```python
+from punctional import Map, FilterList, Mult, GreaterThan
+
+numbers = [1, 2, 3, 4, 5]
+
+Map(Mult(2)).apply(numbers)              # [2, 4, 6, 8, 10]
+FilterList(GreaterThan(2)).apply(numbers) # [3, 4, 5]
+```
+
+---
+
+### 5. Composition
+
+Create reusable pipelines with `Compose`:
+
+```python
+from punctional import Compose, Mult, Add, fint
+
+# Define a reusable transformation
+double_then_add_ten = Compose(Mult(2), Add(10))
+
+fint(5) | double_then_add_ten   # 20  (5 * 2 + 10)
+fint(10) | double_then_add_ten  # 30  (10 * 2 + 10)
+```
+
+---
+
+### 6. Custom Filters
+
+Create your own filters by extending the `Filter` base class:
+
+```python
+from punctional import Filter, fint
+
+class Square(Filter[int, int]):
+    def apply(self, value: int) -> int:
+        return value ** 2
+
+class Power(Filter[int, int]):
+    def __init__(self, exponent: int):
+        self.exponent = exponent
+    
+    def apply(self, value: int) -> int:
+        return value ** self.exponent
+
+fint(5) | Square()    # 25
+fint(2) | Power(10)   # 1024
+```
+
+---
+
+### 7. Functional Dataclasses
+
+Add the `Functional` mixin to any dataclass to enable piping:
+
+```python
+from dataclasses import dataclass
+from punctional import Functional, Filter
+
+@dataclass
+class Point(Functional):
+    x: float
+    y: float
+
+class Scale(Filter[Point, Point]):
+    def __init__(self, factor: float):
+        self.factor = factor
+    
+    def apply(self, p: Point) -> Point:
+        return Point(p.x * self.factor, p.y * self.factor)
+
+class Translate(Filter[Point, Point]):
+    def __init__(self, dx: float, dy: float):
+        self.dx, self.dy = dx, dy
+    
+    def apply(self, p: Point) -> Point:
+        return Point(p.x + self.dx, p.y + self.dy)
+
+# Chain transformations on custom types
+point = Point(3, 4)
+result = point | Scale(2) | Translate(10, 10)  # Point(16, 18)
+```
+
+---
+
+## Complete API Reference
+
+### Monads
+
+| Type | Description |
+|------|-------------|
+| `Option[T]` | Abstract base for optional values |
+| `Some(value)` | Contains a value |
+| `Nothing()` | Represents absence |
+| `some(value)` | Creates `Some` or `Nothing` based on `None` check |
+| `Result[T, E]` | Abstract base for success/failure |
+| `Ok(value)` | Successful result |
+| `Error(error)` | Failed result |
+| `try_result(fn)` | Wraps a function, catching exceptions as `Error` |
+
+### Filters
+
+| Filter | Input → Output | Description |
+|--------|----------------|-------------|
+| `Add(n)` | `number → number` | Addition |
+| `Sub(n)` | `number → number` | Subtraction |
+| `Mult(n)` | `number → number` | Multiplication |
+| `Div(n)` | `number → number` | Division |
+| `GreaterThan(n)` | `number → bool` | Greater than comparison |
+| `LessThan(n)` | `number → bool` | Less than comparison |
+| `Equals(n)` | `any → bool` | Equality check |
+| `AndFilter(*filters)` | `T → bool` | Logical AND |
+| `OrFilter(*filters)` | `T → bool` | Logical OR |
+| `NotFilter(filter)` | `T → bool` | Logical NOT |
+| `ToUpper()` | `str → str` | Uppercase |
+| `ToLower()` | `str → str` | Lowercase |
+| `Contains(s)` | `str → bool` | Substring check |
+| `Map(filter)` | `list → list` | Apply filter to each element |
+| `FilterList(pred)` | `list → list` | Filter elements by predicate |
+| `Compose(*filters)` | `T → U` | Compose multiple filters |
+
+### Core Classes
+
+| Class | Description |
+|-------|-------------|
+| `Filter[T, U]` | Abstract base class for all filters |
+| `Functional` | Mixin that enables `\|` operator on any class |
+| `FunctionalInt` | Wrapper for `int` with pipe support |
+| `FunctionalFloat` | Wrapper for `float` with pipe support |
+| `FunctionalStr` | Wrapper for `str` with pipe support |
+
+---
+
+## Examples
+
+Run the included examples:
+
+```bash
+python -m examples.basics              # Introduction to all features
+python -m examples.extending           # Creating custom filters
+python -m examples.data_transformation # Real-world patterns
+python -m examples.quick_reference     # Quick lookup cheatsheet
+```
+
+---
+
+## Design Principles
+
+1. **Explicit over implicit** — Errors are values, not exceptions
+2. **Composability** — Small, reusable units that combine easily
+3. **Type safety** — Generics provide IDE support and catch bugs early
+4. **Immutability** — Filters return new values, never mutate
+5. **Zero dependencies** — Pure Python, works everywhere
+
+---
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.
+
+---
+
+<p align="center">
+  Made with ❤️ for functional programming in Python
+</p>

{punctional-0.1.0.dist-info → punctional-0.1.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-punctional/__init__.py,sha256=gylyr0Ij6x97I0vc62JzaoRszhcPUdGqwhHl03ooBKY,1271
+punctional/__init__.py,sha256=0fzsSIiCBnYKBug88xYWHVCWtngDcHIAM_enuqkHmKc,1271
 punctional/arithmetic.py,sha256=TzU5wJqu0olmEyh-TuHIpMH_2mw-EFoDRxmK6kAFbUU,1071
 punctional/comparison.py,sha256=X9SzAXbNXUR5_lmPaZPaTMqM_0zwlvNPb93pcpipogI,850
 punctional/core.py,sha256=g3VuKNpfbIBoNf8OEAUDtc5bLdr-PAbbMwupnkz8wPE,2838
@@ -7,7 +7,7 @@ punctional/logical.py,sha256=3TR0Bgv-SwUjo4o177hHe8YLTr3jG4Kb13GZBGmEb9w,980
 punctional/monads.py,sha256=zDGr7GMhiGc5whNj81lQTDgxfJtBOuh8IuNGpT7gq5g,9739
 punctional/string.py,sha256=E8Ajo7_Rok55_ZNbDFQgCub0VCM4-fW_bUNswyUqDds,607
 punctional/types.py,sha256=gS8Z3XtHKT0dttuGUMFsZWMoiLKuE51cRZMOVVaNKJw,1724
-punctional-0.1.0.dist-info/METADATA,sha256=bht_JYz963a87ZmZVfSFspxfZAwxd67UrhPqFSOFBls,12337
-punctional-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-punctional-0.1.0.dist-info/licenses/LICENSE,sha256=-iDh_gcypGAb576TWRWkMhTMvuAaOML4rZwKV1s8Xoo,1070
-punctional-0.1.0.dist-info/RECORD,,
+punctional-0.1.1.dist-info/METADATA,sha256=LObRFwN3ERvb3uJBYtiinfCbWrR4d6oCq-AJ1A2bnR4,12046
+punctional-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+punctional-0.1.1.dist-info/licenses/LICENSE,sha256=-iDh_gcypGAb576TWRWkMhTMvuAaOML4rZwKV1s8Xoo,1070
+punctional-0.1.1.dist-info/RECORD,,

punctional-0.1.0.dist-info/METADATA

@@ -1,445 +0,0 @@
-Metadata-Version: 2.4
-Name: punctional
-Version: 0.1.0
-Summary: A functional programming framework for Python — composable filters, method chaining, and expressive data pipelines with Option and Result monads.
-Project-URL: Homepage, https://github.com/peghaz/punctional
-Project-URL: Repository, https://github.com/peghaz/punctional
-Project-URL: Documentation, https://github.com/peghaz/punctional#readme
-Project-URL: Issues, https://github.com/peghaz/punctional/issues
-Author-email: Mehdi Peghaz <peghaz@example.com>
-License: MIT
-License-File: LICENSE
-Keywords: composition,data-pipeline,filters,functional-programming,method-chaining,monads,option,pipe-operator,result
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-
-# Punctional
-
-> A functional programming framework for Python — enabling composable filters, method chaining, and expressive data pipelines.
-
-[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
-
-## 🎯 What is Punctional?
-
-**Punctional** is a lightweight functional programming library that brings powerful functional programming patterns to Python. It allows you to compose operations using an intuitive pipe (`|`) operator, create reusable transformation filters, and apply common functional design patterns like Option and Result monads.
-
-Whether you're building data pipelines, validation logic, or just want cleaner, more declarative code — Punctional provides the building blocks.
-
-## ✨ Key Features
-
-- **🔗 Pipe Operator Chaining** — Chain transformations using the intuitive `|` operator
-- **🧱 Composable Filters** — Create reusable, testable transformation units
-- **📦 Functional Wrappers** — Wrap native types (`int`, `float`, `str`) for functional operations
-- **🎭 Monads** — Built-in `Option` (Some/Nothing) and `Result` (Ok/Error) monads
-- **🔧 Extensible** — Easily create custom filters for your domain
-- **📋 Dataclass Support** — Make any dataclass functional with the `Functional` mixin
-
-## 📦 Installation
-
-```bash
-pip install punctional
-```
-
-Or install from source:
-
-```bash
-git clone https://github.com/peghaz/punctional.git
-cd punctional
-pip install -e .
-```
-
-## 🚀 Quick Start
-
-```python
-from punctional import fint, fstr, Add, Mult, ToUpper, GreaterThan, AndFilter, LessThan
-
-# Arithmetic chaining
-result = fint(10) | Add(5) | Mult(2)  # (10 + 5) * 2 = 30
-
-# String transformations
-text = fstr("hello") | ToUpper() | Add("!")  # "HELLO!"
-
-# Logical validation
-is_valid = fint(42) | AndFilter(GreaterThan(10), LessThan(100))  # True
-```
-
-## 📚 Core Concepts
-
-### Filters
-
-A **Filter** is the fundamental building block — a transformation that takes an input and produces an output:
-
-```python
-from punctional import Filter, fint
-
-class Square(Filter[int, int]):
-    def apply(self, value: int) -> int:
-        return value ** 2
-
-# Use it
-result = fint(5) | Square()  # 25
-```
-
-### Functional Wrappers
-
-Wrap native Python types to enable pipe operations:
-
-| Function | Type | Description |
-|----------|------|-------------|
-| `fint(x)` | `FunctionalInt` | Functional integer wrapper |
-| `ffloat(x)` | `FunctionalFloat` | Functional float wrapper |
-| `fstr(x)` | `FunctionalStr` | Functional string wrapper |
-
-### The Pipe Operator
-
-Chain filters using the `|` operator for readable, left-to-right transformations:
-
-```python
-# Instead of nested calls:
-result = Div(4).apply(Sub(3).apply(Mult(2).apply(Add(5).apply(10))))
-
-# Write declaratively:
-result = fint(10) | Add(5) | Mult(2) | Sub(3) | Div(4)
-```
-
-## 🔧 Built-in Filters
-
-### Arithmetic Filters
-
-```python
-from punctional import Add, Sub, Mult, Div
-
-fint(10) | Add(5)   # 15
-fint(10) | Sub(3)   # 7
-fint(10) | Mult(2)  # 20
-fint(10) | Div(4)   # 2.5
-```
-
-### Comparison Filters
-
-```python
-from punctional import GreaterThan, LessThan, Equals
-
-fint(42) | GreaterThan(10)  # True
-fint(5) | LessThan(10)      # True
-fint(42) | Equals(42)       # True
-```
-
-### Logical Filters
-
-```python
-from punctional import AndFilter, OrFilter, NotFilter, GreaterThan, LessThan, Equals
-
-# AND: all conditions must be true
-fint(42) | AndFilter(GreaterThan(10), LessThan(100))  # True
-
-# OR: at least one condition must be true
-fint(5) | OrFilter(LessThan(10), GreaterThan(100))    # True
-
-# NOT: negate a condition
-fint(5) | NotFilter(Equals(0))                        # True
-```
-
-### String Filters
-
-```python
-from punctional import ToUpper, ToLower, Contains, fstr
-
-fstr("hello") | ToUpper()              # "HELLO"
-fstr("WORLD") | ToLower()              # "world"
-fstr("hello world") | Contains("world") # True
-fstr("ha") | Mult(3)                   # "hahaha"
-```
-
-### List Filters
-
-```python
-from punctional import Map, FilterList, Reduce, Mult, GreaterThan
-
-numbers = [1, 2, 3, 4, 5]
-
-# Transform each element
-Map(Mult(2)).apply(numbers)  # [2, 4, 6, 8, 10]
-
-# Filter elements
-FilterList(GreaterThan(2)).apply(numbers)  # [3, 4, 5]
-```
-
-### Composition
-
-Create reusable pipelines with `Compose`:
-
-```python
-from punctional import Compose, Mult, Add, fint
-
-# Create a reusable transformation
-double_plus_ten = Compose(Mult(2), Add(10))
-
-fint(5) | double_plus_ten   # 20
-fint(10) | double_plus_ten  # 30
-```
-
-## 🎭 Functional Design Patterns
-
-### Option Monad (Some/Nothing)
-
-Handle nullable values without explicit `None` checks:
-
-```python
-from punctional import Some, Nothing, some
-
-# Wrap a value
-value = Some(42)
-print(value.map(lambda x: x * 2))  # Some(84)
-print(value.get_or_else(0))        # 42
-
-# Handle absence
-empty = Nothing()
-print(empty.map(lambda x: x * 2))  # Nothing
-print(empty.get_or_else(0))        # 0
-
-# Auto-convert from potentially None values
-result = some(potentially_none_value)  # Returns Nothing if None
-```
-
-#### Option Operations
-
-| Method | Description |
-|--------|-------------|
-| `map(f)` | Transform value if present |
-| `flat_map(f)` | Chain operations returning Option |
-| `bind(f)` | Alias for flat_map |
-| `get_or_else(default)` | Get value or default |
-| `get_or_none()` | Get value or None |
-| `filter(predicate)` | Return Nothing if predicate fails |
-| `or_else(alternative)` | Return alternative if Nothing |
-| `is_some()` | Check if value is present |
-| `is_nothing()` | Check if value is absent |
-
-### Result Monad (Ok/Error)
-
-Handle operations that can fail with meaningful errors:
-
-```python
-from punctional import Ok, Error, try_result
-
-# Successful operation
-success = Ok(42)
-print(success.map(lambda x: x * 2))  # Ok(84)
-
-# Failed operation
-failure = Error("Something went wrong")
-print(failure.map(lambda x: x * 2))  # Error("Something went wrong")
-
-# Wrap potentially throwing functions
-def divide(a, b):
-    return a / b
-
-result = try_result(lambda: divide(10, 0))
-# Error(ZeroDivisionError(...))
-```
-
-#### Result Operations
-
-| Method | Description |
-|--------|-------------|
-| `map(f)` | Transform success value |
-| `map_error(f)` | Transform error value |
-| `flat_map(f)` | Chain operations returning Result |
-| `bind(f)` | Alias for flat_map |
-| `get_or_else(default)` | Get value or default |
-| `is_ok()` | Check if successful |
-| `is_error()` | Check if failed |
-| `to_option()` | Convert to Option (discards error info) |
-
-## 🏗️ Extending the Framework
-
-### Creating Custom Filters
-
-#### Simple Filter
-
-```python
-from punctional import Filter
-
-class Increment(Filter[int, int]):
-    def apply(self, value: int) -> int:
-        return value + 1
-```
-
-#### Parameterized Filter
-
-```python
-class Power(Filter[int, int]):
-    def __init__(self, exponent: int):
-        self.exponent = exponent
-    
-    def apply(self, value: int) -> int:
-        return value ** self.exponent
-
-fint(2) | Power(3)  # 8
-```
-
-#### Stateful Filter
-
-```python
-class Accumulator(Filter[int, int]):
-    def __init__(self, initial: int = 0):
-        self.total = initial
-    
-    def apply(self, value: int) -> int:
-        self.total += value
-        return self.total
-
-acc = Accumulator()
-acc(5)   # 5
-acc(10)  # 15
-acc(3)   # 18
-```
-
-### Functional Dataclasses
-
-Make any dataclass functional with the `Functional` mixin:
-
-```python
-from dataclasses import dataclass
-from punctional import Functional, Filter
-
-@dataclass
-class Point(Functional):
-    x: float
-    y: float
-
-class ScalePoint(Filter[Point, Point]):
-    def __init__(self, factor: float):
-        self.factor = factor
-    
-    def apply(self, point: Point) -> Point:
-        return Point(point.x * self.factor, point.y * self.factor)
-
-# Now Point supports piping!
-point = Point(3, 4)
-scaled = point | ScalePoint(2.5)  # Point(7.5, 10.0)
-```
-
-## 📖 Examples
-
-The [examples/](examples/) directory contains comprehensive examples:
-
-| File | Description |
-|------|-------------|
-| [basics.py](examples/basics.py) | Basic usage and introduction to all features |
-| [extending.py](examples/extending.py) | Guide to creating custom filters and domain-specific extensions |
-| [data_transformation.py](examples/data_transformation.py) | Advanced patterns: validation pipelines, data transformations |
-| [quick_reference.py](examples/quick_reference.py) | Cheat sheet for quick lookup |
-
-### Run the examples:
-
-```bash
-python -m examples.basics
-python -m examples.extending
-python -m examples.data_transformation
-```
-
-## 🧪 Common Patterns
-
-### Validation Pipeline
-
-```python
-from punctional import AndFilter, Functional, Filter
-from dataclasses import dataclass
-
-@dataclass
-class Person(Functional):
-    name: str
-    age: int
-    email: str
-
-class ValidateName(Filter[Person, bool]):
-    def apply(self, person: Person) -> bool:
-        return 1 <= len(person.name) <= 100
-
-class ValidateAge(Filter[Person, bool]):
-    def apply(self, person: Person) -> bool:
-        return 0 <= person.age <= 150
-
-class ValidateEmail(Filter[Person, bool]):
-    def apply(self, person: Person) -> bool:
-        return "@" in person.email and "." in person.email
-
-# Use the validation pipeline
-person = Person("Alice", 30, "alice@example.com")
-is_valid = person | AndFilter(ValidateName(), ValidateAge(), ValidateEmail())  # True
-```
-
-### Data Transformation Pipeline
-
-```python
-class ApplyBonus(Filter[Person, Person]):
-    def __init__(self, percentage: float):
-        self.percentage = percentage
-    
-    def apply(self, person: Person) -> Person:
-        return Person(person.name, person.age, person.email)
-
-person | ApplyBonus(10) | PromoteAge() | SaveToDatabase()
-```
-
-### List Processing Pipeline
-
-```python
-from punctional import FilterList, Map, Mult
-
-class IsEven(Filter[int, bool]):
-    def apply(self, value: int) -> bool:
-        return value % 2 == 0
-
-numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-result = FilterList(IsEven()).apply(numbers)  # [2, 4, 6, 8, 10]
-doubled = Map(Mult(2)).apply(result)          # [4, 8, 12, 16, 20]
-```
-
-### Error Handling with Result
-
-```python
-from punctional import Result, Ok, Error
-
-def fetch_user(id: int) -> Result[dict, str]:
-    if id < 0:
-        return Error("Invalid ID")
-    return Ok({"id": id, "name": "Alice"})
-
-result = fetch_user(42).map(lambda u: u["name"]).get_or_else("Unknown")  # "Alice"
-result = fetch_user(-1).map(lambda u: u["name"]).get_or_else("Unknown")  # "Unknown"
-```
-
-## 🎓 Design Principles
-
-1. **Immutability** — Filters don't modify input; they return new values
-2. **Composability** — Filters can be combined to create complex transformations
-3. **Type Safety** — Generic types help catch errors at development time
-4. **Readability** — Pipe operator makes data flow explicit and easy to follow
-5. **Extensibility** — Easy to create domain-specific filters
-
-## 🤝 Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## 📄 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
----
-
-<p align="center">
-  Made with ❤️ for functional programming enthusiasts
-</p>