Package written in Astarte:
Package exec Execute Let three = 3. Let five = "five". Writeln[$ three, $ five]. %Execute %Package
Package in assembler (minimal style):
.package exec .version 41 @BEGIN-IMPLEMENTATION % % Constants and identifiers % @LABEL >2 @STRING "five" @LABEL >3 @ID $ @LABEL >4 @ID Writeln %--------------------- @EXECUTE 2 % % Begin static environment setup % STD-SPECIES Natural STD-SPECIES Char LIST-SPECIES FUNCTION-SPECIES GET-GLOBAL-ID 3 %[0] ($ : Natural -> List(Char)) STD-SPECIES Char LIST-SPECIES STD-SPECIES Char LIST-SPECIES FUNCTION-SPECIES GET-GLOBAL-ID 3 %[1] ($ : List(Char) -> List(Char)) STD-SPECIES Char LIST-SPECIES LIST-SPECIES STD-SPECIES () FUNCTION-SPECIES GET-GLOBAL-ID 4 %[2] (Writln: List(List(Char)) -> () % % End static environment setup, begin executable code % BEGIN-EXECUTABLE 1 SMALL-INT 3 BIND 0 (three) END-TYPE CONST >2 % "five" BIND 1 (five) END-TYPE FINAL-FETCH 0 % fetch three FETCH-GLOBAL 0 % fetch $ : Natural -> List(Char) APPLY FETCH 1 % fetch five FETCH-GLOBAL 1 % fetch $ : List(Char) -> List(Char) APPLY NIL FETCH-GLOBAL 2 % fetch Writeln PAIR PAIR APPLY RETURN END %--------------------- @END-PACKAGE
Package in assembler (more involved style):
.package exec .version 41 @BEGIN-IMPLEMENTATION % % Constants and identifiers % @LABEL >1 @STRING "Exec-exec-1" @LABEL >2 @STRING "five" @LABEL >3 @ID $ @LABEL >4 @ID Writeln %--------------------- @EXECUTE 2 % % Begin static environment setup % STD-SPECIES Natural SPECIES-ONLY %[0] STD-SPECIES Char LIST-SPECIES STORE-AND-LEAVE-SPECIES %[0] SPECIES-ONLY %[1] STD-SPECIES Natural GET-SPECIES 0 FUNCTION-SPECIES GET-GLOBAL-ID >3 %[2] ($ : Natural -> List(Char)) GET-SPECIES 0 GET-SPECIES 0 FUNCTION-SPECIES GET-GLOBAL-ID >3 %[3] ($ : List(Char) -> List(Char)) GET-SPECIES 0 LIST-SPECIES STD-SPECIES () FUNCTION-SPECIES GET-GLOBAL-ID >4 %[4] (Writeln: List(List(Char)) -> ()) % % End static environment setup % BEGIN-EXECUTABLE 1 LINE 3 % Begin source line 3 SNAME >1 LINE 4 % Begin source line 4 SMALL-INT 3 BIND 0 (three) GLOBAL-FETCH-SPECIES 0 END-TYPE LINE 5 % Begin source line 5 CONST >2 % "five" BIND 1 (five) GLOBAL-FETCH-SPECIES 1 END-TYPE LINE 6 % Begin source line 6 FINAL-FETCH 0 FETCH-GLOBAL 2 APPLY FINAL-FETCH 1 FETCH-GLOBAL 3 APPLY NIL FETCH-GLOBAL 4 PAIR-TAIL-APPLY 2 RETURN END %--------------------- @END-PACKAGE
Source in Astarte:
Package def Define frog = "frog". %Package
Assembler version:
.package def .version 41 @BEGIN-IMPLEMENTATION %--------------------- @LABEL >1 @ID frog %--------------------- @LABEL >2 @STRING "frog" %--------------------- @DEFINE >1 % % Species List(Char) of thing being defined % STD-SPECIES Char LIST-SPECIES % % Static environment is empty % BEGIN-GLOBALS 0 % % Computation of thing being defined % BEGIN-EXECUTABLE 0 LINE 3 NAME >1 CONST >2 RETURN END %--------------------- @END-PACKAGE
Source written in Astarte:
Package fundef Define fun(?x:Integer,?y:Integer) = x + y. %Package
Assembler version:
.package fundef .version 41 @BEGIN-IMPLEMENTATION @LABEL >1 @ID fun %--------------------- @DEFINE >1 % % Species (Integer, Integer) -> Integer of function fun % STD-SPECIES Integer STD-SPECIES Integer PAIR-SPECIES STD-SPECIES Integer FUNCTION-SPECIES % % Empty static environment % BEGIN-GLOBALS 0 % % The following code builds the function % BEGIN-EXECUTABLE 0 LINE 3 NAME >1 FUNCTION :0 STD-SPECIES Integer BEGIN-BODY 1 NAME >1 SPLIT BIND 0 (y) STD-SPECIES Integer END-TYPE BIND-AND-LEAVE 1 (x) STD-SPECIES Integer END-TYPE FETCH 0 PLUS LOC-LABEL :0 RETURN END %--------------------- @END-PACKAGE
Source in Astarte:
Package conditional
Execute
If 2 < 3 then
Writeln["That is right"].
else
Writeln["That is wrong"].
%If
%Execute
%Package
Assembler version:
.package conditional .version 41 @BEGIN-IMPLEMENTATION %--------------------- @LABEL >1 @STRING "Exec-conditional-1" %--------------------- @LABEL >2 @LIST 1 @STRING "That is right" %--------------------- @LABEL >3 @LIST 1 @STRING "That is wrong" %--------------------- @LABEL >4 @ID Writeln %--------------------- @EXECUTE 1 % % Static environment setup % STD-SPECIES Char LIST-SPECIES LIST-SPECIES STD-SPECIES () FUNCTION-SPECIES GET-GLOBAL-ID >4 %[0] % % Executable code % BEGIN-EXECUTABLE 0 LINE 3 SNAME >1 LINE 4 SMALL-INT 2 SMALL-INT 3 LT GOTO-IF-FALSE :0 LINE 5 CONST >2 FETCH-GLOBAL 0 TAIL-APPLY RETURN LOC-LABEL :0 LINE 7 CONST >3 FETCH-GLOBAL 0 TAIL-APPLY RETURN END %--------------------- @END-PACKAGE
Source written in Astarte:
Package lazycat
Define lazycat ?x ?y =
Await then
If nil? x
then y
else head x :: lazycat (tail x) y
%If
%Await
%Define
Execute
Writeln[lazycat "abc" "def"].
%Execute
%Package
Assembler version:
.package lazycat .version 41 @BEGIN-IMPLEMENTATION %--------------------- @LABEL >1 @ID lazycat %--------------------- @DEFINE >1 % % Build the species List(x) -> List(x) -> List(x) of lazycat % STD-SPECIES-VAR ANY STORE-AND-LEAVE-SPECIES %[0] LIST-SPECIES STORE-AND-LEAVE-SPECIES %[1] GET-SPECIES 1 GET-SPECIES 1 FUNCTION-SPECIES FUNCTION-SPECIES % % Static environment setup % % This code starts with type List(T) -> List(T) -> List(T) % on the type stack, where T is specific to a particular use % of lazycat. Lazycat wants to know T, which it stores at % index 0 in the static environment. % BEGIN-GLOBALS 1 UNPAIR-SPECIES UNPAIR-SPECIES UNPAIR-SPECIES POP-SPECIES SPECIES-ONLY %[0] (Store T at index 0 in the static env) POP-SPECIES POP-SPECIES % % Now we have T. Begin fetching globals. % GLOBAL-FETCH-SPECIES 0 % T LIST-SPECIES SPECIES-ONLY %[1] Store List(T) at index 1 in the static env GLOBAL-FETCH-SPECIES 0 LIST-SPECIES STORE-AND-LEAVE-SPECIES %[2] Store List(T) at index 0 in the type store GET-SPECIES 0 % List(T) GET-SPECIES 0 % List(T) FUNCTION-SPECIES FUNCTION-SPECIES GET-GLOBAL-ID >1 %[2] % Get lazycat: List(T) -> List(T) -> List(T) % (for the recursive call) % % Build function lazycat % BEGIN-EXECUTABLE 0 LINE 3 NAME >1 FUNCTION :3 GLOBAL-FETCH-SPECIES 0 LIST-SPECIES STORE-AND-LEAVE-SPECIES %[0] GET-SPECIES 0 FUNCTION-SPECIES BEGIN-BODY 1 NAME >1 BIND 0 (x) GLOBAL-FETCH-SPECIES 1 END-TYPE FUNCTION :2 GLOBAL-FETCH-SPECIES 0 LIST-SPECIES BEGIN-BODY 0 NAME >1 BIND 1 (y) GLOBAL-FETCH-SPECIES 1 END-TYPE LINE 4 LAZY :1 GLOBAL-FETCH-SPECIES 1 BEGIN-BODY 0 NAME >1 LINE 5 FETCH 0 NIL? GOTO-IF-FALSE :0 LINE 6 FETCH 1 RETURN LOC-LABEL :0 LINE 7 FETCH 0 HEAD FINAL-FETCH 1 FINAL-FETCH 0 TAIL FETCH-GLOBAL 2 APPLY APPLY PAIR LOC-LABEL :1 LOC-LABEL :2 LOC-LABEL :3 RETURN END %--------------------- @LABEL >2 @STRING "Exec-lazycat-1" %--------------------- @LABEL >3 @STRING "def" %--------------------- @LABEL >4 @STRING "abc" %--------------------- @LABEL >5 @ID Writeln %--------------------- @EXECUTE 1 % % Static environment setup % STD-SPECIES Char LIST-SPECIES STORE-AND-LEAVE-SPECIES %[0] GET-SPECIES 0 GET-SPECIES 0 FUNCTION-SPECIES FUNCTION-SPECIES GET-GLOBAL-ID >1 %[0] (lazycat: List(Char) -> List(Char) -> List(Char) STD-SPECIES Char LIST-SPECIES LIST-SPECIES STD-SPECIES () FUNCTION-SPECIES GET-GLOBAL-ID >5 %[1] % % Perform these instructions % BEGIN-EXECUTABLE 0 LINE 12 SNAME >2 LINE 13 CONST >3 CONST >4 FETCH-GLOBAL 0 APPLY APPLY NIL FETCH-GLOBAL 1 PAIR-TAIL-APPLY 1 RETURN END %--------------------- @END-PACKAGE
Source written in Astarte:
Package extend1 Extension Abstraction MAMMAL. Species Kangaroo isKindOf MAMMAL = (List(Char), Integer). %Extension %Package
Assembler version:
.package extend1 .version 41 % @BEGIN-IMPLEMENTATION %--------------------- @BEGIN-EXTENSION @LABEL >1 @NEW-GENUS s MAMMAL @LABEL >2 @NEW-SPECIES Kangaroo @LABEL >3 @IMPORTED-GENUS EQ @RELATE >2 >3 @RELATE >2 >1 @END-EXTENSION %--------------------- % The following is a definition of a function called kangaroo % that takes a (List(Char), Natural) pair and produces the % equivalent Kangaroo value. No explicit tag is required, % so all this does is return the identity function idf, defined % in another package. This definition cheats because it knows % that the definition of idf is the same for every species, so % it fetches the definition of species () -> (). %--------------------- @LABEL >4 @ID kangaroo @LABEL >5 @ID idf %--------------------- @DEFINE >4 STD-SPECIES Char LIST-SPECIES STD-SPECIES Integer PAIR-SPECIES SPECIES-ID >2 FUNCTION-SPECIES BEGIN-GLOBALS 1 STD-SPECIES () STD-SPECIES () FUNCTION-SPECIES GET-GLOBAL-ID >5 %[0] BEGIN-EXECUTABLE 0 LINE 5 NAME >4 FETCH-GLOBAL 0 RETURN END