On 10 Oct 2007, at 12:49 pm, jerzy.karczmarczuk@info.unicaen.fr wrote:
No, I am sorry, I know a little bit "R". This is not a functional language. There is some laziness (which looks a bit like macro-processing), sure.
There is no macro processing in R (or S).
The manual speaks about promises and about forcing them. But, at the same time we read that the call by value IS the protocol.
That is a misreading. Paragraph 2 of 4.3.3 says The semantics of invoking a function in R argument are call-by-value. ... But that is NOT to be read as "strict", but as contrasting with "call-by-reference". The very next paragraph makes this clear: R has a form of lazy evaluation of function arguments. Arguments are not evaluated until needed. It is important to realise that i some cases the argument will never be evaluated. ... A promise is forced when its value is needed. "Promises" in R are part of the underlying implementation; they are not (as in Scheme) a data type that the programmer can ever see or deal with. They are, in fact, just the same as unevaluated arguments in Haskell.
And the language is impure, with reassignments.
You were happy enough with Scheme. And you didn't say that there were no *pure* lazy dynamically typed languages, only that there were no lazy dynamically typed languages. If you think of R as a lazy and somewhat purer Scheme with lots of number-crunching support and C-like syntax, you won't go far wrong.
I don't see how to make co-inductive constructions, infinite streams, etc. (Perhaps I didn't hard enough?...)
I don't know what co-inductive constructions are. At first sight it looks to be very easy to make infinite streams in R, but it isn't, for an interesting reason. R doesn't evaluate function *arguments*, but it does fully evaluate function *results*, so that returning something that hasn't been fully evaluated requires you to return a function. Fortunately, R is a higher order language (S isn't) so any stream implementation in Scheme has a natural analogue in R. Can we agree that the existence of R shows that a practically useful programming language with dynamic typing and lazy argument evaluation is possible, and that it isn't quite what you had in mind because it evaluates function results in full?