/**
* Send a message to a User (from the web, from IM, from SMS).  The Actor
* will take care of persisting the information in the database.
*
* @param text - the text of the message
* @param src - the source of the message
*/
case class SendMessage(text: String, src: String) extends UserMsg

...

    loop {
      react {
        // The user sends a message containing text and a source.  This can
        // be from the web, from IM, from SMS, etc.
        case SendMessage(text, src) =>
          // create a new Message object to be added to the user's local message and sent
          // to followers
          val msg = Message(text, System.currentTimeMillis, userName, src)
          // add to our local messages (keeping only the maxMessages most recent messages)
          latestMsgs = (msg :: latestMsgs).take(maxMessages)
          // update all our followers (and ourselves) with the message 
          (this :: followers).foreach(_ ! msg)
          // and put it in the database
          MsgStore.create.message(text).source(src).who(userId).save
          // if the message was autogenerated, then autogenerate another message in 5 or so minutes
          if (src == "autogen") autoGen

def onSendMessage( m: SendMessage ) {
  val msg = Message(m.text, System.currentTimeMillis, userName, m.src)
  // add to our local messages (keeping only the maxMessages most recent messages)
  latestMsgs = (msg :: latestMsgs).take(maxMessages)
  // update all our followers (and ourselves) with the message 
  (this :: followers).foreach(_ ! msg)
  // and put it in the database
  MsgStore.create.message(m.text).source(m.src).who(userId).save
  // if the message was autogenerated, then autogenerate another message in 5 or so minutes
  if (m.src == "autogen") autoGen
}

E>        case SendMessage(text, src) =>
E>

| SendMessage(_, _) as msg => SomeHandler(msg)

| SendMessage("some text", _) as msg => SomeHandler(src)
| SendMessage("another text", _) as msg => AnotherHandler(src)

match (pBody)
{
  | PExpr.Sequence([PExpr.Literal(Literal.String(str)) as lit]) =>
  def expr = MakeStringTemplateExpr(str, lit.Location, ctx);
  ...

PExpr.Sequence seq = pBody as PExpr.Sequence;
if (seq != null)
{
    if (seq.body.Length == 1)
    {
        PExpr.Literal lit = seq.body.Head as PExpr.Literal;
        if (lit != null)
        {
            Literal.String strLit = lit.val as Literal.String;
            if (strLit != null)
            {
                PExpr expr = MakeStringTemplateExpr(strLit.val, lit.Location, ctx);
                ...
            }
        }
    }
}

E>def onSendMessage( m: SendMessage ) {
E>  ...
E>}
E>

[EditorBrowsable(EditorBrowsableState.Advanced), SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
protected override void WndProc(ref Message m)
{
    switch (m.Msg)
    {
        case 0x10:
            if (this.CloseReason == CloseReason.None)
            {
                this.CloseReason = CloseReason.TaskManagerClosing;
            }
            this.WmClose(ref m);
            return;

        case 0x11:
        case 0x16:
            this.CloseReason = CloseReason.WindowsShutDown;
            this.WmClose(ref m);
            return;

        case 20:
            this.WmEraseBkgnd(ref m);
            return;

        case 0x18:
            this.WmShowWindow(ref m);
            return;

        case 0x24:
            this.WmGetMinMaxInfo(ref m);
            return;

        case 5:
            this.WmSize(ref m);
            return;

        case 6:
            this.WmActivate(ref m);
            return;

        case 1:
            this.WmCreate(ref m);
            return;

        case 130:
            this.WmNCDestroy(ref m);
            return;

        case 0x84:
            this.WmNCHitTest(ref m);
            return;

        case 0x86:
            if (this.IsRestrictedWindow)
            {
                base.BeginInvoke(new MethodInvoker(this.RestrictedProcessNcActivate));
            }
            base.WndProc(ref m);
            return;

        case 0x47:
            this.WmWindowPosChanged(ref m);
            return;

        case 0xa1:
        case 0xa4:
        case 0xa7:
        case 0xab:
            this.WmNcButtonDown(ref m);
            return;

        case 0x112:
            this.WmSysCommand(ref m);
            return;

        case 0x117:
            this.WmInitMenuPopup(ref m);
            return;

        case 0x120:
            this.WmMenuChar(ref m);
            return;

        case 0x125:
            this.WmUnInitMenuPopup(ref m);
            return;

        case 0x211:
            this.WmEnterMenuLoop(ref m);
            return;

        case 530:
            this.WmExitMenuLoop(ref m);
            return;

        case 0x215:
            base.WndProc(ref m);
            if (base.CaptureInternal && (Control.MouseButtons == MouseButtons.None))
            {
                base.CaptureInternal = false;
            }
            return;

        case 0x222:
            this.WmMdiActivate(ref m);
            return;

        case 0x231:
            this.WmEnterSizeMove(ref m);
            this.DefWndProc(ref m);
            return;

        case 0x232:
            this.WmExitSizeMove(ref m);
            this.DefWndProc(ref m);
            return;
    }
    base.WndProc(ref m);
}

private void WmClose(ref Message m)
{
    FormClosingEventArgs e = new FormClosingEventArgs(this.CloseReason, false);
    if (m.Msg == 0x16)
    {
        e.Cancel = m.WParam == IntPtr.Zero;
    }
    else
    {
        if (this.Modal)
        {
            if (this.dialogResult == DialogResult.None)
            {
                this.dialogResult = DialogResult.Cancel;
            }
            this.CalledClosing = false;
            e.Cancel = !this.CheckCloseDialog(true);
        }
        else
        {
            e.Cancel = !base.Validate(true);
            if (this.IsMdiContainer)
            {
                FormClosingEventArgs args2 = new FormClosingEventArgs(CloseReason.MdiFormClosing, e.Cancel);
                foreach (Form form in this.MdiChildren)
                {
                    if (form.IsHandleCreated)
                    {
                        form.OnClosing(args2);
                        form.OnFormClosing(args2);
                        if (args2.Cancel)
                        {
                            e.Cancel = true;
                            break;
                        }
                    }
                }
            }
            Form[] ownedForms = this.OwnedForms;
            for (int i = base.Properties.GetInteger(PropOwnedFormsCount) - 1; i >= 0; i--)
            {
                FormClosingEventArgs args3 = new FormClosingEventArgs(CloseReason.FormOwnerClosing, e.Cancel);
                if (ownedForms[i] != null)
                {
                    ownedForms[i].OnFormClosing(args3);
                    if (args3.Cancel)
                    {
                        e.Cancel = true;
                        break;
                    }
                }
            }
            this.OnClosing(e);
            this.OnFormClosing(e);
        }
        if (m.Msg == 0x11)
        {
            m.Result = e.Cancel ? IntPtr.Zero : ((IntPtr) 1);
        }
        if (this.Modal)
        {
            return;
        }
    }
    if ((m.Msg != 0x11) && !e.Cancel)
    {
        FormClosedEventArgs args4;
        if (this.IsMdiContainer)
        {
            args4 = new FormClosedEventArgs(CloseReason.MdiFormClosing);
            foreach (Form form2 in this.MdiChildren)
            {
                if (form2.IsHandleCreated)
                {
                    form2.OnClosed(args4);
                    form2.OnFormClosed(args4);
                }
            }
        }
        Form[] ownedForms = this.OwnedForms;
        for (int i = base.Properties.GetInteger(PropOwnedFormsCount) - 1; i >= 0; i--)
        {
            args4 = new FormClosedEventArgs(CloseReason.FormOwnerClosing);
            if (ownedForms[i] != null)
            {
                ownedForms[i].OnClosed(args4);
                ownedForms[i].OnFormClosed(args4);
            }
        }
        args4 = new FormClosedEventArgs(this.CloseReason);
        this.OnClosed(args4);
        this.OnFormClosed(args4);
        base.Dispose();
    }
}

variant Msg
{
  | Msg1 { некоторые данные }
  | Msg2 { некоторые данные }
  | Msg3 { некоторые данные }
    ...
}

using System.Console;

abstract class MsgBase { }

variant Msgs1 : MsgBase
{
  | A
  | B
}

variant Msgs2 : MsgBase
{
  | C
  | D
}

module Program
{
  Main() : void
  {
    def test(x : MsgBase)
    {
      | Msgs1.A => WriteLine("A");
      | Msgs2.D => WriteLine("D");
      | _ => WriteLine("не, а!");
    }
    
    test(Msgs1.A());
    test(Msgs2.D());
    test(Msgs1.B());
    _ = ReadLine();
  }
}

A
D
не, а!

try
{
    PExpr.Sequence seq = pBody as PExpr.Sequence;
    PExpr.Literal lit = seq.body.Head as PExpr.Literal;
    PExpr expr = MakeStringTemplateExpr(lit.val as Literal.String, lit.Location, ctx);
}
catch (Exception) {}

%%
%% Наша структура
%%

-record(sendMessage{text, sender}).

%%
%% Принимаем сообщение типа SendMessage и сразу вытягиваем из него text и sender
%%
send_message_event_handler(#sendMessage{text=Text, sender=Sender}) ->
    logger:log("Sender: %s, text: %s", [Sender, Text]).

//
// Наша структура
// 

struct SendMessage 
{
    char *text;
    char *sender;
};


//
// Принимаем сообщение типа SendMessage
//

void sendMessageEventHandler(const SendMessage &m)
{
    logger::log("Sender: %s, text: %s", m.sender, m.text);
}

iterface Message {
    // Это для обработчика 1
    void doSome1();
    // А это для второго
    void doSome2();
}
class Mess1 implements Message {
    public Mess1(int value) {
        this.value = value;
    }
    private int value;
    public void doSome1() {
        System.out.println(value);
    }
    public void doSome2() {
        System.out.println(value + 5);
    }
}
class Mess2 implements Message {
    public void doSome1() {
        System.out.println("Съешь еще французких булочек да выпей чаю");
    }
    public void doSome2() {
        System.out.println("Чай кончился :(");
    }
}
interface Handler {
    void handle(Message m);
}
class Handler1 implements Handler {
    public void handle(Message m) {
        m.doSome1();
    }
}
class Handler2 implements Handler{
    public void handle(Message m) {
        m.doSome2();
    }
}

abstract class Message;
case class Mess1(int value);
case object Mess2;
trait Handler {
    def handle(Message m): Unit;
}
object Handler1 extends Object with Handler {
    def handle(Message m) = m match {
        case Mess1(v) => Console.println(v)
        case Mess2 => Console.println("Съешь еще французких булочек да выпей чаю")
    }
}
object Handler2 extends Object with Handler {
    def handle(Message m) = m match {
        case Mess1(v) => Console.println(v + 5)
        case Mess2 => Console.println("Чай кончился :(")
    }
}

scala> def foo (x : Option[int]) = x match { case None => 5 }
console>:4: warning: does not cover case {class Some}
  def foo (x : Option[int]) = x match { case None => 5 }

scala>> def foo (x : Option[int]) = x match { case None => 5 }
PM>console>:4: warning: does not cover case {class Some}
PM>  def foo (x : Option[int]) = x match { case None => 5 }
PM>

abstract class Msg;

case class HandleTrx extends Msg;
case class HandleTrxReply extends Msg;
case class Ping extends Msg;
case class Pong extends Msg;

object Demo extends Application
{
    def handleMsg( m: Msg ) {
        m match {
            case HandleTrx() => Console.println( "HandleTrx" )
            case HandleTrxReply() => Console.println( "HandleTrxReply" )
            case Ping() => Console.println( "Ping" )
            case Pong() => Console.println( "Pong" )
        }
    }

    handleMsg( new HandleTrx )
    handleMsg( new Ping )
    handleMsg( new HandleTrxReply )
}

abstract class Msg;

case class HandleTrx extends Msg;
case class HandleTrxReply extends Msg;
case class Ping extends Msg;
case class Pong extends Msg;

case class SetupThroughput extends Msg;
case class SetupThroughputReply extends Msg;

object Demo extends Application
{
    def handleMsg( m: Msg ) {
        m match {
            case HandleTrx() => Console.println( "HandleTrx" )
            case HandleTrxReply() => Console.println( "HandleTrxReply" )
            case Ping() => Console.println( "Ping" )
            case Pong() => Console.println( "Pong" )
        }
    }

    handleMsg( new HandleTrx )
    handleMsg( new Ping )
    handleMsg( new HandleTrxReply )
    handleMsg( new SetupThroughput )
}

HandleTrx
Ping
HandleTrxReply
java.lang.ExceptionInInitializerError
        at Demo.main(Demo.scala)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
        at java.lang.reflect.Method.invoke(Unknown Source)
        at scala.tools.nsc.ObjectRunner$.run(ObjectRunner.scala:76)
        at scala.tools.nsc.MainGenericRunner$.main(MainGenericRunner.scala:106)
        at scala.tools.nsc.MainGenericRunner.main(MainGenericRunner.scala)
Caused by: scala.MatchError: SetupThroughput()
        at Demo$.handleMsg(Demo.scala:14)
        at Demo$.<init>(Demo.scala:25)
        at Demo$.<clinit>(Demo.scala)
        ... 8 more