Cleanup SubScriptActor.registerHandler

[AndreVanDelft]

In SubScriptActor:

    registerHandler(act: Either[ActorRef, ActualAdaptingParameter[ActorRef]]) =
      val vt         = new Trigger  // The value sent from `act` will pop from `vt` and will be
                                // returned from this script to be handled by the parent dataflow
      val handlerFun = here.ancestor(9).getProperty[String, PartialFunction[Any, Script[Any]]]("then").get  
          // PartialFunction from the dataflow this `act` is LHS of. 
          // Will handle the matching messages. 
          // TBD: ancestor(n) should be replaced by a more descriptive methods, 
          // no guessing on the argument `n` should be done.
      val handler    = (act, vt, handlerFun)  // Everything together

      do! handlers += handler  // Save the actor, the trigger and the handler function of the dataflow
      [vt ~~(msg)~~> [do! handlers -= handler; ^msg]]^  
      // Wait for a suitable message to pop from `vt`, 
      // then deregister the handler and return the message 
      // to be handled normally by the dataflow.

The purpose is to make sure only those handlers will execute that are LHS in a dataflow that expects the received actor message.
The code that does that test should be made more generic: a code fragment node should contain a method that tells whether a given value would match the contextual dataflow, in case there is such a data flow. That would be like the matches method in FormalConstrainedParameter. E.g. for usage see KeyTypedReactor.

Moreover, this line

      do! handlers += handler  // Save the actor, the trigger and the handler function of the dataflow

is IMO wrong: it makes an atomic action happen whereas we are only registrering. Probably this should be:

      let handlers += handler  // Save the actor, the trigger and the handler function of the dataflow

[AndreVanDelft]

The current code has also 2 implicit scripts:

implicit script..
  actorRef2script(a: ActorRef)        = registerHandler(Left (  a))
  actorRefParam2script(??a: ActorRef) = registerHandler(Right(??a))

I wonder why there are 2 conversion scripts instead of one.
If I am right just the second would also implicitly convert plain ActorRef values; at least in the old compiler branch that resolved script calls. If this capability has been lost in the transition to the preprocessor, it should be brought back to life at some point.

[AndreVanDelft]

The definition of registerHandler mentions an ActualAdaptingParameter in its parameter list.
Now type ActualAdaptingParameter is meant for actual parameter positions; if you want to make an extra refinement such as registerHandler, do it like this:

  registerHandler(act: FormalConstrainedParameter[ActorRef]]) = ...

(already dropped Either here).

[AndreVanDelft]

If I am right we would need only the second conversion script.

But since we will only need one implicit script, as I assume, we do not need this extra refinement.
The “do!” is misplaced, since it should not be an action here, possibly excluding other actions.

implicit script..
  actorRefParam2script(??a: ActorRef): Any = 
    val vt         = new Trigger  // The value sent from `act` will pop from `vt` 
                                  // and will be returned from this script to be handled by the parent dataflow
    val handlerFun = here.ancestor(9).getProperty[String, PartialFunction[Any, Script[Any]]]("then").get  
          // PartialFunction from the dataflow this `act` is LHS of. 
          //  Will handle the matching messages. 
          // TBD: ancestor(n) should be replaced by a more descriptive methods, 
          // no guessing on the argument `n` should be done.
    val handler    = (act, vt, handlerFun)  // Everything together
    @{there.  onActivate{handlers += handler}
      there.onDeactivate{handlers -= handler}}: vt

[AndreVanDelft]

For the Scala Symposium 2016 paper, I assume that we can replace

val handlerFun = here.ancestor(9).getProperty[String, PartialFunction[Any, Script[Any]]]("then").get

by

val handlerFun = here.getContextualDataflowHandler