feat(v2): generics + typed pipelines

Author: 4thel00z

README.md

@@ -27,14 +27,85 @@ Go already has great error handling, but sometimes you want to express flows as
 
 ## Install
 
-Import the versioned package:
+
+### v2 (default)
+
+**λ v2 is a major rewrite** with generics + typed pipelines.
+
+- Import:
+
+```go
+import λ "github.com/4thel00z/lambda/v2"
+```
+
+- This is a **hard cut**: **no compatibility layer** and **no migration path** from `v1`.
+
+### v1 
+
+Import the default versioned package:
 
 ```go
 import λ "github.com/4thel00z/lambda/v1"
 ```
 
 ## Quickstart
 
+```go
+package main
+
+import (
+	"os"
+
+	λ "github.com/4thel00z/lambda/v2"
+)
+
+func main() {
+	content := λ.Slurp(os.Stdin).String().Must()
+	_ = content
+}
+```
+
+```go
+package main
+
+import (
+	"context"
+	"os"
+
+	λ "github.com/4thel00z/lambda/v2"
+)
+
+func main() {
+	λ.Get("https://example.com").
+		Do(context.Background()).
+		Slurp().
+		WriteToWriter(os.Stdout)
+}
+```
+
+```go
+package main
+
+import (
+	"fmt"
+
+	λ "github.com/4thel00z/lambda/v2"
+)
+
+type MagicSpell struct {
+	Name  string `json:"name"`
+	Power int    `json:"power"`
+}
+
+func main() {
+	spell := λ.FromJSON[MagicSpell](λ.Open("magic.json").Slurp()).Must()
+	fmt.Println(spell.Name, spell.Power)
+}
+```
+
+<details>
+<summary><strong>Show v1 examples</strong></summary>
+
 ### Read all lines from stdin
 
 ```go
@@ -109,11 +180,6 @@ func main() {
 }
 ```
 
-## Examples
-
-<details>
-<summary><strong>Show examples</strong></summary>
-
 ### Functional conditionals
 
 You never need to check an error with an if clause again. Instead you can define the flow as functional chain,
@@ -280,6 +346,14 @@ go run ./example/json
 go run ./example/http
 ```
 
+v2 examples live in `v2/example/`:
+
+```bash
+go run ./v2/example/json
+go run ./v2/example/http
+go run ./v2/example/conditionals
+```
+
 ## Development
 
 ```bash

v2/README.md

@@ -0,0 +1,109 @@
+# λ v2
+
+Functional programming helpers for Go — **typed pipelines** built around `Option[T]`.
+
+Import:
+
+```go
+import λ "github.com/4thel00z/lambda/v2"
+```
+
+## Design notes (v2)
+
+- `Option[T]` holds a value + error.
+- Go does **not** allow methods with their own type parameters, and does **not** allow “specialized methods” on `Option[ConcreteType]`.
+  - Type-changing operations are generic **functions** like `λ.Map`, `λ.Then`, `λ.Try`.
+  - Type-specific fluent pipelines are implemented via small wrapper types like `λ.Bytes`, `λ.Str`, `λ.Req`, `λ.Resp`, `λ.RSAKeys`.
+
+## Quickstart
+
+### Read all stdin
+
+```go
+package main
+
+import (
+	"os"
+	λ "github.com/4thel00z/lambda/v2"
+)
+
+func main() {
+	content := λ.Slurp(os.Stdin).String().Must()
+	_ = content
+}
+```
+
+### Read a file and write to stdout
+
+```go
+package main
+
+import (
+	"os"
+	λ "github.com/4thel00z/lambda/v2"
+)
+
+func main() {
+	λ.Open("lorem_ipsum.txt").Slurp().WriteToWriter(os.Stdout)
+}
+```
+
+### Read JSON into a struct
+
+```go
+package main
+
+import (
+	"fmt"
+	λ "github.com/4thel00z/lambda/v2"
+)
+
+type MagicSpell struct {
+	Name  string `json:"name"`
+	Power int    `json:"power"`
+}
+
+func main() {
+	spell := λ.FromJSON[MagicSpell](λ.Open("magic.json").Slurp()).Must()
+	fmt.Println(spell.Name, spell.Power)
+}
+```
+
+### Simple HTTP request
+
+```go
+package main
+
+import (
+	"context"
+	"os"
+	λ "github.com/4thel00z/lambda/v2"
+)
+
+func main() {
+	λ.Get("https://example.com").
+		Do(context.Background()).
+		Slurp().
+		WriteToWriter(os.Stdout)
+}
+```
+
+### Conditionals (kept, typed)
+
+```go
+package main
+
+import (
+	"errors"
+	λ "github.com/4thel00z/lambda/v2"
+)
+
+func main() {
+	manipulateError := λ.Return(λ.Err[int](errors.New("this error will be thrown")))
+	input := λ.Wrap(0, errors.New("something is weird"))
+	output := λ.If(λ.HasError[int], manipulateError).Else(λ.Identity[int]).Do(input)
+	_ = output
+}
+```
+
+

v2/bytes_string.go

@@ -0,0 +1,103 @@
+package v2
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"strings"
+)
+
+// Bytes is a pipeline wrapper around Option[[]byte].
+type Bytes struct{ Option[[]byte] }
+
+// Str is a pipeline wrapper around Option[string].
+type Str struct{ Option[string] }
+
+// Lines is a pipeline wrapper around Option[[]string].
+type Lines struct{ Option[[]string] }
+
+// Reader is a pipeline wrapper around Option[io.Reader].
+type Reader struct{ Option[io.Reader] }
+
+// ReadCloser is a pipeline wrapper around Option[io.ReadCloser].
+type ReadCloser struct{ Option[io.ReadCloser] }
+
+// WriteCloser is a pipeline wrapper around Option[io.WriteCloser].
+type WriteCloser struct{ Option[io.WriteCloser] }
+
+// BytesOf wraps a raw []byte into a Bytes pipeline.
+func BytesOf(v []byte) Bytes { return Bytes{Ok(v)} }
+
+// StrOf wraps a raw string into a Str pipeline.
+func StrOf(v string) Str { return Str{Ok(v)} }
+
+// LinesOf wraps a raw []string into a Lines pipeline.
+func LinesOf(v []string) Lines { return Lines{Ok(v)} }
+
+// String converts bytes to string.
+func (b Bytes) String() Str {
+	if b.err != nil {
+		return Str{Err[string](b.err)}
+	}
+	return Str{Ok(string(b.v))}
+}
+
+// Bytes converts string to bytes.
+func (s Str) Bytes() Bytes {
+	if s.err != nil {
+		return Bytes{Err[[]byte](s.err)}
+	}
+	return Bytes{Ok([]byte(s.v))}
+}
+
+// Reader converts bytes to an io.Reader.
+func (b Bytes) Reader() Reader {
+	if b.err != nil {
+		return Reader{Err[io.Reader](b.err)}
+	}
+	var r io.Reader = bytes.NewReader(b.v)
+	return Reader{Ok(r)}
+}
+
+// Reader converts string to an io.Reader.
+func (s Str) Reader() Reader {
+	if s.err != nil {
+		return Reader{Err[io.Reader](s.err)}
+	}
+	var r io.Reader = strings.NewReader(s.v)
+	return Reader{Ok(r)}
+}
+
+// ReadAll reads all content from the contained io.Reader.
+func (r Reader) ReadAll() Bytes {
+	if r.err != nil {
+		return Bytes{Err[[]byte](r.err)}
+	}
+	return ReadAll(r.v)
+}
+
+// Slurp reads all content from the contained io.ReadCloser and closes it.
+func (r ReadCloser) Slurp() Bytes {
+	if r.err != nil {
+		return Bytes{Err[[]byte](r.err)}
+	}
+	return Slurp(r.v)
+}
+
+// WriteTo implements io.WriterTo for Bytes.
+func (b Bytes) WriteTo(w io.Writer) (int64, error) {
+	if b.err != nil {
+		return 0, b.err
+	}
+	if w == nil {
+		return 0, errors.New("lambda/v2: nil writer")
+	}
+	n, err := w.Write(b.v)
+	return int64(n), err
+}
+
+// WriteToWriter preserves chain-friendly behavior.
+func (b Bytes) WriteToWriter(w io.Writer) Bytes {
+	_, err := b.WriteTo(w)
+	return Bytes{Wrap(b.v, err)}
+}

v2/bytes_string_test.go

@@ -0,0 +1,22 @@
+package v2
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestBytesStringAndWriteTo(t *testing.T) {
+	var buf bytes.Buffer
+
+	o := BytesOf([]byte("hi"))
+	if o.String().Must() != "hi" {
+		t.Fatalf("String mismatch")
+	}
+	if string(StrOf("hi").Bytes().Must()) != "hi" {
+		t.Fatalf("Bytes mismatch")
+	}
+	n, err := o.WriteTo(&buf)
+	if err != nil || n != 2 || buf.String() != "hi" {
+		t.Fatalf("WriteTo mismatch: n=%d err=%v buf=%q", n, err, buf.String())
+	}
+}