FYI.

The following code outlines the implementation of ATS3 so far:

val source = source_get()

val ABStree0 = source_parse(source) // parsing                             
                                                                           
val (      ) = synread_abstree(ABStree0) // AST-checking                   
                                                                           

val ABStree1 = trans01_abstree(ABStree0) // fixity resolution               
                                                                          
val (      ) = tread01_abstree(ABStree1) // AST-checking for trans01       
                                                                           

val ABStree2 = trans12_abstree(ABStree1) // binding resolution             
                                                                           
val (      ) = tread12_abstree(ABStree2) // AST-checking for trans12       
                                                                           
)
val ABStree30 = trans23_abstree(ABStree2) // resolving overloaded symbols   
                                                                          
val (       ) = tread23_abstree(ABStree30) // ast-checking for trans23     
                                                                           

val ABStree31 = trans33_abstree(ABStree30) // Hindley-style type-inference 
                                                                           
val (       ) = tread33_abstree(ABStree31) // ast-checking for trans33     
                                                                           

val ABStree32 = trans3t_abstree(ABStree31) // resolving template instances 
                                                                           
val (       ) = tread3t_abstree(ABStree32) // ast-checking for trans3t     
          


A functional implementation of a compiler essentially consists of a set of 
trans-functions for translating
one form of abstract syntax tree to another form.

This time I am employing a style of error-handling that internalizes errors 
inside abstract syntax trees,
relying on various checking functions (e.g., tread01, tread12) for 
inspecting abstract syntax trees to report
error-messages. My current implementation of these checking functions only 
produces error-messages that
may be difficult for others (esp. beginners) to understand. But my hope is 
that other interested parties may
re-implement these functions to give more detailed error-message reporting.

As a rough analogy, ATS3 is structured somewhat like a micro kernel (e.g., 
L4). I will focus on implementing
the "kernel" of ATS3. And other interested parties can readily add 
"services" on top of this "kernel".

Cheers!

--Hongwei

-- 
You received this message because you are subscribed to the Google Groups 
"ats-lang-users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to ats-lang-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/ats-lang-users/7fd40236-004b-4774-882c-15b350f374c8%40googlegroups.com.

Reply via email to