World: r3wp

He mentioned the real sizes at some point (in a blog I think), but 
I don't remember the exact numbers.

don't remember that

For my code I find that I only need to think in terms of number of 
copies, or preallocation. On an algorithmic level you can save orders 
of magnitude in memory overhead (space and time) by controlling the 
number of copies.

The FOREACH changes in alpha 49 were done to reduce memory overhead, 
for instance.

Don't force me to disassemble the binary to know that, otherwise 
i'm afraid that Dockimbel will kill me.

Same with exposing COLLECT-WORDS so it can be used instead of BIND/set 
into a temporary object.

Oh the FOREACH overhead has been reduced ?

nice news

not anymore  bind/copy with FOREACH ?

The BIND/copy overhead is still there, but being able to use FOREACH 
on map!, object!, module!, port! and error! means that you don't 
have to generate a block! copy of those types in order to work on 
them. Plus you don't need the EITHER or CASE to screen for those 
cases.

In general the size of the code block passed to FOREACH is much smaller 
than the size of the data passed to it.

foreach works now on ports ? are you sure of that ?

In theory, but I think it works on the port fields as if it were 
an object, not on the returned data.

I haven't checked though.

Uhm, was not my request, it would be more usefull to be able to use 
FOREACH as an ACTOR in a scheme.

So on data, rather than to populate properties of an object port

Yeah, I didn't request that either. Did you file a CureCode ticket 
for FOREACH on ports? I recall some overly general ticket you filed 
that was requested to be broken up iinto individual tickets, but 
not the individual tickets.

have to

Ticket 556.

You might be a little late here - port! has been added to the any-object! 
typeset (I can't say for sure). You gotta file tickets if you want 
to get things done.

At least on a native level. On a mezzanine level you can do it yourself, 
as long as it's a good idea :)

uhm, the any-object! type is troublemaker

Port should not be in it, to allow functions to behave as scheme 
actors

It's not a type, it's a collection of types (typeset!). In this case 
a collection of the types that act like objects.

i'm aware of that, don't do a disgression

It's just there so you can use it in function specs for functions 
that act on objects to let them act on other object-like things, 
when they are being sed in object-like ways.

I'm not sure, but i just think there is a difference in the way of 
treating the argument any-object! and object!
In the first case the port is populated like an object.
In the second, the function is usable as an actor for schemes.
It's really different use cases, I hope i'm wrong here.

If you want FOREACH to work on ports in a certain way, you need to 
write a ticket for that. Mentioning it here won't accomplish anything, 
as Carl almost never sees the stuff we write here.

see the arguments of COPY by example

copy don't use any-object! because of that

COPY hasn't been changed to use any-object! - that may yet happen, 
but any-object! is too new for it to have propagated yet.

I doubt it, as COPY doesn't act on error! and task! in an object-like 
way.

if i understand correctly how Carl managed generic behavior for the 
any-object! argument, COPY will never be changed like you think

I doubt it

Because it would remove the use case of COPY as an actor.

Um, no it wouldn't. It would just allow error!, task! and module! 
to be copied too (which would be a bad idea).

we will see, i just hope you're right here

Typesets are just shortcuts for adding all of the types they contain 
to the function spec. They have no inherent meaning.

ok

so actually they

you say Typesets are useless :)

hi


as far as I know it is possible to convert binary to decimal in R3. 
Is there already a reverse conversion?

to binary!

Typesets are really useful - do you want to write all of that out? 
Plus, they are implemented as bitsets, so they are really efficient.

The backported version of typesets in R2-Forward is implemented as 
blocks of datatype! values - not as efficient.

find any-object! type? :value
Uhm cool, i completly forget that point

ok i changed my mind, it's useful

working with parse as well ?

interesting that to-binary works for decimal, but not money.

bah, you can store a fixed point decimal, what the need to store 
money ?