¿Es esta pregunta solucionable a través deidiomático funcional enfoque, podríagenéricos osindicatos discriminados ser la respuesta?

¿Es posible tener polimorfismo al pasar diferentes tipos a una función mientras la función consume algunos campos comunes?

La idea es poder llamar y reutilizar la función con diferentes tipos y usar los atributos / campos comunes.

type Car = {
    Registration: string
    Owner: string
    Wheels: int
    customAttribute1: string
    customAttribute2: string
}

type Truck = {
   Registration: string
   Owner: string
   Wheels: int
   customField5: string
   customField6: string
}


let SomeComplexMethod (v: Car) = 
    Console.WriteLine("Registration" + v.Registration + "Owner:" + v.Owner + "Wheels" + v.Wheels
    // some complex functionality

Utilizar

SomeComplexMethod(car)
SomeComplexMethod(truck)

Editar

Siguiendo la respuesta. ¿Es posible especificar el tipo de entradav ya que el serializador JSON pregunta por el tipo asociado. Si el automóvil se suministró como entrada, el automóvil se emitirá, si el camión como camión de entrada se emitirá.

let inline someComplexFun v  =
    let owner =  (^v: (member Owner: string)(v)) 
    let registration = (^v: (member Registration: string)(v))
    // process input

    use response = request.GetResponse() :?> HttpWebResponse
    use reader = new StreamReader(response.GetResponseStream())
    use memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(reader.ReadToEnd()))
    (new DataContractJsonSerializer(typeof<Car>)).ReadObject(memoryStream) :?> Car

si el camión fuera la entradav

(new DataContractJsonSerializer(typeof<Truck>)).ReadObject(memoryStream) :?> Truck