=> operator does not work in place of Via

open Akka
open Akka.Actor
open Akka.Streams
open Akka.Streams.Dsl
open Akkling
open Akkling.Streams
open Akkling.Streams.Operators

type IUser = interface end
type IHashtagEntity = interface end

type ITweet = 
    abstract Hashtags: IHashtagEntity list
    abstract CreatedBy: IUser

[<EntryPoint>]
let main _ = 
    use system = ActorSystem.Create("test")
    let mat = system.Materializer()
    
    GraphDsl.Create (fun b ->
        let broadcast = b.Add(Broadcast<ITweet>(2))
        

        b.From(broadcast.Out(0)).Via(Flow.id |> Flow.map (fun (tweet: ITweet) -> tweet.CreatedBy)) |> ignore
        b.From(broadcast.Out(0)) => (Flow.id |> Flow.map (fun (tweet: ITweet) -> tweet.CreatedBy)) |> ignore

        
        ClosedShape.Instance
    ) 
    |> RunnableGraph.FromGraph
    |> Graph.run mat
    |> ignore
    0

I expect Flow<ITweet, IUser, NotUsed> here instead of Flow<ITweet, ITweet, NotUsed>.

[Horusiath]

1. If you have Broadcast(1), then you don’t need broadcast at all.

2. Think of stages as building blocks with inputs and outputs. Graph.create requies you to either join all of them together (so that there are no dangling in-/outputs), or expose them outside:

   • In your case your Flow.id |> Flow.map (..) |> ignore is not closed, as output of Flow.map is still dangling around (just ignored). After Via call, it needs to be connected i.e. to Sink.ignore stage (if you don’t want to do anything with it).
   • You defined broadcast and connected its only output, but still left input disconnected from the rest of the graph. You may want to decide to expose it outside by using SinkShape<_>(broadcast.In), which will produce a sink. You can then connect that sink with the source of your choice to materialize it into fully functioning graph.

You may also want to take a look at the example of using Akkling graph API.

[Horusiath]

I’m not sure right now, but I guess, that the current definition of => may have been not precise enough, and F# type inference gone to the wrong conclusion. So far I still struggle to make Graph DSL F#-friendly.

Unfortunately original Akka GraphDSL uses almost all scala-specific features in one place (implicit params, implicit type casting, custom operators with multiple overloads etc.). It’s hard to create something remotely similar in any other language.