refactor(all): Revamped code base to extend on general Function inste…

…ad of ErrorF

compose/constant_test.go

@@ -0,0 +1,19 @@
+package compose
+
+import (
+	"errors"
+	"time"
+)
+
+const (
+	delayTime  = time.Duration(1e8)
+	retryCount = uint(10)
+
+	// This value should be returned by test Functions.
+	valueOp = 1
+)
+
+var (
+	// This error should be returned by test Functions.
+	errOp = errors.New("error")
+)

compose/doc.go

@@ -1,8 +1,4 @@
-// Package compose contains utility higher-order functions to wrap normal
-// functions.
-//
-// Naming conventions are:
-// - J prefix: Represents Just.
-// - M prefix: Represents Map.
-// - F prefix: Represents FlatMap.
+// Package compose contains higher-order functions to wrap normal functions to
+// provide additional capabilities. It also contains function extensions that
+// call these higher functions for easy chaining.
 package compose

compose/function.go

@@ -0,0 +1,10 @@
+package compose
+
+// Function represents an operation that could return an error.
+type Function func() (interface{}, error)
+
+// Invoke is a convenience method to call a Function. Although it is the same
+// as if we call the function normally, this may look nicer in a chain.
+func (f Function) Invoke() (interface{}, error) {
+	return f()
+}

compose/functionF.go

@@ -0,0 +1,24 @@
+package compose
+
+// FunctionF transforms a Function into another Function.
+type FunctionF func(Function) Function
+
+// Compose composes the functionalities of both FunctionF. We can use this to
+// chain enhance a base Function without exposing implementation details.
+func (ff FunctionF) Compose(selector FunctionF) FunctionF {
+	return func(f Function) Function {
+		return ff(selector(f))
+	}
+}
+
+// ComposeFn is similar to Compose, but it is more convenient when we deal with
+// functions that return FunctionF.
+func (ff FunctionF) ComposeFn(selectorFn func() FunctionF) FunctionF {
+	return ff.Compose(selectorFn())
+}
+
+// Wrap is a convenience method to invoke the wrap on a Function. This may look
+// nice in a function chain.
+func (ff FunctionF) Wrap(f Function) Function {
+	return ff(f)
+}

compose/error_test.go → compose/functionF_test.go

@@ -7,39 +7,39 @@ import (
 func TestCompose(t *testing.T) {
 	published := 0
 
-	var retryF ErrorFF = Retry(retryCount)
+	retryF := RetryF(retryCount)
 
-	publishF := PublishError(func(err error) {
+	publishF := PublishF(func(value interface{}, err error) {
 		published++
 	})
 
-	errF := func() error {
-		return err
+	errF := func() (interface{}, error) {
+		return valueOp, errOp
 	}
 
 	/// When && Then 1
-	retryF.Compose(publishF).Compose(NoopError())(errF)()
+	retryF.Compose(publishF).ComposeFn(NoopF)(errF)()
 
 	if uint(published) != retryCount+1 {
 		t.Errorf("Expected %d, got %d", retryCount+1, published)
 	}
 
 	/// When && Then 2
 	published = 0
-	publishF.Compose(retryF).Compose(NoopError())(errF)()
+	publishF.Compose(retryF).ComposeFn(NoopF)(errF)()
 
 	if published != 1 {
 		t.Errorf("Expected %d, got %d", 1, published)
 	}
 }
 
 func BenchmarkComposition(b *testing.B) {
-	errF := func() error {
-		return err
+	errF := func() (interface{}, error) {
+		return valueOp, errOp
 	}
 
-	publishF := func(err error) {}
-	composeF := PublishError(publishF)
+	publishF := func(value interface{}, err error) {}
+	composeF := PublishF(publishF)
 
 	composed := composeF.
 		Compose(composeF).
@@ -53,8 +53,8 @@ func BenchmarkComposition(b *testing.B) {
 }
 
 func BenchmarkOrdinaryErrorF(b *testing.B) {
-	errF := func() error {
-		return err
+	errF := func() (interface{}, error) {
+		return valueOp, errOp
 	}
 
 	for i := 0; i < b.N; i++ {

compose/noop.go

@@ -0,0 +1,13 @@
+package compose
+
+// NoopF does nothing and simply returns the function.
+func NoopF() FunctionF {
+	return func(f Function) Function {
+		return f
+	}
+}
+
+// Noop is a convenience function that calls the composable NoopF under the hood.
+func (f Function) Noop() Function {
+	return NoopF().Wrap(f)
+}

compose/noop_test.go

@@ -0,0 +1,15 @@
+package compose
+
+import "testing"
+
+func TestNoop(t *testing.T) {
+	/// Setup
+	var errF Function = func() (interface{}, error) {
+		return valueOp, errOp
+	}
+
+	/// When & Then
+	if _, err := errF.Noop().Invoke(); err != errOp {
+		t.Errorf("Expected %v, got %v", errOp, err)
+	}
+}

compose/publish.go

@@ -0,0 +1,18 @@
+package compose
+
+// PublishF publishes the result of a Function for side effects.
+func PublishF(callback func(interface{}, error)) FunctionF {
+	return func(f Function) Function {
+		return func() (interface{}, error) {
+			value, err := f()
+			callback(value, err)
+			return value, err
+		}
+	}
+}
+
+// Publish is a convenience function that calls the composable PublishF under
+// the hood.
+func (f Function) Publish(callback func(interface{}, error)) Function {
+	return PublishF(callback).Wrap(f)
+}

compose/publish_test.go

@@ -0,0 +1,41 @@
+package compose
+
+import (
+	"testing"
+)
+
+func TestPublish(t *testing.T) {
+	/// Setup
+	published := 0
+	var publishedValue interface{}
+	var publishedErr error
+
+	var errF Function = func() (interface{}, error) {
+		return valueOp, errOp
+	}
+
+	publishF := func(value interface{}, err error) {
+		published++
+		publishedValue = value
+		publishedErr = err
+	}
+
+	/// When & Then
+	value, err := errF.Publish(publishF).Retry(retryCount).Invoke()
+
+	if err != errOp || value != nil {
+		t.Errorf("Expected %v, got %v", errOp, err)
+	}
+
+	if publishedValue != valueOp {
+		t.Errorf("Expected %v, got %v", valueOp, publishedValue)
+	}
+
+	if publishedErr != errOp {
+		t.Errorf("Expected %v, got %v", errOp, publishedErr)
+	}
+
+	if uint(published) != retryCount+1 {
+		t.Errorf("Expected %v, got %v", retryCount+1, published)
+	}
+}