World: r3wp

where do you see R2 removing unset! in reduce?

Arghh, It appears that I was arguing about a very old feature

I am not yet adapted to this change

I want a reduce/clean refinement T_T

Will map! have a literal notation?

You can use the serialized notation with map!, but it won't otherwise 
have literal syntax.

#[map! [a: 1]]

Afaik, we don't have any characters left that can be used for delimiters 
to surround some kind of literal value. [], (), <>, and {} are taken.

We don't want to go the Perl 6 route and start using Unicode symbols 
:(

but a prefix can be used to identify the delimiters, its already 
done by rebol in a few case... there surely is a combination left.

but the serialized notation isn't that bad in any case

yep, interesting notation, and underused.

>> mold/all reduce [next 'a/b]
== "[#[path! [a b] 2]]"

>> mold/all reduce [next [a b] ]
== "[#[block! [a b] 2]]"

A serialized serie keeps his index, not bad -)

yep.

Missing something till now.

The sharing of same series is lost when they are serialized. They 
are duplicated instead.

There is missing some internal unique surrogate in the serialized 
format of a serie.
It's why RIF can't be realized until now, i guess...

yep that is a limitation.  it would be easy to implement on top of 
it... because there is an explcit serialized form right in the language.

something like 
#[string! 1: "hahaha" 3]
#[string! :1 5]

they key being valid within one load session.

yep, something like this

it would be a big num, so a binary surrogate would be a better choice 
(more compact).
#[string! "hahaha" 3 #FF00FF00]
#[string! #FF00FF00 5 #FF00FF00]

we could even use this within source code, so that when it loads 
an application, shared strings are pre-linked without needing to 
do init code.

In all cases, it will be a wast of space for all the small series.

I mean in the source

but mold/ doesn't have to add surrogates if they aren't being shared. 
 The internals have reference counters to data, so it alerady knows 
if a value is shared.

you're right

it could even go a step further and check if the shared serie is 
used in the block of code being molded, but that would hamper speed 
a little bit... a /compact refinement could be used to switch this 
extra verification.

perhaps...

it sounds like an easy thing for carl to implement... it only modifies 
a very small subset of natives.

don't know :-)

Would be cool if REBOL interpreter could generate some form of symbol 
file for encapped scripts.

Not the interpreter per say but the REBOL encapsulator.

Even if we can't get that it would be cool to at least to get a some 
form of symbol file for the core.

Just think of how much more bugfixes could be made if that were the 
case.

The serialised would be acceptable, if that were the literal form 
too, instead of - make map! []


It's too bad there's no succinct way left to represent that (and 
objects for that matter)

MOLD/all generates the serialized form, and LOAD reads it. You can 
even write the serialized form literally in your scripts. For map! 
there is no problem with using the serialized form. For objects and 
functions, you'll have binding issues.

I understand that, I use that notation in some work - it's just a 
case where Rebol notation is a little less economical.

I also understand that at a point, you have to say that it's good 
enough. I use Rebol a lot and at times think, it would be great if... 
Many times I get this with apparently trivial details - but then 
perhaps I overly obsess over details.

I do wonder if as the serialized notation used an almost valid Rebol 
sequence #[] (actually, that may well have been valid at one point?) 
you could take a similar approach with regard to maps?  ![] @[]

=[] |[] - not pretty, and perhaps not as graphically immediate as 
other types, but an improvement over make map! [] perhaps?

Stackoverflow question:

     >  Is it possible to know the script/object/function that is executing 
     ?
     > If not will this be possible in R3 ?
            http://stackoverflow.com/questions/1585603


I've given an R2-ish answer.....Perhaps R3 has a better way via stack, 
debug or other guru trick

hehe, found-out Carl started to address bitsets, as new doc starts 
to appear here - http://www.rebol.com/r3/docs/datatypes/bitset.html
:-)

He also restructured a bit main R3 Doc page ....

2.100.91: PARSE: adds DO and ACCEPT. Adds COMPLEMENT on bitsets (first 
draft.)

Pekr, could you describe find/first?

Yes, although I don't know much. You can find it in Carl's own priority 
list - http://rebol.com/r3/docs/project.html, described as - "FIND 
/first with list of targets", priority high. I do remember Carl planned 
to add it because of GUI? You simply want to check on multiple targets, 
and it returns first match ...

I wonder if it has something to do with templates. Can't still see 
what exactly it does.

Same a finding a charset, except it's a set of longer values than 
single characters. Position of the first in the set found returned.

Basically the same as PARSE TO multiple (and might use the same code).

oh, so this would be possible:

find/first string ["steeve" "brian"]
== "steeve came first, brian came second"

Yup. And like TO multiple, the alternative is exponential time and 
tricky to program.