为什么在Scala中可以使用这样的运算符定义？

我使用F#并不太了解 Scala,除了这些语言之间经常有一些相似之处.但是在Scala中查看Akka Streams实现时,我注意到使用了operator~>以这种方式在F#中是不可能的(不幸的是).我不是在谈论只能在一元运算符开头的F#中使用的符号“?”,这并不重要.令我印象深刻的是定义这样的图形的可能性：

in ~> f1 ~> bcast ~> f2 ~> merge ~> f3 ~> out
            bcast ~> f4 ~> merge

由于各种图形元素具有不同的类型(源,流,接收器),因此无法在F#中定义可以跨越它们的单个运算符.但我想知道为什么在Scala中这是可能的 – 这是因为Scala支持方法函数重载(而F#不支持)？

UPDATE. Fydor Soikin在F#中展示了几种重载方式,可以用来在使用F#时实现类似的语法.我试过这个,这里看起来如何：

type StreamSource<'a,'b,'c,'d>(source: Source<'a,'b>) = 
    member this.connect(flow : Flow<'a,'d>) = source.Via(flow)
    member this.connect(sink: Sink<'a,Task>) = source.To(sink)

type StreamFlow<'a,'c>(flow : Flow<'a,'c>) = 
    member this.connect(sink: Sink<'b,Task>) = flow.To(sink)

type StreamOp = StreamOp with
    static member inline ($) (StreamOp,source: Source<'a,'b>) = StreamSource source
    static member inline ($) (StreamOp,flow : Flow<'a,'c>) = StreamFlow flow

let inline connect (a: ^a) (b: ^b) = (^a : (member connect: ^b -> ^c) (a,b)) 
let inline (>~>) (a: ^a) (b: ^b) = connect (StreamOp $a) b

现在我们可以编写以下代码：

let nums = seq { 11..13 }
let source = nums |> Source.From
let sink = Sink.ForEach(fun x -> printfn "%d" x)
let flow = Flow.FromFunction(fun x -> x * 2)
let runnable = source >~> flow >~> sink

def ~>(f: Flow) = ???
def ~>(s: Sink) = ???

trait Streamable { 
  def ~>(s: Streamable) = ???
}
class Flow extends Streamable { ... }
class Sink extends Streamable { ... }

def ~>[A: Streamable](a: A) = ???

def ~>(s: Streamable) = ???