Add list functions with tests

Author: yitsushi

list/fold.go

@@ -1,5 +1,6 @@
 package list
 
+// FoldlIter is a left-associative fold of a chan.
 func FoldlIter[T any, R any](init R, list <-chan T, fold func(carry R, next T) R) R {
 	for value := range list {
 		init = fold(init, value)
@@ -8,6 +9,7 @@ func FoldlIter[T any, R any](init R, list <-chan T, fold func(carry R, next T) R
 	return init
 }
 
+// Foldl is a left-associative fold of a list.
 func Foldl[T any, R any](init R, list []T, fold func(carry R, next T) R) R {
 	for _, value := range list {
 		init = fold(init, value)
@@ -16,6 +18,7 @@ func Foldl[T any, R any](init R, list []T, fold func(carry R, next T) R) R {
 	return init
 }
 
+// Foldr is a right-associative fold of a list.
 func Foldr[T any, R any](init R, list []T, fold func(carry R, next T) R) R {
 	for idx := len(list) - 1; idx >= 0; idx-- {
 		init = fold(init, list[idx])

list/map.go

@@ -0,0 +1,75 @@
+package list
+
+// Map applies fn function to all elements of the list and returns with the list
+// of the results.
+func Map[T any, R any](list []T, fn func(T) R) []R {
+	result := []R{}
+
+	for _, item := range list {
+		result = append(result, fn(item))
+	}
+
+	return result
+}
+
+// MapIter applies fn function to all elements of a chan and returns with the
+// list of the results.
+func MapIter[T any, R any](list <-chan T, fn func(T) R) []R {
+	result := []R{}
+
+	for item := range list {
+		result = append(result, fn(item))
+	}
+
+	return result
+}
+
+// MapStream applies fn function to all elements of a list and streams back the
+// results in the result chan. Can be cancelled with the cancel function.
+func MapStream[T any, R any](list []T, fn func(T) R) (<-chan R, func()) {
+	result := make(chan R)
+	cancel := make(chan bool)
+	cancelFn := func() { close(cancel) }
+
+	go func() {
+		defer close(result)
+
+		for _, item := range list {
+			select {
+			case <-cancel:
+				return
+			default:
+			}
+
+			result <- fn(item)
+		}
+
+	}()
+
+	return result, cancelFn
+}
+
+// MapIterStream applies fn function to all elements of a chan and streams back
+// the results in the result chan. Can be cancelled with the cancel function.
+func MapIterStream[T any, R any](list <-chan T, fn func(T) R) (<-chan R, func()) {
+	result := make(chan R)
+	cancel := make(chan bool)
+	cancelFn := func() { close(cancel) }
+
+	go func() {
+		defer close(result)
+
+		for item := range list {
+			select {
+			case <-cancel:
+				return
+			default:
+			}
+
+			result <- fn(item)
+		}
+
+	}()
+
+	return result, cancelFn
+}

list/map_test.go

@@ -0,0 +1,70 @@
+package list_test
+
+import (
+	"testing"
+
+	"github.com/go-asset/generics/list"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMap(t *testing.T) {
+	result := list.Map([]int{1, 2, 3}, func(v int) int { return v * 2 })
+
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestMapIter(t *testing.T) {
+	ch := make(chan int)
+
+	go func() {
+		for _, v := range []int{1, 2, 3} {
+			ch <- v
+		}
+
+		close(ch)
+	}()
+
+	result := list.MapIter(ch, func(v int) int { return v * 2 })
+
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestMapStream(t *testing.T) {
+	result, cancel := list.MapStream([]int{1, 2, 3}, func(v int) int {
+		return v * 2
+	})
+	defer cancel()
+
+	endResult := []int{}
+
+	for v := range result {
+		endResult = append(endResult, v)
+	}
+
+	assert.Equal(t, []int{2, 4, 6}, endResult)
+}
+
+func TestMapIterStream(t *testing.T) {
+	ch := make(chan int)
+
+	go func() {
+		for _, v := range []int{1, 2, 3} {
+			ch <- v
+		}
+
+		close(ch)
+	}()
+
+	result, cancel := list.MapIterStream(ch, func(v int) int {
+		return v * 2
+	})
+	defer cancel()
+
+	endResult := []int{}
+
+	for v := range result {
+		endResult = append(endResult, v)
+	}
+
+	assert.Equal(t, []int{2, 4, 6}, endResult)
+}

list/misc.go

@@ -0,0 +1,21 @@
+package list
+
+import "github.com/go-asset/generics/maybe"
+
+// Head extract the first element of a list as a Maybe, if the list is empty
+// it's Nothing.
+//
+// It's categorized as "misc" because it's very limited when it can be useful,
+// one example is chaining function calls with Maybe.
+//
+//     doSomething(FromMaybe(Head(myList), 0))
+//
+// But most of the time, it feels useless. Why implementing it anyway? Because
+// why not. ;)
+func Head[T any](list []T) maybe.Maybe[T] {
+	if len(list) == 0 {
+		return maybe.Nothing[T]()
+	}
+
+	return maybe.Just(list[0])
+}

list/misc_test.go

@@ -0,0 +1,19 @@
+package list_test
+
+import (
+	"testing"
+
+	"github.com/go-asset/generics/list"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHead(t *testing.T) {
+	result := list.Head([]int{})
+
+	assert.True(t, result.IsNothing())
+
+	result = list.Head([]int{1, 2, 3})
+
+	assert.False(t, result.IsNothing())
+	assert.Equal(t, 1, result.Value())
+}

main.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"log"
+	"time"
+
+	"github.com/go-asset/generics/list"
+)
+
+func main() {
+	result, cancel := list.MapStream(
+		[]int{1, 2, 3, 4},
+		func(v int) int {
+			time.Sleep(1 * time.Second)
+			return v * 2
+		},
+	)
+	defer cancel()
+
+	endResult := []int{}
+
+	for v := range result {
+		log.Println(v)
+
+		if v == 4 {
+			cancel()
+		}
+
+		endResult = append(endResult, v)
+	}
+}