Simplify API surface

Author: floatdrop

README.md

@@ -33,19 +33,20 @@ import (
 )
 
 func main() {
-	rc := ringchan.New[string](3)
+	input := make(chan string, 5)
+	ring := ringchan.New(input, 3)
 
 	go func() {
 		inputs := []string{"A", "B", "C", "D", "E"}
 		for _, v := range inputs {
-			rc.In <- v
+			input <- v
 		}
-		rc.Close()
+		close(input)
 	}()
 
 	time.Sleep(50 * time.Millisecond)
 
-	for v := range rc.Out {
+	for v := range ring.C {
 		fmt.Println("Got:", v)
 	}
 

example_test.go

@@ -8,19 +8,20 @@ import (
 )
 
 func ExampleNew() {
-	rc := ringchan.New[string](3)
+	input := make(chan string, 5)
+	ring := ringchan.New(input, 3)
 
 	go func() {
 		inputs := []string{"A", "B", "C", "D", "E"}
 		for _, v := range inputs {
-			rc.In <- v
+			input <- v
 		}
-		rc.Close()
+		close(input)
 	}()
 
 	time.Sleep(50 * time.Millisecond)
 
-	for v := range rc.Out {
+	for v := range ring.C {
 		fmt.Println("Got:", v)
 	}
 

ringchan.go

@@ -1,57 +1,37 @@
 package ringchan
 
 type Ring[T any] struct {
-	in  chan T
-	out chan T
-
-	// In is the channel to send values to.
-	In chan<- T
-	// Out is the channel to receive values from.
-	Out <-chan T
+	// C is the channel to receive values from.
+	C <-chan T
 }
 
-// New creates a ring-buffered channel with fixed capacity.
+// New creates a ring-buffered channel with fixed capacity from incoming channel.
 // When full, new inserts will drop the oldest items to make space.
-func New[T any](capacity int) *Ring[T] {
-	in := make(chan T, capacity)
-	out := make(chan T, capacity)
+func New[T any](in <-chan T, size int) *Ring[T] {
+	out := make(chan T, size)
 
 	rc := &Ring[T]{
-		in:  in,
-		out: out,
-		In:  in,
-		Out: out,
+		C: out,
 	}
 
-	go rc.run()
-	return rc
-}
+	go func() {
+		defer close(out)
 
-func (rc *Ring[T]) run() {
-	defer close(rc.out)
-
-	for v := range rc.in {
-		select {
-		case rc.out <- v:
-		default:
-			// Do non-blocking receive to drop the oldest item
-			// if the buffer is full. This avoids blocking in case of an empty buffer.
+		for v := range in {
 			select {
-			case <-rc.out:
-				rc.out <- v
+			case out <- v:
 			default:
-				rc.out <- v
+				// Do non-blocking receive to drop the oldest item
+				// if the buffer is full. This avoids blocking in case of an empty buffer.
+				select {
+				case <-out:
+					out <- v
+				default:
+					out <- v
+				}
 			}
 		}
-	}
-}
-
-// Len returns the number of items currently in the ring buffer.
-func (rc *Ring[T]) Len() int {
-	return len(rc.out)
-}
+	}()
 
-// Close closes the input channel, ending the ring.
-func (rc *Ring[T]) Close() {
-	close(rc.in)
+	return rc
 }

ringchan_test.go

@@ -6,24 +6,25 @@ import (
 )
 
 func TestRingChanBasic(t *testing.T) {
-	rc := New[int](3)
+	input := make(chan int, 5)
+	rc := New(input, 3)
 
 	go func() {
 		for i := 1; i <= 5; i++ {
-			rc.In <- i
+			input <- i
 		}
-		rc.Close()
+		close(input)
 	}()
 
 	time.Sleep(50 * time.Millisecond)
 
-	l := rc.Len()
+	l := len(rc.C)
 	if l != 3 {
 		t.Fatalf("expected Len()=%v, got %v", 3, l)
 	}
 
 	var got []int
-	for v := range rc.Out {
+	for v := range rc.C {
 		got = append(got, v)
 	}
 
@@ -40,29 +41,31 @@ func TestRingChanBasic(t *testing.T) {
 }
 
 func TestRingChanBlockingReceive(t *testing.T) {
-	rc := New[int](1)
+	input := make(chan int, 1)
+	rc := New(input, 1)
 
 	go func() {
 		time.Sleep(100 * time.Millisecond)
-		rc.In <- 42
-		rc.Close()
+		input <- 42
+		close(input)
 	}()
 
-	val := <-rc.Out
+	val := <-rc.C
 	if val != 42 {
 		t.Errorf("expected 42, got %v", val)
 	}
 }
 
 func TestRingChanRangeAfterClose(t *testing.T) {
-	rc := New[string](2)
+	input := make(chan string, 2)
+	rc := New(input, 2)
 
-	rc.In <- "foo"
-	rc.In <- "bar"
-	rc.Close()
+	input <- "foo"
+	input <- "bar"
+	close(input)
 
 	var results []string
-	for v := range rc.Out {
+	for v := range rc.C {
 		results = append(results, v)
 	}