World: r3wp

?

I was answering to Sunanda, a new name to replace money!

exact!

Maxim's suggestion might work syntactically, but we would lose the 
money! syntax, which is the ISO standard syntax for currency. If 
we added a unit! type with Maxim's syntax we could use the same implementation 
internally for both money! and unit!.

They would just differ in syntax.

However, remember that there are limits to the number of possible 
distinct units loaded at once. The value doesn't have more than 1 
byte available to refer to a unit, which means 255 possible units 
in use when you subtract the unspecified unit.

Carl had a blog about this related to money! ...

well, in some time, the dollar wil disappear, so we'll got one more 
unit free

I'm just using money! and unit! as placeholder names for the two 
datatypes though. Final names should be decided. The money! name 
is a good one for the current money! syntax because the syntax matches 
the international currency syntax standard.

The $ is part of the ISO standard, as is the limit of 3 alphabetic 
characters preceeding it.

quoting brian " the syntax matches the international currency syntax 
standard" well... to me that's resoved then .... lets call it currency! 
  :-)

money! means the same thing and is shorter :)

I've just looked up the terms in the dictionnary ... and money actually 
encompasses currency, so it actually is the more precise term here... 
 funny, I had the two words inversed in my head.

funny no one noticed the big lexical change proposed in my example 
unit-conversion example  ... or no one spotted it   ;-)

I just translated the function to a more efficient method in my head. 
What is the lexical change you mention, aside from the unit syntax?

I meant to say:  "no one argued about the .... "

note how inches are represented lexically... ;-)

Oh, the unit syntax. There would be limits to what you could do, 
but the principle is sound. You probably wouldn't be able to do 1".

hehe actually we could, but I understand that it woul make the lexical 
analyser that much more complex than it is already with the "" vs 
{} handling inside/outside of each other... adding the " to word 
would really make it complex. so I don't expect or specifically "want" 
it, just was wondering if some of you would react to it  ;-)

The lexical analyzer has syntax priorities - some characters are 
delimiters, " being one of those.

You need first-class functions to have continuations.

But, if you want them to have reasonable speed... some native support 
helps...

If you want continuations supported well you need to build on a continuation-passing-style 
runtime. As far as I know, the only practical one with good performance 
is Parrot.

That is, unless you switch to a compiled language.

brian, you seem to really know what's happening at various languages 
scene.. cool .. I was just looking a talk (video) about parrot VM 
where it presented these things few weeks back where a woman was 
presenting these features (and I consider myself a language nutcase 
;) )

I haven't really followed Parrot for a couple years - lost interest. 
Suppose I should take another look.

I'm not sure what model Stackless Python uses - in theory if could 
use CPS, but I haven't checked yet.

Strangely enough, the intermediate codes of many compiled dynamic 
languages are switching to SSE, which is procedural CPS.

CPS is cont. passing system... what is SSE ? :)

Static Single Assignment.

CPS = Continuation-Passing Style.

aha.. like in functional languages?

Sorry, SSA

The functional language equivaalent is CPS. SSA is for languages 
with assignment and/or modification.

sorry, my lack of proper CS education shows here :)

Well, the equivalency of SSA and CPS had not yet been demonstrated 
when I had my CS education (years ago).

Stackless moved away from CPS towards coroutines. I think Gambit-Scheme 
(even without compiling) does a decent job. 


I don't want to go the CPS route, but I find it intriguing that the 
Elephant in the room of re-entrant data blocks is .... an ELEPHANT. 
The fact that a problem is hard is no reason not to solve it.

It's not that it's hard, it's *why* it's hard. And that why is why 
R2 was so much faster than R1. Making the system resumable slows 
it down by orders of magnitude unless you design the semantics of 
the language around it.

And we're talking about reentrant code blocks. You don't exit data 
blocks.

It's not the AT series path request that's the problem.

Sorry, the code-vs-data distinction I made above isn't really a code-vs-data 
distinction, it's a path-vs-stack-referencing one. Janko and I have 
been talking about something other than your AT series path request.

Oldes: "How stable is the R3 networking? For example what is the 
cause of HTTP issues?"


R3's low-level networking is pretty stable, but the HTTP scheme is 
only partially done. And no other high-level schemes are there.

The HTTP scheme currently doesn't handle network errors very well 
- that includes server issues.

And what is the best place with info where to start?

http://www.rebol.net/wiki/Ports?

Yup, and read the source.

Oldes - don't forget to study the link in above article, especially 
- http://www.rebol.net/wiki/Port_Examples

BrianH: what will be the equivalent for read/lines in R3? I kind 
of can't live without that function :-) Should I create mezzanine 
for it?

DELINE.

and to get it back we should use write enline output?