¿Se pueden extender los tipos existentes para que funcionen con Seq.sum, etc.?

Question

He estado trabajando con un montón de TimeSpans recientemente, y necesito obtener sumas & promedios.
Sin embargo, TimeSpan no define ni el operador get_Zero ni DivideByInt, por lo que Seq.sum y Seq.average no se pueden usar directamente con este tipo. La siguiente falla al compilar:

open System 
type System.TimeSpan 
    with 
     static member Zero with get() = TimeSpan() 
     static member (/) (n:DateTime, d:int) = DateTime(n.Ticks/(int64) d) 

let ts = [ TimeSpan(10L); TimeSpan(99L) ] 
let sum = ts |> Seq.sum 
let avg = ts |> Seq.average 

• de error: El tipo 'TimeSpan' no admite ningún operadores nombrados 'get_Zero'
• de error: El tipo 'TimeSpan' no admite ningún operadores nombrados 'DivideByInt'
• Advertencia: los miembros de la extensión no pueden proporcionar sobrecargas al operador. Considere definir al operador como parte de la definición de tipo en su lugar.

¿Hay alguna magia F # que pueda definir estos operadores en un tipo existente?

Sé que lo siguiente funcionará (y debería ser más eficiente para arrancar), pero todavía siento curiosidad por lo anterior, así que puedo agregarlo a mi caja de herramientas para usar con otros tipos.

let sum = TimeSpan(ts |> Seq.sumBy (fun t -> t.Ticks)) 
let avg = TimeSpan(let len = ts |> Seq.length in sum.Ticks/int64 len) 

Answer 1

Por lo que yo sé, las limitaciones de miembros estáticos (que son utilizados por funciones como Seq.sum) no son capaces de descubrir los miembros que se agregan por extensiones de tipos (esencialmente, los métodos de extensión), así que no creo hay una manera directa de hacer esto.

La mejor opción que puedo pensar es crear un envoltorio simple alrededor de la estructura System.TimeSpan. Luego puede definir todos los miembros requeridos. El código se vería así:

[<Struct>] 
type TimeSpan(ts:System.TimeSpan) = 
    member x.TimeSpan = ts 
    new(ticks:int64) = TimeSpan(System.TimeSpan(ticks)) 
    static member Zero = TimeSpan(System.TimeSpan.Zero) 
    static member (+) (a:TimeSpan, b:TimeSpan) = 
    TimeSpan(a.TimeSpan + b.TimeSpan) 
    static member DivideByInt (n:TimeSpan, d:int) = 
    TimeSpan(n.TimeSpan.Ticks/(int64 d)) 

let ts = [ TimeSpan(10L); TimeSpan(99L) ] 
let sum = ts |> Seq.sum 
let avg = ts |> Seq.average 

me llamaron del tipo TimeSpan, por lo que oculta el estándar de tipo System.TimeSpan. Sin embargo, aún necesita escribir ts.TimeSpan cuando necesite acceder al tipo de sistema subyacente, por lo que esto no es tan bueno como podría ser.

Answer 2

Mhh lo siguiente es bastante feo, pero funciona. ¿Ayuda? Defino un contenedor para TimeSpan que se puede volver a convertir implícitamente a TimeSpan.

type MyTimeSpan(ts : TimeSpan) = 
    member t.op_Implicit : TimeSpan = ts 
    static member (+) (t1 : MyTimeSpan, t2 : MyTimeSpan) = 
     new MyTimeSpan(TimeSpan.FromTicks(t1.op_Implicit.Ticks + t2.op_Implicit.Ticks)) 
    static member Zero = new MyTimeSpan(TimeSpan.Zero) 
    static member DivideByInt (t : MyTimeSpan, i : int) = 
     new MyTimeSpan(TimeSpan.FromTicks(int64 (float t.op_Implicit.Ticks/float i))) 

let toMyTS ts = new MyTimeSpan(ts) 

let l = [TimeSpan.FromSeconds(3.); TimeSpan.FromSeconds(4.)] 
      |> List.map toMyTS 
      |> List.average