Consider adding a phantom type to Kleisli

Non viene indicato alcun file né test. Inizia individuando la definizione di Kleisli e il relativo operatore di composizione di categorie, quindi riproduci l’esempio mostrato della restrizione dei valori. Il lavoro è completato quando è stata presa una decisione sull’approccio basato sul tipo fantasma e, se viene accettato, è stato verificato che la composizione con binding let funziona senza introdurre le restrizioni dei valori indicate.

We could get better types, but we risk more value restrictions.

For instance, defining it like this:

/// Kleisli arrows of a monad. Represents a function 'T -> 'Monad<'U>
[<Struct; NoEquality; NoComparison>]
type Kleisli<'t, '``monad<'u>``,'u> = Kleisli of ('t -> '``monad<'u>``) with

    // Profunctor
    static member inline Dimap (Kleisli bmc: Kleisli<'B,'``Monad<'C>``,'C>, ab: 'A->'B, cd: 'C->'D) = let cmd = map cd in Kleisli (ab >> bmc >> cmd) : Kleisli<'A,'``Monad<'D>``,'D>
    static member        Contramap (Kleisli f : Kleisli<'B,'``Monad<'C>``,'C>, k: 'A->'B) = Kleisli (k >> f)      : Kleisli<'A,'``Monad<'C>``,'C>
    static member inline Map (Kleisli f : Kleisli<'B,'``Monad<'C>``,'C>, cd: 'C->'D     ) = Kleisli (map cd << f) : Kleisli<'B,'``Monad<'D>``,'D>
    
    // Category
    static member inline get_Id () = Kleisli result : Kleisli<'a,'b,'a>
    static member inline (<<<) (Kleisli (f: 'U->'``Monad<'V>``): Kleisli<'U,'``Monad<'V>``,'V>, Kleisli (g: 'T->'``Monad<'U>``): Kleisli<'T,'``Monad<'U>``,'U>) = 
        Kleisli ( (g >=> f) : 'T->'``Monad<'V>``) : Kleisli<'T, '``Monad<'V>``, 'V>

Allows us to run:

let r5: List<_> = (runKleisli (getCatId ())) 5
let k = Kleisli (fun y -> [y; y * 2 ; y * 3]) <<< Kleisli (fun x -> [x + 3; x * 2])
let r8n16n24n10n20n30 = runKleisli k  5

But we get a value restriction

error FS0030: Value restriction. The value 'k' has been inferred to have generic type
    [<Struct>]
val k : Kleisli<int,int list,'_a>    
Either define 'k' as a simple data term, make it a function with explicit arguments or, if you do not intend for it to be generic, add a type annotation.

that we can avoid, by not let-binding k

let r5: List<_> = (runKleisli (getCatId ())) 5
let r8n16n24n10n20n30 = runKleisli (Kleisli (fun y -> [y; y * 2 ; y * 3]) <<< Kleisli (fun x -> [x + 3; x * 2]))  5

or by adding another constraint:

    static member inline (<<<) (Kleisli (f: 'U->'``Monad<'V>``): Kleisli<'U,'``Monad<'V>``,'V>, Kleisli (g: 'T->'``Monad<'U>``): Kleisli<'T,'``Monad<'U>``,'U>) =
        let _ = if true then Unchecked.defaultof<'``Monad<'V>``> else result (Unchecked.defaultof<'V>)
        Kleisli ( (g >=> f) : 'T->'``Monad<'V>``) : Kleisli<'T, '``Monad<'V>``, 'V>