On 10 Oct 2007, at 12:49 pm, [EMAIL PROTECTED] 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?
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
