Mise en forme Fluent/enchaînant méthode de C# en F #

Question

Certains apis comme Ninject utiliser les APIs de style couramment, par exemple:

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

Lorsque je tente de formater le code comme celui-ci en F # le compilateur se plaint à l'espace entre les appels de méthode .

Est-il possible de mettre les appels de méthode sur des lignes séparées? Je pensais quelque chose comme l'opérateur de pipelining |> mais je ne sais pas exactement comment dans ce cas.

Comment cela devrait-il être formaté en F #?

Answer 1

Etes-vous sûr que cela ne fonctionne pas?

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

(notez un espace avant les . s)

Oui, il 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()) 

Tant que vous avez des principaux espaces lorsque vous essayez de poursuivre une seule expression sur plusieurs lignes, vous allez bien.

(Notez que le pipelining en général ne fonctionnera que si vous avez conçu des API avec des paramètres de méthode au curry.)