There are different idioms in ReasonML and OCaml, camelCase vs snake_case and PascalCase vs Giraffe_case meaning that there'd be some friction if someone would like to use this in the OCaml world.

We can provide aliases, similar to what Tablecloth are doing, but that still leaves us with the status-codes being PascalCase'd.

Could also provide a separate library

An idea is to provide good default libraries, a part from offering the interface.

It'd be nice if this could include support for HTTPS and HTTP2 as well!

Something like:

fetch-native-lwt
fetch-native-repromise

fetch-node-future
fetch-node-repromise

Fetch Native

• fetch-native-lwt (HTTP/HTTPS)
• fetch-native-repromise (HTTP/HTTPS)

Fetch Node

• fetch-node-future (HTTP/HTTPS)
• fetch-node-repromise (HTTP/HTTPS)

One issue I see currently is that there's no way to extend the current Fetch-implementation.

E.g. it'd be nice for consumers to extend with custom functionality:

module Body: {
   ...
   let toJSON = ... => ...
}

E.g.

Fetch.get
Fetch.post
Fetch.put

May be something for further down the road (or not at all), but logging to remember it!

both fetch and e.g. axios use a similar API. Seeing as reason-fetch bases many of its decisions from whatwg, it might be an idea to go with a similar API (AbortSignal) to that.

Is this what you were seeing as well @ulrikstrid? @opam/conf-openssl

Found these, could be related:

ocaml/opam-repository#12876
ocaml/opam-repository#13636

Originally posted by @lessp in #13 (comment)

Experiments have been started in #31 the goal is to create an implementation which uses promise.

As raised by @anmonteiro and @ulrikstrid, the should at least split its dependencies:

@anmonteiro

I might be a minority here, but a suggestion I'd make is to get rid of (most) dependencies
personally I'm very careful in what (transitive) dependencies I depend on
and I don't think I'd use a library that brings in reason as a dependency, or a "core" library like tablecloth

@ulrikstrid

The core fetch library should probably not have any dependencies and then there should be implementations that have dependencies

Currently the return type is not transparent. I think this should be possible by using destructive substitution, but I'm not sure how!

From:

(
  ~body: option(string), 
  ~headers: option(list(Fetch.Headers.t)), 
  ~meth: option(Fetch.Method.t), 
  string, 
  unit
) => Fetch.IO.t;

To:

(
  ~body: option(string), 
  ~headers: option(list(Fetch.Headers.t)), 
  ~meth: option(Fetch.Method.t), 
  string, 
  unit
) => Promise.t(result(Response.t, exn));