type ActorFunc func(actor *Actor)

package main

import (
	"fmt"
	"github.com/hedisam/goactor"
	"log"
	"time"
)

func main() {
	// Spawn returns a PID which can be used to send message to the actor
	pid := goactor.Spawn(echo, nil) // [*1]

	// Send takes the pid of the target actor and a message to send
	err := goactor.Send(pid, "Hello, Actor") // [*2]
	if err != nil {
		log.Println(err)
	}

	// let's wait a bit to make sure echo gets the chance of printing the message
	<-time.After(100 * time.Millisecond) // [*3]
}

// echo is our actor function (aka our actor's body)
func echo(actor *goactor.Actor) {
	// this is the body of our actor. echo actor will be running until this function returns.
	
	// [*4]
	// Receive accepts a MessageHandler function. It will block until its message handler
	// returns false.
	err := actor.Receive(func(message interface{}) (loop bool) {
		fmt.Printf("[+] Echo received: %v\n", message)
		return false
	})
	if err != nil {
		log.Println(err)
	}
}

package main

import (
	"fmt"
	"github.com/hedisam/goactor"
	"github.com/hedisam/goactor/sysmsg"
	"log"
	"time"
)

func main() {
	// NewParentActor accepts a mailbox builder function (MailboxBuilderFunc) as its parameter, just like the
	// second argument of goactor.Spawn
	// MailboxBuilderFunc can be used to provide a customized mailbox to the actor.
	parent, dispose := goactor.NewParentActor(nil)
	defer dispose() // don't forget to defer the dispose function of a parent actor

	iPanicPID := goactor.Spawn(iWillPanic, nil)

	// when you monitor another actor, you expect to get notified about anything (bad) that happens to the target actor.
	err := parent.Monitor(iPanicPID)
	if err != nil {
		log.Println(err)
		return
	}

	// let's send a message to the iWillPanic actor which is supposed to panic as soon as it wants to process the message
	err = goactor.Send(iPanicPID, "No matter what message it is, it cause you to panic")
	if err != nil {
		log.Println(err)
		return
	}

	// ReceiveWithTimeout returns a timeout error if no messages came through by the specified timeout
	err = parent.ReceiveWithTimeout(time.Millisecond * 100, func(message interface{}) (loop bool) {
		switch msg := message.(type) {
		case sysmsg.SystemMessage:
			fmt.Printf("[+] parent received a system message from %s: %v", msg.Sender().ID(), msg)
		}
		return false
	})
	if err != nil {
		log.Println(err)
	}
}

func iWillPanic(actor *goactor.Actor) {
	_ = actor.Receive(func(message interface{}) (loop bool) {
		// after panic-ing, iWillPanic actor broadcasts a specific system message of type sysmsg.SystemMessage so
		// any actor that's linked or monitoring this one will receive the message.
		panic(message)
	})
}

package main

import (
	"fmt"
	"github.com/hedisam/goactor"
	"github.com/hedisam/goactor/sysmsg"
	"log"
	"time"
)

func main() {
	parent, dispose := goactor.NewParentActor(nil)
	defer dispose()

	iPanicPID := goactor.Spawn(iWillPanic, nil)

	///////////////////////////
	// the following line of code has changed compared to the previous sample code
	//////////////////////////
	// our parent actor will panic/exit if its linked actor panics
	err := parent.Link(iPanicPID)
	if err != nil {
		log.Println(err)
		return
	}

	// let's send a message to iWillPanic actor which is supposed to panic as soon as it wants to process the message
	err = goactor.Send(iPanicPID, "No matter what message it is, it cause you to panic")
	if err != nil {
		log.Println(err)
		return
	}
	
	/////////////////
	// the following receive method should not get any messages since the parent actor will exit along
	// with 'iWillPanic'
	////////////////
	// ReceiveWithTimeout returns a timeout error if no messages came through by the specified timeout
	err = parent.ReceiveWithTimeout(time.Millisecond * 100, func(message interface{}) (loop bool) {
		switch msg := message.(type) {
		case sysmsg.SystemMessage:
			fmt.Printf("[+] parent received a system message from %s: %v", msg.Sender().ID(), msg)
		}
		return false
	})
	if err != nil {
		log.Println(err)
	}
}

func iWillPanic(actor *goactor.Actor) {
	_ = actor.Receive(func(message interface{}) (loop bool) {
		// after panic-ing, iWillPanic actor broadcasts a specific system message of type sysmsg.SystemMessage so
		// any actor that's linked or monitoring this one will receive the message.
		panic(message)
	})
}

package main

import (
	"fmt"
	"github.com/hedisam/goactor"
	"github.com/hedisam/goactor/mailbox"
	"github.com/hedisam/goactor/sysmsg"
	"log"
	"time"
)

func main() {
	// let's provide each of our actors a different customized mailbox
	queueMailboxBuilder := func() goactor.Mailbox {
		return mailbox.NewQueueMailbox(5, 5, 100 * time.Millisecond, mailbox.DefaultGoSchedulerInterval)
	}
	chanMailboxBuilder := func() goactor.Mailbox {
		return mailbox.NewChanMailbox(5, 5, 100 * time.Millisecond)
	}

	parent, dispose := goactor.NewParentActor(queueMailboxBuilder)
	defer dispose()

	// by trapping exit messages the parent actor can survive if its linked actors panic or exit abnormally
	parent.SetTrapExit(true)

	iPanicPID := goactor.Spawn(iWillPanic, chanMailboxBuilder)

	err := parent.Link(iPanicPID)
	if err != nil {
		log.Println(err)
		return
	}

	// let's send a message to iWillPanic actor which is supposed to panic as soon as it wants to process the message
	err = goactor.Send(iPanicPID, "No matter what message it is, it cause you to panic")
	if err != nil {
		log.Println(err)
		return
	}

	// we expect to receive a system message since the parent actor is trapping exit messages
	err = parent.ReceiveWithTimeout(time.Millisecond * 100, func(message interface{}) (loop bool) {
		switch msg := message.(type) {
		case sysmsg.SystemMessage:
			fmt.Printf("[+] parent received a system message from %s: %v\n", msg.Sender().ID(), msg)
		}
		return false
	})
	// receive timeout is not going to get triggered so this err should be nil
	if err != nil {
		log.Println(err)
	}

	fmt.Println("[!] parent actor is ok")
}

func iWillPanic(actor *goactor.Actor) {
	_ = actor.Receive(func(message interface{}) (loop bool) {
		// after panic-ing, iWillPanic actor broadcasts a specific system message of type sysmsg.SystemMessage so any
		// actor that's linked or monitoring this one will receive the message.
		panic(message)
	})
}