World: r3wp

(and, said 32 bits are needed only for block-like data values, for 
other values, like objects, one bit is plenty)

You didn't post the relevant code so I can't evaluate what you are 
saying. I'm searching for the code now.

do http://www.rebol.org/download-a-script.r?script-name=identity.r

(it is posted above)

I got the link, but am reading it to find the code.

(R2 code, unadjusted for R3)

There's a lot of code in there, not all of it relavant.

...but this variant does not use Mark bits, since those are available 
only in C

search for EQUAL-STATE?

I'm translating while I read, boith to R3 and C.

LOL

It's not as hard as it sounds :)

Already found some R2-isms, and I'm not just talking about the reflective 
accessors. Assumed case-sensitive equivalence of words, for instance.

yes, lots of those, no adjustment for R3, it is a surprise that it 
works at all

Words in R3 preserve the case they are typed in, but are considered 
equivalent on a case-insensitive basis.

...but that is the case of R2 words too

(the variants having different case are "automatic aliases", as I 
call them)

R2 words preserve the case they are *first* typed in, not the case 
they are  in every time.

I would need to see an example where it differs

I noticed the difference before, but am not able to replicate it 
now :(

nevermind, we will "rediscover" it :-D

In any case, for R3 line 502:
            if strict-not-equal? mold :a mold :b [return false]
should probably be this:
            if not-equal? mold :a mold :b [return false]

well, that is "in transition" still

Probably for R2 as well, if your statement about R2 case-preserving 
is true.

depends on the level of strictness we want to achieve for the said 
EQUAL-STATE? function...

Unless you want
>> equal-state? [A] [a]
== false

yes, that is what I achieved, as it looks

(lots of possibilities, and it was written long ago)

You do topological comparison here, not  marking.

yes, I am actually unable to do marking in Rebol

but, if you want a model, I can write one

do you know how many bits can I use for marking?

(or is it just one bit? - in that case it indeed is a problem)

Well, my point was that marking isn't enough here, and that this 
kind of comparison (the kind in equal-state?) is needed.

so, the question is, how many marking bits are available

Only Carl has that answer. Still reading...

You would have to do something similar to a simplified EQUAL-STATE? 
even in a C version. There will never be enough bits for marking 
because every concurrent instance of your comparison would need its 
own set. Having thread-local done lists would work though.

concurrent instance of your comparison
 -> "concurrently running instance of your comparison function"

concurrently running instance of EQUAL? - yes, understood, that would 
be impossible, but such a thing can be made "atomic/protected", can't 
it?

No.

why? RECYCLE and MOLD will be protected, won't they?

You can make GC single-instance, but not MOLD or EQUAL?. MOLD and 
EQUAL? will be done too often to lock.

too often to lock - I would say, that RECYCLE is more likely to be 
"encountered" than MOLD or EQUAL?

Unlikely - RECYCLE isn't FREE. The whole point to GC is that it isn't 
done that often.

yes, but it takes time: the "probability of encountering" is proportional 
to running time as well as to call frequency

OK, EQUAL-STATE? is too strict in another way: It also considers 
values that precede the series references. I'm going to figure out 
if it will still work if changed to use the level of equivalence 
expected from EQUAL?. Note:
>> equal? next [a a] next [b a]
== true
>> equal? next [a a] next 'b/a
== false
Not sure about that last one - will it be true in R3?

yes, re strictness, it will probably be found too strict in a number 
of ways

What about equal? [a b] 'a/b ?

(it was certainly not a prototype of any specific member of the current 
equality coparison hierarchy)

Are we doing equivalence within any-block! or limiting it to within 
any-path! ?