Avoid channel pointer usages.

Author: johnteee

README.md

@@ -323,8 +323,8 @@ actual, _ = Maybe.Just(result).ToInt()
 // Ask channel
 // Result would be 30
 ch := Ask.New(3).AskChannel(actorRoot)
-actual, _ = Maybe.Just(<-*ch).ToInt()
-close(*ch)
+actual, _ = Maybe.Just(<-ch).ToInt()
+close(ch)
 
 // Timeout cases
 // Result would be 0 (zero value, timeout)

actor.go

@@ -16,7 +16,7 @@ type ActorHandle interface {
 type ActorDef struct {
 	id       time.Time
 	isClosed bool
-	ch       *chan interface{}
+	ch       chan interface{}
 	effect   func(*ActorDef, interface{})
 
 	context map[string]interface{}
@@ -34,12 +34,11 @@ func (actorSelf *ActorDef) GetDefault() *ActorDef {
 
 // New New Actor instance
 func (actorSelf *ActorDef) New(effect func(*ActorDef, interface{})) *ActorDef {
-	ch := make(chan interface{})
-	return actorSelf.NewByOptions(effect, &ch, map[string]interface{}{})
+	return actorSelf.NewByOptions(effect, make(chan interface{}), map[string]interface{}{})
 }
 
 // NewByOptions New Actor by its options
-func (actorSelf *ActorDef) NewByOptions(effect func(*ActorDef, interface{}), ioCh *chan interface{}, context map[string]interface{}) *ActorDef {
+func (actorSelf *ActorDef) NewByOptions(effect func(*ActorDef, interface{}), ioCh chan interface{}, context map[string]interface{}) *ActorDef {
 	newOne := ActorDef{
 		id:       time.Now(),
 		ch:       ioCh,
@@ -58,7 +57,7 @@ func (actorSelf *ActorDef) Send(message interface{}) {
 		return
 	}
 
-	*(actorSelf.ch) <- message
+	actorSelf.ch <- message
 }
 
 // Spawn Spawn a new Actor with parent(this actor)
@@ -93,7 +92,7 @@ func (actorSelf *ActorDef) GetID() time.Time {
 func (actorSelf *ActorDef) Close() {
 	actorSelf.isClosed = true
 
-	close(*actorSelf.ch)
+	close(actorSelf.ch)
 }
 
 // IsClosed Check is Closed
@@ -102,7 +101,7 @@ func (actorSelf *ActorDef) IsClosed() bool {
 }
 
 func (actorSelf *ActorDef) run() {
-	for message := range *actorSelf.ch {
+	for message := range actorSelf.ch {
 		actorSelf.effect(actorSelf, message)
 	}
 }
@@ -113,7 +112,7 @@ var Actor ActorDef
 // AskDef Ask inspired by Erlang/Akka
 type AskDef struct {
 	id time.Time
-	ch *chan interface{}
+	ch chan interface{}
 
 	Message interface{}
 }
@@ -124,18 +123,17 @@ func (askSelf *AskDef) New(message interface{}) *AskDef {
 }
 
 // NewByOptions New Ask by its options
-func (askSelf *AskDef) NewByOptions(message interface{}, ioCh *chan interface{}) *AskDef {
+func (askSelf *AskDef) NewByOptions(message interface{}, ioCh chan interface{}) *AskDef {
 	return AskNewByOptionsGenerics(message, ioCh)
 }
 
 // AskNewGenerics New Ask instance
 func AskNewGenerics(message interface{}) *AskDef {
-	ch := make(chan interface{})
-	return AskNewByOptionsGenerics(message, &ch)
+	return AskNewByOptionsGenerics(message, make(chan interface{}))
 }
 
 // AskNewByOptionsGenerics New Ask by its options
-func AskNewByOptionsGenerics(message interface{}, ioCh *chan interface{}) *AskDef {
+func AskNewByOptionsGenerics(message interface{}, ioCh chan interface{}) *AskDef {
 	newOne := AskDef{
 		id: time.Now(),
 		ch: ioCh,
@@ -149,14 +147,14 @@ func AskNewByOptionsGenerics(message interface{}, ioCh *chan interface{}) *AskDe
 // AskOnce Sender Ask
 func (askSelf *AskDef) AskOnce(target ActorHandle, timeout *time.Duration) (interface{}, error) {
 	ch := askSelf.AskChannel(target)
-	defer close(*ch)
+	defer close(ch)
 	var result interface{}
 	// var err error
 	if timeout == nil {
-		result = <-*ch
+		result = <-ch
 	} else {
 		select {
-		case result = <-*ch:
+		case result = <-ch:
 		case <-time.After(*timeout):
 			return result, ErrActorAskTimeout
 		}
@@ -166,15 +164,15 @@ func (askSelf *AskDef) AskOnce(target ActorHandle, timeout *time.Duration) (inte
 }
 
 // AskChannel Sender Ask
-func (askSelf *AskDef) AskChannel(target ActorHandle) *chan interface{} {
+func (askSelf *AskDef) AskChannel(target ActorHandle) chan interface{} {
 	target.Send(askSelf)
 
 	return askSelf.ch
 }
 
 // Reply Receiver Reply
 func (askSelf *AskDef) Reply(response interface{}) {
-	*askSelf.ch <- response
+	askSelf.ch <- response
 }
 
 // Ask Ask utils instance

actor_test.go

@@ -124,8 +124,8 @@ func TestActorAsk(t *testing.T) {
 	// Ask channel
 	expectedInt = 30
 	ch := AskNewGenerics(3).AskChannel(actorRoot)
-	actual, _ = Maybe.Just(<-*ch).ToInt()
-	close(*ch)
+	actual, _ = Maybe.Just(<-ch).ToInt()
+	close(ch)
 	assert.Equal(t, expectedInt, actual)
 
 	// Timeout cases

cor.go

@@ -38,17 +38,20 @@ type CorDef struct {
 	isClosed  AtomBool
 	closedM   sync.Mutex
 
-	opCh     *chan *CorOp
-	resultCh *chan interface{}
+	opCh     chan *CorOp
+	resultCh chan interface{}
 
 	effect func()
 }
 
 // New New a Cor instance
 func (corSelf *CorDef) New(effect func()) *CorDef {
-	opCh := make(chan *CorOp, 5)
-	resultCh := make(chan interface{}, 5)
-	cor := &CorDef{effect: effect, opCh: &opCh, resultCh: &resultCh, isStarted: AtomBool{flag: 0}}
+	cor := &CorDef{
+		effect:    effect,
+		opCh:      make(chan *CorOp, 5),
+		resultCh:  make(chan interface{}, 5),
+		isStarted: AtomBool{flag: 0},
+	}
 	return cor
 }
 
@@ -114,13 +117,13 @@ func (corSelf *CorDef) YieldRef(out interface{}) interface{} {
 	var op *CorOp
 	var more bool
 	// fmt.Println(corSelf, "Wait for", "op")
-	op, more = <-*corSelf.opCh
+	op, more = <-corSelf.opCh
 	// fmt.Println(corSelf, "Wait for", "op", "done")
 
 	if more && op != nil && op.cor != nil {
 		cor := op.cor
 		cor.doCloseSafe(func() {
-			*cor.resultCh <- out
+			cor.resultCh <- out
 		})
 	}
 	result = op.val
@@ -138,7 +141,7 @@ func (corSelf *CorDef) YieldFrom(target *CorDef, in interface{}) interface{} {
 	target.receive(corSelf, in)
 
 	// fmt.Println(corSelf, "Wait for", "result")
-	result, _ = <-*corSelf.resultCh
+	result, _ = <-corSelf.resultCh
 	// fmt.Println(corSelf, "Wait for", "result", "done")
 
 	return result
@@ -148,7 +151,7 @@ func (corSelf *CorDef) receive(cor *CorDef, in interface{}) {
 	corSelf.doCloseSafe(func() {
 		if corSelf.opCh != nil {
 			// fmt.Println(corSelf, "Wait for", "receive", cor, in)
-			*(corSelf.opCh) <- &CorOp{cor: cor, val: in}
+			corSelf.opCh <- &CorOp{cor: cor, val: in}
 			// fmt.Println(corSelf, "Wait for", "receive", "done")
 		}
 	})
@@ -186,10 +189,10 @@ func (corSelf *CorDef) close() {
 
 	corSelf.closedM.Lock()
 	if corSelf.resultCh != nil {
-		close(*corSelf.resultCh)
+		close(corSelf.resultCh)
 	}
 	if corSelf.opCh != nil {
-		close(*corSelf.opCh)
+		close(corSelf.opCh)
 	}
 	corSelf.closedM.Unlock()
 }