From c473e663e86413894962311381c7feed9aa22281 Mon Sep 17 00:00:00 2001 From: Benjamin VAUDOUR Date: Sun, 3 Mar 2024 09:06:29 +0100 Subject: [PATCH] Corrections module collection --- collection/slice.go | 105 ++++++++++++++++++-------------------------- 1 file changed, 43 insertions(+), 62 deletions(-) diff --git a/collection/slice.go b/collection/slice.go index 2e8f168..dbe9e3e 100644 --- a/collection/slice.go +++ b/collection/slice.go @@ -1,5 +1,9 @@ package collection +import ( + "slices" +) + // Slice crée un slice générique contenant les valeurs d’entrée. func Slice[T any](in ...T) (out []any) { out = make([]any, len(in)) @@ -12,41 +16,34 @@ func Slice[T any](in ...T) (out []any) { } // Add ajoute les valeurs d’entrée en fin du slice. -func Add[T any](s *([]T), in ...T) { +func Add[T any, S ~[]T](s *S, in ...T) { *s = append(*s, in...) } // Insert ajoute les valeurs d’entrée en début du slice. -func Insert[T any](s *([]T), in ...T) { - *s = append(in, (*s)...) +func Insert[T any, S ~[]T](s *S, in ...T) { + *s = slices.Insert(*s, 0, in...) } // InsertAt ajoute les valeurs d’entrée à l’index i du slice. // - Si l’index est inférieur à 0, agit comme Insert. // - Si l’index est supérieur ou égal à la taille du slice, agit comme Add. -func InsertAt[T any](s *([]T), i int, in ...T) { +func InsertAt[T any, S ~[]T](s *S, i int, in ...T) { + if i <= 0 { Insert(s, in...) - return } else if i >= len(*s) { Add(s, in...) - return + } else { + *s = slices.Insert(*s, i, in...) } - - l1, l2 := len(*s), len(in) - result := make([]T, l1+l2) - copy(result[:i], (*s)[:i]) - copy(result[i:i+l2], in) - copy(result[i+l2:], (*s)[i:]) - - *s = result } // Diff retourne un slice contenant les entrées de s1 qui ne sont pas dans s2. -func Diff[T comparable](s1, s2 []T) (out []T) { - ss := NewSet(s2...) +func Diff[T comparable, S ~[]T](in1, in2 S) (out S) { + ss := NewSet(in2...) - for _, e := range s1 { + for _, e := range in1 { if !ss.Contains(e) { Add(&out, e) } @@ -56,10 +53,10 @@ func Diff[T comparable](s1, s2 []T) (out []T) { } // Intersect retourne un slice contenant les entrées contenues à la fois dans s1 et s2. -func Intersect[T comparable](s1, s2 []T) (out []T) { - ss := NewSet(s2...) +func Intersect[T comparable, S ~[]T](in1, in2 S) (out S) { + ss := NewSet(in2...) - for _, e := range s1 { + for _, e := range in1 { if ss.Contains(e) { Add(&out, e) } @@ -69,10 +66,10 @@ func Intersect[T comparable](s1, s2 []T) (out []T) { } // Uniq supprime les valeurs redondantes du slice. -func Uniq[T comparable](s []T) (out []T) { +func Uniq[T comparable, S ~[]T](in S) (out S) { ss := NewSet[T]() - for _, e := range s { + for _, e := range in { if !ss.Contains(e) { ss.Add(e) Add(&out, e) @@ -83,49 +80,43 @@ func Uniq[T comparable](s []T) (out []T) { } // AddUniq ajoute les entrées en fin de slice si elles n’existent pas dans le slice. -func AddUniq[T comparable](s *([]T), in ...T) { +func AddUniq[T comparable, S ~[]T](s *S, in ...T) { in2 := Uniq(Diff(in, *s)) Add(s, in2...) } // InsertUniq ajoute les entrées en début de slice si elles n’existent pas dans le slice. -func InsertUniq[T comparable](s *([]T), in ...T) { +func InsertUniq[T comparable, S ~[]T](s *S, in ...T) { in2 := Uniq(Diff(in, *s)) Insert(s, in2...) } // InsertAtUniq ajoute les entrées dans le slice à la position donnée si elles n’existent pas dans le slice. -func InsertAtUniq[T comparable](s *([]T), i int, in ...T) { +func InsertAtUniq[T comparable, S ~[]T](s *S, i int, in ...T) { in2 := Uniq(Diff(in, *s)) InsertAt(s, i, in2...) } // Contains retourne vrai si le slice contient la valeur d’entrée. -func Contains[T comparable](s []T, in T) bool { - for _, e := range s { - if e == in { - return true - } - } - - return false +func Contains[T comparable, S ~[]T](s S, in T) bool { + return slices.Contains(s, in) } // ContainsOneOf retourne vrai si le slice contient une des valeurs d’entrée. -func ContainsOneOf[T comparable](s []T, in ...T) bool { +func ContainsOneOf[T comparable, S ~[]T](s S, in ...T) bool { return NewSet(s...).ContainsOneOf(in...) } // ContainsAll retourne vrai si le slice contient toutes les valeurs d’entrée. -func ContainsAll[T comparable](s []T, in ...T) bool { +func ContainsAll[T comparable, S ~[]T](s S, in ...T) bool { return NewSet(s...).ContainsAll(in...) } // Maps retourne un slice à partir d’un autre slice en appliquant une fonction de transformation pour chaque valeur. -func Maps[T1, T2 any](s []T1, f func(T1) T2) (out []T2) { - out = make([]T2, len(s)) +func Maps[T1, T2 any, S1 ~[]T1, S2 ~[]T2](in S1, f func(T1) T2) (out S2) { + out = make(S2, len(in)) - for i, e := range s { + for i, e := range in { out[i] = f(e) } @@ -133,8 +124,8 @@ func Maps[T1, T2 any](s []T1, f func(T1) T2) (out []T2) { } // Filter retourne un nouveau slice dont les valeurs passent la fonction. -func Filter[T any](s []T, f func(T) bool) (out []T) { - for _, e := range s { +func Filter[T any, S ~[]T](in S, f func(T) bool) (out S) { + for _, e := range in { if f(e) { Add(&out, e) } @@ -144,12 +135,12 @@ func Filter[T any](s []T, f func(T) bool) (out []T) { } // Reduce applique une fonction à tous les éléments dont le résultat sert à la prochaine itération. -func Reduce[T any](s []T, f func(T, T) T, initial ...T) (out T) { +func Reduce[T any, S ~[]T](in S, f func(T, T) T, initial ...T) (out T) { if len(initial) > 0 { out = initial[0] } - for _, e := range s { + for _, e := range in { out = f(out, e) } @@ -157,10 +148,10 @@ func Reduce[T any](s []T, f func(T, T) T, initial ...T) (out T) { } // Reverse inverse l’ordre du slice. -func Reverse[T any](s []T) (out []T) { - l := len(s) - out = make([]T, l) - for i, e := range s { +func Reverse[T any, S ~[]T](in S) (out S) { + l := len(in) + out = make(S, l) + for i, e := range in { out[l-1-i] = e } @@ -168,12 +159,12 @@ func Reverse[T any](s []T) (out []T) { } // Zip retourne une map dont les clés sont les valeurs du premier slice et les valeurs, les valeurs du second. -func Zip[K comparable, V any](s1 []K, s2 []V) (out map[K]V) { +func Zip[K comparable, V any, SK ~[]K, SV ~[]V](keys SK, values SV) (out map[K]V) { out = make(map[K]V) - l := min(len(s1), len(s2)) + l := min(len(keys), len(values)) - for i, k := range s1[:l] { - out[k] = s2[i] + for i, k := range keys[:l] { + out[k] = values[i] } return @@ -190,16 +181,6 @@ func Unzip[K comparable, V any](m map[K]V) (keys []K, values []V) { } // Equal retourne vrai si les slices sont identiques. -func Equal[T comparable](sl1, sl2 []T) bool { - if len(sl1) != len(sl2) { - return false - } - - for i, e1 := range sl1 { - if e1 != sl2[i] { - return false - } - } - - return true +func Equal[T comparable, S ~[]T](s1, s2 S) bool { + return slices.Equal(s1, s2) }