Type entity

Type entities can represent -type, -opaque attributes(user-defined types), built-in types or any type expression in an erlang file. Please note that type expressions consisting of only a single atom(e.g.: ok, 'error') are filtered from the results of any selector that returns type entities.

Initial selector

When a type expression is indicated by the given position, the @type initial-selector can be used to return the corresponding type entity.

Selectors

The type of the result elements are indicated in parenthesis.

• file (file): The defining file of the type.
• arguments (type): The arguments of the type.
• subtypes (type): Subtypes of the given type.
• specref (spec): Specs using this type.
• references (type): The references of the type.
• paramsref (type): The references of the types arguments.

Properties

The following properties are defined for spec entities:

• name (atom): The name of the type
• arity (int): The arity of the type.
• exported (bool): Returns whether the type is exported.
• opaque (bool): Returns whether the type is opaque.
• builtin (bool): Returns whether the type is built-in.

Textual output format

When using any of our interfaces, other than ris?, this entity will be represented in the output as a string with the following possible formats:

• When the entity represents a user-defined or built-in type:

  Type -> string (Module:Name/Arity)
  Module -> atom (defining module of the type)
  Name -> atom (name of the type = Type.name)
  Arity -> int (number of parameters of the type = Type.arity)
  

• When the entity represents a type expression:

  Type -> string (textual representation of the type expression, as it was formatted in the source)
  

Review of non-trivial selectors

Due to the multiple structures represented by this entity, some of the selectors have a complex specification. These are described below:

Type.arguments:

Returns the type or type expression of the given type's parameters.

%%-type myt(Key, Val) :: myt(Key, ok).
ri:q("mods.types.params").           
a:myt/2
    Key
     Val
ok
ri:q("mods.types.subtypes.params").
 myt(Key, ok)
    Key

Type.subtypes:

If the given type is a user-defined type it returns the type's body as a type expression. When the given type is a type expression it returns the expression's subexpressions(1-level deep).

ri:q("mods.types.subtypes").
a:prp_user/2
     [{atom(), Key, Val}]
a:myt/2
     myt(Key, ok)
ok
ri:q("mods.types.subtypes.subtypes").
 [{atom(), Key, Val}]
    {atom(), Key, Val}
 myt(Key, ok)
    Key

Type.specrefs:

For user-defined and built-in types, returns the specs referencing this type.

ri:q("mods.types.specrefs").
b:prp_user/2
    -spec g(prp_user(X,Y))->'ok'.

Type.references:

Returns the type expressions using this user-defined or built-in type. If the given type is a type expression it tries to find the user-defined or built-in type referenced in the type expression and continues from there. Otherwise the result is empty.

ri:q("mods.types.refs").                  
b:prp_user/2
    prp_user(X,Y)
a:myt/2
     myt(list(), ok)
     myt(Key, ok)