实现接口时F＃“代码不够通用”“^ T无法推广”

Question

I'm trying to implement the IJsonSerializer from Giraffe.Serialization.Json in a project to use Microsoft.FSharpLu.Json, but am having trouble with one of the generic methods (code below)

type FSharpLuSerializer () =
    interface Giraffe.Serialization.Json.IJsonSerializer with
        member __.Deserialize<'T> (json : string) =
            Microsoft.FSharpLu.Json.Default.deserialize<'T> json

I am given the error

This code is not sufficiently generic. The type variable ^T could not be generalized because it would escape its scope

I've seen other questions with the same error, but I'm not sure how to apply their solutions to my situation. I imagine it has something to do with FSharpLu.Json using ^T, but I don't know what my workaround would be

https://github.com/Microsoft/fsharplu/blob/master/FSharpLu.Json/Default.fs

Here's the Giraffe IJSonSerializer interface

[<AllowNullLiteral>]
type IJsonSerializer =
    abstract member SerializeToString<'T>      : 'T -> string
    abstract member SerializeToBytes<'T>       : 'T -> byte array
    abstract member SerializeToStreamAsync<'T> : 'T -> Stream -> Task

    abstract member Deserialize<'T>      : string -> 'T
    abstract member Deserialize<'T>      : byte[] -> 'T
    abstract member DeserializeAsync<'T> : Stream -> Task<'T>

Answer 1

I ran across this when I encountered the same problem. I just wrote this, and it appears to be working. I'll run it through some more paces, and if it's good, I'll push out a NuGet package where this can be plugged in.

open Giraffe.Serialization
open Microsoft.FSharpLu.Json
open Newtonsoft.Json
open System.IO
open System.Text
open System.Threading.Tasks

type FSharpLuJsonSerializer() =
  interface IJsonSerializer with
    member __.SerializeToString<'T>      (x : 'T) =
      Compact.serialize x
    member __.SerializeToBytes<'T>       (x : 'T) =
      Text.Encoding.UTF8.GetBytes (Compact.serialize x)
    member __.SerializeToStreamAsync<'T> (x : 'T) (stream : Stream) =
      let serializer = new JsonSerializer()
      serializer.Converters.Add (CompactUnionJsonConverter ())
      use sw = new StreamWriter (stream)
      use writer = new JsonTextWriter (sw)
      serializer.Serialize (writer, obj)
      Task.CompletedTask

    member __.Deserialize<'T> (json : string) =
      (Compact.deserialize >> box) json :?> 'T
    member __.Deserialize<'T> (bytes : byte[]) =
      (Compact.deserialize >> box) (Encoding.UTF8.GetString (ReadOnlySpan bytes)) :?> 'T
    member __.DeserializeAsync<'T> (stream : Stream) =
      Task.FromResult<'T> ((Compact.deserializeStream >> box) stream :?> 'T)

Feedback from F# folks welcomed as well.

Answer 2

After jumping onto the F# Slack, there is an even easier way to do this that doesn't require all the boxing and casting. FSharpLu uses Newtonsoft.Json under the hood, and its compact functionality comes from the CompactUnionJsonConverter type. You can add this converter to Giraffe's default JsonSerializerSettings , and it works - meaning that you don't have to completely reimplement IJsonSerializer .

  open Giraffe.Serialization
  open Microsoft.FSharpLu.Json
  open Newtonsoft.Json

  let jsonSettings = 
    let x = NewtonsoftJsonSerializer.DefaultSettings
    x.Converters.Add (CompactUnionJsonConverter (true))
    x

Then, where you configure your services...

    services.AddSingleton<IJsonSerializer>(NewtonsoftJsonSerializer jsonSettings)

Huge thanks to Nino Floris (@ninofloris) for this suggestion.

Answer 3

this is a messy one, in general, interfaces need to capture the type to be applied via generics on methods, to complicate matters further, your FSharpLu.Json library is using inline SRTPs, SRTPs inline template the method invocation call on the ^ constraint type so in the compiled code there is a concreate, fixed type method for each call, this is different to the normal reified generics used in .net that resolve the type at runtime.

As you cannot inline an interface, try add the type constraint on the interface, that will catch the type and avoid the generalisation issue.

type IJsonSerializer<'T> =
abstract member SerializeToString      : 'T -> string
...