Formateo de código encadenamiento método / fluidez de C # en F #

Question

Algunas API como Ninject utilizar las API de estilo fluido, ejemplo:

Bind<ISomething>()
.To<Something>()
.WithConstructorArgument("arg1", "somevalue")
.OnActivation(x => x.DoSomething())

Cuando intento formato del código como este en F # el compilador se queja en el espacio en blanco entre las llamadas a métodos.

¿Es posible poner las llamadas a métodos en líneas separadas? Estaba pensando en algo así como el operador de canalización |> pero no exactamente seguro de cómo en este caso.

¿Cómo debe ser formateado en F #?

Answer 1

¿Estás seguro de que esto no funciona?

Bind<ISomething>() 
 .To<Something>() 
 .WithConstructorArgument("arg1", "somevalue") 
 .OnActivation(fun x -> x.DoSomething()) 

(billete de un espacio antes de los .s)

Sí, está bien:

type ISomething = interface end
type Something = class end

type Foo() =
    member this.To<'a>() = this   //'
    member this.WithConstructorArgument(s1,s2) = this
    member this.OnActivation(x:Foo->unit) = this
    member this.DoSomething() = ()

let Bind<'a>() = new Foo() //'

let r = 
    Bind<ISomething>() 
        .To<Something>() 
        .WithConstructorArgument("arg1", "somevalue") 
        .OnActivation(fun x -> x.DoSomething()) 

Siempre y cuando usted tiene un poco de espacios en blanco, cuando se intenta seguir una sola expresión en varias líneas, que estás bien.

(Tenga en cuenta que, en general, la canalización no funcionará a menos que tenga API diseñadas para ello con los parámetros del método al curry.)