World: r3wp

There's always a design trade-off.

I have various systems where real keys (usually strings) are mapped 
to surrogate keys (usually integers). It's a good compromise in many 
cases.

What is THE best way to store a large hash table in memory  like 
a dictionary, .. and access the data?

terry, about accessing data, there is a speed issue with doing so 
with using indexes with paths, so data/2 is much slower than second 
data or pick data 2. that should solve at least that aspect.

Not sure there is one best way.....I have a structure that has 158,000 
keys indexing 120,000 documents. All in  memory. 
The index (when loaded) is nearly 6meg.

The code uses nested tables, hashes, surrogate keys and a couple 
of other tricks devised for the purpose.

It's worth playing with approaches. You can normally expect a  ten 
fold improvement between initial ideas and later improvements.

yeah, i see that just pokin around with some data now..

I take it your keys are string?

Just thinknig that even Carl's tiny web server, that loads the www 
content into a hash table would be a very fast server

Don't even need mod-rewrites.. just intercept the GET request and 
take it from there

I've been working with Apache and PHP quite a bit, and it just feels 
really bloated.

Is there any reason why to write for example: [ b: make block! 100 
] instead of just  [ b: copy [] ] ?

make block! 100 means that you can insert at least 98 values before 
a reallocation is needed

Whereas.

copy [] reserves some other number (you can find out, more-or-less, 
by close observation of stats)

(the difference is an implementation quirk)

i mean the diff between 100 and 98

to say it another way, as long as length? b is less than 98, insert 
tail b is guaranteed to be O(1)

it looks, that the copy is faster a little bit, at least if I don't 
know how big the block can be, so it's probably better to use copy 
[] (if I don't know precise size):

>> tm 1000 [b: make block! 20000 loop 5 [insert/dup tail b 0 1000]]
0:00:00.907
>> tm 1000 [b: make block! 200 loop 5 [insert/dup tail b 0 1000]]
0:00:00.453
>> tm 1000 [b: copy [] loop 5 [insert/dup tail b 0 1000]]
0:00:00.437

>> tm 1000 [b: make block! 5002 loop 5 [insert/dup tail b 0 1000]]
0:00:00.343

Try do it several times and take the average.

perhaps also make block! is easier to garbage collect?

Is there a rebol based wiki that has versioning?

This seems at least inconsistent to me:

>> to integer! none
== 0
>> to decimal! none
** Script Error: Invalid argument: none
** Near: to decimal! none

also happens with empty strings

rebolek: i believe that is on rambo already. if not, feel free to 
add it.

oldes: i would guess that make block! n also clears the allocated 
memory, so it may be slower than a reallocation if you are using 
something like insert/dup etc. i think that when reallocating, the 
size is always doubled, up to a limit after which it is increased 
linearly.

Gabriele, you're right, it's there: Ticket #4162

I have a deep question, when we use clear, does it clear the pre-allocated 
space (shrinking back a series) or does it only set the series termination 
to the specified index?

both are usefull, I just wonder which one is done internally?

I believe it keeps the allocated space, so it's more efficient to 
reuse a series, rather than always starting a new one with copy.

That's what I believe... I've just always had that tingling "What 
if"

Max: you can easily check:
>> a: make string! 1100
== ""
>> string-address? a
== 17267856
>> string-address? clear a
== 17267856

string-address?  what is that?  Ladislav - you amaze me sometimes 
with your memory and knowledge of ALL rebol funcs... I never even 
saw thar arcane magic!

I think it's based on his peek-addr stuff.

oh, that is an internal ladislav mastery script

I mentioned the script recently on the ML: http://www.fm.tul.cz/~ladislav/rebol/peekpoke.r

(but it can be called arcane magic, I guess :-)

;-)

>> a: "this is a string"
== "this is a string"
>> adr: string-address? a
== 17496432
>> len: length? a
== 16
>> clear a
== ""
>> as-string memory? adr len
== "^@his is a string"

;-)

this is quite clean :-)  hum for debugging .

Anton used the same words, IIRC

very powerfull.  i learned something more today :)

Anyone remember the way to set all the fields of an object! to another, 
similar object! ?
I want to do this for font objects.

a: make object! [b: 445 c: 444]
 b: make object! [b: 999]
b: construct/with third a  b  ;; set b to a's values and fields

I have a further requirement; the object should be modified in place.

Let me get my example together:

f: make svv/vid-styles/text/font []
f2: make svv/vid-face/font []

Ok, so I want to modify F's fields so they are the same as F2's fields.

I think I found the way:

set f reduce bind copy next first f2 f2

You beat me to it with a better solution -- I was going to suggest 
a loop:
foreach v next first f [set in f v get in f2 v]

Yes, I was hoping for a bulk-set operation.