F # typu ograniczeń na teksty stałe

Question

Próbuję określić ogólny operatora konwersji z ciągu znaków do wyliczenia i chciałbym używać go tak:

let day = asEnum<DayOfWeek>("Monday") 

Ale z tej realizacji:

let asEnum<'a, 'b when 'a: (new : unit -> 'a) and 'a : struct and 'a :> ValueType and 'a : enum<'b>> text = 
    match Enum.TryParse<'a>(text) with 
    | true, value -> Some value 
    | false, _ -> None 

mogę użyć tylko to tak:

let day = asEnum<DayOfWeek,_>("Monday") 

lub to:

let day:DayOfWeek option = asEnum("Monday") 

Jeśli pominąć 'a : enum<'b> całkowicie od rodzaju przymusu, mogę mieć to jak chcę, ale jeśli ktoś nie określił to domyślnie int, co bardzo mi się nie podoba, ja wolałby dać błąd czasu kompilacji, tak jak wtedy, gdy określę ograniczenie. Może jest jakaś sztuczka, żeby podać tylko jeden parametr i mieć drugi? Jakieś pomysły?

Answer 1

Niestety, aby wspomagając w ten sposób ograniczenie wydaje się, trzeba przeliterować to wszystko: (jak KVB wskazał, można uniknąć powielania tych ograniczeń TryParse dodając 'T : enum<int> ograniczenia poza nawiasach kątowych)

działa to również:

let asEnum<'T 
    when 'T : enum<int> 
    and 'T : struct 
    and 'T :> ValueType 
    and 'T : (new : unit -> 'T)> text = 
    match Enum.TryParse<'T>(text) with 
    | true, value -> Some value 
    | _ -> None 

to daje błąd kompilacji, jeśli typ bazowy nie jest int:

type ByteEnum = 
    | None = 0uy 

asEnum<ByteEnum> "None" //ERROR: The type 'int' does not match the type 'byte' 

Answer 2

Co powiesz na to?

let asEnum s :'a option when 'a:enum<'b> = 
    match System.Enum.TryParse s with 
    | true, v -> Some v 
    | _ -> None 

// works, but warns that type params shouldn't be given explicitly 
asEnum<System.Reflection.BindingFlags,_> "DeclaredOnly"  
// also okay 
(asEnum "DeclaredOnly" : System.Reflection.BindingFlags option) 

Answer 3

Inną rzeczą próbowałem było to:

type AsEnum = 

    static member Get<'a, 'b when 'a: (new : unit -> 'a) and 'a : struct and 'a :> ValueType and 'a : enum<int>> (text:string) = 

     match Enum.TryParse<'a>(text) with 
     | true, value -> Some value 
     | _ -> None 

    static member Get<'a, 'b when 'a: (new : unit -> 'a) and 'a : struct and 'a :> ValueType and 'a : enum<int64>> (text:string) = 

     match Enum.TryParse<'a>(text) with 
     | true, value -> Some value 
     | _ -> None 

let a = AsEnum.Get<BindingFlags>.Get "DeclaredOnly" 

spróbować, aby zobaczyć, czy mogę dostać kompilator wywnioskować który przeciążać zadzwonić, ale jeśli nie powiedzie się z powodu błędu niejednoznaczności

Answer 4

A niewielka aktualizacja około 3 lat później^_^

Korzystanie z tego ciągu znaków do przekształcenia ciągu znaków w wyliczenie

type System.String with 
     /// Strongly-typed shortcut for Enum.TryParse(). 
     member this.ToEnum<'a when 'a :> System.Enum and 'a : struct and 'a : (new: unit -> 'a)>() = 
      let ok, v = System.Enum.TryParse<'a>(this, true) 
      if ok then Some v else None  

Należy zachować ostrożność przy deklaracji wyliczeniowej.

type failingEnum = 
      | FirstValue 
      | SecondValue 
      | AnotherValue 

type compliantEnum = 
      | FirstValue = 0 
      | SecondValue = 1 
      | AnotherValue = 2 

Następnie

let x = "whatever".ToEnum<failingEnum>(); 
//- will give error failingEnum is not compatible with the type System.Enum 

let x = "whatever".ToEnum<compliantEnum>(); 
//- will succeed !