Some refactor.

README.md

@@ -1,6 +1,6 @@
 ### resilience4go
 
-[![Build](https://github.com/CharLemAznable/gofn/actions/workflows/go.yml/badge.svg)](https://github.com/CharLemAznable/resilience4go/actions/workflows/go.yml)
+[![Build](https://github.com/CharLemAznable/resilience4go/actions/workflows/go.yml/badge.svg)](https://github.com/CharLemAznable/resilience4go/actions/workflows/go.yml)
 ![GitHub release (latest by date)](https://img.shields.io/github/v/release/CharLemAznable/resilience4go)
 
 [![MIT Licence](https://badges.frapsoft.com/os/mit/mit.svg?v=103)](https://opensource.org/licenses/mit-license.php)

bulkhead/decorate.go

@@ -1,6 +1,6 @@
 package bulkhead
 
-import "github.com/CharLemAznable/gofn/common"
+import "github.com/CharLemAznable/ge"
 
 func DecorateRunnable(bulkhead Bulkhead, fn func() error) func() error {
 	return func() error {
@@ -15,7 +15,7 @@ func DecorateRunnable(bulkhead Bulkhead, fn func() error) func() error {
 func DecorateSupplier[T any](bulkhead Bulkhead, fn func() (T, error)) func() (T, error) {
 	return func() (T, error) {
 		if err := bulkhead.acquire(); err != nil {
-			return common.Zero[T](), err
+			return ge.Zero[T](), err
 		}
 		defer bulkhead.release()
 		return fn()
@@ -35,7 +35,7 @@ func DecorateConsumer[T any](bulkhead Bulkhead, fn func(T) error) func(T) error
 func DecorateFunction[T any, R any](bulkhead Bulkhead, fn func(T) (R, error)) func(T) (R, error) {
 	return func(t T) (R, error) {
 		if err := bulkhead.acquire(); err != nil {
-			return common.Zero[R](), err
+			return ge.Zero[R](), err
 		}
 		defer bulkhead.release()
 		return fn(t)

bulkhead/event_listener.go

@@ -1,7 +1,7 @@
 package bulkhead
 
 import (
-	"github.com/CharLemAznable/resilience4go/utils"
+	"github.com/CharLemAznable/ge"
 	"sync"
 )
 
@@ -30,21 +30,21 @@ type eventListener struct {
 func (listener *eventListener) OnPermitted(consumer func(PermittedEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onPermitted = utils.AppendElementUnique(listener.onPermitted, consumer)
+	listener.onPermitted = ge.AppendElementUnique(listener.onPermitted, consumer)
 	return listener
 }
 
 func (listener *eventListener) OnRejected(consumer func(RejectedEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onRejected = utils.AppendElementUnique(listener.onRejected, consumer)
+	listener.onRejected = ge.AppendElementUnique(listener.onRejected, consumer)
 	return listener
 }
 
 func (listener *eventListener) OnFinished(consumer func(FinishedEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onFinished = utils.AppendElementUnique(listener.onFinished, consumer)
+	listener.onFinished = ge.AppendElementUnique(listener.onFinished, consumer)
 	return listener
 }
 
@@ -53,11 +53,11 @@ func (listener *eventListener) Dismiss(consumer any) EventListener {
 	defer listener.Unlock()
 	switch c := consumer.(type) {
 	case func(PermittedEvent):
-		listener.onPermitted = utils.RemoveElementByValue(listener.onPermitted, c)
+		listener.onPermitted = ge.RemoveElementByValue(listener.onPermitted, c)
 	case func(RejectedEvent):
-		listener.onRejected = utils.RemoveElementByValue(listener.onRejected, c)
+		listener.onRejected = ge.RemoveElementByValue(listener.onRejected, c)
 	case func(FinishedEvent):
-		listener.onFinished = utils.RemoveElementByValue(listener.onFinished, c)
+		listener.onFinished = ge.RemoveElementByValue(listener.onFinished, c)
 	}
 	return listener
 }
@@ -68,11 +68,11 @@ func (listener *eventListener) consumeEvent(event Event) {
 		defer listener.RUnlock()
 		switch e := event.(type) {
 		case *permittedEvent:
-			utils.ConsumeEvent(listener.onPermitted, PermittedEvent(e))
+			ge.ConsumeEach(listener.onPermitted, PermittedEvent(e))
 		case *rejectedEvent:
-			utils.ConsumeEvent(listener.onRejected, RejectedEvent(e))
+			ge.ConsumeEach(listener.onRejected, RejectedEvent(e))
 		case *finishedEvent:
-			utils.ConsumeEvent(listener.onFinished, FinishedEvent(e))
+			ge.ConsumeEach(listener.onFinished, FinishedEvent(e))
 		}
 	}()
 }

cache/cache.go

@@ -1,7 +1,7 @@
 package cache
 
 import (
-	"github.com/CharLemAznable/gofn/common"
+	"github.com/CharLemAznable/ge"
 	"github.com/dgraph-io/ristretto"
 	"sync"
 )
@@ -29,7 +29,7 @@ func NewCache[K any, V any](name string, configs ...ConfigBuilder) Cache[K, V] {
 		KeyToHash:          config.keyToHashFn,
 		IgnoreInternalCost: true,
 	})
-	common.PanicIfError(err)
+	ge.PanicIfError(err)
 	c := &cache[K, V]{
 		name:           name,
 		config:         config,
@@ -83,14 +83,14 @@ func (c *cache[K, V]) GetOrLoad(key K, loader func(K) (V, error)) (V, error) {
 
 	if v, found := c.ristrettoCache.Get(key); found {
 		c.eventListener.consumeEvent(newCacheHitEvent(c.name, key))
-		vv, err := common.Cast[*valueWithError](v)
-		common.PanicIfError(err)
+		vv, err := ge.Cast[*valueWithError](v)
+		ge.PanicIfError(err)
 		vvv := vv.value
 		if c.unmarshalFn != nil {
 			vvv = c.unmarshalFn(vv.value)
 		}
-		value, err := common.CastOrZero[V](vvv)
-		common.PanicIfError(err)
+		value, err := ge.CastOrZero[V](vvv)
+		ge.PanicIfError(err)
 		return value, vv.error
 	}
 	c.eventListener.consumeEvent(newCacheMissEvent(c.name, key))

cache/event_listener.go

@@ -1,7 +1,7 @@
 package cache
 
 import (
-	"github.com/CharLemAznable/resilience4go/utils"
+	"github.com/CharLemAznable/ge"
 	"sync"
 )
 
@@ -27,14 +27,14 @@ type eventListener struct {
 func (listener *eventListener) OnCacheHit(consumer func(HitEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onCacheHit = utils.AppendElementUnique(listener.onCacheHit, consumer)
+	listener.onCacheHit = ge.AppendElementUnique(listener.onCacheHit, consumer)
 	return listener
 }
 
 func (listener *eventListener) OnCacheMiss(consumer func(MissEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onCacheMiss = utils.AppendElementUnique(listener.onCacheMiss, consumer)
+	listener.onCacheMiss = ge.AppendElementUnique(listener.onCacheMiss, consumer)
 	return listener
 }
 
@@ -43,9 +43,9 @@ func (listener *eventListener) Dismiss(consumer any) EventListener {
 	defer listener.Unlock()
 	switch c := consumer.(type) {
 	case func(HitEvent):
-		listener.onCacheHit = utils.RemoveElementByValue(listener.onCacheHit, c)
+		listener.onCacheHit = ge.RemoveElementByValue(listener.onCacheHit, c)
 	case func(MissEvent):
-		listener.onCacheMiss = utils.RemoveElementByValue(listener.onCacheMiss, c)
+		listener.onCacheMiss = ge.RemoveElementByValue(listener.onCacheMiss, c)
 	}
 	return listener
 }
@@ -56,9 +56,9 @@ func (listener *eventListener) consumeEvent(event Event) {
 		defer listener.RUnlock()
 		switch e := event.(type) {
 		case *hitEvent:
-			utils.ConsumeEvent(listener.onCacheHit, HitEvent(e))
+			ge.ConsumeEach(listener.onCacheHit, HitEvent(e))
 		case *missEvent:
-			utils.ConsumeEvent(listener.onCacheMiss, MissEvent(e))
+			ge.ConsumeEach(listener.onCacheMiss, MissEvent(e))
 		}
 	}()
 }

circuitbreaker/circuitbreaker.go

@@ -2,7 +2,7 @@ package circuitbreaker
 
 import (
 	"fmt"
-	"github.com/CharLemAznable/gofn/common"
+	"github.com/CharLemAznable/ge"
 	"sync/atomic"
 	"time"
 )
@@ -119,7 +119,7 @@ func (machine *stateMachine) execute(fn func() (any, error)) (any, error) {
 	}
 	start := time.Now()
 	finished := make(chan *channelValue)
-	panicked := make(common.Panicked)
+	panicked := make(ge.Panicked)
 	go func() {
 		defer panicked.Recover()
 		ret, err := fn()
@@ -130,7 +130,7 @@ func (machine *stateMachine) execute(fn func() (any, error)) (any, error) {
 		machine.onResult(start, result.ret, result.err)
 		return result.ret, result.err
 	case err := <-panicked.Caught():
-		machine.onResult(start, nil, common.WrapPanic(err))
+		machine.onResult(start, nil, ge.WrapPanic(err))
 		panic(err)
 	}
 }

circuitbreaker/config.go

@@ -2,7 +2,7 @@ package circuitbreaker
 
 import (
 	"fmt"
-	"github.com/CharLemAznable/resilience4go/utils"
+	"github.com/CharLemAznable/ge"
 	"time"
 )
 
@@ -71,7 +71,7 @@ func WithSlidingWindow(slidingWindowType SlidingWindowType, slidingWindowSize in
 		config.slidingWindowType = slidingWindowType
 		config.slidingWindowSize = slidingWindowSize
 		if CountBased == slidingWindowType {
-			config.minimumNumberOfCalls = utils.Min(minimumNumberOfCalls, slidingWindowSize)
+			config.minimumNumberOfCalls = ge.Min(minimumNumberOfCalls, slidingWindowSize)
 		} else {
 			config.minimumNumberOfCalls = minimumNumberOfCalls
 		}

circuitbreaker/decorate.go

@@ -1,6 +1,6 @@
 package circuitbreaker
 
-import "github.com/CharLemAznable/gofn/common"
+import "github.com/CharLemAznable/ge"
 
 func DecorateRunnable(breaker CircuitBreaker, fn func() error) func() error {
 	return func() error {
@@ -16,7 +16,7 @@ func DecorateSupplier[T any](breaker CircuitBreaker, fn func() (T, error)) func(
 		ret, err := breaker.execute(func() (any, error) {
 			return fn()
 		})
-		return common.CastQuietly[T](ret), err
+		return ge.CastQuietly[T](ret), err
 	}
 }
 
@@ -34,6 +34,6 @@ func DecorateFunction[T any, R any](breaker CircuitBreaker, fn func(T) (R, error
 		ret, err := breaker.execute(func() (any, error) {
 			return fn(t)
 		})
-		return common.CastQuietly[R](ret), err
+		return ge.CastQuietly[R](ret), err
 	}
 }

circuitbreaker/event_listener.go

@@ -1,7 +1,7 @@
 package circuitbreaker
 
 import (
-	"github.com/CharLemAznable/resilience4go/utils"
+	"github.com/CharLemAznable/ge"
 	"sync"
 )
 
@@ -39,42 +39,42 @@ type eventListener struct {
 func (listener *eventListener) OnSuccess(consumer func(SuccessEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onSuccess = utils.AppendElementUnique(listener.onSuccess, consumer)
+	listener.onSuccess = ge.AppendElementUnique(listener.onSuccess, consumer)
 	return listener
 }
 
 func (listener *eventListener) OnError(consumer func(ErrorEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onError = utils.AppendElementUnique(listener.onError, consumer)
+	listener.onError = ge.AppendElementUnique(listener.onError, consumer)
 	return listener
 }
 
 func (listener *eventListener) OnNotPermitted(consumer func(NotPermittedEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onNotPermitted = utils.AppendElementUnique(listener.onNotPermitted, consumer)
+	listener.onNotPermitted = ge.AppendElementUnique(listener.onNotPermitted, consumer)
 	return listener
 }
 
 func (listener *eventListener) OnStateTransition(consumer func(StateTransitionEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onStateTransition = utils.AppendElementUnique(listener.onStateTransition, consumer)
+	listener.onStateTransition = ge.AppendElementUnique(listener.onStateTransition, consumer)
 	return listener
 }
 
 func (listener *eventListener) OnFailureRateExceeded(consumer func(FailureRateExceededEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onFailureRateExceeded = utils.AppendElementUnique(listener.onFailureRateExceeded, consumer)
+	listener.onFailureRateExceeded = ge.AppendElementUnique(listener.onFailureRateExceeded, consumer)
 	return listener
 }
 
 func (listener *eventListener) OnSlowCallRateExceeded(consumer func(SlowCallRateExceededEvent)) EventListener {
 	listener.Lock()
 	defer listener.Unlock()
-	listener.onSlowCallRateExceeded = utils.AppendElementUnique(listener.onSlowCallRateExceeded, consumer)
+	listener.onSlowCallRateExceeded = ge.AppendElementUnique(listener.onSlowCallRateExceeded, consumer)
 	return listener
 }
 
@@ -83,17 +83,17 @@ func (listener *eventListener) Dismiss(consumer any) EventListener {
 	defer listener.Unlock()
 	switch c := consumer.(type) {
 	case func(SuccessEvent):
-		listener.onSuccess = utils.RemoveElementByValue(listener.onSuccess, c)
+		listener.onSuccess = ge.RemoveElementByValue(listener.onSuccess, c)
 	case func(ErrorEvent):
-		listener.onError = utils.RemoveElementByValue(listener.onError, c)
+		listener.onError = ge.RemoveElementByValue(listener.onError, c)
 	case func(NotPermittedEvent):
-		listener.onNotPermitted = utils.RemoveElementByValue(listener.onNotPermitted, c)
+		listener.onNotPermitted = ge.RemoveElementByValue(listener.onNotPermitted, c)
 	case func(StateTransitionEvent):
-		listener.onStateTransition = utils.RemoveElementByValue(listener.onStateTransition, c)
+		listener.onStateTransition = ge.RemoveElementByValue(listener.onStateTransition, c)
 	case func(FailureRateExceededEvent):
-		listener.onFailureRateExceeded = utils.RemoveElementByValue(listener.onFailureRateExceeded, c)
+		listener.onFailureRateExceeded = ge.RemoveElementByValue(listener.onFailureRateExceeded, c)
 	case func(SlowCallRateExceededEvent):
-		listener.onSlowCallRateExceeded = utils.RemoveElementByValue(listener.onSlowCallRateExceeded, c)
+		listener.onSlowCallRateExceeded = ge.RemoveElementByValue(listener.onSlowCallRateExceeded, c)
 	}
 	return listener
 }
@@ -104,17 +104,17 @@ func (listener *eventListener) consumeEvent(event Event) {
 		defer listener.RUnlock()
 		switch e := event.(type) {
 		case *successEvent:
-			utils.ConsumeEvent(listener.onSuccess, SuccessEvent(e))
+			ge.ConsumeEach(listener.onSuccess, SuccessEvent(e))
 		case *errorEvent:
-			utils.ConsumeEvent(listener.onError, ErrorEvent(e))
+			ge.ConsumeEach(listener.onError, ErrorEvent(e))
 		case *notPermittedEvent:
-			utils.ConsumeEvent(listener.onNotPermitted, NotPermittedEvent(e))
+			ge.ConsumeEach(listener.onNotPermitted, NotPermittedEvent(e))
 		case *stateTransitionEvent:
-			utils.ConsumeEvent(listener.onStateTransition, StateTransitionEvent(e))
+			ge.ConsumeEach(listener.onStateTransition, StateTransitionEvent(e))
 		case *failureRateExceededEvent:
-			utils.ConsumeEvent(listener.onFailureRateExceeded, FailureRateExceededEvent(e))
+			ge.ConsumeEach(listener.onFailureRateExceeded, FailureRateExceededEvent(e))
 		case *slowCallRateExceededEvent:
-			utils.ConsumeEvent(listener.onSlowCallRateExceeded, SlowCallRateExceededEvent(e))
+			ge.ConsumeEach(listener.onSlowCallRateExceeded, SlowCallRateExceededEvent(e))
 		}
 	}()
 }

circuitbreaker/metrics.go

@@ -1,7 +1,7 @@
 package circuitbreaker
 
 import (
-	"github.com/CharLemAznable/resilience4go/utils"
+	"github.com/CharLemAznable/ge"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -27,7 +27,7 @@ func newMetrics(slidingWindowSize int64, slidingWindowType SlidingWindowType, co
 	}
 	if CountBased == slidingWindowType {
 		m.recorder = newFixedSizeSlidingWindowRecorder(slidingWindowSize)
-		m.minimumNumberOfCalls = utils.Min(config.minimumNumberOfCalls, slidingWindowSize)
+		m.minimumNumberOfCalls = ge.Min(config.minimumNumberOfCalls, slidingWindowSize)
 	} else {
 		m.recorder = newSlidingTimeWindowRecorder(slidingWindowSize)
 		m.minimumNumberOfCalls = config.minimumNumberOfCalls
@@ -282,7 +282,7 @@ func (s *slidingTimeWindowRecorder) moveWindowToCurrentEpochSecond(latestPartial
 	if differenceInSeconds == 0 {
 		return latestPartialAggregation
 	}
-	secondsToMoveTheWindow := utils.Min(differenceInSeconds, s.timeWindowSizeInSeconds)
+	secondsToMoveTheWindow := ge.Min(differenceInSeconds, s.timeWindowSizeInSeconds)
 	var currentPartialAggregation *partialAggregation
 	for secondsToMoveTheWindow > 0 {
 		secondsToMoveTheWindow--