META: Mini-Erlang Typing Application

Mini-Erlang Typing Application is a static analysis of polymorphic types tool. This tool uses a subset of the CoreErlang language to analyse source code expressions and give type information to the user.

How to use the tool

These are the bash commands to use the tool:

meta.sh: Runs the tool with a list of options and files to analyse. The working folder of this script is the tests folder.
build.sh: Builds the tool using the Erlang compiler command. The compiled BEAM files will be in the folder ./out/production/meta.
generate.sh: This script generates the Erlang code to parse Mini-Erlang source code files. It will be necessary only when a modification is done in the minierlang.yrl file.
debugb.sh: Builds the tool like build.sh but adding the debug info needed by the Erlang debugger.
debug.sh: Runs the Erlang debugger to debug the tool if needed.

For example, to build and run the tool you can use this command:

clear ; ./build.sh ; ./meta.sh map.txt

The main options of the tool are:

-h, --help: Shows the help message with the tool's options.
-v, --version: Shows the version of the tool.
-c, --code: Shows the source code of the files being analysed.

Mini-Erlang syntax

This follow is the BNF syntax for the Mini-Erlang language:

expression  ::= variable
              | literal
              | "fun" "(" variables ")" "->" expression
              | "[" expression "|" expression "]"
              | "{" expressions "}"
              | variable "(" variables ")"
              | "let" variable "=" expression "in" expression
              | "letrec" fundefs "in" expression
              | "case" variable "of" clauses "end"
              | "receive" clauses "after" variable "->" expression

clause      ::= pattern "when" expression "->" expression

pattern     ::= variable
              | literal
              | "[" pattern "|" pattern "]"
              | "{" patterns "}"

lit         ::= ATOM | INTEGER | FLOAT | "[]"

expressions ::= expression | expression "," expressions
variables   ::= variable   | variable "," variables
clauses     ::= clause     | clause "," clauses
patterns    ::= pattern    | pattern "," patterns

Types syntax

In the following table we will see the types shown by the tool:

Name	Form	Description
`PAIRS`	`PAIR; ...`	Branches of the execution
`PAIR`	`TYPE where COND, ... end`	Type of the branch with constraints
`COND`	`VAR <= TYPE`	Subseteq constraint
	`LIT <= TYPE`	Subseteq condition
	`VAR := TYPE`	Match constraint
`TYPE`	`LIT`	Singleton set that represents a literal value
	`VAR`	Type variable used in polymorphic types
	`none()`	Set with no values
	`any()`	Set with all values
	`atom()`	Set with all atom values
	`integer()`	Set with all integer values
	`float()`	Set with all float values
	`nelist(TYPE, TYPE)`	Set of non-empty lists where the first type represents the body and the second the termination
	`{TYPE, ...}`	Set of tuples where each component has a type
	`TYPE + TYPE`	The union of types
	`TYPE when COND, ...`	Type with constraints
	`FUNC; ...`	Functional type overloaded
`FUNC`	`forall VAR, ...: (TYPE, ...) -> TYPE`	Functional scheme type

Remember that [] is the literal that represents the empty list. Atoms, integer and floats literals are the same used in Erlang.

gorkinovich/meta

META: Mini-Erlang Typing Application

How to use the tool

Mini-Erlang syntax

Types syntax