How to use Js.Dict.t type for Js.Dict.get

Question

I am trying to convert some JS to Reason, along the way I need to type a JSON response and also check if a key exists in an object.

This is my current code:

let api_key = "";
let api_url = "http://ws.audioscrobbler.com/2.0";
let method = "user.getRecentTracks";
let user = "montogeek";

type trackAttr = {
  nowplaying: bool
};

type artistT = {
  text: string
}

type trackT = {
  attr: trackAttr,
  name: string,
  artist: artistT
};

type recentTrackT = {
  track: array(Js.Dict.t(trackT))
};

type response = {
  recenttracks: recentTrackT
};

Js.Promise.(Fetch.fetch(api_url ++ "?method=" ++ method ++ "&" ++ user ++ "=" ++ user ++ "&limit=1&format=json&api_key=" ++ api_key)
    |> then_(Fetch.Response.json)
    |> then_(json: response => {
      let lasttrack = json.recenttracks.track[0];

      let online = switch (Js.Dict.get(lasttrack, "attr")) {
      | None => false
      | Some(track) => track.attr.nowplaying
      };
      let info = online ? "Enjoying" ++ lasttrack.name ++ "by " ++ lasttrack.artist["#text"] ++ "}" : "";

      { online, info }
    }));

Currently I am getting this error:

We've found a bug for you!
  /Users/montogeek/Infinite/Lov/online/src/lastfm.re 37:41-49

  35 ┆ | Some(track) => track.attr.nowplaying
  36 ┆ };
  37 ┆ let info = online ? "Enjoying" ++ lasttrack.name ++ "by " ++ lasttrack
       .artist["#text"] ++ "}" : "";
  38 ┆
  39 ┆ { online, info }

  This has type:
    Js.Dict.t(trackT) (defined as Js.Dict.t(trackT))
  But somewhere wanted:
    trackT

I can't remove Js.Dict.t type because Js.Dict.get won't like it.

How can I type the response so it works?

Thanks!

glennsl · Accepted Answer · 2018-05-23T17:51:32.957

You might want to try building this in smaller increments, as you've been digging yourself a pretty deep hole here.

First of all, you're describing your JSON repsonse in terms of record types, not JS object types.

This is a record type:

type  t = { foo: string };

and this is a JS object type:

type t = {. "foo": string };

A subtle but pretty significant difference.

Secondly Js.Dict.t(trackT) is not what you think it is (though what exactly that is is also unclear to me). It describes a JS object used as a hash, with keys of type String and values of type trackT. This looks like an attempt to fix the first issue, but only serves to make the hole deeper, so maybe just revert that.

Thirdly, you can't just assert that the JSON response has the type response by annotating it. This is a sound type system, where this'll just give you a type error. If you want to circumvent the type system (which is almost always a bad idea) you have to be much more explicit about it.

There's also a number of other minor errors, but that's out of scope for this.

So what you should do instead is one of two things:

The proper way is to use a library such as bs-json to decode the JSON response into the record types you've already defined, validating the shape of the data at the boundary where it should be done, and then continue to use the record types as normal:

/* assume record types are defined above */

module Decode = {
  open Json.Decode;

  let trackAttr = json => {
    nowplaying: json |> field("nowplaying", bool)
  };

  let artist = json => {
    text: json |> field("text", string)
  }

  let track = json => {
    attr: json |> optional(field("attr", trackAttr)),
    name: json |> field("name", string),
    artist: json |> field("artist", artist)
  };

  let recentTrack = json => {
    track: json |> field("track", array(track))
  };

  let response = json => {
    recenttracks: json |> field("recenttracks", recentTrack)
  };
};

Js.Promise.(Fetch.fetch(api_url ++ "?method=" ++ method ++ "&" ++ user ++ "=" ++ user ++ "&limit=1&format=json&api_key=" ++ api_key)
    |> then_(Fetch.Response.json)
    |> then_(json => {
      let response = Decode.response(json);
      let lasttrack = response.recenttracks.track[0];
      ...
    }));

The quick and dirty way is to convert the record types into JS object types, and then just assert that the data has that shape, thereby circumventing the type system. If it doesn't have the shape you expect, you might get runtime errors anywhere and will need to track down the source of the problem manually. Here's how that might look:

type trackAttr = {.
  "nowplaying": bool
};

type artistT = {.
  "text": string
}

type trackT = {.
  "attr": trackAttr,
  "name": string,
  "artist": artistT
};

type recentTrackT = {.
  "track": array(trackT)
};

type response = {.
  "recenttracks": recentTrackT
};

external unsafeCastJsonAsResponse : Js.Json.t => response = "%identity";

Js.Promise.(Fetch.fetch(api_url ++ "?method=" ++ method ++ "&" ++ user ++ "=" ++ user ++ "&limit=1&format=json&api_key=" ++ api_key)
    |> then_(Fetch.Response.json)
    |> then_(json => {
      let response = unsafeCastJsonAsResponse(json);
      let lasttrack = response##recenttracks##track[0];
      ...
    }));

How to use Js.Dict.t type for Js.Dict.get

1 Answers1