f# - tiempo - unidades de medida para niños

F#Unidades de medida, problemas con genéricos

Question

( Todavía estoy golpeando con unidades de medida en F #)

Tengo un problema al hacer funciones ''genéricas'' que toman flotadores ''tipeados''.

La siguiente clase de maqueta está destinada a mantener las pestañas en un error acumulado en la posición, en función de un factor ''c''. Al compilador no le gusta que diga 0. <''A> en el cuerpo del tipo ("parámetro de tipo inesperado en literal de unidad de medida").

///Corrects cumulative error in position based on s and c
type Corrector(s_init:float<''a>) =
    let deltaS ds c = sin (ds / c) //incremental error function

    //mutable values
    let mutable nominal_s = s_init
    let mutable error_s = 0.<''a>  //<-- COMPILER NO LIKE

    ///Set new start pos and reset error to zero
    member sc.Reset(s) = 
        nominal_s <- s
        error_s <- 0.<''a>  //<-- COMPILER NO LIKE

    ///Pass in new pos and c to corrector, returns corrected s and current error    
    member sc.Next(s:float<''a>, c:float<''a>) = 
        let ds = s - nominal_s //distance since last request
        nominal_s <- s   //update nominal s
        error_s <- error_s + (deltaS ds c) //calculate cumulative error
        (nominal_s + error_s, error_s) //pass back tuple

Creo que otra pregunta relacionada todavía tiene que ver con las funciones "genéricas".

En el siguiente código, lo que intento hacer es crear una función que tome un #seq de cualquier tipo de flotantes y aplicarlo a una función que solo acepte flotantes ''vainilla''. La tercera línea da un error de '' Restricción de valor '', y no veo ninguna salida. (Eliminar el # resuelve el problema, pero me gustaría evitar tener que escribir lo mismo para listas, secuencias, matrices, etc.)

[<Measure>] type km //define a unit of measure
let someFloatFn x = x + 1.2 //this is a function which takes ''vanilla'' floats
let MapSeqToNonUnitFunction (x:#seq<float<''a>>) = Seq.map (float >> someFloatFn) x
let testList = [ 1 .. 4 ] |> List.map float |> List.map ((*) 1.0<km>)
MapSeqToNonUnitFunction testList

Answer 1

Puede cambiar el primer ''compilador no me gusta'' a

let mutable error_s : float<''a> = 0.0<_>

y al compilador parece gustarle eso.

En cuanto a la segunda pregunta, no veo el mismo error que tú, y esto

[<Measure>] type km 
//define a unit of measure
let someFloatFn x = x + 1.2 //this is a function which takes ''vanilla'' floats
let MapSeqToNonUnitFunction (x:seq<float<_>>) = Seq.map (float >> someFloatFn) x
let testList = [ 1 .. 4 ] |> List.map float |> List.map ((*) 1.0<km>)
let testList2 = testList :> seq<_>
let result = MapSeqToNonUnitFunction testList2
printfn "%A" result

compila para mí (aunque el upcast to seq <_> es un poco molesto, no estoy seguro si hay una manera fácil de deshacerse de él o no).

Además, creo que la convención es nombrar los parámetros de unidades ''u,'' v, ... en lugar de ''a,'' b, ...

Answer 2

Las unidades de medida no se pueden usar como parámetros de tipo. Esto se debe a que son borrados por el compilador durante la compilación. Esta pregunta es bastante similar: F # Unidades de medida - valores de ''elevación'' para flotar <algo>