World: r3wp

port id ??

oh dear ..

would you delete my ticket then?

done

:)

thanks

User poll:

a: charset ""
b: charset ""
same? a b ; == true

do you find it a bug or a feature?

mmm... more of a bug, I think.

I think bug, when other datatypes throw false.

Looks like a bug in same -- it comes up even if you add a copy
a: charset ""
b: charset ""
same? a b ; == true
But insert something into one of them, and the same is now false.

thanks, I personally tend to think it *is* a bug, because they are 
only equal

Nice catch, by the way!
That should have been:
a: copy charset ""
b: copy charset ""
same? a b ; == true

of course, it fits integer! handling ...
>> a: 1
== 1
>> b: 1
== 1
>> same? a b
== true

why do you think copy is necessary?

i was just testimg how far the (at the time alleged) bug went

in the  middle. Tried a bit. Same charsets  are compacted.

means the are same, even when created by mutiple inserts. Makes sense 
 to  do that  and  share an internal pointer.

Thought that wouldbe hard to fix. If it can be fixed easily its  
a bug.

Hmm, Volker -- maybe it is subtle undocumented behaviour:
a: charset ""
b: charset ""
same? a b
== true

insert a 1
same? a b
== false

insert b 1
same? a b
== true

I would vote for a bug too. Although charset uses the same source 
"unbound string", result of 'charset evaluation is stored to the 
same memory location, and referenced by two words?

>> a: b: charset [#"a" #"b"] c: insert charset [#"a"] #"b"  probe 
same? a c  insert a #"c"  ? a ? b ? c
true
A is a bitset of value: make bitset! #{
0000000000000000000000000E00000000000000000000000000000000000000
}
B is a bitset of value: make bitset! #{
0000000000000000000000000E00000000000000000000000000000000000000
}
C is a bitset of value: make bitset! #{
0000000000000000000000000600000000000000000000000000000000000000
}

Bug. Fix:   a and b share something which then has a pointer  to 
the bitset.  The pointer to that something should be  compared, notthe 
pointer  to the string.

uh, even when  using copy charset "" still 'same? returns 'true? 
Now I am lost ....

I show you something from my article:

a: b: charset [#"a" #"b"] c: insert charset [#"a"] #"b
identical?: func [
    {are the values identical?}
    a [any-type!]
    b [any-type!]
    /local var var2
] [
    ; compare types

    if not-equal? type? get/any 'a type? get/any 'b [return false]
    ; there is only one #[unset!] value
    unless value? 'a [return true]
    ; errors can be disarmed and compared afterwards
    if error? :a [a: disarm :a b: disarm :b]
    ; we need to be transitive for decimals and money
    if any [decimal? :a money? :a] [
        return found? all [same? a b zero? a - b]
    ]
    ; we need to be transitive for dates

    if date? :a [return found? all [same? a b same? a/time b/time]]
    ; we need to be able to compare even the closed ports
    if port? :a [return equal? reduce [a] reduce [b]]
    ; our function has to work for structs
    if struct? :a [return same? third a third b]
    ; we can have something stronger than SAME? for bitsets
    if bitset? :a [
        unless same? a b [return false]
        if 0 = length? a [return true]
        unless equal? var: find a 0 find b 0 [return false]
        either var [
            remove/part a 0
            var2: find b 0
            insert a 0
        ] [
            insert a 0
            var2: find b 0
            remove/part a 0
        ]
        return var <> var2 
    ]
    same? :a :b
]
identical? a b ; == true
identical? a c ; == false

identical? a copy a ; == false

the question probably is, what we consider being "identical"? Is 
5 in memory slot 1234 identical to 5 in memory slot 4321? It could 
be. But I can also imagine that 'same serves the purpose of finding 
out, if two words reference the same slot?

your question is answered in http://www.fm.tul.cz/~ladislav/rebol/identity.html

ok, thanks, will read it ...

Expected behavior: things  which are modified  when one thing is 
 modified should be same.

Expected Reason for  current behavior:  bitsets with the  same data 
 share the  same data automatically  to save  space.

Expected Reason for bug: 'same? compares the  pointer to  the data, 
which is automatically made same with equal data.
Expected Fix: comare something else :)

:-)

Expected Reason for  current behavior:  bitsets with the  same data 
 share the  same data automatically  to save  space.
 proven wrong above

Expected Reason for bug: 'same? compares the  pointer to  the data, 
which is automatically made same with equal data.
 proven wrong above

Yep, I think SAME? was just quickly implemented using the existing 
equality function.

then it needs to be fixed, and we need precise definition, of what 
actually 'same compares and decides upon

can you make a simpler example, so i can analyze code? My tests say 
 yes, what  do i miss?

The the explanation with equal? makes sensse too.

I have proven, that there is a function (IDENTICAL?), which has got 
the following property:
a: b: charset [#"a" #"b"] c: insert charset [#"a"] #"b
identical? a b ; == true
identical? a c ; == false
identical? a copy a ; == false

but  how does itdecide that? If  it is by modifying the data, that 
would be re-samed when you change  the data  back

nothing is re-samed, if it were, IDENTICAL? a b would have to yield 
FALSE

hu? a and b have the equal content. so  they would point to  the 
same  data. so  'same? would return true.

Hmm, complicated . you may be  right. *thinking

would cost  much performance to keep track of all the data.

you are right, that it is *theoretically* possible, but in that case 
my IDENTICAL? function wouldn't be able to yield TRUE

It would if there is  an intemediate  structure. value -> intermediate 
-> bitsetdata.

then a and b point to that structure. the pointer in the structure 
is  changed. but a and b return the same still  the stuff.

.. return still the equal stuff.

I rather state it in a positive way: since my IDENTICAL? function 
correctly compares bitsets (can be tested), the model I am using 
is correct

IMHO  but  implementations would  have the same results, but mine 
is more silly;)