World: r3wp

though for these tests, no swapping occured.

I recently watched a talk by Poul Henning Kamp, author of Varnish, 
who talked about how many people misunderstand how memory allocation 
works in modern OS'es. Since he's a FreeBSD kernel developer, he 
has some bias, but he made some interesting points in that memory 
allocation is nearly free in various unixes, but most people ignore 
that an only allocate, perhaps just enough or below what they need.

Whether this can be translated directly to REBOL, I don't know.

problem is when you task switch, or run several RAM intensive apps... 
they do kill each other, even on unix.

but that's because the RAM is actually used, correct?

(based on rendering 3D animations which required 4GB of swap file 
, just to load a scene  ;-)

yes... but as long as only one application is running the CPU, you 
can have A LOT of apps in virtual RAM without real system slow down 
(on unix).

I guess I'm wrong with Windows. allocating a 100 MB string takes 
time.

takes even longer under OSX.

while[here: find/skip here key 2][insert tail result second here 
here: at here 2]

rebol0  (untried)   suspect  parse is more efficent

ahh party moved to profileing and it has all been done

For more precise system usage under Windows, please use SysInternals 
tools (now part of MS)

http://technet.microsoft.com/en-us/sysinternals/default.aspx... 
look at RAM Map, Process Manager, etc.

Q. how to use a word as a string value in path?
ie: ["a" 1 "b" 2]
n: "b"
ie/(n)
>> 2

nvm

very strange    a: true      logic? a  => true

but a:[true]  logic? a/1 => false

That's because [true] is a word, not a value. Try this:
     a: reduce [true]  logic? a/1  >> true

oki thanks

What's the advantage of using words in blocks? 
ie: [a "one b "two] vs ie2: ["a" "one" "b" "two"]

seeing you run out global word space very quickly?

dialects and selection

ie2/("a")
>> "one"

so dialects then?

yes, and the code readability maybe - ie2/("a") vs ie2/a

using words as table keys is probably not a good idea.

why? because of word limit? or any other consequences?

limit, forbidden chars, etc.

word comparison is faster than string comparison

(word comparison is O(1), while string comparison is O(n))

moreover, words have context, strings don't

Is it a benefit, that SWITCH is case insensitive?

>> s: "aA"
== "aA"
>> switch s/1 [#"A" [print "A"] #"a" [print "a"]]
A

use strings not chars

On words in blocks, if you use strings they may be duplicated as 
you copy blocks, which words aren't.

On SWITCH, I think it's consistent with REBOL in general.

Steeve, no, doesn't work with strings:

>> switch s/1 ["A" [print "A"] "a" [print "a"]]
== none

s/1 is a char! And SWITCH won't find it with a string.

Gregg, "consistent"? Ahh... ;)


I was thinking about changing the string into a binary. What would 
you think FIRST used on a binary returns? I would expect a binary, 
but it's actually an integer. I sometimes have a hard time seeing 
the consistency in REBOL. But I know, it's hard to find the logic 
way in all this. So many datatypes. :)

Also changing s/1 to a string gives unwanted result:

>> s
== "aA"
>> switch to string! s/1 ["A" [print "A"] "a" [print "a"]]
A


So I end up with getting the integer value of a char to make this 
work:

>> switch to integer! s/1 [65 [print "A"] 97 [print "a"]]
a

Not so good, as I see it.

Ah! it's probably impossible to convert a char! into a string!, so 
forget it...

hmmm. I just realized that you asked for insensitive case

Yes, I need to test on chars in a string, and #"a" should be different 
from #"A".

The only way using SWITCH, I see, is to operate with ascii values, 
and that isn't good.

well, just use parse instead, its mostly the same structure than 
a switch.

parse/case s [
	#"A" (do something)
           | #"a" (...)
           | ...
]

Yes, parse can be used. My motivation was thoughts about switch. 
It seems, it could be improved.

REBOL3 is pretty consistently case-ignorant in this regard:

>> #"a" = #"A"
== true

And the SWITCH behaviour is just consistent with that.

(R2 is more inconsistent in this regard, as #"a" = #"A" is false, 
but SWITCH behaves case-insensitively, as you described.)

>> #"a" == #"A" 
 
== false

Perhaps SWITCH needs a /Strictly refinement?