define (f[::type] [a[::type]]...) body | bigloo syntax |
define-inline (f[::type] [a[::type]]...) body | bigloo syntax |
let ((var[::type] ...) ...) body | bigloo syntax |
let loop ((var[::type] ...) ...) body | bigloo syntax |
let* ((var[::type] ...) ...) body | bigloo syntax |
letrec ((var[::type] ...) ...) body | bigloo syntax |
labels ((var[::type] (var[::type]...) b) ...) body | bigloo syntax |
Type annotations are optional. That is, for any of these
constructions, if a type annotation is missing, Bigloo uses
the default generic type obj instead.
Here is an example of type annotated program:
(module example
(export (vector-fill!::vector ::vector ::obj)))
(define (vector-fill! v filler)
(let loop ((i::long (- (vector-length v) 1)))
(if (= i 0)
v
(begin
(vector-set! v i filler)
(loop (- i 1))))))
(let ((v::vector (make-vector 3 4)))
(vector-fill! v "dummy"))
|
The types that can be used in annotations are any of:
- the basic Scheme types
pair , null , bstring ,
bint (presented in Section Defining an extern type).
- the basic extern types
long , int , char ,
string presented in Section Defining an extern type.
- the compound extern types described in Section ref Defining an
extern type.
- the types introduced by class declarations (Section
Class declaration).
When a function that contains type annotation is exported, the type
annotations must be written in the prototype of the function in
the export clause. In that case the type annotation need to be
written in the function definition:
(module foo
(export (succ::int ::int)))
(define (succ x) (+ 1 x))
|
|