Is it possible to create typespec for a 'wrapper'?

I am working on creating protocols, behaviours and implementations for multiple kinds of containers. (See Implement Containers for more info)

In many cases, the implementation is separated from the interface. However, it would be really nice if it were possible to write @specs that worked with a collection(/container/wrapper, etc.) containing certain datatypes.

For instance, there is the built-in type list(item). Now, item could be any (which is its default), but if a spec is written containing list(integer) and a non-integer is passed there, then Dialyzer will warn you.

So I’d like to do the same for other types of collection-like data structures. However, as the implementation is hidden from view from the behaviours and protocols, I cannot actually say anything about the internals of these data structures (Other than ‘it should implement this protocol’).

So I’d like to create symbolic wrapper types. Something like:

@type collection(item) :: type

(Using @opaque is probably better here, but that is beside the point.)

Above example will however not compile, as item is a free type variable which is not allowed:

== Compilation error in file lib/insertable.ex ==
** (CompileError) lib/insertable.ex:45: type variable item is only used once (is unbound)
    (stdlib) lists.erl:1338: :lists.foreach/2
    lib/insertable.ex:1: (file)

Is there a way to introduce item on the right hand side here? Or is there another way to create a type for wrapping-structures like queues, sets, trees etc that allows restricting what type of values should be inside?

If you have any kind of use call to your module then you could build up the types in the remote module dynamically.

If you are wanting to do something like an ‘unbound’ item that is to be filled in then I usually make an opaque item and use it, then have the other modules reference that type as it’s internal type (and/or refine it via use).

What do you mean by introduce it on the right side? Can you show a complete example of what you ‘want’ it to look/act like?

(Or you could MLElixir that allows for types with arguments and refining. ^.^ /s)

@josevalim responded to me in the IRC channel, stating that Dialyzer cannot handle the dynamic protocol dispatch (at least as it currently stands), that creating specs for this probably wouldn’t really work.

So… I guess it is impossible, at least right now.

1 Like