GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages
lfe_types(7) lfe_types(7)

lfe_types - LFE Types and Functions Specifications

This is a description of the type syntax.
LFE type Erlang type
(none) none()
(any) any()
(atom) atom()
(integer) integer()
(range i1 i2) I1..I2
(float) float()
(bitstring m n) <<_:M,_:_*N>>
(binary) <<_:0,_:_*8>>
(bitstring) <<_:0,_:_*1>>
... ...
(lambda any <type>) fun((...) -> <type>)
(lambda () <type>) fun(() -> <type>)
(lambda (<tlist>) <type>) fun((<tlist>) -> <type>)
(map) map()
(map <pairlist>) #{<pairlist>}
(tuple) tuple()
(tuple <tlist>) {<tlist>}
(UNION <tlist>) <type> | <type>
Apart from the predefined types in the Erlang type system we also have the following predefined types which cannot be redefined: UNION, call, lambda and range. The usage of bitstring, tuple and map have also been extended.
The general form of bitstrings is (bitstring m n) which denotes a bitstring which starts with m bits and continues with segments of n bits. (binary) is a short form for a sequence of bytes while (bitstring) is a short form for a sequence of bits. There is currently no short form for an empty binary, (bitstring 0 0) must be used.

(deftype (type-name) type-def)
(defopaque (type-name) type-def)
(deftype (type-name par1 par2) type-def)
(defopaque (type-name par1 par2) type-def)
For unparameterised types the parentheses around the type name are optional. An example:
(deftype foo (tuple 'foo (integer) (list)))
(deftype bar (tuple 'bar (integer) (list)))

(defrecord rec (field1 default1 type1) (field2 default2) field3)
Fields with type annotations MUST give a default value and fields without type annotations get the default type (any).

(defspec (func-name arity) function-spec ...)
where
function-spec = (arg-type-list ret-type)
function-spec = (arg-type-list ret-type constraint-list)
arg-type-list = (arg-type ...)
constraint-list = (constraint ...)
constraint = (var var-type)
    
For multiple types add more function specs. The parentheses around the function name and the arity are optional. For example from the docs:
(defspec foo ([(pos_integer)] (pos_integer)))
(defspec (foo 1)   ([(pos_integer)] (pos_integer))   ([(integer)] (integer)))
(defspec (remove-if 2)   ([(lambda ((any)) (boolean)) (list)] (list)))
Or with constraints:
(defspec id ((X) X ((X (tuple)))))
(defspec (foo 1)   ([(tuple X (integer))] X ((X (atom))))   ([(list Y)] Y ((Y (number)))))
(defspec (remove-if 2)   ([pred (list)] (list) [(pred (lambda ((any)) (boolean)))]))
Note that a constraint variable doesn't need to start with an upper-case like an Erlang variable, though in some case it may be easier to read.
Note we are using the alternate list form with [ ] instead of parentheses to make it easier to see the function arguments.

Robert Virding.
2016

Search for    or go to Top of page |  Section 7 |  Main Index

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with ManDoc.