How do we make element creation and lookup both type safe and convenient. about bs-webapi-incubator HOT 7 CLOSED

Definitely something like:

val safeTagNameCast : 'a -> 'b kind -> 'b 

Could be re-used!

from bs-webapi-incubator.

@glennsl You could do something like:

type image 

external src : image -> string -> unit = "" [@@bs.set]
(* .. add function on image *) 

type paragraph
(* .. add function on paragraph *)

type link
(* .. add function on link *)

type _ kind = 
  | Image : image kind
  | Paragraph : paragraph kind 
  | Link : link kind 

module Document : sig 

  type t 

  val dom : t 

  val createElement : t -> 'a kind -> 'a 

end = struct 

  type t 

  external dom : t = "dom" [@@bs.val]

  external createElementEx : t -> string -> 'a = "createElement" [@@bs.send]
 
  let createElement : 
    type a. t -> a kind -> a = 
    fun t kind ->
      match kind with
      | Image -> createElementEx t "img"
      | Paragraph -> createElementEx t "p"
      | Link -> createElementEx t "a"

end

let ()  = 
  let img1 = Document.createElement Document.dom Image in 
  src img1 "blah.jpg";
  let p1 = Document.createElement Document.dom Paragraph in 
  src p1 "blah.jpg" (* Compilation Error *)

from bs-webapi-incubator.

@mransan Thanks! This is precisely what I was thinking of, but unable to actually formulate.

So then we'd have to maintain a massive variant, and a massive match in any function that uses it, as opposed to maintaining a whole boatload of separate functions in each element's module.

What does this mean for the extensibility and maintenance of the API as the DOM and HTML specifications change? This is of course the classic expression problem, but which is more important for a DOM API, the ability to easily add new kinds, or the ability to easily add new functions that operate on them?

Pros:

• We won't need to add otherwise empty modules for element interfaces that don't add any additional functionality.
• getElementsByTagName would certainly be more intuitive to use
• This could theoretically be used even for functions such as getElementById
• Is user extensible
• The same pattern could be applied to e.g. nodeType.

Cons:

• Will produce a big switch that adds to code size and runtime cost for each function that will use this
• Confusing interaction with subtyping?

I'm just thinking out loud here. What are your thoughts on the tradeoffs?

from bs-webapi-incubator.

Regarding getElementById, you would also have to do some check to make sure the element tag name is matching the GADT constructor no ?

from bs-webapi-incubator.

Yeah you'd have to check the tagName, which I doubt we want to do for the default "getElementById", but we could perhaps have an overload that does so. But it's nice to have the option at least, and it will probably be useful for other functions too.

from bs-webapi-incubator.

@glennsl I need to understand the subtyping better before making an opinion :)

from bs-webapi-incubator.

Understandable. Fortunately I wrote an essay on it 😁

from bs-webapi-incubator.