added testable example, updated README

Author: roboslone

README.md

@@ -4,95 +4,6 @@ A way to structure your application modules.
 
 <img width="573" height="435" alt="Screenshot 2025-09-26 at 10 14 57" src="https://github.com/user-attachments/assets/3e67e0f7-dd48-4ca0-98e5-80d216e86749" />
 
-^ Output of internal [tool](https://github.com/roboslone/go-framework/blob/main/.tools/main.go#L13) built on `go-framework`.  
-Linting and testing are done in parallel.
-
-## Example
-
-```go
-// State describes your application, both configuration and runtime.
-// In this example state configures `Interval` for "incrementer" and "printer" modules,
-// and also stores `Counter`, which is modified by "incrementer" and read by "printer".
-type State {
-    // configuration
-    Interval time.Duration
-
-    // runtime
-    Counter int
-}
-
-// CounterIncrementer is a simple module, that increments given `Counter` each `Interval`.
-type CounterIncrementer struct {}
-
-func (*CounterIncrementer) Start(ctx context.Context, s *State) error {
-	go func() {
-		timedLoop(ctx, s.Interval, func() { s.Counter++ })
-	}()
-	return nil
-}
-
-// CounterPrinter is a simple module, that prints given `Counter` each `Interval`.
-// It depends on CounterIncrementer.
-type CounterPrinter struct {}
-
-func (*CounterPrinter) Start(ctx context.Context, s *State) error {
-	go func() {
-		timedLoop(ctx, s.Interval, func() { log.Println(s.Counter) })
-	}()
-	return nil
-}
-
-func (*CounterPrinter) Dependencies(_ context.Context) []string {
-	return []string{
-		"incrementer",
-	}
-}
-
-func timedLoop(ctx context.Context, d time.Duration, fn func()) {
-	ticker := time.NewTicker(d)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			fn()
-		case <-ctx.Done():
-			return
-		}
-	}
-}
-
-// App contains all available modules and their dependencies.
-var App = framework.NewApplication[State](
-    "counter",
-    framework.Modules{
-        "incrementer": &CounterIncrementer{},
-        "printer":     &CounterPrinter{},
-    },
-)
-
-// Prepares and starts both `incrementer` and `printer`.
-App.Run(context.Background(), &State{}, "printer")
-
-// To ensure all your application modules are valid (satisfy at least one module interface):
-func TestApp(t *testing.T) {
-	if err := App.Check(); err != nil {
-		t.Error(err)
-	}
-}
-```
-
-## Module interfaces
-Available interfaces can be found in `module.go`:
-
-```go
-Dependent
-Preparable[State any]
-Startable[State any]
-Awaitable[State any]
-Cleanable[State any]
-```
-
 ## Command line tool
 There's a command line tool for running simple command modules (`framework.CommandModule`).
 
@@ -137,3 +48,14 @@ fexec --help
 #         pre-commit
 #                 depends on lint, test
 ```
+
+## Module interfaces
+Available interfaces can be found in `module.go`:
+
+```go
+Dependent
+Preparable[State any]
+Startable[State any]
+Awaitable[State any]
+Cleanable[State any]
+```

example_test.go

@@ -0,0 +1,90 @@
+package framework_test
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	framework "github.com/roboslone/go-framework"
+)
+
+// ExampleState describes example application, both configuration and runtime.
+type ExampleState struct {
+	// configuration
+	Interval      time.Duration
+	MaxIterations int
+
+	// runtime
+	Channel chan int
+}
+
+// Sender is a simple module, that sends increasing integers to `Channel` each `Interval`.
+type Sender struct{}
+
+func (*Sender) Start(ctx context.Context, s *ExampleState) error {
+	go func() {
+		defer close(s.Channel)
+
+		ticker := time.NewTicker(s.Interval)
+		var i int
+		for {
+			select {
+			case <-ticker.C:
+				s.Channel <- i
+				i++
+
+				if i >= s.MaxIterations {
+					return
+				}
+
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+	return nil
+}
+
+// Receiver is a simple module, that prints values from `Channel`.
+// It depends on Sender.
+type Receiver struct{}
+
+func (*Receiver) Start(ctx context.Context, s *ExampleState) error {
+	for i := range s.Channel {
+		fmt.Println(i)
+	}
+	return nil
+}
+
+func (*Receiver) Dependencies(_ context.Context) []string {
+	return []string{
+		"sender",
+	}
+}
+
+func ExampleApplication() {
+	// app contains all available modules and their dependencies.
+	app := framework.NewApplication[ExampleState](
+		"counter",
+		framework.Modules{
+			"sender":   &Sender{},
+			"receiver": &Receiver{},
+		},
+	)
+
+	state := &ExampleState{
+		Interval:      75 * time.Millisecond,
+		MaxIterations: 3,
+		Channel:       make(chan int),
+	}
+
+	// Ensure each module satisfies at least one module interface.
+	fmt.Println("check error:", app.Check())
+
+	fmt.Println("run error:", app.Run(context.Background(), state, "receiver"))
+	// Output: check error: <nil>
+	// 0
+	// 1
+	// 2
+	// run error: <nil>
+}