server: Simplify the API for static and single-run services.

- Rework NewStatic as "Static", which returns a plain constructor.
- Remove the "Simple" type and move its Run method to a top-level function.
- Update usage examples.

#46 (comment)

cmd/examples/server/server.go

@@ -100,7 +100,7 @@ func main() {
 		log.Fatalln("Listen:", err)
 	}
 	log.Printf("Listening at %v...", lst.Addr())
-	server.Loop(lst, server.NewStatic(mux), &server.LoopOptions{
+	server.Loop(lst, server.Static(mux), &server.LoopOptions{
 		ServerOptions: &jrpc2.ServerOptions{
 			Logger:      log.New(os.Stderr, "[jrpc2.Server] ", log.LstdFlags|log.Lshortfile),
 			Concurrency: *maxTasks,

server/example_test.go

@@ -46,10 +46,10 @@ func (s Service) Finish(stat jrpc2.ServerStatus) {
 	close(s.done)
 }
 
-func ExampleNewSimple() {
+func ExampleRun() {
 	done := make(chan struct{})
 	cch, sch := channel.Direct()
-	go server.NewSimple(Service{done}, nil).Run(sch)
+	go server.Run(sch, Service{done}, nil)
 
 	cli := jrpc2.NewClient(cch, nil)
 	if _, err := cli.Call(context.Background(), "Hello", nil); err != nil {

server/loop.go

@@ -19,16 +19,14 @@ type Service interface {
 	Finish(jrpc2.ServerStatus)
 }
 
-type singleton struct{ assigner jrpc2.Assigner }
+// Static wraps a jrpc2.Assigner to trivially implement the Service interface.
+func Static(m jrpc2.Assigner) func() Service { return static{methods: m}.New }
 
-func (s singleton) Assigner() (jrpc2.Assigner, error) { return s.assigner, nil }
-func (singleton) Finish(jrpc2.ServerStatus)           {}
+type static struct{ methods jrpc2.Assigner }
 
-// NewStatic creates a static (singleton) service from the given assigner.
-func NewStatic(assigner jrpc2.Assigner) func() Service {
-	svc := singleton{assigner}
-	return func() Service { return svc }
-}
+func (s static) New() Service                      { return s }
+func (s static) Assigner() (jrpc2.Assigner, error) { return s.methods, nil }
+func (static) Finish(jrpc2.ServerStatus)           {}
 
 // Loop obtains connections from lst and starts a server for each with the
 // given service constructor and options, running in a new goroutine. If accept

server/loop_test.go

@@ -16,7 +16,7 @@ import (
 var newChan = channel.Line
 
 // A static test service that returns the same thing each time.
-var testService = NewStatic(handler.Map{
+var testService = Static(handler.Map{
 	"Test": handler.New(func(context.Context) (string, error) {
 		return "OK", nil
 	}),

server/run.go

@@ -0,0 +1,23 @@
+package server
+
+import (
+	"github.com/creachadair/jrpc2"
+	"github.com/creachadair/jrpc2/channel"
+)
+
+// Run starts a server for svc on the given channel, and blocks until it
+// returns.  The server exit status is reported to the service, and the error
+// value is returned.
+//
+// If the caller does not need the error value and does not want to wait for
+// the server to complete, call Run in a goroutine.
+func Run(ch channel.Channel, svc Service, opts *jrpc2.ServerOptions) error {
+	assigner, err := svc.Assigner()
+	if err != nil {
+		return err
+	}
+	srv := jrpc2.NewServer(assigner, opts).Start(ch)
+	stat := srv.WaitStatus()
+	svc.Finish(stat)
+	return stat.Err
+}

server/simple_test.go → server/run_test.go

@@ -26,7 +26,7 @@ func (t *testService) Finish(stat jrpc2.ServerStatus) {
 	t.stat = stat
 }
 
-func TestSimple(t *testing.T) {
+func TestRun(t *testing.T) {
 	svc := &testService{assigner: handler.Map{
 		"Test": handler.New(func(ctx context.Context) string {
 			return "OK"
@@ -44,8 +44,7 @@ func TestSimple(t *testing.T) {
 		}
 	}()
 
-	srv := server.NewSimple(svc, nil)
-	if err := srv.Run(spipe); err != nil {
+	if err := server.Run(spipe, svc, nil); err != nil {
 		t.Errorf("Server failed: %v", err)
 	}
 	if result != "OK" {