From ad58cfac43455501716e12c7c92e7eb44a0c9b6a Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sun, 22 Sep 2024 15:16:32 +0530
Subject: [PATCH 01/35] slice add length

---
 src/pkg/asserter/Slice.go       | 30 ++++++++++++++++++++++++++
 src/test/asserter/Slice_test.go | 37 +++++++++++++++++++++++++++++++++
 2 files changed, 67 insertions(+)
 create mode 100644 src/pkg/asserter/Slice.go
 create mode 100644 src/test/asserter/Slice_test.go

diff --git a/src/pkg/asserter/Slice.go b/src/pkg/asserter/Slice.go
new file mode 100644
index 0000000..b103e6c
--- /dev/null
+++ b/src/pkg/asserter/Slice.go
@@ -0,0 +1,30 @@
+package asserter
+
+import (
+	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/message"
+	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+)
+
+func NewSlice[T any](a assertion.Assertion, val []T) *Slice[T] {
+	return &Slice[T]{a, val}
+}
+
+type Slice[T any] struct {
+	a assertion.Assertion
+	e []T
+}
+
+func (s *Slice[T]) HasLength(l int) *Slice[T] {
+	if len(s.e) != l {
+		s.a.FailWith(
+			message.Expected().
+				Value(s.e).
+				Verb(verbs.ToHaveLength).
+				Value(l).
+				Verb(verbs.ButWas).
+				Value(len(s.e)),
+		)
+	}
+	return s
+}
diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/Slice_test.go
new file mode 100644
index 0000000..3258bed
--- /dev/null
+++ b/src/test/asserter/Slice_test.go
@@ -0,0 +1,37 @@
+package asserter
+
+import (
+	"github.com/sku0x20/assertG/src/pkg/asserter"
+	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/gRunner/src/pkg/runner"
+	"testing"
+)
+
+func init_Slice(t *testing.T) *assertion.Soft {
+	return assertion.NewSoft(t)
+}
+
+func Test_Slice(t *testing.T) {
+	r := runner.NewTestsRunner(t, init_Slice)
+	r.Add(hasLengthPass_Slice)
+	r.Add(hasLengthFail_Slice)
+	r.Run()
+}
+
+func hasLengthPass_Slice(t *testing.T, s *assertion.Soft) {
+	intS := []int{10}
+	a := asserter.NewSlice(s, intS)
+	a = a.HasLength(1)
+	if s.Failed() {
+		t.Fatalf("should not have failed")
+	}
+}
+
+func hasLengthFail_Slice(t *testing.T, s *assertion.Soft) {
+	intS := []int{10}
+	a := asserter.NewSlice(s, intS)
+	a = a.HasLength(2)
+	if !s.Failed() {
+		t.Fatalf("should have failed")
+	}
+}

From c3c906bb30f83e176d1abe521fe7ef8ae2fbb3ed Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Thu, 26 Sep 2024 14:17:57 +0530
Subject: [PATCH 02/35] add ContainsExactlyInOrder

---
 src/pkg/asserter/Slice.go       | 36 +++++++++++++++++++++++++++++++++
 src/pkg/message/verbs/verbs.go  |  2 ++
 src/test/asserter/Slice_test.go | 24 ++++++++++++++++++++++
 3 files changed, 62 insertions(+)

diff --git a/src/pkg/asserter/Slice.go b/src/pkg/asserter/Slice.go
index b103e6c..95343a0 100644
--- a/src/pkg/asserter/Slice.go
+++ b/src/pkg/asserter/Slice.go
@@ -4,12 +4,27 @@ import (
 	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"reflect"
 )
 
 func NewSlice[T any](a assertion.Assertion, val []T) *Slice[T] {
 	return &Slice[T]{a, val}
 }
 
+type Times string
+type Order string
+
+const (
+	EXACTLY  Times = "EXACTLY"
+	ONCE           = "ONCE"
+	MULTIPLE       = "MULTIPLE"
+)
+
+const (
+	IN_ORDER  Order = "IN_ORDER"
+	ANY_ORDER       = "ANY_ORDER"
+)
+
 type Slice[T any] struct {
 	a assertion.Assertion
 	e []T
@@ -28,3 +43,24 @@ func (s *Slice[T]) HasLength(l int) *Slice[T] {
 	}
 	return s
 }
+
+func (s *Slice[T]) Contains(times Times, order Order, elems ...T) *Slice[T] {
+	switch {
+	case times == EXACTLY && order == IN_ORDER:
+		s.containsExactlyInOrder(elems...)
+	}
+	return s
+}
+
+func (s *Slice[T]) containsExactlyInOrder(elems ...T) {
+	if !reflect.DeepEqual(s.e, elems) {
+		s.a.FailWith(
+			message.Expected().
+				Value(s.e).
+				Verb(verbs.ToContain).
+				Value(elems).
+				Verb(verbs.Exactly).
+				Verb(verbs.InOrder),
+		)
+	}
+}
diff --git a/src/pkg/message/verbs/verbs.go b/src/pkg/message/verbs/verbs.go
index c018cbc..49d8bf8 100644
--- a/src/pkg/message/verbs/verbs.go
+++ b/src/pkg/message/verbs/verbs.go
@@ -12,4 +12,6 @@ const (
 	ButWas       = "ButWas"
 	ToBeTrue     = "ToBeTrue"
 	ToBeFalse    = "ToBeFalse"
+	Exactly      = "Exactly"
+	InOrder      = "InOrder"
 )
diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/Slice_test.go
index 3258bed..80041a5 100644
--- a/src/test/asserter/Slice_test.go
+++ b/src/test/asserter/Slice_test.go
@@ -15,9 +15,33 @@ func Test_Slice(t *testing.T) {
 	r := runner.NewTestsRunner(t, init_Slice)
 	r.Add(hasLengthPass_Slice)
 	r.Add(hasLengthFail_Slice)
+	r.Add(ContainsExactlyInOrder_Slice)
 	r.Run()
 }
 
+func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
+	tests := []struct {
+		e    []int
+		a    []int
+		fail bool
+	}{
+		{[]int{1, 2}, []int{1, 2}, false},
+		{[]int{1, 2}, []int{1, 3}, true},
+		{[]int{1, 2}, []int{1}, true},
+		{[]int{1, 2}, []int{2, 1}, true},
+	}
+	for _, test := range tests {
+		tm.Run("", func(t *testing.T) {
+			s := assertion.NewSoft(t)
+			a := asserter.NewSlice(s, test.e)
+			a = a.Contains(asserter.EXACTLY, asserter.IN_ORDER, test.a...)
+			if s.Failed() != test.fail {
+				t.Fatalf("should have failed = %t", test.fail)
+			}
+		})
+	}
+}
+
 func hasLengthPass_Slice(t *testing.T, s *assertion.Soft) {
 	intS := []int{10}
 	a := asserter.NewSlice(s, intS)

From 685b69978db546fc1bcdb295ca953c2e2a950f83 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Thu, 26 Sep 2024 15:48:52 +0530
Subject: [PATCH 03/35] ContainsExactlyInOrder_Slice: change test input from
 int to struct

---
 src/test/asserter/Slice_test.go | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/Slice_test.go
index 80041a5..ec0fb72 100644
--- a/src/test/asserter/Slice_test.go
+++ b/src/test/asserter/Slice_test.go
@@ -20,20 +20,24 @@ func Test_Slice(t *testing.T) {
 }
 
 func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
+	type s struct {
+		a int
+		b int
+	}
+	e := []*s{{10, 20}, {20, 30}}
 	tests := []struct {
-		e    []int
-		a    []int
+		a    []*s
 		fail bool
 	}{
-		{[]int{1, 2}, []int{1, 2}, false},
-		{[]int{1, 2}, []int{1, 3}, true},
-		{[]int{1, 2}, []int{1}, true},
-		{[]int{1, 2}, []int{2, 1}, true},
+		{[]*s{{10, 20}, {20, 30}}, false},
+		{[]*s{{10, 20}, {20, 10}}, true},
+		{[]*s{{10, 20}}, true},
+		{[]*s{{20, 30}, {10, 20}}, true},
 	}
 	for _, test := range tests {
 		tm.Run("", func(t *testing.T) {
 			s := assertion.NewSoft(t)
-			a := asserter.NewSlice(s, test.e)
+			a := asserter.NewSlice(s, e)
 			a = a.Contains(asserter.EXACTLY, asserter.IN_ORDER, test.a...)
 			if s.Failed() != test.fail {
 				t.Fatalf("should have failed = %t", test.fail)

From edef9130a130e73934758798e643952c2769e1f7 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Thu, 26 Sep 2024 15:58:24 +0530
Subject: [PATCH 04/35] ContainsExactlyInOrder_Slice: change slice of pointers
 to slice of values

---
 src/test/asserter/Slice_test.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/Slice_test.go
index ec0fb72..ef8dd2e 100644
--- a/src/test/asserter/Slice_test.go
+++ b/src/test/asserter/Slice_test.go
@@ -24,15 +24,15 @@ func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 		a int
 		b int
 	}
-	e := []*s{{10, 20}, {20, 30}}
+	e := []s{{10, 20}, {20, 30}}
 	tests := []struct {
-		a    []*s
+		a    []s
 		fail bool
 	}{
-		{[]*s{{10, 20}, {20, 30}}, false},
-		{[]*s{{10, 20}, {20, 10}}, true},
-		{[]*s{{10, 20}}, true},
-		{[]*s{{20, 30}, {10, 20}}, true},
+		{[]s{{10, 20}, {20, 30}}, false},
+		{[]s{{10, 20}, {20, 10}}, true},
+		{[]s{{10, 20}}, true},
+		{[]s{{20, 30}, {10, 20}}, true},
 	}
 	for _, test := range tests {
 		tm.Run("", func(t *testing.T) {

From 092f8266e7f8fabd592de76e9c7d2e38ba3e987c Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Thu, 26 Sep 2024 16:11:45 +0530
Subject: [PATCH 05/35] refactor

---
 src/test/asserter/Slice_test.go | 57 +++++++++++++++++----------------
 1 file changed, 30 insertions(+), 27 deletions(-)

diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/Slice_test.go
index ef8dd2e..b62d853 100644
--- a/src/test/asserter/Slice_test.go
+++ b/src/test/asserter/Slice_test.go
@@ -16,36 +16,10 @@ func Test_Slice(t *testing.T) {
 	r.Add(hasLengthPass_Slice)
 	r.Add(hasLengthFail_Slice)
 	r.Add(ContainsExactlyInOrder_Slice)
+	r.Add(ContainsExactlyAnyOrder_Slice)
 	r.Run()
 }
 
-func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
-	type s struct {
-		a int
-		b int
-	}
-	e := []s{{10, 20}, {20, 30}}
-	tests := []struct {
-		a    []s
-		fail bool
-	}{
-		{[]s{{10, 20}, {20, 30}}, false},
-		{[]s{{10, 20}, {20, 10}}, true},
-		{[]s{{10, 20}}, true},
-		{[]s{{20, 30}, {10, 20}}, true},
-	}
-	for _, test := range tests {
-		tm.Run("", func(t *testing.T) {
-			s := assertion.NewSoft(t)
-			a := asserter.NewSlice(s, e)
-			a = a.Contains(asserter.EXACTLY, asserter.IN_ORDER, test.a...)
-			if s.Failed() != test.fail {
-				t.Fatalf("should have failed = %t", test.fail)
-			}
-		})
-	}
-}
-
 func hasLengthPass_Slice(t *testing.T, s *assertion.Soft) {
 	intS := []int{10}
 	a := asserter.NewSlice(s, intS)
@@ -63,3 +37,32 @@ func hasLengthFail_Slice(t *testing.T, s *assertion.Soft) {
 		t.Fatalf("should have failed")
 	}
 }
+
+type s struct {
+	a int
+	b int
+}
+type test struct {
+	a    []s
+	fail bool
+}
+
+func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
+	e := []s{{10, 20}, {20, 30}}
+	tests := []test{
+		{[]s{{10, 20}, {20, 30}}, false},
+		{[]s{{10, 20}, {20, 10}}, true},
+		{[]s{{10, 20}}, true},
+		{[]s{{20, 30}, {10, 20}}, true},
+	}
+	for _, ct := range tests {
+		tm.Run("", func(t *testing.T) {
+			sa := assertion.NewSoft(t)
+			a := asserter.NewSlice(sa, e)
+			a = a.Contains(asserter.EXACTLY, asserter.IN_ORDER, ct.a...)
+			if sa.Failed() != ct.fail {
+				t.Fatalf("should have failed = %t", ct.fail)
+			}
+		})
+	}
+}

From dfe3a9f677a99219bd196655699b7b9395bfeca8 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Thu, 26 Sep 2024 16:31:31 +0530
Subject: [PATCH 06/35] add ContainsExactlyAnyOrder_Slice

---
 src/pkg/asserter/Slice.go       | 31 +++++++++++++++++++++++++++++++
 src/pkg/message/verbs/verbs.go  |  1 +
 src/test/asserter/Slice_test.go | 20 ++++++++++++++++++++
 3 files changed, 52 insertions(+)

diff --git a/src/pkg/asserter/Slice.go b/src/pkg/asserter/Slice.go
index 95343a0..50fda7b 100644
--- a/src/pkg/asserter/Slice.go
+++ b/src/pkg/asserter/Slice.go
@@ -5,6 +5,7 @@ import (
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
 	"reflect"
+	"slices"
 )
 
 func NewSlice[T any](a assertion.Assertion, val []T) *Slice[T] {
@@ -48,6 +49,8 @@ func (s *Slice[T]) Contains(times Times, order Order, elems ...T) *Slice[T] {
 	switch {
 	case times == EXACTLY && order == IN_ORDER:
 		s.containsExactlyInOrder(elems...)
+	case times == EXACTLY && order == ANY_ORDER:
+		s.containsExactlyInAnyOrder(elems...)
 	}
 	return s
 }
@@ -64,3 +67,31 @@ func (s *Slice[T]) containsExactlyInOrder(elems ...T) {
 		)
 	}
 }
+
+func (s *Slice[T]) containsExactlyInAnyOrder(elems ...T) {
+	if len(s.e) != len(elems) {
+		s.a.FailWith(
+			message.Expected().
+				Value(s.e).
+				Verb(verbs.ToContain).
+				Value(elems).
+				Verb(verbs.Exactly).
+				Verb(verbs.InAnyOrder),
+		)
+		return
+	}
+	for _, e := range elems {
+		if !slices.ContainsFunc(s.e, func(t T) bool {
+			return reflect.DeepEqual(t, e)
+		}) {
+			s.a.FailWith(
+				message.Expected().
+					Value(s.e).
+					Verb(verbs.ToContain).
+					Value(elems).
+					Verb(verbs.Exactly).
+					Verb(verbs.InAnyOrder),
+			)
+		}
+	}
+}
diff --git a/src/pkg/message/verbs/verbs.go b/src/pkg/message/verbs/verbs.go
index 49d8bf8..99a199e 100644
--- a/src/pkg/message/verbs/verbs.go
+++ b/src/pkg/message/verbs/verbs.go
@@ -14,4 +14,5 @@ const (
 	ToBeFalse    = "ToBeFalse"
 	Exactly      = "Exactly"
 	InOrder      = "InOrder"
+	InAnyOrder   = "InAnyOrder"
 )
diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/Slice_test.go
index b62d853..878fabc 100644
--- a/src/test/asserter/Slice_test.go
+++ b/src/test/asserter/Slice_test.go
@@ -66,3 +66,23 @@ func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 		})
 	}
 }
+
+func ContainsExactlyAnyOrder_Slice(tm *testing.T, _ *assertion.Soft) {
+	e := []s{{10, 20}, {20, 30}}
+	tests := []test{
+		{[]s{{10, 20}, {20, 30}}, false},
+		{[]s{{10, 20}, {20, 10}}, true},
+		{[]s{{10, 20}}, true},
+		{[]s{{20, 30}, {10, 20}}, false},
+	}
+	for _, ct := range tests {
+		tm.Run("", func(t *testing.T) {
+			sa := assertion.NewSoft(t)
+			a := asserter.NewSlice(sa, e)
+			a = a.Contains(asserter.EXACTLY, asserter.ANY_ORDER, ct.a...)
+			if sa.Failed() != ct.fail {
+				t.Fatalf("should have failed = %t", ct.fail)
+			}
+		})
+	}
+}

From d03e2b30c0891873b21a8be37f5bb9031613060c Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Thu, 26 Sep 2024 23:34:05 +0530
Subject: [PATCH 07/35] add ContainsOnceInOrder_Slice

---
 src/pkg/asserter/Slice.go       | 46 +++++++++++++++++++++++++++++++++
 src/pkg/message/verbs/verbs.go  |  1 +
 src/test/asserter/Slice_test.go | 45 +++++++++++++++++++++++++-------
 3 files changed, 82 insertions(+), 10 deletions(-)

diff --git a/src/pkg/asserter/Slice.go b/src/pkg/asserter/Slice.go
index 50fda7b..d90ff6e 100644
--- a/src/pkg/asserter/Slice.go
+++ b/src/pkg/asserter/Slice.go
@@ -51,6 +51,8 @@ func (s *Slice[T]) Contains(times Times, order Order, elems ...T) *Slice[T] {
 		s.containsExactlyInOrder(elems...)
 	case times == EXACTLY && order == ANY_ORDER:
 		s.containsExactlyInAnyOrder(elems...)
+	case times == ONCE && order == IN_ORDER:
+		s.containsOnceInOrder(elems...)
 	}
 	return s
 }
@@ -92,6 +94,50 @@ func (s *Slice[T]) containsExactlyInAnyOrder(elems ...T) {
 					Verb(verbs.Exactly).
 					Verb(verbs.InAnyOrder),
 			)
+			return
 		}
 	}
 }
+
+func (s *Slice[T]) containsOnceInOrder(elems ...T) {
+	ei := make([]int, 0)
+	for _, elem := range elems {
+		indexes := allIndex(s.e, func(t T) bool {
+			return reflect.DeepEqual(elem, t)
+		})
+		if len(indexes) != 1 {
+			s.a.FailWith(
+				message.Expected().
+					Value(s.e).
+					Verb(verbs.ToContain).
+					Value(elems).
+					Verb(verbs.Once).
+					Verb(verbs.InAnyOrder),
+			)
+			return
+		}
+		ei = append(ei, indexes[0])
+	}
+	for i := 1; i < len(ei); i++ {
+		if ei[i] < ei[i-1] {
+			s.a.FailWith(
+				message.Expected().
+					Value(s.e).
+					Verb(verbs.ToContain).
+					Value(elems).
+					Verb(verbs.Once).
+					Verb(verbs.InAnyOrder),
+			)
+		}
+	}
+}
+
+func allIndex[T any](s []T, f func(t T) bool) []int {
+	in := make([]int, 0, len(s))
+	for i := range s {
+		if f(s[i]) {
+			in = append(in, i)
+		}
+	}
+	return in
+}
diff --git a/src/pkg/message/verbs/verbs.go b/src/pkg/message/verbs/verbs.go
index 99a199e..4c70b0a 100644
--- a/src/pkg/message/verbs/verbs.go
+++ b/src/pkg/message/verbs/verbs.go
@@ -13,6 +13,7 @@ const (
 	ToBeTrue     = "ToBeTrue"
 	ToBeFalse    = "ToBeFalse"
 	Exactly      = "Exactly"
+	Once         = "Once"
 	InOrder      = "InOrder"
 	InAnyOrder   = "InAnyOrder"
 )
diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/Slice_test.go
index 878fabc..f9993e0 100644
--- a/src/test/asserter/Slice_test.go
+++ b/src/test/asserter/Slice_test.go
@@ -17,6 +17,7 @@ func Test_Slice(t *testing.T) {
 	r.Add(hasLengthFail_Slice)
 	r.Add(ContainsExactlyInOrder_Slice)
 	r.Add(ContainsExactlyAnyOrder_Slice)
+	r.Add(ContainsOnceInOrder_Slice)
 	r.Run()
 }
 
@@ -43,6 +44,7 @@ type s struct {
 	b int
 }
 type test struct {
+	e    []s
 	a    []s
 	fail bool
 }
@@ -50,15 +52,15 @@ type test struct {
 func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 	e := []s{{10, 20}, {20, 30}}
 	tests := []test{
-		{[]s{{10, 20}, {20, 30}}, false},
-		{[]s{{10, 20}, {20, 10}}, true},
-		{[]s{{10, 20}}, true},
-		{[]s{{20, 30}, {10, 20}}, true},
+		{e, []s{{10, 20}, {20, 30}}, false},
+		{e, []s{{10, 20}, {20, 10}}, true},
+		{e, []s{{10, 20}}, true},
+		{e, []s{{20, 30}, {10, 20}}, true},
 	}
 	for _, ct := range tests {
 		tm.Run("", func(t *testing.T) {
 			sa := assertion.NewSoft(t)
-			a := asserter.NewSlice(sa, e)
+			a := asserter.NewSlice(sa, ct.e)
 			a = a.Contains(asserter.EXACTLY, asserter.IN_ORDER, ct.a...)
 			if sa.Failed() != ct.fail {
 				t.Fatalf("should have failed = %t", ct.fail)
@@ -70,15 +72,15 @@ func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 func ContainsExactlyAnyOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 	e := []s{{10, 20}, {20, 30}}
 	tests := []test{
-		{[]s{{10, 20}, {20, 30}}, false},
-		{[]s{{10, 20}, {20, 10}}, true},
-		{[]s{{10, 20}}, true},
-		{[]s{{20, 30}, {10, 20}}, false},
+		{e, []s{{10, 20}, {20, 30}}, false},
+		{e, []s{{10, 20}, {20, 10}}, true},
+		{e, []s{{10, 20}}, true},
+		{e, []s{{20, 30}, {10, 20}}, false},
 	}
 	for _, ct := range tests {
 		tm.Run("", func(t *testing.T) {
 			sa := assertion.NewSoft(t)
-			a := asserter.NewSlice(sa, e)
+			a := asserter.NewSlice(sa, ct.e)
 			a = a.Contains(asserter.EXACTLY, asserter.ANY_ORDER, ct.a...)
 			if sa.Failed() != ct.fail {
 				t.Fatalf("should have failed = %t", ct.fail)
@@ -86,3 +88,26 @@ func ContainsExactlyAnyOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 		})
 	}
 }
+
+func ContainsOnceInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
+	e := []s{{10, 20}, {20, 30}, {30, 40}}
+	tests := []test{
+		{e, []s{{10, 20}, {30, 40}}, false},
+		{e, []s{{10, 20}, {20, 10}}, true},
+		{e, []s{{30, 40}, {10, 20}}, true},
+		{[]s{{10, 20}, {20, 30}, {30, 40}, {30, 40}},
+			[]s{{10, 20}, {30, 40}}, true},
+		{[]s{{10, 20}, {20, 30}, {20, 30}, {30, 40}},
+			[]s{{10, 20}, {30, 40}}, false},
+	}
+	for _, ct := range tests {
+		tm.Run("", func(t *testing.T) {
+			sa := assertion.NewSoft(t)
+			a := asserter.NewSlice(sa, ct.e)
+			a = a.Contains(asserter.ONCE, asserter.IN_ORDER, ct.a...)
+			if sa.Failed() != ct.fail {
+				t.Fatalf("should have failed = %t", ct.fail)
+			}
+		})
+	}
+}

From fa823f87f31e58eec7d0cd97e5808f51940d7bea Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Thu, 26 Sep 2024 23:38:32 +0530
Subject: [PATCH 08/35] refactor Slice

---
 src/pkg/asserter/Slice.go | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/pkg/asserter/Slice.go b/src/pkg/asserter/Slice.go
index d90ff6e..b916812 100644
--- a/src/pkg/asserter/Slice.go
+++ b/src/pkg/asserter/Slice.go
@@ -5,7 +5,6 @@ import (
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
 	"reflect"
-	"slices"
 )
 
 func NewSlice[T any](a assertion.Assertion, val []T) *Slice[T] {
@@ -83,9 +82,7 @@ func (s *Slice[T]) containsExactlyInAnyOrder(elems ...T) {
 		return
 	}
 	for _, e := range elems {
-		if !slices.ContainsFunc(s.e, func(t T) bool {
-			return reflect.DeepEqual(t, e)
-		}) {
+		if len(allIndexDeepEqual(s.e, e)) != 1 {
 			s.a.FailWith(
 				message.Expected().
 					Value(s.e).
@@ -101,10 +98,8 @@ func (s *Slice[T]) containsExactlyInAnyOrder(elems ...T) {
 
 func (s *Slice[T]) containsOnceInOrder(elems ...T) {
 	ei := make([]int, 0)
-	for _, elem := range elems {
-		indexes := allIndex(s.e, func(t T) bool {
-			return reflect.DeepEqual(elem, t)
-		})
+	for _, e := range elems {
+		indexes := allIndexDeepEqual(s.e, e)
 		if len(indexes) != 1 {
 			s.a.FailWith(
 				message.Expected().
@@ -132,6 +127,12 @@ func (s *Slice[T]) containsOnceInOrder(elems ...T) {
 	}
 }
 
+func allIndexDeepEqual[T any](s []T, elem T) []int {
+	return allIndex(s, func(t T) bool {
+		return reflect.DeepEqual(t, elem)
+	})
+}
+
 func allIndex[T any](s []T, f func(t T) bool) []int {
 	in := make([]int, 0, len(s))
 	for i := range s {

From 636b2a5c41845af13f30c76200ad7b1682f7e0ba Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 15:24:13 +0530
Subject: [PATCH 09/35] refactor

---
 src/test/asserter/Slice_test.go | 41 +++++++++++++++------------------
 1 file changed, 19 insertions(+), 22 deletions(-)

diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/Slice_test.go
index f9993e0..6e863a6 100644
--- a/src/test/asserter/Slice_test.go
+++ b/src/test/asserter/Slice_test.go
@@ -18,6 +18,7 @@ func Test_Slice(t *testing.T) {
 	r.Add(ContainsExactlyInOrder_Slice)
 	r.Add(ContainsExactlyAnyOrder_Slice)
 	r.Add(ContainsOnceInOrder_Slice)
+	//r.Add(ContainsOnceAnyOrder_Slice)
 	r.Run()
 }
 
@@ -57,16 +58,9 @@ func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 		{e, []s{{10, 20}}, true},
 		{e, []s{{20, 30}, {10, 20}}, true},
 	}
-	for _, ct := range tests {
-		tm.Run("", func(t *testing.T) {
-			sa := assertion.NewSoft(t)
-			a := asserter.NewSlice(sa, ct.e)
-			a = a.Contains(asserter.EXACTLY, asserter.IN_ORDER, ct.a...)
-			if sa.Failed() != ct.fail {
-				t.Fatalf("should have failed = %t", ct.fail)
-			}
-		})
-	}
+	runTests(tm, tests, func(a *asserter.Slice[s], elem ...s) *asserter.Slice[s] {
+		return a.Contains(asserter.EXACTLY, asserter.IN_ORDER, elem...)
+	})
 }
 
 func ContainsExactlyAnyOrder_Slice(tm *testing.T, _ *assertion.Soft) {
@@ -77,16 +71,9 @@ func ContainsExactlyAnyOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 		{e, []s{{10, 20}}, true},
 		{e, []s{{20, 30}, {10, 20}}, false},
 	}
-	for _, ct := range tests {
-		tm.Run("", func(t *testing.T) {
-			sa := assertion.NewSoft(t)
-			a := asserter.NewSlice(sa, ct.e)
-			a = a.Contains(asserter.EXACTLY, asserter.ANY_ORDER, ct.a...)
-			if sa.Failed() != ct.fail {
-				t.Fatalf("should have failed = %t", ct.fail)
-			}
-		})
-	}
+	runTests(tm, tests, func(a *asserter.Slice[s], elem ...s) *asserter.Slice[s] {
+		return a.Contains(asserter.EXACTLY, asserter.ANY_ORDER, elem...)
+	})
 }
 
 func ContainsOnceInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
@@ -100,11 +87,21 @@ func ContainsOnceInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 		{[]s{{10, 20}, {20, 30}, {20, 30}, {30, 40}},
 			[]s{{10, 20}, {30, 40}}, false},
 	}
+	runTests(tm, tests, func(a *asserter.Slice[s], elem ...s) *asserter.Slice[s] {
+		return a.Contains(asserter.ONCE, asserter.IN_ORDER, elem...)
+	})
+}
+
+func runTests(
+	t *testing.T,
+	tests []test,
+	fnAssertion func(a *asserter.Slice[s], elem ...s) *asserter.Slice[s],
+) {
 	for _, ct := range tests {
-		tm.Run("", func(t *testing.T) {
+		t.Run("", func(t *testing.T) {
 			sa := assertion.NewSoft(t)
 			a := asserter.NewSlice(sa, ct.e)
-			a = a.Contains(asserter.ONCE, asserter.IN_ORDER, ct.a...)
+			a = fnAssertion(a, ct.a...)
 			if sa.Failed() != ct.fail {
 				t.Fatalf("should have failed = %t", ct.fail)
 			}

From 34910654293c272e1675e3c162e6ac0ee0eb3a09 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 16:46:31 +0530
Subject: [PATCH 10/35] tidy

---
 src/test/asserter/{ => slice}/Slice_test.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
 rename src/test/asserter/{ => slice}/Slice_test.go (98%)

diff --git a/src/test/asserter/Slice_test.go b/src/test/asserter/slice/Slice_test.go
similarity index 98%
rename from src/test/asserter/Slice_test.go
rename to src/test/asserter/slice/Slice_test.go
index 6e863a6..9bed226 100644
--- a/src/test/asserter/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -1,4 +1,4 @@
-package asserter
+package slice
 
 import (
 	"github.com/sku0x20/assertG/src/pkg/asserter"
@@ -18,7 +18,6 @@ func Test_Slice(t *testing.T) {
 	r.Add(ContainsExactlyInOrder_Slice)
 	r.Add(ContainsExactlyAnyOrder_Slice)
 	r.Add(ContainsOnceInOrder_Slice)
-	//r.Add(ContainsOnceAnyOrder_Slice)
 	r.Run()
 }
 

From 1b7563336cbee25af9f28ad3c1170766e866b021 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 16:50:24 +0530
Subject: [PATCH 11/35] aligning towards

https://github.com/sku0x20/assertG/issues/1#issuecomment-2780644901
---
 src/test/asserter/slice/Slice_test.go | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index 9bed226..07bf989 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -17,7 +17,6 @@ func Test_Slice(t *testing.T) {
 	r.Add(hasLengthFail_Slice)
 	r.Add(ContainsExactlyInOrder_Slice)
 	r.Add(ContainsExactlyAnyOrder_Slice)
-	r.Add(ContainsOnceInOrder_Slice)
 	r.Run()
 }
 
@@ -75,22 +74,6 @@ func ContainsExactlyAnyOrder_Slice(tm *testing.T, _ *assertion.Soft) {
 	})
 }
 
-func ContainsOnceInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
-	e := []s{{10, 20}, {20, 30}, {30, 40}}
-	tests := []test{
-		{e, []s{{10, 20}, {30, 40}}, false},
-		{e, []s{{10, 20}, {20, 10}}, true},
-		{e, []s{{30, 40}, {10, 20}}, true},
-		{[]s{{10, 20}, {20, 30}, {30, 40}, {30, 40}},
-			[]s{{10, 20}, {30, 40}}, true},
-		{[]s{{10, 20}, {20, 30}, {20, 30}, {30, 40}},
-			[]s{{10, 20}, {30, 40}}, false},
-	}
-	runTests(tm, tests, func(a *asserter.Slice[s], elem ...s) *asserter.Slice[s] {
-		return a.Contains(asserter.ONCE, asserter.IN_ORDER, elem...)
-	})
-}
-
 func runTests(
 	t *testing.T,
 	tests []test,

From 524c20c79a35572795dd758d5cbabb478cc6aa15 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 16:54:28 +0530
Subject: [PATCH 12/35] tiding up

---
 src/test/asserter/slice/Slice_test.go | 29 ++++++++++-----------------
 1 file changed, 11 insertions(+), 18 deletions(-)

diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index 07bf989..024e919 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -7,33 +7,26 @@ import (
 	"testing"
 )
 
-func init_Slice(t *testing.T) *assertion.Soft {
-	return assertion.NewSoft(t)
-}
-
 func Test_Slice(t *testing.T) {
-	r := runner.NewTestsRunner(t, init_Slice)
-	r.Add(hasLengthPass_Slice)
-	r.Add(hasLengthFail_Slice)
-	r.Add(ContainsExactlyInOrder_Slice)
-	r.Add(ContainsExactlyAnyOrder_Slice)
+	r := runner.NewTestsRunnerEmptyInit[any](t)
+	r.Add(hasLength)
+	//r.Add(ContainsExactlyInOrder_Slice)
+	//r.Add(ContainsExactlyAnyOrder_Slice)
 	r.Run()
 }
 
-func hasLengthPass_Slice(t *testing.T, s *assertion.Soft) {
+func hasLength(t *testing.T, _ any) {
 	intS := []int{10}
-	a := asserter.NewSlice(s, intS)
+	sa := assertion.NewSoft(t)
+	a := asserter.NewSlice(sa, intS)
 	a = a.HasLength(1)
-	if s.Failed() {
+	if sa.Failed() {
 		t.Fatalf("should not have failed")
 	}
-}
-
-func hasLengthFail_Slice(t *testing.T, s *assertion.Soft) {
-	intS := []int{10}
-	a := asserter.NewSlice(s, intS)
+	sa = assertion.NewSoft(t)
+	a = asserter.NewSlice(sa, intS)
 	a = a.HasLength(2)
-	if !s.Failed() {
+	if !sa.Failed() {
 		t.Fatalf("should have failed")
 	}
 }

From a2b66ac45846ff5ecdd235e40850ff60f8f0a8d7 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 17:09:56 +0530
Subject: [PATCH 13/35] add todo

---
 src/pkg/asserter/Equator.go | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 src/pkg/asserter/Equator.go

diff --git a/src/pkg/asserter/Equator.go b/src/pkg/asserter/Equator.go
new file mode 100644
index 0000000..14ef125
--- /dev/null
+++ b/src/pkg/asserter/Equator.go
@@ -0,0 +1,3 @@
+package asserter
+
+// todo: extract equalTo interface

From 24ad97fc2389e1f18cf5d4ff963bacf530739ff6 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 17:16:07 +0530
Subject: [PATCH 14/35] add IsEqualTo

---
 src/pkg/asserter/Slice.go             | 128 +++-----------------------
 src/test/asserter/slice/Slice_test.go |  50 ++++------
 2 files changed, 30 insertions(+), 148 deletions(-)

diff --git a/src/pkg/asserter/Slice.go b/src/pkg/asserter/Slice.go
index b916812..3a81499 100644
--- a/src/pkg/asserter/Slice.go
+++ b/src/pkg/asserter/Slice.go
@@ -11,134 +11,34 @@ func NewSlice[T any](a assertion.Assertion, val []T) *Slice[T] {
 	return &Slice[T]{a, val}
 }
 
-type Times string
-type Order string
-
-const (
-	EXACTLY  Times = "EXACTLY"
-	ONCE           = "ONCE"
-	MULTIPLE       = "MULTIPLE"
-)
-
-const (
-	IN_ORDER  Order = "IN_ORDER"
-	ANY_ORDER       = "ANY_ORDER"
-)
-
 type Slice[T any] struct {
-	a assertion.Assertion
-	e []T
+	assertion assertion.Assertion
+	actual    []T
 }
 
 func (s *Slice[T]) HasLength(l int) *Slice[T] {
-	if len(s.e) != l {
-		s.a.FailWith(
+	if len(s.actual) != l {
+		s.assertion.FailWith(
 			message.Expected().
-				Value(s.e).
+				Value(s.actual).
 				Verb(verbs.ToHaveLength).
 				Value(l).
 				Verb(verbs.ButWas).
-				Value(len(s.e)),
+				Value(len(s.actual)),
 		)
 	}
 	return s
 }
 
-func (s *Slice[T]) Contains(times Times, order Order, elems ...T) *Slice[T] {
-	switch {
-	case times == EXACTLY && order == IN_ORDER:
-		s.containsExactlyInOrder(elems...)
-	case times == EXACTLY && order == ANY_ORDER:
-		s.containsExactlyInAnyOrder(elems...)
-	case times == ONCE && order == IN_ORDER:
-		s.containsOnceInOrder(elems...)
-	}
-	return s
-}
-
-func (s *Slice[T]) containsExactlyInOrder(elems ...T) {
-	if !reflect.DeepEqual(s.e, elems) {
-		s.a.FailWith(
+func (s *Slice[T]) IsEqualTo(expected []T) *Slice[T] {
+	s.HasLength(len(expected))
+	if !reflect.DeepEqual(s.actual, expected) {
+		s.assertion.FailWith(
 			message.Expected().
-				Value(s.e).
-				Verb(verbs.ToContain).
-				Value(elems).
-				Verb(verbs.Exactly).
-				Verb(verbs.InOrder),
+				Value(s.actual).
+				Verb(verbs.ToEqual).
+				Value(expected),
 		)
 	}
-}
-
-func (s *Slice[T]) containsExactlyInAnyOrder(elems ...T) {
-	if len(s.e) != len(elems) {
-		s.a.FailWith(
-			message.Expected().
-				Value(s.e).
-				Verb(verbs.ToContain).
-				Value(elems).
-				Verb(verbs.Exactly).
-				Verb(verbs.InAnyOrder),
-		)
-		return
-	}
-	for _, e := range elems {
-		if len(allIndexDeepEqual(s.e, e)) != 1 {
-			s.a.FailWith(
-				message.Expected().
-					Value(s.e).
-					Verb(verbs.ToContain).
-					Value(elems).
-					Verb(verbs.Exactly).
-					Verb(verbs.InAnyOrder),
-			)
-			return
-		}
-	}
-}
-
-func (s *Slice[T]) containsOnceInOrder(elems ...T) {
-	ei := make([]int, 0)
-	for _, e := range elems {
-		indexes := allIndexDeepEqual(s.e, e)
-		if len(indexes) != 1 {
-			s.a.FailWith(
-				message.Expected().
-					Value(s.e).
-					Verb(verbs.ToContain).
-					Value(elems).
-					Verb(verbs.Once).
-					Verb(verbs.InAnyOrder),
-			)
-			return
-		}
-		ei = append(ei, indexes[0])
-	}
-	for i := 1; i < len(ei); i++ {
-		if ei[i] < ei[i-1] {
-			s.a.FailWith(
-				message.Expected().
-					Value(s.e).
-					Verb(verbs.ToContain).
-					Value(elems).
-					Verb(verbs.Once).
-					Verb(verbs.InAnyOrder),
-			)
-		}
-	}
-}
-
-func allIndexDeepEqual[T any](s []T, elem T) []int {
-	return allIndex(s, func(t T) bool {
-		return reflect.DeepEqual(t, elem)
-	})
-}
-
-func allIndex[T any](s []T, f func(t T) bool) []int {
-	in := make([]int, 0, len(s))
-	for i := range s {
-		if f(s[i]) {
-			in = append(in, i)
-		}
-	}
-	return in
+	return s
 }
diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index 024e919..dc90131 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -10,7 +10,7 @@ import (
 func Test_Slice(t *testing.T) {
 	r := runner.NewTestsRunnerEmptyInit[any](t)
 	r.Add(hasLength)
-	//r.Add(ContainsExactlyInOrder_Slice)
+	r.Add(IsEqualTo)
 	//r.Add(ContainsExactlyAnyOrder_Slice)
 	r.Run()
 }
@@ -31,54 +31,36 @@ func hasLength(t *testing.T, _ any) {
 	}
 }
 
-type s struct {
-	a int
-	b int
-}
 type test struct {
-	e    []s
-	a    []s
-	fail bool
-}
-
-func ContainsExactlyInOrder_Slice(tm *testing.T, _ *assertion.Soft) {
-	e := []s{{10, 20}, {20, 30}}
-	tests := []test{
-		{e, []s{{10, 20}, {20, 30}}, false},
-		{e, []s{{10, 20}, {20, 10}}, true},
-		{e, []s{{10, 20}}, true},
-		{e, []s{{20, 30}, {10, 20}}, true},
-	}
-	runTests(tm, tests, func(a *asserter.Slice[s], elem ...s) *asserter.Slice[s] {
-		return a.Contains(asserter.EXACTLY, asserter.IN_ORDER, elem...)
-	})
+	actual     []int
+	expected   []int
+	shouldFail bool
 }
 
-func ContainsExactlyAnyOrder_Slice(tm *testing.T, _ *assertion.Soft) {
-	e := []s{{10, 20}, {20, 30}}
+func IsEqualTo(t *testing.T, _ any) {
 	tests := []test{
-		{e, []s{{10, 20}, {20, 30}}, false},
-		{e, []s{{10, 20}, {20, 10}}, true},
-		{e, []s{{10, 20}}, true},
-		{e, []s{{20, 30}, {10, 20}}, false},
+		{[]int{10, 20, 30}, []int{10}, true},
+		{[]int{10, 20, 30}, []int{10, 20, 30, 40}, true},
+		{[]int{10, 20, 30}, []int{30, 10, 20}, true},
+		{[]int{10, 20, 30}, []int{10, 20, 30}, false},
 	}
-	runTests(tm, tests, func(a *asserter.Slice[s], elem ...s) *asserter.Slice[s] {
-		return a.Contains(asserter.EXACTLY, asserter.ANY_ORDER, elem...)
+	runTests(t, tests, func(a *asserter.Slice[int], expected []int) *asserter.Slice[int] {
+		return a.IsEqualTo(expected)
 	})
 }
 
 func runTests(
 	t *testing.T,
 	tests []test,
-	fnAssertion func(a *asserter.Slice[s], elem ...s) *asserter.Slice[s],
+	fnAssertion func(a *asserter.Slice[int], elem []int) *asserter.Slice[int],
 ) {
 	for _, ct := range tests {
 		t.Run("", func(t *testing.T) {
 			sa := assertion.NewSoft(t)
-			a := asserter.NewSlice(sa, ct.e)
-			a = fnAssertion(a, ct.a...)
-			if sa.Failed() != ct.fail {
-				t.Fatalf("should have failed = %t", ct.fail)
+			a := asserter.NewSlice(sa, ct.actual)
+			a = fnAssertion(a, ct.expected)
+			if sa.Failed() != ct.shouldFail {
+				t.Fatalf("should have failed")
 			}
 		})
 	}

From 464c5c9e0cd2fd97ba027b473445cc7bf0d0ca60 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 17:31:05 +0530
Subject: [PATCH 15/35] add equator

---
 src/pkg/asserter/Equator.go | 3 ---
 src/pkg/equator/Equator.go  | 5 +++++
 2 files changed, 5 insertions(+), 3 deletions(-)
 delete mode 100644 src/pkg/asserter/Equator.go
 create mode 100644 src/pkg/equator/Equator.go

diff --git a/src/pkg/asserter/Equator.go b/src/pkg/asserter/Equator.go
deleted file mode 100644
index 14ef125..0000000
--- a/src/pkg/asserter/Equator.go
+++ /dev/null
@@ -1,3 +0,0 @@
-package asserter
-
-// todo: extract equalTo interface
diff --git a/src/pkg/equator/Equator.go b/src/pkg/equator/Equator.go
new file mode 100644
index 0000000..7b30fd2
--- /dev/null
+++ b/src/pkg/equator/Equator.go
@@ -0,0 +1,5 @@
+package equator
+
+type Equator[T any] interface {
+	compare(a T, b any) bool
+}

From 5c86c0831ab0f0f54636f7547f691a2689bfa2fa Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 17:41:30 +0530
Subject: [PATCH 16/35] add ReflectDeepEquator.g

---
 src/pkg/equator/Equator.go                  |  2 +-
 src/pkg/equator/ReflectDeepEquator.go       | 14 +++++++
 src/test/equator/ReflectDeepEquator_test.go | 42 +++++++++++++++++++++
 3 files changed, 57 insertions(+), 1 deletion(-)
 create mode 100644 src/pkg/equator/ReflectDeepEquator.go
 create mode 100644 src/test/equator/ReflectDeepEquator_test.go

diff --git a/src/pkg/equator/Equator.go b/src/pkg/equator/Equator.go
index 7b30fd2..568913c 100644
--- a/src/pkg/equator/Equator.go
+++ b/src/pkg/equator/Equator.go
@@ -1,5 +1,5 @@
 package equator
 
 type Equator[T any] interface {
-	compare(a T, b any) bool
+	AreEqual(a T, b any) bool
 }
diff --git a/src/pkg/equator/ReflectDeepEquator.go b/src/pkg/equator/ReflectDeepEquator.go
new file mode 100644
index 0000000..fbc8653
--- /dev/null
+++ b/src/pkg/equator/ReflectDeepEquator.go
@@ -0,0 +1,14 @@
+package equator
+
+import "reflect"
+
+type ReflectDeepEquator[T any] struct {
+}
+
+func NewReflectDeepEquator[T any]() *ReflectDeepEquator[T] {
+	return &ReflectDeepEquator[T]{}
+}
+
+func (r *ReflectDeepEquator[T]) AreEqual(a T, b any) bool {
+	return reflect.DeepEqual(a, b)
+}
diff --git a/src/test/equator/ReflectDeepEquator_test.go b/src/test/equator/ReflectDeepEquator_test.go
new file mode 100644
index 0000000..d0dec8c
--- /dev/null
+++ b/src/test/equator/ReflectDeepEquator_test.go
@@ -0,0 +1,42 @@
+package equator
+
+import (
+	"github.com/sku0x20/assertG/src/pkg/equator"
+	"testing"
+)
+
+func Test_ReflectDeepEquator(t *testing.T) {
+	type sa struct {
+		a int
+		b string
+		c []string
+	}
+	a := sa{10, "10", []string{"10"}}
+	a2 := sa{10, "10", []string{"10"}}
+
+	b := struct {
+		a int
+		b string
+		c []string
+	}{10, "10", []string{"20"}}
+
+	c := struct {
+		a int
+		b int
+		c []string
+	}{10, 10, []string{"10"}}
+
+	rde := equator.NewReflectDeepEquator[sa]()
+	if !rde.AreEqual(a, a2) {
+		t.Fatalf("should be equal")
+	}
+	if rde.AreEqual(a, b) {
+		t.Fatalf("should not be equal")
+	}
+	if rde.AreEqual(a, c) {
+		t.Fatalf("should not be equal")
+	}
+	if rde.AreEqual(b, c) {
+		t.Fatalf("should not be equal")
+	}
+}

From 4bec8c5b28893c90aa7b36f06a604ff4fed8ac6c Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 17:47:36 +0530
Subject: [PATCH 17/35] add ComparableEquator.go

---
 src/pkg/equator/ComparableEquator.go       | 12 +++++++++++
 src/test/equator/ComparableEquator_test.go | 25 ++++++++++++++++++++++
 2 files changed, 37 insertions(+)
 create mode 100644 src/pkg/equator/ComparableEquator.go
 create mode 100644 src/test/equator/ComparableEquator_test.go

diff --git a/src/pkg/equator/ComparableEquator.go b/src/pkg/equator/ComparableEquator.go
new file mode 100644
index 0000000..0db0786
--- /dev/null
+++ b/src/pkg/equator/ComparableEquator.go
@@ -0,0 +1,12 @@
+package equator
+
+type ComparableEquator[T comparable] struct {
+}
+
+func NewComparableEquator[T comparable]() *ComparableEquator[T] {
+	return &ComparableEquator[T]{}
+}
+
+func (c *ComparableEquator[T]) AreEqual(a T, b any) bool {
+	return a == b
+}
diff --git a/src/test/equator/ComparableEquator_test.go b/src/test/equator/ComparableEquator_test.go
new file mode 100644
index 0000000..6a0392c
--- /dev/null
+++ b/src/test/equator/ComparableEquator_test.go
@@ -0,0 +1,25 @@
+package equator
+
+import (
+	"github.com/sku0x20/assertG/src/pkg/equator"
+	"testing"
+)
+
+func Test_ComparableEquator(t *testing.T) {
+	a := 10
+	a2 := 10
+
+	b := struct {
+		a int
+		b string
+		c []string
+	}{10, "10", []string{"20"}}
+
+	rde := equator.NewComparableEquator[int]()
+	if !rde.AreEqual(a, a2) {
+		t.Fatalf("should be equal")
+	}
+	if rde.AreEqual(a, b) {
+		t.Fatalf("should not be equal")
+	}
+}

From 783c26977c189829fe170799c577caa429df0d42 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 18:06:53 +0530
Subject: [PATCH 18/35] migrate Any to using the Equator

---
 src/pkg/api/Equal.go          |  5 -----
 src/pkg/assert/any.go         |  5 ++++-
 src/pkg/asserter/Any.go       | 37 ++++++++++++++---------------------
 src/test/api/FakeEqual.go     | 13 ------------
 src/test/asserter/Any_test.go | 33 +++++++++++++++++++------------
 5 files changed, 39 insertions(+), 54 deletions(-)
 delete mode 100644 src/pkg/api/Equal.go
 delete mode 100644 src/test/api/FakeEqual.go

diff --git a/src/pkg/api/Equal.go b/src/pkg/api/Equal.go
deleted file mode 100644
index ebd50e3..0000000
--- a/src/pkg/api/Equal.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package api
-
-type Equal interface {
-	Equal(other any) bool
-}
diff --git a/src/pkg/assert/any.go b/src/pkg/assert/any.go
index 1deca66..f9ef14f 100644
--- a/src/pkg/assert/any.go
+++ b/src/pkg/assert/any.go
@@ -3,12 +3,15 @@ package assert
 import (
 	"github.com/sku0x20/assertG/src/pkg/asserter"
 	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/equator"
 )
 
 func (a *Assert) ThatAny(value any) *asserter.Any {
 	return ThatAny(a.a, value)
 }
 
+// todo: take equator
+
 func ThatAny(a assertion.Assertion, value any) *asserter.Any {
-	return asserter.NewAny(a, value)
+	return asserter.NewAny(a, equator.NewReflectDeepEquator[any](), value)
 }
diff --git a/src/pkg/asserter/Any.go b/src/pkg/asserter/Any.go
index da37eb4..588790a 100644
--- a/src/pkg/asserter/Any.go
+++ b/src/pkg/asserter/Any.go
@@ -1,34 +1,27 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/api"
 	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/equator"
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
-	"reflect"
 )
 
-func NewAny(a assertion.Assertion, value any) *Any {
-	return &Any{a: a, e: value}
+func NewAny(a assertion.Assertion, equator equator.Equator[any], value any) *Any {
+	return &Any{assertion: a, equator: equator, actual: value}
 }
 
 type Any struct {
-	a assertion.Assertion
-	e any
+	assertion assertion.Assertion
+	equator   equator.Equator[any]
+	actual    any
 }
 
 func (a *Any) IsEqualTo(val any) *Any {
-	casted, ok := a.e.(api.Equal)
-	var equal bool
-	if ok {
-		equal = casted.Equal(val)
-	} else {
-		equal = reflect.DeepEqual(a.e, val)
-	}
-	if !equal {
-		a.a.FailWith(
+	if !a.equator.AreEqual(a.actual, val) {
+		a.assertion.FailWith(
 			message.Expected().
-				Value(a.e).
+				Value(a.actual).
 				Verb(verbs.ToEqual).
 				Value(val),
 		)
@@ -37,10 +30,10 @@ func (a *Any) IsEqualTo(val any) *Any {
 }
 
 func (a *Any) IsNil() *Any {
-	if a.e != nil {
-		a.a.FailWith(
+	if a.actual != nil {
+		a.assertion.FailWith(
 			message.Expected().
-				Value(a.e).
+				Value(a.actual).
 				Verb(verbs.ToBeNil),
 		)
 	}
@@ -48,10 +41,10 @@ func (a *Any) IsNil() *Any {
 }
 
 func (a *Any) IsNotNil() *Any {
-	if a.e == nil {
-		a.a.FailWith(
+	if a.actual == nil {
+		a.assertion.FailWith(
 			message.Expected().
-				Value(a.e).
+				Value(a.actual).
 				Verb(verbs.NotToBeNil),
 		)
 	}
diff --git a/src/test/api/FakeEqual.go b/src/test/api/FakeEqual.go
deleted file mode 100644
index 3316634..0000000
--- a/src/test/api/FakeEqual.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package api
-
-func NewFakeEqual(e bool) *FakeEqual {
-	return &FakeEqual{e: e}
-}
-
-type FakeEqual struct {
-	e bool
-}
-
-func (f *FakeEqual) Equal(_ any) bool {
-	return f.e
-}
diff --git a/src/test/asserter/Any_test.go b/src/test/asserter/Any_test.go
index 652ca0d..2158394 100644
--- a/src/test/asserter/Any_test.go
+++ b/src/test/asserter/Any_test.go
@@ -3,7 +3,7 @@ package asserter
 import (
 	"github.com/sku0x20/assertG/src/pkg/asserter"
 	"github.com/sku0x20/assertG/src/pkg/assertion"
-	"github.com/sku0x20/assertG/src/test/api"
+	"github.com/sku0x20/assertG/src/pkg/equator"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
@@ -16,7 +16,7 @@ func Test_Any(t *testing.T) {
 	r := runner.NewTestsRunner[*assertion.Soft](t, init_Any)
 	r.Add(equalFail_Any)
 	r.Add(equalPass_Any)
-	r.Add(implementsEqual_Any)
+	r.Add(customEquator_Any)
 	r.Add(nilPass_Any)
 	r.Add(nilFail_Any)
 	r.Add(notNilPass_Any)
@@ -25,7 +25,7 @@ func Test_Any(t *testing.T) {
 }
 
 func equalFail_Any(t *testing.T, s *assertion.Soft) {
-	a := asserter.NewAny(s, 30)
+	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 30)
 	a = a.IsEqualTo("something")
 	if !s.Failed() {
 		t.Fatalf("should have failed")
@@ -38,23 +38,30 @@ func equalPass_Any(t *testing.T, s *assertion.Soft) {
 	}
 	s1 := "something"
 	s2 := "something"
-	a := asserter.NewAny(s, &st{&s1})
+	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), &st{&s1})
 	a = a.IsEqualTo(&st{&s2})
 	if s.Failed() {
 		t.Fatalf("should not have failed")
 	}
 }
 
-func implementsEqual_Any(t *testing.T, s *assertion.Soft) {
-	a := asserter.NewAny(s, api.NewFakeEqual(false))
-	a = a.IsEqualTo(api.NewFakeEqual(false))
-	if !s.Failed() {
-		t.Fatalf("should have failed")
+type FakeEquator struct {
+}
+
+func (f *FakeEquator) AreEqual(a any, b any) bool {
+	return true
+}
+
+func customEquator_Any(t *testing.T, s *assertion.Soft) {
+	a := asserter.NewAny(s, &FakeEquator{}, 10)
+	a = a.IsEqualTo(20)
+	if s.Failed() {
+		t.Fatalf("should have passed")
 	}
 }
 
 func nilPass_Any(t *testing.T, s *assertion.Soft) {
-	a := asserter.NewAny(s, nil)
+	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), nil)
 	a = a.IsNil()
 	if s.Failed() {
 		t.Fatalf("should not have failed")
@@ -62,7 +69,7 @@ func nilPass_Any(t *testing.T, s *assertion.Soft) {
 }
 
 func nilFail_Any(t *testing.T, s *assertion.Soft) {
-	a := asserter.NewAny(s, 10)
+	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 10)
 	a = a.IsNil()
 	if !s.Failed() {
 		t.Fatalf("should have failed")
@@ -70,7 +77,7 @@ func nilFail_Any(t *testing.T, s *assertion.Soft) {
 }
 
 func notNilPass_Any(t *testing.T, s *assertion.Soft) {
-	a := asserter.NewAny(s, 10)
+	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 10)
 	a = a.IsNotNil()
 	if s.Failed() {
 		t.Fatalf("should not have failed")
@@ -78,7 +85,7 @@ func notNilPass_Any(t *testing.T, s *assertion.Soft) {
 }
 
 func notNilFail_Any(t *testing.T, s *assertion.Soft) {
-	a := asserter.NewAny(s, nil)
+	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), nil)
 	a = a.IsNotNil()
 	if !s.Failed() {
 		t.Fatalf("should have failed")

From 96f3754e2e1ac2287ecca9f330b43e25dccc5c25 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 18:11:35 +0530
Subject: [PATCH 19/35] rename to assert_type

---
 .../HardAssert_test.go}                       | 12 ++++-----
 .../{assertion => assert_type}/utils.go       |  2 +-
 src/pkg/assert/any.go                         |  4 +--
 src/pkg/assert/assert.go                      |  6 ++---
 src/pkg/assert/bool.go                        |  4 +--
 src/pkg/assert/string.go                      |  4 +--
 .../AssertType.go}                            |  4 +--
 src/pkg/assert_type/HardAssert.go             | 18 +++++++++++++
 src/pkg/assert_type/SoftAssert.go             | 25 +++++++++++++++++++
 src/pkg/asserter/Any.go                       |  6 ++---
 src/pkg/asserter/Bool.go                      |  6 ++---
 src/pkg/asserter/Slice.go                     |  6 ++---
 src/pkg/asserter/String.go                    |  6 ++---
 src/pkg/assertion/Hard.go                     | 18 -------------
 src/pkg/assertion/Soft.go                     | 25 -------------------
 src/test/assert/any_test.go                   |  6 ++---
 src/test/assert/assert_test.go                |  4 +--
 src/test/assert/bool_test.go                  |  6 ++---
 src/test/assert/string_test.go                |  6 ++---
 .../SoftAssert_test.go}                       |  6 ++---
 src/test/asserter/Any_test.go                 | 22 ++++++++--------
 src/test/asserter/Bool_test.go                | 14 +++++------
 src/test/asserter/String_test.go              | 22 ++++++++--------
 src/test/asserter/slice/Slice_test.go         |  8 +++---
 src/test/e2e_test.go                          |  6 ++---
 25 files changed, 123 insertions(+), 123 deletions(-)
 rename src/integrationtest/{assertion/Hard_test.go => assert_type/HardAssert_test.go} (75%)
 rename src/integrationtest/{assertion => assert_type}/utils.go (97%)
 rename src/pkg/{assertion/Assertion.go => assert_type/AssertType.go} (64%)
 create mode 100644 src/pkg/assert_type/HardAssert.go
 create mode 100644 src/pkg/assert_type/SoftAssert.go
 delete mode 100644 src/pkg/assertion/Hard.go
 delete mode 100644 src/pkg/assertion/Soft.go
 rename src/test/{assertion/Soft_test.go => assert_type/SoftAssert_test.go} (77%)

diff --git a/src/integrationtest/assertion/Hard_test.go b/src/integrationtest/assert_type/HardAssert_test.go
similarity index 75%
rename from src/integrationtest/assertion/Hard_test.go
rename to src/integrationtest/assert_type/HardAssert_test.go
index 3a0b50a..5ba2f41 100644
--- a/src/integrationtest/assertion/Hard_test.go
+++ b/src/integrationtest/assert_type/HardAssert_test.go
@@ -1,7 +1,7 @@
-package assertion
+package assert_type
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
@@ -33,16 +33,16 @@ func Test_Hard(t *testing.T) {
 }
 
 func hardReal(t *testing.T) {
-	r := runner.NewTestsRunner[*assertion.Hard](t, initE)
+	r := runner.NewTestsRunner[*assert_type.HardAssert](t, initE)
 	r.Add(printsMsg)
 	r.Run()
 }
 
-func initE(t *testing.T) *assertion.Hard {
-	return assertion.NewHard(t)
+func initE(t *testing.T) *assert_type.HardAssert {
+	return assert_type.NewHardAssert(t)
 }
 
-func printsMsg(t *testing.T, h *assertion.Hard) {
+func printsMsg(t *testing.T, h *assert_type.HardAssert) {
 	msg := message.Expected().
 		Verb(verbs.ToBeNil)
 	h.FailWith(msg)
diff --git a/src/integrationtest/assertion/utils.go b/src/integrationtest/assert_type/utils.go
similarity index 97%
rename from src/integrationtest/assertion/utils.go
rename to src/integrationtest/assert_type/utils.go
index 5d25705..65aaa97 100644
--- a/src/integrationtest/assertion/utils.go
+++ b/src/integrationtest/assert_type/utils.go
@@ -1,4 +1,4 @@
-package assertion
+package assert_type
 
 import (
 	"os"
diff --git a/src/pkg/assert/any.go b/src/pkg/assert/any.go
index f9ef14f..0274c98 100644
--- a/src/pkg/assert/any.go
+++ b/src/pkg/assert/any.go
@@ -1,8 +1,8 @@
 package assert
 
 import (
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/assertG/src/pkg/equator"
 )
 
@@ -12,6 +12,6 @@ func (a *Assert) ThatAny(value any) *asserter.Any {
 
 // todo: take equator
 
-func ThatAny(a assertion.Assertion, value any) *asserter.Any {
+func ThatAny(a assert_type.AssertType, value any) *asserter.Any {
 	return asserter.NewAny(a, equator.NewReflectDeepEquator[any](), value)
 }
diff --git a/src/pkg/assert/assert.go b/src/pkg/assert/assert.go
index 08ff5d4..1981629 100644
--- a/src/pkg/assert/assert.go
+++ b/src/pkg/assert/assert.go
@@ -1,11 +1,11 @@
 package assert
 
-import "github.com/sku0x20/assertG/src/pkg/assertion"
+import "github.com/sku0x20/assertG/src/pkg/assert_type"
 
-func NewAssert(a assertion.Assertion) *Assert {
+func NewAssert(a assert_type.AssertType) *Assert {
 	return &Assert{a: a}
 }
 
 type Assert struct {
-	a assertion.Assertion
+	a assert_type.AssertType
 }
diff --git a/src/pkg/assert/bool.go b/src/pkg/assert/bool.go
index bfcf496..d50a4b2 100644
--- a/src/pkg/assert/bool.go
+++ b/src/pkg/assert/bool.go
@@ -1,14 +1,14 @@
 package assert
 
 import (
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 )
 
 func (a *Assert) ThatBool(val bool) *asserter.Bool {
 	return ThatBool(a.a, val)
 }
 
-func ThatBool(a assertion.Assertion, val bool) *asserter.Bool {
+func ThatBool(a assert_type.AssertType, val bool) *asserter.Bool {
 	return asserter.NewBool(a, val)
 }
diff --git a/src/pkg/assert/string.go b/src/pkg/assert/string.go
index b7a361d..6b8a2b4 100644
--- a/src/pkg/assert/string.go
+++ b/src/pkg/assert/string.go
@@ -1,14 +1,14 @@
 package assert
 
 import (
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 )
 
 func (a *Assert) ThatString(value string) *asserter.String {
 	return ThatString(a.a, value)
 }
 
-func ThatString(a assertion.Assertion, value string) *asserter.String {
+func ThatString(a assert_type.AssertType, value string) *asserter.String {
 	return asserter.NewString(a, value)
 }
diff --git a/src/pkg/assertion/Assertion.go b/src/pkg/assert_type/AssertType.go
similarity index 64%
rename from src/pkg/assertion/Assertion.go
rename to src/pkg/assert_type/AssertType.go
index 9b06060..986866f 100644
--- a/src/pkg/assertion/Assertion.go
+++ b/src/pkg/assert_type/AssertType.go
@@ -1,7 +1,7 @@
-package assertion
+package assert_type
 
 import "github.com/sku0x20/assertG/src/pkg/message"
 
-type Assertion interface {
+type AssertType interface {
 	FailWith(msg *message.Message)
 }
diff --git a/src/pkg/assert_type/HardAssert.go b/src/pkg/assert_type/HardAssert.go
new file mode 100644
index 0000000..25fa237
--- /dev/null
+++ b/src/pkg/assert_type/HardAssert.go
@@ -0,0 +1,18 @@
+package assert_type
+
+import (
+	"github.com/sku0x20/assertG/src/pkg/message"
+	"testing"
+)
+
+func NewHardAssert(t *testing.T) *HardAssert {
+	return &HardAssert{t: t}
+}
+
+type HardAssert struct {
+	t *testing.T
+}
+
+func (h *HardAssert) FailWith(msg *message.Message) {
+	h.t.Fatalf("%s", msg.ToString())
+}
diff --git a/src/pkg/assert_type/SoftAssert.go b/src/pkg/assert_type/SoftAssert.go
new file mode 100644
index 0000000..97b6734
--- /dev/null
+++ b/src/pkg/assert_type/SoftAssert.go
@@ -0,0 +1,25 @@
+package assert_type
+
+import (
+	"github.com/sku0x20/assertG/src/pkg/message"
+	"testing"
+)
+
+func NewSoftAssert(t *testing.T) *SoftAssert {
+	return &SoftAssert{t, false}
+}
+
+type SoftAssert struct {
+	t      *testing.T
+	failed bool
+}
+
+func (s *SoftAssert) FailWith(msg *message.Message) {
+	s.failed = true
+	s.t.Helper()
+	s.t.Logf(msg.ToString())
+}
+
+func (s *SoftAssert) Failed() bool {
+	return s.failed
+}
diff --git a/src/pkg/asserter/Any.go b/src/pkg/asserter/Any.go
index 588790a..b306d61 100644
--- a/src/pkg/asserter/Any.go
+++ b/src/pkg/asserter/Any.go
@@ -1,18 +1,18 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/equator"
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
 )
 
-func NewAny(a assertion.Assertion, equator equator.Equator[any], value any) *Any {
+func NewAny(a assert_type.AssertType, equator equator.Equator[any], value any) *Any {
 	return &Any{assertion: a, equator: equator, actual: value}
 }
 
 type Any struct {
-	assertion assertion.Assertion
+	assertion assert_type.AssertType
 	equator   equator.Equator[any]
 	actual    any
 }
diff --git a/src/pkg/asserter/Bool.go b/src/pkg/asserter/Bool.go
index cfe314d..4bd0d64 100644
--- a/src/pkg/asserter/Bool.go
+++ b/src/pkg/asserter/Bool.go
@@ -1,17 +1,17 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
 )
 
-func NewBool(a assertion.Assertion, val bool) *Bool {
+func NewBool(a assert_type.AssertType, val bool) *Bool {
 	return &Bool{a: a, e: val}
 }
 
 type Bool struct {
-	a assertion.Assertion
+	a assert_type.AssertType
 	e bool
 }
 
diff --git a/src/pkg/asserter/Slice.go b/src/pkg/asserter/Slice.go
index 3a81499..4d9b6ec 100644
--- a/src/pkg/asserter/Slice.go
+++ b/src/pkg/asserter/Slice.go
@@ -1,18 +1,18 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
 	"reflect"
 )
 
-func NewSlice[T any](a assertion.Assertion, val []T) *Slice[T] {
+func NewSlice[T any](a assert_type.AssertType, val []T) *Slice[T] {
 	return &Slice[T]{a, val}
 }
 
 type Slice[T any] struct {
-	assertion assertion.Assertion
+	assertion assert_type.AssertType
 	actual    []T
 }
 
diff --git a/src/pkg/asserter/String.go b/src/pkg/asserter/String.go
index 9eeede1..e6d1710 100644
--- a/src/pkg/asserter/String.go
+++ b/src/pkg/asserter/String.go
@@ -1,18 +1,18 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
 	"strings"
 )
 
-func NewString(a assertion.Assertion, val string) *String {
+func NewString(a assert_type.AssertType, val string) *String {
 	return &String{a, val}
 }
 
 type String struct {
-	a assertion.Assertion
+	a assert_type.AssertType
 	e string
 }
 
diff --git a/src/pkg/assertion/Hard.go b/src/pkg/assertion/Hard.go
deleted file mode 100644
index 3d9b66d..0000000
--- a/src/pkg/assertion/Hard.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package assertion
-
-import (
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"testing"
-)
-
-func NewHard(t *testing.T) *Hard {
-	return &Hard{t: t}
-}
-
-type Hard struct {
-	t *testing.T
-}
-
-func (h *Hard) FailWith(msg *message.Message) {
-	h.t.Fatalf("%s", msg.ToString())
-}
diff --git a/src/pkg/assertion/Soft.go b/src/pkg/assertion/Soft.go
deleted file mode 100644
index 26c5f10..0000000
--- a/src/pkg/assertion/Soft.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package assertion
-
-import (
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"testing"
-)
-
-func NewSoft(t *testing.T) *Soft {
-	return &Soft{t, false}
-}
-
-type Soft struct {
-	t      *testing.T
-	failed bool
-}
-
-func (s *Soft) FailWith(msg *message.Message) {
-	s.failed = true
-	s.t.Helper()
-	s.t.Logf(msg.ToString())
-}
-
-func (s *Soft) Failed() bool {
-	return s.failed
-}
diff --git a/src/test/assert/any_test.go b/src/test/assert/any_test.go
index ea732d3..c8580b5 100644
--- a/src/test/assert/any_test.go
+++ b/src/test/assert/any_test.go
@@ -2,8 +2,8 @@ package assert
 
 import (
 	assertP "github.com/sku0x20/assertG/src/pkg/assert"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
@@ -16,7 +16,7 @@ func Test_Any(t *testing.T) {
 }
 
 func viaPackage_Any(t *testing.T, e any) {
-	var a any = assertP.ThatAny(assertion.NewSoft(t), "some val")
+	var a any = assertP.ThatAny(assert_type.NewSoftAssert(t), "some val")
 	casted, ok := a.(*asserter.Any)
 	if !ok {
 		t.Fatalf("unable to cast")
@@ -27,7 +27,7 @@ func viaPackage_Any(t *testing.T, e any) {
 }
 
 func viaVariable_Any(t *testing.T, e any) {
-	assert := assertP.NewAssert(assertion.NewSoft(t))
+	assert := assertP.NewAssert(assert_type.NewSoftAssert(t))
 	var a any = assert.ThatAny("some val")
 	casted, ok := a.(*asserter.Any)
 	if !ok {
diff --git a/src/test/assert/assert_test.go b/src/test/assert/assert_test.go
index 45de4bc..cd83804 100644
--- a/src/test/assert/assert_test.go
+++ b/src/test/assert/assert_test.go
@@ -2,13 +2,13 @@ package assert
 
 import (
 	assertP "github.com/sku0x20/assertG/src/pkg/assert"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"testing"
 )
 
 func Test_Assert(t *testing.T) {
 	var assert any
-	assert = assertP.NewAssert(assertion.NewSoft(t))
+	assert = assertP.NewAssert(assert_type.NewSoftAssert(t))
 	casted, ok := assert.(*assertP.Assert)
 	if !ok {
 		t.Fatalf("err")
diff --git a/src/test/assert/bool_test.go b/src/test/assert/bool_test.go
index 7dc9a96..a04c055 100644
--- a/src/test/assert/bool_test.go
+++ b/src/test/assert/bool_test.go
@@ -2,8 +2,8 @@ package assert
 
 import (
 	assertP "github.com/sku0x20/assertG/src/pkg/assert"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
@@ -16,7 +16,7 @@ func Test_Bool(t *testing.T) {
 }
 
 func viaPackage_Bool(t *testing.T, e any) {
-	var a any = assertP.ThatBool(assertion.NewSoft(t), true)
+	var a any = assertP.ThatBool(assert_type.NewSoftAssert(t), true)
 	casted, ok := a.(*asserter.Bool)
 	if !ok {
 		t.Fatalf("unable to cast")
@@ -27,7 +27,7 @@ func viaPackage_Bool(t *testing.T, e any) {
 }
 
 func viaVariable_Bool(t *testing.T, e any) {
-	assert := assertP.NewAssert(assertion.NewSoft(t))
+	assert := assertP.NewAssert(assert_type.NewSoftAssert(t))
 	var a any = assert.ThatBool(false)
 	casted, ok := a.(*asserter.Bool)
 	if !ok {
diff --git a/src/test/assert/string_test.go b/src/test/assert/string_test.go
index 05c2c64..de8eacb 100644
--- a/src/test/assert/string_test.go
+++ b/src/test/assert/string_test.go
@@ -2,8 +2,8 @@ package assert
 
 import (
 	assertP "github.com/sku0x20/assertG/src/pkg/assert"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
@@ -16,7 +16,7 @@ func Test_String(t *testing.T) {
 }
 
 func viaPackage_String(t *testing.T, e any) {
-	var a any = assertP.ThatString(assertion.NewSoft(t), "some val")
+	var a any = assertP.ThatString(assert_type.NewSoftAssert(t), "some val")
 	casted, ok := a.(*asserter.String)
 	if !ok {
 		t.Fatalf("unable to cast")
@@ -27,7 +27,7 @@ func viaPackage_String(t *testing.T, e any) {
 }
 
 func viaVariable_String(t *testing.T, e any) {
-	assert := assertP.NewAssert(assertion.NewSoft(t))
+	assert := assertP.NewAssert(assert_type.NewSoftAssert(t))
 	var a any = assert.ThatString("some val")
 	casted, ok := a.(*asserter.String)
 	if !ok {
diff --git a/src/test/assertion/Soft_test.go b/src/test/assert_type/SoftAssert_test.go
similarity index 77%
rename from src/test/assertion/Soft_test.go
rename to src/test/assert_type/SoftAssert_test.go
index 21145e7..f3f5d3e 100644
--- a/src/test/assertion/Soft_test.go
+++ b/src/test/assert_type/SoftAssert_test.go
@@ -1,14 +1,14 @@
-package assertion
+package assert_type
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/message"
 	"github.com/sku0x20/assertG/src/pkg/message/verbs"
 	"testing"
 )
 
 func Test_Soft(t *testing.T) {
-	s := assertion.NewSoft(t)
+	s := assert_type.NewSoftAssert(t)
 	if s.Failed() {
 		t.Fatalf("should not be in failed state")
 	}
diff --git a/src/test/asserter/Any_test.go b/src/test/asserter/Any_test.go
index 2158394..8830193 100644
--- a/src/test/asserter/Any_test.go
+++ b/src/test/asserter/Any_test.go
@@ -1,19 +1,19 @@
 package asserter
 
 import (
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/assertG/src/pkg/equator"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
 
-func init_Any(t *testing.T) *assertion.Soft {
-	return assertion.NewSoft(t)
+func init_Any(t *testing.T) *assert_type.SoftAssert {
+	return assert_type.NewSoftAssert(t)
 }
 
 func Test_Any(t *testing.T) {
-	r := runner.NewTestsRunner[*assertion.Soft](t, init_Any)
+	r := runner.NewTestsRunner[*assert_type.SoftAssert](t, init_Any)
 	r.Add(equalFail_Any)
 	r.Add(equalPass_Any)
 	r.Add(customEquator_Any)
@@ -24,7 +24,7 @@ func Test_Any(t *testing.T) {
 	r.Run()
 }
 
-func equalFail_Any(t *testing.T, s *assertion.Soft) {
+func equalFail_Any(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 30)
 	a = a.IsEqualTo("something")
 	if !s.Failed() {
@@ -32,7 +32,7 @@ func equalFail_Any(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func equalPass_Any(t *testing.T, s *assertion.Soft) {
+func equalPass_Any(t *testing.T, s *assert_type.SoftAssert) {
 	type st struct {
 		s *string
 	}
@@ -52,7 +52,7 @@ func (f *FakeEquator) AreEqual(a any, b any) bool {
 	return true
 }
 
-func customEquator_Any(t *testing.T, s *assertion.Soft) {
+func customEquator_Any(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewAny(s, &FakeEquator{}, 10)
 	a = a.IsEqualTo(20)
 	if s.Failed() {
@@ -60,7 +60,7 @@ func customEquator_Any(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func nilPass_Any(t *testing.T, s *assertion.Soft) {
+func nilPass_Any(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), nil)
 	a = a.IsNil()
 	if s.Failed() {
@@ -68,7 +68,7 @@ func nilPass_Any(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func nilFail_Any(t *testing.T, s *assertion.Soft) {
+func nilFail_Any(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 10)
 	a = a.IsNil()
 	if !s.Failed() {
@@ -76,7 +76,7 @@ func nilFail_Any(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func notNilPass_Any(t *testing.T, s *assertion.Soft) {
+func notNilPass_Any(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 10)
 	a = a.IsNotNil()
 	if s.Failed() {
@@ -84,7 +84,7 @@ func notNilPass_Any(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func notNilFail_Any(t *testing.T, s *assertion.Soft) {
+func notNilFail_Any(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), nil)
 	a = a.IsNotNil()
 	if !s.Failed() {
diff --git a/src/test/asserter/Bool_test.go b/src/test/asserter/Bool_test.go
index 2264e6d..ce3022b 100644
--- a/src/test/asserter/Bool_test.go
+++ b/src/test/asserter/Bool_test.go
@@ -1,14 +1,14 @@
 package asserter
 
 import (
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
 
-func init_Bool(t *testing.T) *assertion.Soft {
-	return assertion.NewSoft(t)
+func init_Bool(t *testing.T) *assert_type.SoftAssert {
+	return assert_type.NewSoftAssert(t)
 }
 
 func Test_Bool(t *testing.T) {
@@ -20,7 +20,7 @@ func Test_Bool(t *testing.T) {
 	r.Run()
 }
 
-func truePass_Bool(t *testing.T, s *assertion.Soft) {
+func truePass_Bool(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 1 == 1)
 	a = a.IsTrue()
 	if s.Failed() {
@@ -28,7 +28,7 @@ func truePass_Bool(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func trueFail_Bool(t *testing.T, s *assertion.Soft) {
+func trueFail_Bool(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 2 == 1)
 	a = a.IsTrue()
 	if !s.Failed() {
@@ -36,7 +36,7 @@ func trueFail_Bool(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func falsePass_Bool(t *testing.T, s *assertion.Soft) {
+func falsePass_Bool(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 2 == 1)
 	a = a.IsFalse()
 	if s.Failed() {
@@ -44,7 +44,7 @@ func falsePass_Bool(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func falseFail_Bool(t *testing.T, s *assertion.Soft) {
+func falseFail_Bool(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 1 == 1)
 	a = a.IsFalse()
 	if !s.Failed() {
diff --git a/src/test/asserter/String_test.go b/src/test/asserter/String_test.go
index 34f958d..29de77f 100644
--- a/src/test/asserter/String_test.go
+++ b/src/test/asserter/String_test.go
@@ -1,14 +1,14 @@
 package asserter
 
 import (
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
 
-func init_String(t *testing.T) *assertion.Soft {
-	return assertion.NewSoft(t)
+func init_String(t *testing.T) *assert_type.SoftAssert {
+	return assert_type.NewSoftAssert(t)
 }
 
 func Test_String(t *testing.T) {
@@ -24,7 +24,7 @@ func Test_String(t *testing.T) {
 	r.Run()
 }
 
-func equalPass_String(t *testing.T, s *assertion.Soft) {
+func equalPass_String(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.IsEqualTo("some val")
 	if s.Failed() {
@@ -32,7 +32,7 @@ func equalPass_String(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func equalFail_String(t *testing.T, s *assertion.Soft) {
+func equalFail_String(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.IsEqualTo("other val")
 	if !s.Failed() {
@@ -40,7 +40,7 @@ func equalFail_String(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func containsPass_String(t *testing.T, s *assertion.Soft) {
+func containsPass_String(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.Contains("val")
 	if s.Failed() {
@@ -48,7 +48,7 @@ func containsPass_String(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func containsFail_String(t *testing.T, s *assertion.Soft) {
+func containsFail_String(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.Contains("other")
 	if !s.Failed() {
@@ -56,7 +56,7 @@ func containsFail_String(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func notContainsPass_String(t *testing.T, s *assertion.Soft) {
+func notContainsPass_String(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.NotContains("other")
 	if s.Failed() {
@@ -64,7 +64,7 @@ func notContainsPass_String(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func notContainsFail_String(t *testing.T, s *assertion.Soft) {
+func notContainsFail_String(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.NotContains("some")
 	if !s.Failed() {
@@ -72,7 +72,7 @@ func notContainsFail_String(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func hasLengthPass_String(t *testing.T, s *assertion.Soft) {
+func hasLengthPass_String(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.HasLength(8)
 	if s.Failed() {
@@ -80,7 +80,7 @@ func hasLengthPass_String(t *testing.T, s *assertion.Soft) {
 	}
 }
 
-func hasLengthFail_String(t *testing.T, s *assertion.Soft) {
+func hasLengthFail_String(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.HasLength(10)
 	if !s.Failed() {
diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index dc90131..24a9c12 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -1,8 +1,8 @@
 package slice
 
 import (
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
@@ -17,13 +17,13 @@ func Test_Slice(t *testing.T) {
 
 func hasLength(t *testing.T, _ any) {
 	intS := []int{10}
-	sa := assertion.NewSoft(t)
+	sa := assert_type.NewSoftAssert(t)
 	a := asserter.NewSlice(sa, intS)
 	a = a.HasLength(1)
 	if sa.Failed() {
 		t.Fatalf("should not have failed")
 	}
-	sa = assertion.NewSoft(t)
+	sa = assert_type.NewSoftAssert(t)
 	a = asserter.NewSlice(sa, intS)
 	a = a.HasLength(2)
 	if !sa.Failed() {
@@ -56,7 +56,7 @@ func runTests(
 ) {
 	for _, ct := range tests {
 		t.Run("", func(t *testing.T) {
-			sa := assertion.NewSoft(t)
+			sa := assert_type.NewSoftAssert(t)
 			a := asserter.NewSlice(sa, ct.actual)
 			a = fnAssertion(a, ct.expected)
 			if sa.Failed() != ct.shouldFail {
diff --git a/src/test/e2e_test.go b/src/test/e2e_test.go
index e77a3be..5517092 100644
--- a/src/test/e2e_test.go
+++ b/src/test/e2e_test.go
@@ -2,20 +2,20 @@ package test
 
 import (
 	assertP "github.com/sku0x20/assertG/src/pkg/assert"
-	"github.com/sku0x20/assertG/src/pkg/assertion"
+	"github.com/sku0x20/assertG/src/pkg/assert_type"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
 
 func Test_WithoutRunner(t *testing.T) {
-	assert := assertP.NewAssert(assertion.NewHard(t))
+	assert := assertP.NewAssert(assert_type.NewHardAssert(t))
 	assert.ThatAny(10).
 		IsNotNil().
 		IsEqualTo(10)
 }
 
 func initE(t *testing.T) *assertP.Assert {
-	return assertP.NewAssert(assertion.NewHard(t))
+	return assertP.NewAssert(assert_type.NewHardAssert(t))
 }
 
 func Test_WithRunner(t *testing.T) {

From cd4f4a4a8644afcd07e4c24c4419688a1c6bab41 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 18:13:46 +0530
Subject: [PATCH 20/35] rename pkg to main

---
 src/integrationtest/assert_type/HardAssert_test.go | 6 +++---
 src/{pkg => main}/assert/any.go                    | 6 +++---
 src/{pkg => main}/assert/assert.go                 | 2 +-
 src/{pkg => main}/assert/bool.go                   | 4 ++--
 src/{pkg => main}/assert/string.go                 | 4 ++--
 src/{pkg => main}/assert_type/AssertType.go        | 2 +-
 src/{pkg => main}/assert_type/HardAssert.go        | 2 +-
 src/{pkg => main}/assert_type/SoftAssert.go        | 2 +-
 src/{pkg => main}/asserter/Any.go                  | 8 ++++----
 src/{pkg => main}/asserter/Bool.go                 | 6 +++---
 src/{pkg => main}/asserter/Slice.go                | 6 +++---
 src/{pkg => main}/asserter/String.go               | 6 +++---
 src/{pkg => main}/equator/ComparableEquator.go     | 0
 src/{pkg => main}/equator/Equator.go               | 0
 src/{pkg => main}/equator/ReflectDeepEquator.go    | 0
 src/{pkg => main}/message/Message.go               | 0
 src/{pkg => main}/message/defined.go               | 2 +-
 src/{pkg => main}/message/verbs/verbs.go           | 0
 src/test/assert/any_test.go                        | 6 +++---
 src/test/assert/assert_test.go                     | 4 ++--
 src/test/assert/bool_test.go                       | 6 +++---
 src/test/assert/string_test.go                     | 6 +++---
 src/test/assert_type/SoftAssert_test.go            | 6 +++---
 src/test/asserter/Any_test.go                      | 6 +++---
 src/test/asserter/Bool_test.go                     | 4 ++--
 src/test/asserter/String_test.go                   | 4 ++--
 src/test/asserter/slice/Slice_test.go              | 4 ++--
 src/test/e2e_test.go                               | 4 ++--
 src/test/equator/ComparableEquator_test.go         | 2 +-
 src/test/equator/ReflectDeepEquator_test.go        | 2 +-
 src/test/message/Message_test.go                   | 2 +-
 src/test/message/defined_test.go                   | 4 ++--
 32 files changed, 58 insertions(+), 58 deletions(-)
 rename src/{pkg => main}/assert/any.go (65%)
 rename src/{pkg => main}/assert/assert.go (71%)
 rename src/{pkg => main}/assert/bool.go (68%)
 rename src/{pkg => main}/assert/string.go (70%)
 rename src/{pkg => main}/assert_type/AssertType.go (61%)
 rename src/{pkg => main}/assert_type/HardAssert.go (84%)
 rename src/{pkg => main}/assert_type/SoftAssert.go (88%)
 rename src/{pkg => main}/asserter/Any.go (80%)
 rename src/{pkg => main}/asserter/Bool.go (74%)
 rename src/{pkg => main}/asserter/Slice.go (82%)
 rename src/{pkg => main}/asserter/String.go (86%)
 rename src/{pkg => main}/equator/ComparableEquator.go (100%)
 rename src/{pkg => main}/equator/Equator.go (100%)
 rename src/{pkg => main}/equator/ReflectDeepEquator.go (100%)
 rename src/{pkg => main}/message/Message.go (100%)
 rename src/{pkg => main}/message/defined.go (64%)
 rename src/{pkg => main}/message/verbs/verbs.go (100%)

diff --git a/src/integrationtest/assert_type/HardAssert_test.go b/src/integrationtest/assert_type/HardAssert_test.go
index 5ba2f41..8769720 100644
--- a/src/integrationtest/assert_type/HardAssert_test.go
+++ b/src/integrationtest/assert_type/HardAssert_test.go
@@ -1,9 +1,9 @@
 package assert_type
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"strings"
 	"testing"
diff --git a/src/pkg/assert/any.go b/src/main/assert/any.go
similarity index 65%
rename from src/pkg/assert/any.go
rename to src/main/assert/any.go
index 0274c98..50baf82 100644
--- a/src/pkg/assert/any.go
+++ b/src/main/assert/any.go
@@ -1,9 +1,9 @@
 package assert
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/equator"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
 )
 
 func (a *Assert) ThatAny(value any) *asserter.Any {
diff --git a/src/pkg/assert/assert.go b/src/main/assert/assert.go
similarity index 71%
rename from src/pkg/assert/assert.go
rename to src/main/assert/assert.go
index 1981629..f692c20 100644
--- a/src/pkg/assert/assert.go
+++ b/src/main/assert/assert.go
@@ -1,6 +1,6 @@
 package assert
 
-import "github.com/sku0x20/assertG/src/pkg/assert_type"
+import "github.com/sku0x20/assertG/src/main/assert_type"
 
 func NewAssert(a assert_type.AssertType) *Assert {
 	return &Assert{a: a}
diff --git a/src/pkg/assert/bool.go b/src/main/assert/bool.go
similarity index 68%
rename from src/pkg/assert/bool.go
rename to src/main/assert/bool.go
index d50a4b2..6135eb2 100644
--- a/src/pkg/assert/bool.go
+++ b/src/main/assert/bool.go
@@ -1,8 +1,8 @@
 package assert
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
 )
 
 func (a *Assert) ThatBool(val bool) *asserter.Bool {
diff --git a/src/pkg/assert/string.go b/src/main/assert/string.go
similarity index 70%
rename from src/pkg/assert/string.go
rename to src/main/assert/string.go
index 6b8a2b4..405c4c9 100644
--- a/src/pkg/assert/string.go
+++ b/src/main/assert/string.go
@@ -1,8 +1,8 @@
 package assert
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
 )
 
 func (a *Assert) ThatString(value string) *asserter.String {
diff --git a/src/pkg/assert_type/AssertType.go b/src/main/assert_type/AssertType.go
similarity index 61%
rename from src/pkg/assert_type/AssertType.go
rename to src/main/assert_type/AssertType.go
index 986866f..aa1d7f0 100644
--- a/src/pkg/assert_type/AssertType.go
+++ b/src/main/assert_type/AssertType.go
@@ -1,6 +1,6 @@
 package assert_type
 
-import "github.com/sku0x20/assertG/src/pkg/message"
+import "github.com/sku0x20/assertG/src/main/message"
 
 type AssertType interface {
 	FailWith(msg *message.Message)
diff --git a/src/pkg/assert_type/HardAssert.go b/src/main/assert_type/HardAssert.go
similarity index 84%
rename from src/pkg/assert_type/HardAssert.go
rename to src/main/assert_type/HardAssert.go
index 25fa237..e2f53c6 100644
--- a/src/pkg/assert_type/HardAssert.go
+++ b/src/main/assert_type/HardAssert.go
@@ -1,7 +1,7 @@
 package assert_type
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/message"
+	"github.com/sku0x20/assertG/src/main/message"
 	"testing"
 )
 
diff --git a/src/pkg/assert_type/SoftAssert.go b/src/main/assert_type/SoftAssert.go
similarity index 88%
rename from src/pkg/assert_type/SoftAssert.go
rename to src/main/assert_type/SoftAssert.go
index 97b6734..84126ed 100644
--- a/src/pkg/assert_type/SoftAssert.go
+++ b/src/main/assert_type/SoftAssert.go
@@ -1,7 +1,7 @@
 package assert_type
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/message"
+	"github.com/sku0x20/assertG/src/main/message"
 	"testing"
 )
 
diff --git a/src/pkg/asserter/Any.go b/src/main/asserter/Any.go
similarity index 80%
rename from src/pkg/asserter/Any.go
rename to src/main/asserter/Any.go
index b306d61..2950488 100644
--- a/src/pkg/asserter/Any.go
+++ b/src/main/asserter/Any.go
@@ -1,10 +1,10 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/equator"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 )
 
 func NewAny(a assert_type.AssertType, equator equator.Equator[any], value any) *Any {
diff --git a/src/pkg/asserter/Bool.go b/src/main/asserter/Bool.go
similarity index 74%
rename from src/pkg/asserter/Bool.go
rename to src/main/asserter/Bool.go
index 4bd0d64..2f5082d 100644
--- a/src/pkg/asserter/Bool.go
+++ b/src/main/asserter/Bool.go
@@ -1,9 +1,9 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 )
 
 func NewBool(a assert_type.AssertType, val bool) *Bool {
diff --git a/src/pkg/asserter/Slice.go b/src/main/asserter/Slice.go
similarity index 82%
rename from src/pkg/asserter/Slice.go
rename to src/main/asserter/Slice.go
index 4d9b6ec..9dcff00 100644
--- a/src/pkg/asserter/Slice.go
+++ b/src/main/asserter/Slice.go
@@ -1,9 +1,9 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 	"reflect"
 )
 
diff --git a/src/pkg/asserter/String.go b/src/main/asserter/String.go
similarity index 86%
rename from src/pkg/asserter/String.go
rename to src/main/asserter/String.go
index e6d1710..4ea5d11 100644
--- a/src/pkg/asserter/String.go
+++ b/src/main/asserter/String.go
@@ -1,9 +1,9 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 	"strings"
 )
 
diff --git a/src/pkg/equator/ComparableEquator.go b/src/main/equator/ComparableEquator.go
similarity index 100%
rename from src/pkg/equator/ComparableEquator.go
rename to src/main/equator/ComparableEquator.go
diff --git a/src/pkg/equator/Equator.go b/src/main/equator/Equator.go
similarity index 100%
rename from src/pkg/equator/Equator.go
rename to src/main/equator/Equator.go
diff --git a/src/pkg/equator/ReflectDeepEquator.go b/src/main/equator/ReflectDeepEquator.go
similarity index 100%
rename from src/pkg/equator/ReflectDeepEquator.go
rename to src/main/equator/ReflectDeepEquator.go
diff --git a/src/pkg/message/Message.go b/src/main/message/Message.go
similarity index 100%
rename from src/pkg/message/Message.go
rename to src/main/message/Message.go
diff --git a/src/pkg/message/defined.go b/src/main/message/defined.go
similarity index 64%
rename from src/pkg/message/defined.go
rename to src/main/message/defined.go
index ebf7cbf..58de2c9 100644
--- a/src/pkg/message/defined.go
+++ b/src/main/message/defined.go
@@ -1,6 +1,6 @@
 package message
 
-import "github.com/sku0x20/assertG/src/pkg/message/verbs"
+import "github.com/sku0x20/assertG/src/main/message/verbs"
 
 func Expected() *Message {
 	return NewMessage().
diff --git a/src/pkg/message/verbs/verbs.go b/src/main/message/verbs/verbs.go
similarity index 100%
rename from src/pkg/message/verbs/verbs.go
rename to src/main/message/verbs/verbs.go
diff --git a/src/test/assert/any_test.go b/src/test/assert/any_test.go
index c8580b5..6ade6ad 100644
--- a/src/test/assert/any_test.go
+++ b/src/test/assert/any_test.go
@@ -1,9 +1,9 @@
 package assert
 
 import (
-	assertP "github.com/sku0x20/assertG/src/pkg/assert"
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
+	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/assert/assert_test.go b/src/test/assert/assert_test.go
index cd83804..9589a80 100644
--- a/src/test/assert/assert_test.go
+++ b/src/test/assert/assert_test.go
@@ -1,8 +1,8 @@
 package assert
 
 import (
-	assertP "github.com/sku0x20/assertG/src/pkg/assert"
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
+	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert_type"
 	"testing"
 )
 
diff --git a/src/test/assert/bool_test.go b/src/test/assert/bool_test.go
index a04c055..2cb3fd3 100644
--- a/src/test/assert/bool_test.go
+++ b/src/test/assert/bool_test.go
@@ -1,9 +1,9 @@
 package assert
 
 import (
-	assertP "github.com/sku0x20/assertG/src/pkg/assert"
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
+	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/assert/string_test.go b/src/test/assert/string_test.go
index de8eacb..0bd3835 100644
--- a/src/test/assert/string_test.go
+++ b/src/test/assert/string_test.go
@@ -1,9 +1,9 @@
 package assert
 
 import (
-	assertP "github.com/sku0x20/assertG/src/pkg/assert"
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
+	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/assert_type/SoftAssert_test.go b/src/test/assert_type/SoftAssert_test.go
index f3f5d3e..9940724 100644
--- a/src/test/assert_type/SoftAssert_test.go
+++ b/src/test/assert_type/SoftAssert_test.go
@@ -1,9 +1,9 @@
 package assert_type
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 	"testing"
 )
 
diff --git a/src/test/asserter/Any_test.go b/src/test/asserter/Any_test.go
index 8830193..088c712 100644
--- a/src/test/asserter/Any_test.go
+++ b/src/test/asserter/Any_test.go
@@ -1,9 +1,9 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
-	"github.com/sku0x20/assertG/src/pkg/equator"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/asserter/Bool_test.go b/src/test/asserter/Bool_test.go
index ce3022b..6615b9b 100644
--- a/src/test/asserter/Bool_test.go
+++ b/src/test/asserter/Bool_test.go
@@ -1,8 +1,8 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/asserter/String_test.go b/src/test/asserter/String_test.go
index 29de77f..fc154ee 100644
--- a/src/test/asserter/String_test.go
+++ b/src/test/asserter/String_test.go
@@ -1,8 +1,8 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index 24a9c12..951bd94 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -1,8 +1,8 @@
 package slice
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
-	"github.com/sku0x20/assertG/src/pkg/asserter"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/e2e_test.go b/src/test/e2e_test.go
index 5517092..7be493f 100644
--- a/src/test/e2e_test.go
+++ b/src/test/e2e_test.go
@@ -1,8 +1,8 @@
 package test
 
 import (
-	assertP "github.com/sku0x20/assertG/src/pkg/assert"
-	"github.com/sku0x20/assertG/src/pkg/assert_type"
+	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert_type"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/equator/ComparableEquator_test.go b/src/test/equator/ComparableEquator_test.go
index 6a0392c..1f5b60e 100644
--- a/src/test/equator/ComparableEquator_test.go
+++ b/src/test/equator/ComparableEquator_test.go
@@ -1,7 +1,7 @@
 package equator
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/equator"
+	"github.com/sku0x20/assertG/src/main/equator"
 	"testing"
 )
 
diff --git a/src/test/equator/ReflectDeepEquator_test.go b/src/test/equator/ReflectDeepEquator_test.go
index d0dec8c..9a24425 100644
--- a/src/test/equator/ReflectDeepEquator_test.go
+++ b/src/test/equator/ReflectDeepEquator_test.go
@@ -1,7 +1,7 @@
 package equator
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/equator"
+	"github.com/sku0x20/assertG/src/main/equator"
 	"testing"
 )
 
diff --git a/src/test/message/Message_test.go b/src/test/message/Message_test.go
index 1d3ed41..bb12a45 100644
--- a/src/test/message/Message_test.go
+++ b/src/test/message/Message_test.go
@@ -1,7 +1,7 @@
 package message
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/message"
+	"github.com/sku0x20/assertG/src/main/message"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
diff --git a/src/test/message/defined_test.go b/src/test/message/defined_test.go
index 996789d..2c8cf03 100644
--- a/src/test/message/defined_test.go
+++ b/src/test/message/defined_test.go
@@ -1,8 +1,8 @@
 package message
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )

From 2d2f5cc836742a78b33e58ad083b91fe0821791c Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 18:15:47 +0530
Subject: [PATCH 21/35] migrate from any to generic

---
 src/main/assert/any.go                        | 17 ----
 src/main/assert/generic.go                    | 20 ++++
 src/main/asserter/Any.go                      | 52 -----------
 src/main/asserter/Generic.go                  | 57 ++++++++++++
 .../assert/{any_test.go => generic_test.go}   | 18 ++--
 src/test/asserter/Any_test.go                 | 93 -------------------
 src/test/asserter/generic/Generic_test.go     | 93 +++++++++++++++++++
 src/test/e2e_test.go                          |  4 +-
 8 files changed, 181 insertions(+), 173 deletions(-)
 delete mode 100644 src/main/assert/any.go
 create mode 100644 src/main/assert/generic.go
 delete mode 100644 src/main/asserter/Any.go
 create mode 100644 src/main/asserter/Generic.go
 rename src/test/assert/{any_test.go => generic_test.go} (60%)
 delete mode 100644 src/test/asserter/Any_test.go
 create mode 100644 src/test/asserter/generic/Generic_test.go

diff --git a/src/main/assert/any.go b/src/main/assert/any.go
deleted file mode 100644
index 50baf82..0000000
--- a/src/main/assert/any.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package assert
-
-import (
-	"github.com/sku0x20/assertG/src/main/assert_type"
-	"github.com/sku0x20/assertG/src/main/asserter"
-	"github.com/sku0x20/assertG/src/main/equator"
-)
-
-func (a *Assert) ThatAny(value any) *asserter.Any {
-	return ThatAny(a.a, value)
-}
-
-// todo: take equator
-
-func ThatAny(a assert_type.AssertType, value any) *asserter.Any {
-	return asserter.NewAny(a, equator.NewReflectDeepEquator[any](), value)
-}
diff --git a/src/main/assert/generic.go b/src/main/assert/generic.go
new file mode 100644
index 0000000..b606b5d
--- /dev/null
+++ b/src/main/assert/generic.go
@@ -0,0 +1,20 @@
+package assert
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
+)
+
+// methods cannot have type parameters
+// todo: use global registry for AssertType
+
+func (a *Assert) That(value any) *asserter.Generic[any] {
+	return That(a.a, value)
+}
+
+// todo: create fn that take equator
+
+func That[T any](a assert_type.AssertType, value T) *asserter.Generic[T] {
+	return asserter.NewGeneric(a, equator.NewReflectDeepEquator[T](), value)
+}
diff --git a/src/main/asserter/Any.go b/src/main/asserter/Any.go
deleted file mode 100644
index 2950488..0000000
--- a/src/main/asserter/Any.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package asserter
-
-import (
-	"github.com/sku0x20/assertG/src/main/assert_type"
-	"github.com/sku0x20/assertG/src/main/equator"
-	"github.com/sku0x20/assertG/src/main/message"
-	"github.com/sku0x20/assertG/src/main/message/verbs"
-)
-
-func NewAny(a assert_type.AssertType, equator equator.Equator[any], value any) *Any {
-	return &Any{assertion: a, equator: equator, actual: value}
-}
-
-type Any struct {
-	assertion assert_type.AssertType
-	equator   equator.Equator[any]
-	actual    any
-}
-
-func (a *Any) IsEqualTo(val any) *Any {
-	if !a.equator.AreEqual(a.actual, val) {
-		a.assertion.FailWith(
-			message.Expected().
-				Value(a.actual).
-				Verb(verbs.ToEqual).
-				Value(val),
-		)
-	}
-	return a
-}
-
-func (a *Any) IsNil() *Any {
-	if a.actual != nil {
-		a.assertion.FailWith(
-			message.Expected().
-				Value(a.actual).
-				Verb(verbs.ToBeNil),
-		)
-	}
-	return a
-}
-
-func (a *Any) IsNotNil() *Any {
-	if a.actual == nil {
-		a.assertion.FailWith(
-			message.Expected().
-				Value(a.actual).
-				Verb(verbs.NotToBeNil),
-		)
-	}
-	return a
-}
diff --git a/src/main/asserter/Generic.go b/src/main/asserter/Generic.go
new file mode 100644
index 0000000..b3d5b6c
--- /dev/null
+++ b/src/main/asserter/Generic.go
@@ -0,0 +1,57 @@
+package asserter
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
+	"reflect"
+)
+
+func NewGeneric[T any](
+	a assert_type.AssertType,
+	equator equator.Equator[T],
+	value T,
+) *Generic[T] {
+	return &Generic[T]{assertion: a, equator: equator, actual: value}
+}
+
+type Generic[T any] struct {
+	assertion assert_type.AssertType
+	equator   equator.Equator[T]
+	actual    T
+}
+
+func (g *Generic[T]) IsEqualTo(val any) *Generic[T] {
+	if !g.equator.AreEqual(g.actual, val) {
+		g.assertion.FailWith(
+			message.Expected().
+				Value(g.actual).
+				Verb(verbs.ToEqual).
+				Value(val),
+		)
+	}
+	return g
+}
+
+func (g *Generic[T]) IsNil() *Generic[T] {
+	if !reflect.DeepEqual(g.actual, nil) {
+		g.assertion.FailWith(
+			message.Expected().
+				Value(g.actual).
+				Verb(verbs.ToBeNil),
+		)
+	}
+	return g
+}
+
+func (g *Generic[T]) IsNotNil() *Generic[T] {
+	if reflect.DeepEqual(g.actual, nil) {
+		g.assertion.FailWith(
+			message.Expected().
+				Value(g.actual).
+				Verb(verbs.NotToBeNil),
+		)
+	}
+	return g
+}
diff --git a/src/test/assert/any_test.go b/src/test/assert/generic_test.go
similarity index 60%
rename from src/test/assert/any_test.go
rename to src/test/assert/generic_test.go
index 6ade6ad..d1c6c32 100644
--- a/src/test/assert/any_test.go
+++ b/src/test/assert/generic_test.go
@@ -8,16 +8,16 @@ import (
 	"testing"
 )
 
-func Test_Any(t *testing.T) {
+func Test_Generic(t *testing.T) {
 	r := runner.NewTestsRunnerEmptyInit[any](t)
-	r.Add(viaPackage_Any)
-	r.Add(viaVariable_Any)
+	r.Add(viaPackage_G)
+	r.Add(viaVariable_G)
 	r.Run()
 }
 
-func viaPackage_Any(t *testing.T, e any) {
-	var a any = assertP.ThatAny(assert_type.NewSoftAssert(t), "some val")
-	casted, ok := a.(*asserter.Any)
+func viaPackage_G(t *testing.T, e any) {
+	var a any = assertP.That(assert_type.NewSoftAssert(t), "some val")
+	casted, ok := a.(*asserter.Generic[string])
 	if !ok {
 		t.Fatalf("unable to cast")
 	}
@@ -26,10 +26,10 @@ func viaPackage_Any(t *testing.T, e any) {
 	}
 }
 
-func viaVariable_Any(t *testing.T, e any) {
+func viaVariable_G(t *testing.T, e any) {
 	assert := assertP.NewAssert(assert_type.NewSoftAssert(t))
-	var a any = assert.ThatAny("some val")
-	casted, ok := a.(*asserter.Any)
+	var a any = assert.That("some val")
+	casted, ok := a.(*asserter.Generic[any])
 	if !ok {
 		t.Fatalf("unable to cast")
 	}
diff --git a/src/test/asserter/Any_test.go b/src/test/asserter/Any_test.go
deleted file mode 100644
index 088c712..0000000
--- a/src/test/asserter/Any_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package asserter
-
-import (
-	"github.com/sku0x20/assertG/src/main/assert_type"
-	"github.com/sku0x20/assertG/src/main/asserter"
-	"github.com/sku0x20/assertG/src/main/equator"
-	"github.com/sku0x20/gRunner/src/pkg/runner"
-	"testing"
-)
-
-func init_Any(t *testing.T) *assert_type.SoftAssert {
-	return assert_type.NewSoftAssert(t)
-}
-
-func Test_Any(t *testing.T) {
-	r := runner.NewTestsRunner[*assert_type.SoftAssert](t, init_Any)
-	r.Add(equalFail_Any)
-	r.Add(equalPass_Any)
-	r.Add(customEquator_Any)
-	r.Add(nilPass_Any)
-	r.Add(nilFail_Any)
-	r.Add(notNilPass_Any)
-	r.Add(notNilFail_Any)
-	r.Run()
-}
-
-func equalFail_Any(t *testing.T, s *assert_type.SoftAssert) {
-	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 30)
-	a = a.IsEqualTo("something")
-	if !s.Failed() {
-		t.Fatalf("should have failed")
-	}
-}
-
-func equalPass_Any(t *testing.T, s *assert_type.SoftAssert) {
-	type st struct {
-		s *string
-	}
-	s1 := "something"
-	s2 := "something"
-	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), &st{&s1})
-	a = a.IsEqualTo(&st{&s2})
-	if s.Failed() {
-		t.Fatalf("should not have failed")
-	}
-}
-
-type FakeEquator struct {
-}
-
-func (f *FakeEquator) AreEqual(a any, b any) bool {
-	return true
-}
-
-func customEquator_Any(t *testing.T, s *assert_type.SoftAssert) {
-	a := asserter.NewAny(s, &FakeEquator{}, 10)
-	a = a.IsEqualTo(20)
-	if s.Failed() {
-		t.Fatalf("should have passed")
-	}
-}
-
-func nilPass_Any(t *testing.T, s *assert_type.SoftAssert) {
-	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), nil)
-	a = a.IsNil()
-	if s.Failed() {
-		t.Fatalf("should not have failed")
-	}
-}
-
-func nilFail_Any(t *testing.T, s *assert_type.SoftAssert) {
-	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 10)
-	a = a.IsNil()
-	if !s.Failed() {
-		t.Fatalf("should have failed")
-	}
-}
-
-func notNilPass_Any(t *testing.T, s *assert_type.SoftAssert) {
-	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), 10)
-	a = a.IsNotNil()
-	if s.Failed() {
-		t.Fatalf("should not have failed")
-	}
-}
-
-func notNilFail_Any(t *testing.T, s *assert_type.SoftAssert) {
-	a := asserter.NewAny(s, equator.NewReflectDeepEquator[any](), nil)
-	a = a.IsNotNil()
-	if !s.Failed() {
-		t.Fatalf("should have failed")
-	}
-}
diff --git a/src/test/asserter/generic/Generic_test.go b/src/test/asserter/generic/Generic_test.go
new file mode 100644
index 0000000..ccc0b31
--- /dev/null
+++ b/src/test/asserter/generic/Generic_test.go
@@ -0,0 +1,93 @@
+package generic
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/gRunner/src/pkg/runner"
+	"testing"
+)
+
+func init_G(t *testing.T) *assert_type.SoftAssert {
+	return assert_type.NewSoftAssert(t)
+}
+
+func Test_Generic(t *testing.T) {
+	r := runner.NewTestsRunner[*assert_type.SoftAssert](t, init_G)
+	r.Add(equalFail)
+	r.Add(equalPass)
+	r.Add(customEquator)
+	r.Add(nilPass)
+	r.Add(nilFail)
+	r.Add(notNilPass)
+	r.Add(notNilFail)
+	r.Run()
+}
+
+func equalFail(t *testing.T, s *assert_type.SoftAssert) {
+	a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[int](), 30)
+	a = a.IsEqualTo("something")
+	if !s.Failed() {
+		t.Fatalf("should have failed")
+	}
+}
+
+func equalPass(t *testing.T, s *assert_type.SoftAssert) {
+	type st struct {
+		s *string
+	}
+	s1 := "something"
+	s2 := "something"
+	a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[*st](), &st{&s1})
+	a = a.IsEqualTo(&st{&s2})
+	if s.Failed() {
+		t.Fatalf("should not have failed")
+	}
+}
+
+type FakeEquator struct {
+}
+
+func (f *FakeEquator) AreEqual(a int, b any) bool {
+	return true
+}
+
+func customEquator(t *testing.T, s *assert_type.SoftAssert) {
+	a := asserter.NewGeneric(s, &FakeEquator{}, 10)
+	a = a.IsEqualTo(20)
+	if s.Failed() {
+		t.Fatalf("should have passed")
+	}
+}
+
+func nilPass(t *testing.T, s *assert_type.SoftAssert) {
+	a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[any](), nil)
+	a = a.IsNil()
+	if s.Failed() {
+		t.Fatalf("should not have failed")
+	}
+}
+
+func nilFail(t *testing.T, s *assert_type.SoftAssert) {
+	a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[int](), 10)
+	a = a.IsNil()
+	if !s.Failed() {
+		t.Fatalf("should have failed")
+	}
+}
+
+func notNilPass(t *testing.T, s *assert_type.SoftAssert) {
+	a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[int](), 10)
+	a = a.IsNotNil()
+	if s.Failed() {
+		t.Fatalf("should not have failed")
+	}
+}
+
+func notNilFail(t *testing.T, s *assert_type.SoftAssert) {
+	a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[any](), nil)
+	a = a.IsNotNil()
+	if !s.Failed() {
+		t.Fatalf("should have failed")
+	}
+}
diff --git a/src/test/e2e_test.go b/src/test/e2e_test.go
index 7be493f..477c19b 100644
--- a/src/test/e2e_test.go
+++ b/src/test/e2e_test.go
@@ -9,7 +9,7 @@ import (
 
 func Test_WithoutRunner(t *testing.T) {
 	assert := assertP.NewAssert(assert_type.NewHardAssert(t))
-	assert.ThatAny(10).
+	assert.That(10).
 		IsNotNil().
 		IsEqualTo(10)
 }
@@ -25,7 +25,7 @@ func Test_WithRunner(t *testing.T) {
 }
 
 func makeAssert(_ *testing.T, assert *assertP.Assert) {
-	assert.ThatAny(10).
+	assert.That(10).
 		IsNotNil().
 		IsEqualTo(10)
 }

From 480b3b05d9872bfbd8342b7615165ba5b6cb4346 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 22:27:33 +0530
Subject: [PATCH 22/35] add GlobalRegistry

---
 src/main/registry/GlobalRegistry.go      | 15 +++++++++++++++
 src/test/registry/GlobalRegistry_test.go | 22 ++++++++++++++++++++++
 2 files changed, 37 insertions(+)
 create mode 100644 src/main/registry/GlobalRegistry.go
 create mode 100644 src/test/registry/GlobalRegistry_test.go

diff --git a/src/main/registry/GlobalRegistry.go b/src/main/registry/GlobalRegistry.go
new file mode 100644
index 0000000..d170eac
--- /dev/null
+++ b/src/main/registry/GlobalRegistry.go
@@ -0,0 +1,15 @@
+package registry
+
+import "github.com/sku0x20/assertG/src/main/assert_type"
+
+var (
+	assertType assert_type.AssertType = nil
+)
+
+func GlobalRegistryGetAssertType() assert_type.AssertType {
+	return assertType
+}
+
+func GlobalRegistrySetAssertType(at assert_type.AssertType) {
+	assertType = at
+}
diff --git a/src/test/registry/GlobalRegistry_test.go b/src/test/registry/GlobalRegistry_test.go
new file mode 100644
index 0000000..af76c92
--- /dev/null
+++ b/src/test/registry/GlobalRegistry_test.go
@@ -0,0 +1,22 @@
+package registry
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/registry"
+	"github.com/sku0x20/gRunner/src/pkg/runner"
+	"testing"
+)
+
+func Test_GlobalRegistry(t *testing.T) {
+	r := runner.NewTestsRunnerEmptyInit[any](t)
+	r.Add(setAssertType)
+	r.Run()
+}
+
+func setAssertType(t *testing.T, _ any) {
+	sa := assert_type.NewSoftAssert(t)
+	registry.GlobalRegistrySetAssertType(sa)
+	if registry.GlobalRegistryGetAssertType() != sa {
+		t.Fatalf("different AssertType")
+	}
+}

From 34d1c10840a0eae07634db442afc090bb59a1c76 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 22:39:41 +0530
Subject: [PATCH 23/35] use registry with generic.go

---
 src/main/assert/generic.go      | 18 +++++++++++-------
 src/test/assert/generic_test.go | 22 +++++++++++++---------
 2 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/main/assert/generic.go b/src/main/assert/generic.go
index b606b5d..c45406f 100644
--- a/src/main/assert/generic.go
+++ b/src/main/assert/generic.go
@@ -4,17 +4,21 @@ import (
 	"github.com/sku0x20/assertG/src/main/assert_type"
 	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/assertG/src/main/registry"
 )
 
 // methods cannot have type parameters
-// todo: use global registry for AssertType
+// using global registry for AssertType
 
-func (a *Assert) That(value any) *asserter.Generic[any] {
-	return That(a.a, value)
+func That[T any](value T) *asserter.Generic[T] {
+	at := registry.GlobalRegistryGetAssertType()
+	return ThatWith(at, equator.NewReflectDeepEquator[T](), value)
 }
 
-// todo: create fn that take equator
-
-func That[T any](a assert_type.AssertType, value T) *asserter.Generic[T] {
-	return asserter.NewGeneric(a, equator.NewReflectDeepEquator[T](), value)
+func ThatWith[T any](
+	at assert_type.AssertType,
+	equator equator.Equator[T],
+	value T,
+) *asserter.Generic[T] {
+	return asserter.NewGeneric(at, equator, value)
 }
diff --git a/src/test/assert/generic_test.go b/src/test/assert/generic_test.go
index d1c6c32..c575558 100644
--- a/src/test/assert/generic_test.go
+++ b/src/test/assert/generic_test.go
@@ -1,22 +1,23 @@
 package assert
 
 import (
-	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert"
 	"github.com/sku0x20/assertG/src/main/assert_type"
 	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
 
 func Test_Generic(t *testing.T) {
 	r := runner.NewTestsRunnerEmptyInit[any](t)
-	r.Add(viaPackage_G)
-	r.Add(viaVariable_G)
+	r.Add(that)
+	r.Add(thatWith)
 	r.Run()
 }
 
-func viaPackage_G(t *testing.T, e any) {
-	var a any = assertP.That(assert_type.NewSoftAssert(t), "some val")
+func that(t *testing.T, e any) {
+	var a any = assert.That("some val")
 	casted, ok := a.(*asserter.Generic[string])
 	if !ok {
 		t.Fatalf("unable to cast")
@@ -26,10 +27,13 @@ func viaPackage_G(t *testing.T, e any) {
 	}
 }
 
-func viaVariable_G(t *testing.T, e any) {
-	assert := assertP.NewAssert(assert_type.NewSoftAssert(t))
-	var a any = assert.That("some val")
-	casted, ok := a.(*asserter.Generic[any])
+func thatWith(t *testing.T, e any) {
+	var a any = assert.ThatWith(
+		assert_type.NewSoftAssert(t),
+		equator.NewComparableEquator[string](),
+		"some val",
+	)
+	casted, ok := a.(*asserter.Generic[string])
 	if !ok {
 		t.Fatalf("unable to cast")
 	}

From 1a59a723d78e97704ea85fd81b485095a8fdc705 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 22:46:41 +0530
Subject: [PATCH 24/35] migrate assert.ThatBool

---
 src/main/assert/bool.go      |  8 +++++---
 src/test/assert/bool_test.go | 15 +++++++--------
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/main/assert/bool.go b/src/main/assert/bool.go
index 6135eb2..a5851eb 100644
--- a/src/main/assert/bool.go
+++ b/src/main/assert/bool.go
@@ -3,12 +3,14 @@ package assert
 import (
 	"github.com/sku0x20/assertG/src/main/assert_type"
 	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/registry"
 )
 
-func (a *Assert) ThatBool(val bool) *asserter.Bool {
-	return ThatBool(a.a, val)
+func ThatBool(val bool) *asserter.Bool {
+	at := registry.GlobalRegistryGetAssertType()
+	return ThatBoolWith(at, val)
 }
 
-func ThatBool(a assert_type.AssertType, val bool) *asserter.Bool {
+func ThatBoolWith(a assert_type.AssertType, val bool) *asserter.Bool {
 	return asserter.NewBool(a, val)
 }
diff --git a/src/test/assert/bool_test.go b/src/test/assert/bool_test.go
index 2cb3fd3..cb7f196 100644
--- a/src/test/assert/bool_test.go
+++ b/src/test/assert/bool_test.go
@@ -1,7 +1,7 @@
 package assert
 
 import (
-	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert"
 	"github.com/sku0x20/assertG/src/main/assert_type"
 	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
@@ -10,13 +10,13 @@ import (
 
 func Test_Bool(t *testing.T) {
 	r := runner.NewTestsRunnerEmptyInit[any](t)
-	r.Add(viaPackage_Bool)
-	r.Add(viaVariable_Bool)
+	r.Add(thatBool)
+	r.Add(thatBoolWith)
 	r.Run()
 }
 
-func viaPackage_Bool(t *testing.T, e any) {
-	var a any = assertP.ThatBool(assert_type.NewSoftAssert(t), true)
+func thatBool(t *testing.T, e any) {
+	var a any = assert.ThatBool(true)
 	casted, ok := a.(*asserter.Bool)
 	if !ok {
 		t.Fatalf("unable to cast")
@@ -26,9 +26,8 @@ func viaPackage_Bool(t *testing.T, e any) {
 	}
 }
 
-func viaVariable_Bool(t *testing.T, e any) {
-	assert := assertP.NewAssert(assert_type.NewSoftAssert(t))
-	var a any = assert.ThatBool(false)
+func thatBoolWith(t *testing.T, e any) {
+	var a any = assert.ThatBoolWith(assert_type.NewSoftAssert(t), false)
 	casted, ok := a.(*asserter.Bool)
 	if !ok {
 		t.Fatalf("unable to cast")

From e0032aa5ae6b72673c62e8ebe58833928e9c4939 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 22:48:49 +0530
Subject: [PATCH 25/35] migrate string

---
 src/main/assert/string.go      |  8 +++++---
 src/test/assert/string_test.go | 15 +++++++--------
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/main/assert/string.go b/src/main/assert/string.go
index 405c4c9..37212d5 100644
--- a/src/main/assert/string.go
+++ b/src/main/assert/string.go
@@ -3,12 +3,14 @@ package assert
 import (
 	"github.com/sku0x20/assertG/src/main/assert_type"
 	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/registry"
 )
 
-func (a *Assert) ThatString(value string) *asserter.String {
-	return ThatString(a.a, value)
+func ThatString(value string) *asserter.String {
+	at := registry.GlobalRegistryGetAssertType()
+	return ThatStringWith(at, value)
 }
 
-func ThatString(a assert_type.AssertType, value string) *asserter.String {
+func ThatStringWith(a assert_type.AssertType, value string) *asserter.String {
 	return asserter.NewString(a, value)
 }
diff --git a/src/test/assert/string_test.go b/src/test/assert/string_test.go
index 0bd3835..34485a0 100644
--- a/src/test/assert/string_test.go
+++ b/src/test/assert/string_test.go
@@ -1,7 +1,7 @@
 package assert
 
 import (
-	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert"
 	"github.com/sku0x20/assertG/src/main/assert_type"
 	"github.com/sku0x20/assertG/src/main/asserter"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
@@ -10,13 +10,13 @@ import (
 
 func Test_String(t *testing.T) {
 	r := runner.NewTestsRunnerEmptyInit[any](t)
-	r.Add(viaPackage_String)
-	r.Add(viaVariable_String)
+	r.Add(thatString)
+	r.Add(thatStringWith)
 	r.Run()
 }
 
-func viaPackage_String(t *testing.T, e any) {
-	var a any = assertP.ThatString(assert_type.NewSoftAssert(t), "some val")
+func thatString(t *testing.T, e any) {
+	var a any = assert.ThatString("some val")
 	casted, ok := a.(*asserter.String)
 	if !ok {
 		t.Fatalf("unable to cast")
@@ -26,9 +26,8 @@ func viaPackage_String(t *testing.T, e any) {
 	}
 }
 
-func viaVariable_String(t *testing.T, e any) {
-	assert := assertP.NewAssert(assert_type.NewSoftAssert(t))
-	var a any = assert.ThatString("some val")
+func thatStringWith(t *testing.T, e any) {
+	var a any = assert.ThatStringWith(assert_type.NewSoftAssert(t), "some val")
 	casted, ok := a.(*asserter.String)
 	if !ok {
 		t.Fatalf("unable to cast")

From 98632228ab7da972a80284337852349118b8e521 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 22:57:34 +0530
Subject: [PATCH 26/35] remove assert

---
 src/main/assert/assert.go      | 11 -----------
 src/test/assert/assert_test.go | 19 -------------------
 src/test/e2e_test.go           | 23 +++++++++++++++--------
 3 files changed, 15 insertions(+), 38 deletions(-)
 delete mode 100644 src/main/assert/assert.go
 delete mode 100644 src/test/assert/assert_test.go

diff --git a/src/main/assert/assert.go b/src/main/assert/assert.go
deleted file mode 100644
index f692c20..0000000
--- a/src/main/assert/assert.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package assert
-
-import "github.com/sku0x20/assertG/src/main/assert_type"
-
-func NewAssert(a assert_type.AssertType) *Assert {
-	return &Assert{a: a}
-}
-
-type Assert struct {
-	a assert_type.AssertType
-}
diff --git a/src/test/assert/assert_test.go b/src/test/assert/assert_test.go
deleted file mode 100644
index 9589a80..0000000
--- a/src/test/assert/assert_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package assert
-
-import (
-	assertP "github.com/sku0x20/assertG/src/main/assert"
-	"github.com/sku0x20/assertG/src/main/assert_type"
-	"testing"
-)
-
-func Test_Assert(t *testing.T) {
-	var assert any
-	assert = assertP.NewAssert(assert_type.NewSoftAssert(t))
-	casted, ok := assert.(*assertP.Assert)
-	if !ok {
-		t.Fatalf("err")
-	}
-	if casted == nil {
-		t.Fatalf("casted is nil")
-	}
-}
diff --git a/src/test/e2e_test.go b/src/test/e2e_test.go
index 477c19b..e70bcc6 100644
--- a/src/test/e2e_test.go
+++ b/src/test/e2e_test.go
@@ -1,31 +1,38 @@
 package test
 
 import (
-	assertP "github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert"
 	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/registry"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
 
 func Test_WithoutRunner(t *testing.T) {
-	assert := assertP.NewAssert(assert_type.NewHardAssert(t))
+	registry.GlobalRegistrySetAssertType(assert_type.NewHardAssert(t))
 	assert.That(10).
 		IsNotNil().
 		IsEqualTo(10)
 }
 
-func initE(t *testing.T) *assertP.Assert {
-	return assertP.NewAssert(assert_type.NewHardAssert(t))
+func initE(t *testing.T) any {
+	registry.GlobalRegistrySetAssertType(assert_type.NewSoftAssert(t))
+	return nil
 }
 
 func Test_WithRunner(t *testing.T) {
-	r := runner.NewTestsRunner[*assertP.Assert](t, initE)
-	r.Add(makeAssert)
+	r := runner.NewTestsRunner[any](t, initE)
+	r.Add(makeAndValidateAssert)
 	r.Run()
 }
 
-func makeAssert(_ *testing.T, assert *assertP.Assert) {
+func makeAndValidateAssert(t *testing.T, _ any) {
 	assert.That(10).
 		IsNotNil().
-		IsEqualTo(10)
+		IsEqualTo(20)
+
+	sa := registry.GlobalRegistryGetAssertType().(*assert_type.SoftAssert)
+	if !sa.Failed() {
+		t.Fatalf("should have failed")
+	}
 }

From f0d88d7f0fcea741aca144abec64452f17ec05a8 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 22:58:12 +0530
Subject: [PATCH 27/35] fix warning

---
 src/test/assert/bool_test.go    | 4 ++--
 src/test/assert/generic_test.go | 4 ++--
 src/test/assert/string_test.go  | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/test/assert/bool_test.go b/src/test/assert/bool_test.go
index cb7f196..2422402 100644
--- a/src/test/assert/bool_test.go
+++ b/src/test/assert/bool_test.go
@@ -15,7 +15,7 @@ func Test_Bool(t *testing.T) {
 	r.Run()
 }
 
-func thatBool(t *testing.T, e any) {
+func thatBool(t *testing.T, _ any) {
 	var a any = assert.ThatBool(true)
 	casted, ok := a.(*asserter.Bool)
 	if !ok {
@@ -26,7 +26,7 @@ func thatBool(t *testing.T, e any) {
 	}
 }
 
-func thatBoolWith(t *testing.T, e any) {
+func thatBoolWith(t *testing.T, _ any) {
 	var a any = assert.ThatBoolWith(assert_type.NewSoftAssert(t), false)
 	casted, ok := a.(*asserter.Bool)
 	if !ok {
diff --git a/src/test/assert/generic_test.go b/src/test/assert/generic_test.go
index c575558..97601a7 100644
--- a/src/test/assert/generic_test.go
+++ b/src/test/assert/generic_test.go
@@ -16,7 +16,7 @@ func Test_Generic(t *testing.T) {
 	r.Run()
 }
 
-func that(t *testing.T, e any) {
+func that(t *testing.T, _ any) {
 	var a any = assert.That("some val")
 	casted, ok := a.(*asserter.Generic[string])
 	if !ok {
@@ -27,7 +27,7 @@ func that(t *testing.T, e any) {
 	}
 }
 
-func thatWith(t *testing.T, e any) {
+func thatWith(t *testing.T, _ any) {
 	var a any = assert.ThatWith(
 		assert_type.NewSoftAssert(t),
 		equator.NewComparableEquator[string](),
diff --git a/src/test/assert/string_test.go b/src/test/assert/string_test.go
index 34485a0..dbd31dc 100644
--- a/src/test/assert/string_test.go
+++ b/src/test/assert/string_test.go
@@ -15,7 +15,7 @@ func Test_String(t *testing.T) {
 	r.Run()
 }
 
-func thatString(t *testing.T, e any) {
+func thatString(t *testing.T, _ any) {
 	var a any = assert.ThatString("some val")
 	casted, ok := a.(*asserter.String)
 	if !ok {
@@ -26,7 +26,7 @@ func thatString(t *testing.T, e any) {
 	}
 }
 
-func thatStringWith(t *testing.T, e any) {
+func thatStringWith(t *testing.T, _ any) {
 	var a any = assert.ThatStringWith(assert_type.NewSoftAssert(t), "some val")
 	casted, ok := a.(*asserter.String)
 	if !ok {

From 35b5909048503ee6eaf3c15c3ed3250b52a99c68 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 23:02:44 +0530
Subject: [PATCH 28/35] tidy

---
 src/test/asserter/{ => bool}/Bool_test.go     | 22 +++++------
 src/test/asserter/{ => string}/String_test.go | 38 +++++++++----------
 2 files changed, 30 insertions(+), 30 deletions(-)
 rename src/test/asserter/{ => bool}/Bool_test.go (60%)
 rename src/test/asserter/{ => string}/String_test.go (58%)

diff --git a/src/test/asserter/Bool_test.go b/src/test/asserter/bool/Bool_test.go
similarity index 60%
rename from src/test/asserter/Bool_test.go
rename to src/test/asserter/bool/Bool_test.go
index 6615b9b..3dba261 100644
--- a/src/test/asserter/Bool_test.go
+++ b/src/test/asserter/bool/Bool_test.go
@@ -1,4 +1,4 @@
-package asserter
+package bool
 
 import (
 	"github.com/sku0x20/assertG/src/main/assert_type"
@@ -7,20 +7,20 @@ import (
 	"testing"
 )
 
-func init_Bool(t *testing.T) *assert_type.SoftAssert {
+func init_B(t *testing.T) *assert_type.SoftAssert {
 	return assert_type.NewSoftAssert(t)
 }
 
 func Test_Bool(t *testing.T) {
-	r := runner.NewTestsRunner(t, init_Bool)
-	r.Add(truePass_Bool)
-	r.Add(trueFail_Bool)
-	r.Add(falsePass_Bool)
-	r.Add(falseFail_Bool)
+	r := runner.NewTestsRunner(t, init_B)
+	r.Add(truePass)
+	r.Add(trueFail)
+	r.Add(falsePass)
+	r.Add(falseFail)
 	r.Run()
 }
 
-func truePass_Bool(t *testing.T, s *assert_type.SoftAssert) {
+func truePass(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 1 == 1)
 	a = a.IsTrue()
 	if s.Failed() {
@@ -28,7 +28,7 @@ func truePass_Bool(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func trueFail_Bool(t *testing.T, s *assert_type.SoftAssert) {
+func trueFail(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 2 == 1)
 	a = a.IsTrue()
 	if !s.Failed() {
@@ -36,7 +36,7 @@ func trueFail_Bool(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func falsePass_Bool(t *testing.T, s *assert_type.SoftAssert) {
+func falsePass(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 2 == 1)
 	a = a.IsFalse()
 	if s.Failed() {
@@ -44,7 +44,7 @@ func falsePass_Bool(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func falseFail_Bool(t *testing.T, s *assert_type.SoftAssert) {
+func falseFail(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 1 == 1)
 	a = a.IsFalse()
 	if !s.Failed() {
diff --git a/src/test/asserter/String_test.go b/src/test/asserter/string/String_test.go
similarity index 58%
rename from src/test/asserter/String_test.go
rename to src/test/asserter/string/String_test.go
index fc154ee..9d70cee 100644
--- a/src/test/asserter/String_test.go
+++ b/src/test/asserter/string/String_test.go
@@ -1,4 +1,4 @@
-package asserter
+package string
 
 import (
 	"github.com/sku0x20/assertG/src/main/assert_type"
@@ -7,24 +7,24 @@ import (
 	"testing"
 )
 
-func init_String(t *testing.T) *assert_type.SoftAssert {
+func init_S(t *testing.T) *assert_type.SoftAssert {
 	return assert_type.NewSoftAssert(t)
 }
 
 func Test_String(t *testing.T) {
-	r := runner.NewTestsRunner(t, init_String)
-	r.Add(equalPass_String)
-	r.Add(equalFail_String)
-	r.Add(containsPass_String)
-	r.Add(containsFail_String)
-	r.Add(notContainsPass_String)
-	r.Add(notContainsFail_String)
-	r.Add(hasLengthPass_String)
-	r.Add(hasLengthFail_String)
+	r := runner.NewTestsRunner(t, init_S)
+	r.Add(equalPass)
+	r.Add(equalFail)
+	r.Add(containsPass)
+	r.Add(containsFail)
+	r.Add(notContainsPass)
+	r.Add(notContainsFail)
+	r.Add(hasLengthPass)
+	r.Add(hasLengthFail)
 	r.Run()
 }
 
-func equalPass_String(t *testing.T, s *assert_type.SoftAssert) {
+func equalPass(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.IsEqualTo("some val")
 	if s.Failed() {
@@ -32,7 +32,7 @@ func equalPass_String(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func equalFail_String(t *testing.T, s *assert_type.SoftAssert) {
+func equalFail(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.IsEqualTo("other val")
 	if !s.Failed() {
@@ -40,7 +40,7 @@ func equalFail_String(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func containsPass_String(t *testing.T, s *assert_type.SoftAssert) {
+func containsPass(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.Contains("val")
 	if s.Failed() {
@@ -48,7 +48,7 @@ func containsPass_String(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func containsFail_String(t *testing.T, s *assert_type.SoftAssert) {
+func containsFail(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.Contains("other")
 	if !s.Failed() {
@@ -56,7 +56,7 @@ func containsFail_String(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func notContainsPass_String(t *testing.T, s *assert_type.SoftAssert) {
+func notContainsPass(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.NotContains("other")
 	if s.Failed() {
@@ -64,7 +64,7 @@ func notContainsPass_String(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func notContainsFail_String(t *testing.T, s *assert_type.SoftAssert) {
+func notContainsFail(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.NotContains("some")
 	if !s.Failed() {
@@ -72,7 +72,7 @@ func notContainsFail_String(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func hasLengthPass_String(t *testing.T, s *assert_type.SoftAssert) {
+func hasLengthPass(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.HasLength(8)
 	if s.Failed() {
@@ -80,7 +80,7 @@ func hasLengthPass_String(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
-func hasLengthFail_String(t *testing.T, s *assert_type.SoftAssert) {
+func hasLengthFail(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewString(s, "some val")
 	a = a.HasLength(10)
 	if !s.Failed() {

From 791ccfefef7dda12463e431a27ecca2b21cb75c7 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 23:03:29 +0530
Subject: [PATCH 29/35] tidy warnings

---
 src/test/asserter/bool/Bool_test.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/test/asserter/bool/Bool_test.go b/src/test/asserter/bool/Bool_test.go
index 3dba261..c75e0c1 100644
--- a/src/test/asserter/bool/Bool_test.go
+++ b/src/test/asserter/bool/Bool_test.go
@@ -20,6 +20,7 @@ func Test_Bool(t *testing.T) {
 	r.Run()
 }
 
+//goland:noinspection GoBoolExpressions
 func truePass(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 1 == 1)
 	a = a.IsTrue()
@@ -28,6 +29,7 @@ func truePass(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
+//goland:noinspection GoBoolExpressions
 func trueFail(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 2 == 1)
 	a = a.IsTrue()
@@ -36,6 +38,7 @@ func trueFail(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
+//goland:noinspection GoBoolExpressions
 func falsePass(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 2 == 1)
 	a = a.IsFalse()
@@ -44,6 +47,7 @@ func falsePass(t *testing.T, s *assert_type.SoftAssert) {
 	}
 }
 
+//goland:noinspection GoBoolExpressions
 func falseFail(t *testing.T, s *assert_type.SoftAssert) {
 	a := asserter.NewBool(s, 1 == 1)
 	a = a.IsFalse()

From f68d8b02cf29e44ff8be5ee754da2ded3b42f688 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 23:19:48 +0530
Subject: [PATCH 30/35] add elemEquator in Slice.go

---
 src/main/asserter/Slice.go            | 51 ++++++++++++++++++++-------
 src/test/asserter/slice/Slice_test.go | 37 ++++++++++++++++---
 2 files changed, 71 insertions(+), 17 deletions(-)

diff --git a/src/main/asserter/Slice.go b/src/main/asserter/Slice.go
index 9dcff00..9a164fc 100644
--- a/src/main/asserter/Slice.go
+++ b/src/main/asserter/Slice.go
@@ -2,18 +2,23 @@ package asserter
 
 import (
 	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/equator"
 	"github.com/sku0x20/assertG/src/main/message"
 	"github.com/sku0x20/assertG/src/main/message/verbs"
-	"reflect"
 )
 
-func NewSlice[T any](a assert_type.AssertType, val []T) *Slice[T] {
-	return &Slice[T]{a, val}
+func NewSlice[T any](
+	a assert_type.AssertType,
+	elemEquator equator.Equator[T],
+	val []T,
+) *Slice[T] {
+	return &Slice[T]{a, elemEquator, val}
 }
 
 type Slice[T any] struct {
-	assertion assert_type.AssertType
-	actual    []T
+	assertion   assert_type.AssertType
+	elemEquator equator.Equator[T]
+	actual      []T
 }
 
 func (s *Slice[T]) HasLength(l int) *Slice[T] {
@@ -32,13 +37,35 @@ func (s *Slice[T]) HasLength(l int) *Slice[T] {
 
 func (s *Slice[T]) IsEqualTo(expected []T) *Slice[T] {
 	s.HasLength(len(expected))
-	if !reflect.DeepEqual(s.actual, expected) {
-		s.assertion.FailWith(
-			message.Expected().
-				Value(s.actual).
-				Verb(verbs.ToEqual).
-				Value(expected),
-		)
+	for i := 0; i < len(expected); i++ {
+		if !s.elemEquator.AreEqual(s.actual[i], expected[i]) {
+			s.assertion.FailWith(
+				message.Expected().
+					Value(s.actual).
+					Verb(verbs.ToEqual).
+					Value(expected),
+			)
+		}
 	}
 	return s
 }
+
+//func (s *Slice[T]) IsEqualToIgnoringOrder(expected []T) *Slice[T] {
+//	s.HasLength(len(expected))
+//	//for _, elem := range expected {
+//	//	for _, actual := range s.actual {
+//	//		if elem == actual {
+//	//			break
+//	//		}
+//	//	}
+//	//}
+//	//if !reflect.DeepEqual(s.actual, expected) {
+//	//	s.assertion.FailWith(
+//	//		message.Expected().
+//	//			Value(s.actual).
+//	//			Verb(verbs.ToEqual).
+//	//			Value(expected),
+//	//	)
+//	//}
+//	return s
+//}
diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index 951bd94..f0496be 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -3,6 +3,7 @@ package slice
 import (
 	"github.com/sku0x20/assertG/src/main/assert_type"
 	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"testing"
 )
@@ -11,20 +12,20 @@ func Test_Slice(t *testing.T) {
 	r := runner.NewTestsRunnerEmptyInit[any](t)
 	r.Add(hasLength)
 	r.Add(IsEqualTo)
-	//r.Add(ContainsExactlyAnyOrder_Slice)
+	//r.Add(IsEqualToIgnoringOrder)
 	r.Run()
 }
 
 func hasLength(t *testing.T, _ any) {
 	intS := []int{10}
 	sa := assert_type.NewSoftAssert(t)
-	a := asserter.NewSlice(sa, intS)
+	a := asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS)
 	a = a.HasLength(1)
 	if sa.Failed() {
 		t.Fatalf("should not have failed")
 	}
 	sa = assert_type.NewSoftAssert(t)
-	a = asserter.NewSlice(sa, intS)
+	a = asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS)
 	a = a.HasLength(2)
 	if !sa.Failed() {
 		t.Fatalf("should have failed")
@@ -45,10 +46,36 @@ func IsEqualTo(t *testing.T, _ any) {
 		{[]int{10, 20, 30}, []int{10, 20, 30}, false},
 	}
 	runTests(t, tests, func(a *asserter.Slice[int], expected []int) *asserter.Slice[int] {
+		defer func() {
+			if r := recover(); r != nil {
+				// panic is valid in the 1st and 2nd case
+				t.Logf("recovered from panic: %v", r)
+			}
+		}()
 		return a.IsEqualTo(expected)
 	})
 }
 
+//func IsEqualToIgnoringOrder(t *testing.T, _ any) {
+//	t.Skip()
+//	tests := []test{
+//		{[]int{10, 20, 30}, []int{10}, true},
+//		{[]int{10, 20, 30}, []int{10, 20, 30, 40}, true},
+//		{[]int{10, 20, 30}, []int{0, 20, 30}, true},
+//		{[]int{10, 20, 30}, []int{30, 10, 20}, false},
+//		{[]int{10, 20, 30}, []int{10, 20, 30}, false},
+//	}
+//	runTests(t, tests, func(a *asserter.Slice[int], expected []int) *asserter.Slice[int] {
+//		defer func() {
+//			if r := recover(); r != nil {
+//				// panic is valid in the 1st and 2nd case
+//				t.Logf("recovered from panic: %v", r)
+//			}
+//		}()
+//		return a.IsEqualToIgnoringOrder(expected)
+//	})
+//}
+
 func runTests(
 	t *testing.T,
 	tests []test,
@@ -57,10 +84,10 @@ func runTests(
 	for _, ct := range tests {
 		t.Run("", func(t *testing.T) {
 			sa := assert_type.NewSoftAssert(t)
-			a := asserter.NewSlice(sa, ct.actual)
+			a := asserter.NewSlice(sa, equator.NewComparableEquator[int](), ct.actual)
 			a = fnAssertion(a, ct.expected)
 			if sa.Failed() != ct.shouldFail {
-				t.Fatalf("should have failed")
+				t.Fatalf("should have failed = %t", ct.shouldFail)
 			}
 		})
 	}

From a03aab0ccc1c7847e3006809cd9291220774c615 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 23:27:53 +0530
Subject: [PATCH 31/35] add slice.IsEqualToIgnoringOrder

---
 src/main/asserter/Slice.go            | 37 +++++++++++++------------
 src/test/asserter/slice/Slice_test.go | 39 +++++++++++++--------------
 2 files changed, 37 insertions(+), 39 deletions(-)

diff --git a/src/main/asserter/Slice.go b/src/main/asserter/Slice.go
index 9a164fc..e6afd64 100644
--- a/src/main/asserter/Slice.go
+++ b/src/main/asserter/Slice.go
@@ -50,22 +50,21 @@ func (s *Slice[T]) IsEqualTo(expected []T) *Slice[T] {
 	return s
 }
 
-//func (s *Slice[T]) IsEqualToIgnoringOrder(expected []T) *Slice[T] {
-//	s.HasLength(len(expected))
-//	//for _, elem := range expected {
-//	//	for _, actual := range s.actual {
-//	//		if elem == actual {
-//	//			break
-//	//		}
-//	//	}
-//	//}
-//	//if !reflect.DeepEqual(s.actual, expected) {
-//	//	s.assertion.FailWith(
-//	//		message.Expected().
-//	//			Value(s.actual).
-//	//			Verb(verbs.ToEqual).
-//	//			Value(expected),
-//	//	)
-//	//}
-//	return s
-//}
+func (s *Slice[T]) IsEqualToIgnoringOrder(expected []T) *Slice[T] {
+	s.HasLength(len(expected))
+outer:
+	for _, elem := range expected {
+		for _, actual := range s.actual {
+			if s.elemEquator.AreEqual(actual, elem) {
+				continue outer
+			}
+		}
+		s.assertion.FailWith(
+			message.Expected().
+				Value(s.actual).
+				Verb(verbs.ToEqual).
+				Value(expected),
+		)
+	}
+	return s
+}
diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index f0496be..6905bb1 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -12,7 +12,7 @@ func Test_Slice(t *testing.T) {
 	r := runner.NewTestsRunnerEmptyInit[any](t)
 	r.Add(hasLength)
 	r.Add(IsEqualTo)
-	//r.Add(IsEqualToIgnoringOrder)
+	r.Add(IsEqualToIgnoringOrder)
 	r.Run()
 }
 
@@ -56,25 +56,24 @@ func IsEqualTo(t *testing.T, _ any) {
 	})
 }
 
-//func IsEqualToIgnoringOrder(t *testing.T, _ any) {
-//	t.Skip()
-//	tests := []test{
-//		{[]int{10, 20, 30}, []int{10}, true},
-//		{[]int{10, 20, 30}, []int{10, 20, 30, 40}, true},
-//		{[]int{10, 20, 30}, []int{0, 20, 30}, true},
-//		{[]int{10, 20, 30}, []int{30, 10, 20}, false},
-//		{[]int{10, 20, 30}, []int{10, 20, 30}, false},
-//	}
-//	runTests(t, tests, func(a *asserter.Slice[int], expected []int) *asserter.Slice[int] {
-//		defer func() {
-//			if r := recover(); r != nil {
-//				// panic is valid in the 1st and 2nd case
-//				t.Logf("recovered from panic: %v", r)
-//			}
-//		}()
-//		return a.IsEqualToIgnoringOrder(expected)
-//	})
-//}
+func IsEqualToIgnoringOrder(t *testing.T, _ any) {
+	tests := []test{
+		{[]int{10, 20, 30}, []int{10}, true},
+		{[]int{10, 20, 30}, []int{10, 20, 30, 40}, true},
+		{[]int{10, 20, 30}, []int{0, 20, 30}, true},
+		{[]int{10, 20, 30}, []int{30, 10, 20}, false},
+		{[]int{10, 20, 30}, []int{10, 20, 30}, false},
+	}
+	runTests(t, tests, func(a *asserter.Slice[int], expected []int) *asserter.Slice[int] {
+		defer func() {
+			if r := recover(); r != nil {
+				// panic is valid in the 1st and 2nd case
+				t.Logf("recovered from panic: %v", r)
+			}
+		}()
+		return a.IsEqualToIgnoringOrder(expected)
+	})
+}
 
 func runTests(
 	t *testing.T,

From c133c8bed092a1f77af1924d2c994153a844ab4b Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 23:29:53 +0530
Subject: [PATCH 32/35] tidy

---
 src/test/asserter/slice/Slice_test.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index 6905bb1..9346096 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -11,8 +11,8 @@ import (
 func Test_Slice(t *testing.T) {
 	r := runner.NewTestsRunnerEmptyInit[any](t)
 	r.Add(hasLength)
-	r.Add(IsEqualTo)
-	r.Add(IsEqualToIgnoringOrder)
+	r.Add(isEqualTo)
+	r.Add(isEqualToIgnoringOrder)
 	r.Run()
 }
 
@@ -38,7 +38,7 @@ type test struct {
 	shouldFail bool
 }
 
-func IsEqualTo(t *testing.T, _ any) {
+func isEqualTo(t *testing.T, _ any) {
 	tests := []test{
 		{[]int{10, 20, 30}, []int{10}, true},
 		{[]int{10, 20, 30}, []int{10, 20, 30, 40}, true},
@@ -56,7 +56,7 @@ func IsEqualTo(t *testing.T, _ any) {
 	})
 }
 
-func IsEqualToIgnoringOrder(t *testing.T, _ any) {
+func isEqualToIgnoringOrder(t *testing.T, _ any) {
 	tests := []test{
 		{[]int{10, 20, 30}, []int{10}, true},
 		{[]int{10, 20, 30}, []int{10, 20, 30, 40}, true},

From d8ffcb6bff9a576c24f22b5b6fb79e4403871f58 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 23:33:44 +0530
Subject: [PATCH 33/35] add contains

---
 src/main/asserter/Slice.go            | 15 +++++++++++++++
 src/test/asserter/slice/Slice_test.go | 17 +++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/src/main/asserter/Slice.go b/src/main/asserter/Slice.go
index e6afd64..73ca565 100644
--- a/src/main/asserter/Slice.go
+++ b/src/main/asserter/Slice.go
@@ -35,6 +35,21 @@ func (s *Slice[T]) HasLength(l int) *Slice[T] {
 	return s
 }
 
+func (s *Slice[T]) Contains(elem T) *Slice[T] {
+	for _, actual := range s.actual {
+		if s.elemEquator.AreEqual(actual, elem) {
+			break
+		}
+		s.assertion.FailWith(
+			message.Expected().
+				Value(s.actual).
+				Verb(verbs.ToContain).
+				Value(elem),
+		)
+	}
+	return s
+}
+
 func (s *Slice[T]) IsEqualTo(expected []T) *Slice[T] {
 	s.HasLength(len(expected))
 	for i := 0; i < len(expected); i++ {
diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index 9346096..cd066e7 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -13,6 +13,7 @@ func Test_Slice(t *testing.T) {
 	r.Add(hasLength)
 	r.Add(isEqualTo)
 	r.Add(isEqualToIgnoringOrder)
+	r.Add(contains)
 	r.Run()
 }
 
@@ -32,6 +33,22 @@ func hasLength(t *testing.T, _ any) {
 	}
 }
 
+func contains(t *testing.T, _ any) {
+	intS := []int{10, 20, 30}
+	sa := assert_type.NewSoftAssert(t)
+	a := asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS)
+	a = a.Contains(10)
+	if sa.Failed() {
+		t.Fatalf("should not have failed")
+	}
+	sa = assert_type.NewSoftAssert(t)
+	a = asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS)
+	a = a.Contains(50)
+	if !sa.Failed() {
+		t.Fatalf("should have failed")
+	}
+}
+
 type test struct {
 	actual     []int
 	expected   []int

From 87f7deaa54057f5e74c544e2a59ea5a6e9064204 Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 23:39:00 +0530
Subject: [PATCH 34/35] add NotContains assertion

---
 src/main/asserter/Slice.go            | 14 ++++++++++++++
 src/test/asserter/slice/Slice_test.go | 17 +++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/src/main/asserter/Slice.go b/src/main/asserter/Slice.go
index 73ca565..8990f14 100644
--- a/src/main/asserter/Slice.go
+++ b/src/main/asserter/Slice.go
@@ -50,6 +50,20 @@ func (s *Slice[T]) Contains(elem T) *Slice[T] {
 	return s
 }
 
+func (s *Slice[T]) NotContains(elem T) *Slice[T] {
+	for _, actual := range s.actual {
+		if s.elemEquator.AreEqual(actual, elem) {
+			s.assertion.FailWith(
+				message.Expected().
+					Value(s.actual).
+					Verb(verbs.NotToContain).
+					Value(elem),
+			)
+		}
+	}
+	return s
+}
+
 func (s *Slice[T]) IsEqualTo(expected []T) *Slice[T] {
 	s.HasLength(len(expected))
 	for i := 0; i < len(expected); i++ {
diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go
index cd066e7..f8fc5d9 100644
--- a/src/test/asserter/slice/Slice_test.go
+++ b/src/test/asserter/slice/Slice_test.go
@@ -14,6 +14,7 @@ func Test_Slice(t *testing.T) {
 	r.Add(isEqualTo)
 	r.Add(isEqualToIgnoringOrder)
 	r.Add(contains)
+	r.Add(notContains)
 	r.Run()
 }
 
@@ -49,6 +50,22 @@ func contains(t *testing.T, _ any) {
 	}
 }
 
+func notContains(t *testing.T, _ any) {
+	intS := []int{10, 20, 30}
+	sa := assert_type.NewSoftAssert(t)
+	a := asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS)
+	a = a.NotContains(50)
+	if sa.Failed() {
+		t.Fatalf("should not have failed")
+	}
+	sa = assert_type.NewSoftAssert(t)
+	a = asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS)
+	a = a.NotContains(20)
+	if !sa.Failed() {
+		t.Fatalf("should have failed")
+	}
+}
+
 type test struct {
 	actual     []int
 	expected   []int

From c0aa2c1c2443f8439d10252d3a5a4d8e8c7b667e Mon Sep 17 00:00:00 2001
From: siddhant <siddhantkumarupmanyu@gmail.com>
Date: Sat, 5 Apr 2025 23:44:37 +0530
Subject: [PATCH 35/35] add assert.ThatSlice

---
 src/main/assert/slice.go      | 21 +++++++++++++++++
 src/test/assert/slice_test.go | 43 +++++++++++++++++++++++++++++++++++
 2 files changed, 64 insertions(+)
 create mode 100644 src/main/assert/slice.go
 create mode 100644 src/test/assert/slice_test.go

diff --git a/src/main/assert/slice.go b/src/main/assert/slice.go
new file mode 100644
index 0000000..797134d
--- /dev/null
+++ b/src/main/assert/slice.go
@@ -0,0 +1,21 @@
+package assert
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/assertG/src/main/registry"
+)
+
+func ThatSlice[T any](value []T) *asserter.Slice[T] {
+	at := registry.GlobalRegistryGetAssertType()
+	return ThatSliceWith(at, equator.NewReflectDeepEquator[T](), value)
+}
+
+func ThatSliceWith[T any](
+	a assert_type.AssertType,
+	elemEquator equator.Equator[T],
+	value []T,
+) *asserter.Slice[T] {
+	return asserter.NewSlice(a, elemEquator, value)
+}
diff --git a/src/test/assert/slice_test.go b/src/test/assert/slice_test.go
new file mode 100644
index 0000000..aa2aaa5
--- /dev/null
+++ b/src/test/assert/slice_test.go
@@ -0,0 +1,43 @@
+package assert
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/gRunner/src/pkg/runner"
+	"testing"
+)
+
+func Test_Slice(t *testing.T) {
+	r := runner.NewTestsRunnerEmptyInit[any](t)
+	r.Add(thatSlice)
+	r.Add(thatSliceWith)
+	r.Run()
+}
+
+func thatSlice(t *testing.T, _ any) {
+	var a any = assert.ThatSlice([]string{"some val"})
+	casted, ok := a.(*asserter.Slice[string])
+	if !ok {
+		t.Fatalf("unable to cast")
+	}
+	if casted == nil {
+		t.Fatalf("casted is nil")
+	}
+}
+
+func thatSliceWith(t *testing.T, _ any) {
+	var a any = assert.ThatSliceWith(
+		assert_type.NewSoftAssert(t),
+		equator.NewComparableEquator[string](),
+		[]string{"some val"},
+	)
+	casted, ok := a.(*asserter.Slice[string])
+	if !ok {
+		t.Fatalf("unable to cast")
+	}
+	if casted == nil {
+		t.Fatalf("casted is nil")
+	}
+}