This page is about HaskellFiles.
The project is about mostly the same thing as InteLib, integratin functional language into C++ via "direct integration method". In this case the functional language is HaskellLanguage. Actually, the project will also share some code with InteLib (the s-expression library) and maintain some level of InteLib compatibility (compatibility by data, except some special cases).
[The english original of the method's name is immediate integration, not "direct integration"; the term first appeared in the paper published in 2000 (co-authored by me and Bolshakova), and as far as I remember it was Bolshakova's idea to invent such a name for the method -- Andrey Stolyarov]
This page is maintained by MeDendik. All not signed paragraphs are assumed to be signed by me. Please, sign and select with italics anything you add to the page. -- MeDendik
I assume to call the work something like "Common data expression and type expression (structuring and evaluating) core for integration of lazy evalutaion into OO-language"
The idea is the following.
As I tried to explain on seminar and on my page (MeDendik), haskell has several language constructions and extensions built around only two main entities. These entities are data expressions and type expressions.
Data expressions define everything in the program (with exceptions for data declarations, module headers and class declarations). Haskell is true high-order language in that it does in no way distinguish between functions and values. It is because of that face haskell's program is just a set of variables and data expressions bound to them. Data expression is a tree of variables and data constructors built using application operation (whitespace) and braces.
On the other hand type expressions type expressions do nothing in haskell program except for attaching to data expressions and specifying their types -- no matter whether they are specified explicitly or implicitly.
Actually, there are two more types of expressions: data declarations which are very like a couple of a type expression and a data-value expression (which ebnf like data-value ::= ( data-cons ( type-expression ) * ) * ), and kind expressions which are very like type expressions to define what type expressions may be used in a particular class declaration kind expressions actually never appear in haskell code and one never meets them, -- except some rare error messages).
So the first thing about these expressions is that they all look very similar to s-expressions. In case of data expressions cons-like expressions denote application, while atom-like expressions denote variables and data constructors. In case of type expressions we have to warp a little -- we start considering function application just another type constructor -- but then we get then we only need a cons-like expressions to denote "type applications" and we have atom-like expressions to denote type variables and type constructors.
This demonstrates principal similarity between haskell's structure and lisp. (Actually haskell may be thought of as a typed and very much more convenient way for writing lazy-pure-lisp -- just as lisp my be thought of as a more convenient way for writing lambda expressions).
BTW, take a look at FC++ http://www.cc.gatech.edu/%7Eyannis/fc++/ - surprisingly is is ideologically based on Haskell, read the papers -- AndreyStolyarov
Well, my first opinion on FC++ is: