Message type safety / union type about echo-process

[louthy]

Unfortunately it's only a Union type in name. I find it easiest to do this:

Declare your messages like so:

        public class Msg { }
        public class Add : Msg { }
        public class Remove : Msg { }
        public class Show : Msg { }

Then create a static Inbox method to take a Msg, which uses the ternary operators and pattern matching on the types to make something that looks like a match statement in functional programming:

        public static class MyActor
        {
            public static Unit Inbox(Msg msg) =>
                msg is Add a    ? Add(a)
              : msg is Remove r ? Remove(r)
              : msg is Show s   ? Show(s)
              : unit;

            static Unit Add(Add msg)
            {
                // Use Add message
                return unit;
            }

            static Unit Remove(Remove msg)
            {
                // Use Remove message
                return unit;
            }

            static Unit Show(Show msg)
            {
                // Use Show message
                return unit;
            }
        }

Because the Inbox returns Unit and not void, you will need to wrap it with act when spawning:

        spawn("my-actor", act<Msg, Unit>(MyActor.Inbox));

Or make the Inbox less attractive and return void:

            public static void Inbox(Msg msg)
            {
                var _ = msg is Add a    ? Add(a)
                      : msg is Remove r ? Remove(r)
                      : msg is Show s   ? Show(s)
                      : unit;
            }

I need to update those samples, as this approach is much easier these days (with C#7).