An actor doesn't stop after return Stop effect

open Akka.FSharp
open Akka.Actor

let actorSystem = System.create "NotificationWorker" (Configuration.defaultConfig())

let pnm3 =
    Akkling.Spawn.spawn actorSystem "procs-node-mon3" (
        Akkling.Props.props <| 
            fun (mb:Akkling.Actors.Actor<string>) ->
                let rec loop0 () = Akkling.ComputationExpressions.actor {
                    let! msg = mb.Receive ()
                    if msg = "stop" then
                        printfn "stop"
                        return Akkling.Actors.Stop
                    printfn "123"   
                    }
                loop0 ())
                
                
pnm3.Tell("stop", ActorRefs.Nobody)
pnm3.Tell("", ActorRefs.Nobody)

I would expect after telling “stop”, the actor would be stopped, but it still accepts messages.

> 
stop
123
val it : unit = ()

> 
123
val it : unit = ()

The second 123 should not print, should it?

[Horusiath]

@ingted When comparing Akka.FSharp and Akkling, your computation expressions are not equivalent:

// Akka.FSharp
let pnm =
    spawn actorSystem "procs-node-mon" <|  fun (mb:Actor<string>) ->
        let rec loop0 () = actor {
           let! _ = mb.Receive ()
           printfn "123" }
        loop0 ()

Here, there’s no loop, it’s just catching a message and finishing (no tail recursion occurs).

// Akkling
spawn actorSystem ("procs-node-mon3" + System.Guid.NewGuid().ToString()) (props <|  fun (mb:Actor<string>) ->
  let loop0 () = actor {
    let! msg = mb.Receive ()
    printfn "s: %s" msg 
    if msg = "stop" then
      printfn "stop"
      return Stop
    //else
      printfn "123"  }
  loop0 ())

Here, since else is commented out, it means, that if is not expression but the statement - which means that it doesn’t return any value. And since F# doesn’t have early returns, it means that Stop effect will be implicitly ignored. Why return is even allowed in this scope, I have no idea, looks like the issue with F# compiler.

[Horusiath]

If I remember correctly actor {..} computation expression in Akka.FSharp either has not Zero member defined, so it must always return something at some point, or uses Zero as default returned value, in which case loop will just stop executing.

Unlike Akka.FSharp, Akkling operates on effects as return types, and Akkling’s actor computation expression defines Zero member as ignored effect - meaning, nothing will change and the last loop roll will be used for the next received message.