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?