CODEWITHSUNDEEP
ocaml
ZhangLiao
ZhangLiao

Reputation: 25

Subtyping for Yojson element in a yojson list

I meet an error about subtyping. For this code, List.map (fun ((String goal_feat):> Basic.t) -> goal_feat) (goal_feats_json:> Basic.t list). I meet the following error in vscode: 

This expression cannot be coerced to type
  Yojson.Basic.t =
    [ Assoc of (string * Yojson.Basic.t) list
    | Bool of bool
    | Float of float
    | Int of int
    | List of Yojson.Basic.t list
    | Null
    | String of string ];
it has type [< String of 'a ] -> 'b but is here used with type
  [< Yojson.Basic.t ].

While compiling, I meet the following error. Error: Syntax error: ')' expected.

If I change the code to List.map (fun ((String goal_feat): Basic.t) -> goal_feat) (goal_feats_json:> Basic.t list), which useq explicit type cast instead of subtyping, then the error disappeared. I can not understand what is the problem with my code when i use subtyping. Much appreciation to anyone who could give me some help.

Upvotes: 1

Views: 308

Answers (1)

ivg
ivg

Reputation: 35260

First of all, most likely the answer that you're looking for is 

let to_strings xs =
  List.map (function `String x -> x | _ -> assert false) (xs :> t list)

The compiler is telling you that your function is handling only one case and you're passing it a list that may contain many other things, so there is a possibility for runtime error. So it is better to indicate to the compiler that you know that only the variants tagged with String are expected. This is what we did in the example above. Now our function has type [> Yojson.Basic.t].

Now back to your direct question. The syntax for coercion is (expr : typeexpr), however in the fun ((String goal_feat):> Basic.t) -> goal_feat snippet, String goal_feat is a pattern, and you cannot coerce a pattern, so we shall use parenthesized pattern here it to give it the right, more general, type1, e.g.,

let exp xs =
  List.map (fun (`String x : t) -> x ) (xs :> t list)

This will tell the compiler that the parameter of your function shall belong to a wider type and immediately turn the error into warning 8,

Warning 8: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
(`Bool _|`Null|`Assoc _|`List _|`Float _|`Int _)

which says what I was saying in the first part of the post. It is usually a bad idea to leave warning 8 unattended, so I would suggest you to use the first solution, or, otherwise, find a way to prove to the compiler that your list doesn't have any other variants, e.g., you can use List.filter_map for that:

let collect_strings : t list -> [`String of string] list = fun xs ->
  List.filter_map (function
      | `String s -> Some (`String s)
      | _ -> None) xs

And a more natural solution would be to return untagged strings (unless you really need the to be tagged, e.g., when you need to pass this list to a function that is polymorphic over [> t] (Besides, I am using t for Yojson.Basic.t to make the post shorter, but you should use the right name in your code). So here is the solution that will extract strings and make everyone happy (it will throw away values with other tags), 

let collect_strings : t list -> string list = fun xs ->
  List.filter_map (function
      | `String s -> Some s
      | _ -> None) xs

Note, that there is no need for type annotations here, and we can easily remove them to get the most general polymoprhic type:

let collect_strings xs =
  List.filter_map (function
      | `String s -> Some s
      | _ -> None) xs

It will get the type 

[> `String a] list -> 'a list

which means, a list of polymorphic variants with any tags, returning a list of objects that were tagged with the String tag.

1)It is not a limitation that coercion doesn't work on patterns, moreover it wouldn't make any sense to coerce a pattern. The coercion takes an expression with an existing type and upcasts (weakens) it to a supertype. A function parameter is not an expression, so there is nothing here to coerce. You can just annotate it with the type, e.g., fun (x : #t) -> x will say that our function expects values of type [< t] which is less general than the unannotated type 'a. To summarize, coercion is needed when you have a function that accepts an value that have a object or polymorphic variant type, and in you would like at some expressions to use it with a weakened (upcasted type) for example 

type a = [`A]
type b = [`B]
type t = [a | b]

let f : t -> unit = fun _ -> ()
let example : a -> unit = fun x -> f (x :> t)

Here we have type t with two subtypes a and b. Our function f is accepting the base type t, but example is specific to a. In order to be able to use f on an object of type a we need an explicit type coercion to weaken (we lose the type information here) its type to t. Notice that, we do not change the type of x per se, so the following example still type checks:

let rec example : a -> unit = fun x -> f (x :> t); example x

I.e., we weakened the type of the argument to f but the variable x is still having the stronger type a, so we can still use it as a value of type a.

Upvotes: 1

Related Questions