Uso del símbolo F # pipe con un constructor de objetos

Question

Estoy tratando de encontrar la sintaxis correcta para usar el operador de tuberías |> en la creación de un objeto. Actualmente estoy usando un miembro estático para crear el objeto y simplemente conectarlo a eso. Aquí está la versión simplificada.

type Shape = 
    val points : Vector[] 

    new (points) = 
     { points = points; } 

    static member create(points) = 
     Shape(points) 

    static member concat(shapes : Shape list) = 
     shapes 
      |> List.map (fun shape -> shape.points) 
      |> Array.concat 
      |> Shape.create 

Lo que yo quiero hacer ...

static member concat(shapes : Shape list) = 
     shapes 
      |> List.map (fun shape -> shape.points) 
      |> Array.concat 
      |> (new Shape) 

es algo como esto posible? No quiero duplicar código repitiendo mi constructor con el miembro estático create.

actualización constructores son funciones de primera clase como de F # 4.0

En F # 4.0 la sintaxis correcta es.

static member concat(shapes : Shape list) = 
     shapes 
      |> List.map (fun shape -> shape.points) 
      |> Array.concat 
      |> Shape 

Answer 1

Siempre hay

(fun args -> new Shape(args)) 

Answer 2

Al parecer, los constructores de objetos no son componibles. constructores unión discriminados no parecen tener este problema:

> 1 + 1 |> Some;; 
val it : int option = Some 2 

Si desea utilizar la tubería, la respuesta de Brian es probablemente el mejor. En este caso, consideraría simplemente envolver toda la expresión con Shape().