Rewrite readme, split example to file

Author: floatdrop

README.md

@@ -19,224 +19,7 @@ A simple, thread-safe debounce library for Go that delays function execution unt
 ## Installation
 
 ```bash
-go get github.com/your-username/debounce
-```
-
-## Quick Start
-
-```go
-package main
-
-import (
-    "fmt"
-    "time"
-    "github.com/your-username/debounce"
-)
-
-func main() {
-    // Create a debounced function with 500ms delay
-    debounced := debounce.New(500 * time.Millisecond)
-    
-    // This will only execute once, after 500ms
-    debounced(func() {
-        fmt.Println("Hello, World!")
-    })
-    
-    debounced(func() {
-        fmt.Println("This will be executed instead")
-    })
-    
-    // Wait for execution
-    time.Sleep(1 * time.Second)
-}
-```
-
-## Usage
-
-### Basic Debouncing
-
-```go
-debounced := debounce.New(200 * time.Millisecond)
-
-// Rapid calls - only the last one executes
-for i := 0; i < 10; i++ {
-    debounced(func() {
-        fmt.Printf("Executed at %v\n", time.Now())
-    })
-    time.Sleep(50 * time.Millisecond) // Less than debounce duration
-}
-```
-
-### Call Limit
-
-Execute immediately after a specified number of calls:
-
-```go
-debounced := debounce.New(
-    1*time.Second,
-    debounce.WithMaxCalls(5),
-)
-
-// Will execute immediately after 5 calls
-for i := 0; i < 10; i++ {
-    debounced(func() {
-        fmt.Printf("Executed after %d calls\n", i+1)
-    })
-}
-```
-
-### Time Limit
-
-Execute immediately after a maximum wait time, regardless of debounce duration:
-
-```go
-debounced := debounce.New(
-    10*time.Second,                    // Long debounce duration
-    debounce.WithMaxWait(2*time.Second), // But execute after 2 seconds max
-)
-
-// Will execute after 2 seconds, not 10
-debounced(func() {
-    fmt.Println("Executed due to time limit")
-})
-```
-
-### Combined Limits
-
-```go
-debounced := debounce.New(
-    5*time.Second,
-    debounce.WithMaxCalls(3),
-    debounce.WithMaxWait(2*time.Second),
-)
-
-// Executes when either:
-// - 3 calls are made, OR
-// - 2 seconds have passed, OR  
-// - 5 seconds pass without new calls
-```
-
-### Real-World Example: Search Input
-
-```go
-package main
-
-import (
-    "fmt"
-    "time"
-    "github.com/your-username/debounce"
-)
-
-func searchAPI(query string) {
-    fmt.Printf("Searching for: %s\n", query)
-    // Simulate API call
-}
-
-func main() {
-    // Debounce search to avoid excessive API calls
-    debouncedSearch := debounce.New(300 * time.Millisecond)
-    
-    // Simulate rapid user typing
-    queries := []string{"h", "he", "hel", "hell", "hello", "hello world"}
-    
-    for _, query := range queries {
-        // Capture query in closure
-        q := query
-        debouncedSearch(func() {
-            searchAPI(q)
-        })
-        time.Sleep(100 * time.Millisecond) // Simulate typing speed
-    }
-    
-    // Wait for final search
-    time.Sleep(500 * time.Millisecond)
-    // Output: Searching for: hello world
-}
-```
-
-## API Reference
-
-### `New(after time.Duration, options ...Option) func(f func())`
-
-Creates a new debounced function.
-
-**Parameters:**
-- `after`: Duration to wait before executing the function
-- `options`: Optional configuration options
-
-**Returns:** A debounced function that accepts a function to execute
-
-### Options
-
-#### `WithMaxCalls(count int) Option`
-
-Sets the maximum number of calls before immediate execution.
-
-- `count`: Maximum number of calls (use -1 for no limit)
-- Default: No limit (-1)
-
-#### `WithMaxWait(limit time.Duration) Option`
-
-Sets the maximum wait time before immediate execution.
-
-- `limit`: Maximum duration to wait
-- Default: No limit
-
-## Behavior
-
-### Function Selection
-When multiple calls are made quickly, only the **last** function provided will be executed:
-
-```go
-debounced := debounce.New(100 * time.Millisecond)
-
-debounced(func() { fmt.Println("First") })
-debounced(func() { fmt.Println("Second") })
-debounced(func() { fmt.Println("Third") })
-
-// Output: Third
-```
-
-### Execution Conditions
-The debounced function executes immediately when any of these conditions are met:
-
-1. **Call limit reached**: Number of calls >= `WithMaxCalls` value
-2. **Time limit reached**: Time elapsed >= `WithMaxWait` value
-3. **Natural debounce**: No new calls for the specified `after` duration
-
-### Reset Behavior
-After execution, all counters and timers are reset:
-
-```go
-debounced := debounce.New(100*time.Millisecond, debounce.WithMaxCalls(2))
-
-// First batch
-debounced(func() { fmt.Println("First execution") })
-debounced(func() { fmt.Println("First execution") }) // Executes immediately
-
-// Second batch - counters are reset
-debounced(func() { fmt.Println("Second execution") })
-debounced(func() { fmt.Println("Second execution") }) // Executes immediately again
-```
-
-## Thread Safety
-
-This library is fully thread-safe and can be used safely across multiple goroutines:
-
-```go
-debounced := debounce.New(100 * time.Millisecond)
-
-var wg sync.WaitGroup
-for i := 0; i < 100; i++ {
-    wg.Add(1)
-    go func(id int) {
-        defer wg.Done()
-        debounced(func() {
-            fmt.Printf("Executed from goroutine %d\n", id)
-        })
-    }(i)
-}
-wg.Wait()
+go get github.com/floatdrop/debounce
 ```
 
 ## Use Cases

debounce.go

@@ -4,10 +4,7 @@
 // Use of this source code is governed by an MIT-style
 // license that can be found in the LICENSE file.
 
-// A simple, thread-safe debounce library for Go that delays function execution until
-// after a specified duration has elapsed since the last invocation.
-// Perfect for rate limiting, reducing redundant operations, and
-// optimizing performance in high-frequency scenarios.
+// Package debounce provides a debouncer func.
 package debounce
 
 import (

example_test.go

@@ -0,0 +1,26 @@
+package debounce_test
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/floatdrop/debounce"
+)
+
+func ExampleNew() {
+	// Create a debounced function with 500ms delay
+	debounced := debounce.New(500 * time.Millisecond)
+
+	// This will only execute once, after 500ms
+	debounced(func() {
+		fmt.Println("Hello, World!")
+	})
+
+	debounced(func() {
+		fmt.Println("This will be executed instead")
+	})
+
+	// Wait for execution
+	time.Sleep(1 * time.Second)
+	// Output: This will be executed instead
+}