(estoytodavía golpeando encendido con unidades de medida en F #)

Tengo un problema para hacer funciones 'genéricas' que toman flotantes 'tipadas'.

La siguiente clase de maqueta está diseñada para mantener pestañas sobre un error acumulativo en la posición, basado en 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 aún tiene que ver con las funciones 'genéricas'.

En el siguiente código, lo que estoy tratando de hacer es crear una función que tome un #seq de cualquier tipo de flotantes y lo aplique a una función que solo acepte flotantes 'vainilla'. La tercera línea da un 'Restricción de valor'error, y no puedo ver 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