World: r4wp

Gregg, BrianH reported this issue as a bug today:
http://issue.cc/r3/2031

Funny timing. :-)

cant' we press escape to halt a script or when at an    'ASK  prompt?

escape doesn't work, but ctrl-c works (on Windows), it returns "** 
Access error: read failed: [scheme: 'console] reason: 87" but remains 
in the console.

when its launched from windows it closes the whole intepreter  :-(

Interesting, I tested with the old R3 version and the latest Saphirion 
version, it doesn't close the console.

(I'm on win8)

Is it possible to acess UNIX sockets?

Currently, there is no support for Unix domain sockets implemented 
(neither high- nor low-level).

I thought so...

Did anyone started a R3 code-review and already took notes that are 
published?

I think it makes a lot of sense to publish all notes in a structred 
way, so it's easier to work on the R3 code base.

I think that 'subtract should allow for binary values:

>> help subtract
USAGE:
        SUBTRACT value1 value2

DESCRIPTION:
        Returns the second value subtracted from the first.
        SUBTRACT is an action value.

ARGUMENTS:
        value1 (scalar! date!)
        value2 (scalar! date!)
>> subtract img1b img2b

** Script error: subtract does not allow binary! for its value1 argument

Rebol 2.101.0.4.20:

>> difference #{FFFFFF} #{EEEEEE}
== #{FFEE}

I would expect it to return #{111111}

Why not use XOR?

>> to binary! (to integer! #{ffffff}) - to integer! #{eeeeee}
== #{0000000000111111}

I think that 'subtract should allow for binary values


Hm, what if they're not of the same length, the two binary sequences?

What if they're longer than 8 bytes?

#[[Bo
Rebol 2.101.0.4.20:

>> difference #{FFFFFF} #{EEEEEE}
== #{FFEE}

I would expect it to return #{111111}
]]Bo

That is not a well informed expectation, Bo.:


* in Rebol, binary values are series of octets (small integers, 0 
to 255)
* in Rebol, set functions handle series as sets of values
* DIFFERENCE is a set function yielding set difference

* in the above case the first st contains #{FF} (=255), which is 
not contained in the second series

* the second series contains #{EE} (=238), which is not contained 
in the first series
* thus, the set difference is #{FFEE}

Does this help:


>> to binary! difference to bitset! #{FFFFFF} to bitset! #{EEEEEE}
== #{111111}

hum, wow.  there always seems to be a conversion path to get the 
numbers do what we want... I'm sure accountants would love rebol 
 ;-)


want a deficit... just turn it into a binary, want a profit, just 
turn it into a bitset first   ;-)

Gregg already mentioned XOR, I'll repeat: why not XOR?

>> #{FFFFFF} xor #{EEEEEE}
== #{111111}

Ladislav: I was expecting 'difference to treat binaries the same 
as the 'difference in the 'draw dialect in R2.  I seem to have been 
mistaken.

Geomol: If subtracting two binary numbers of different lengths, it 
would be like subtracting two decimal numbers of different lengths.

Gregg and Andreas: 'xor seems to work, for the most part.  I have 
to do some more testing to know for sure.

Thanks for your help, everyone!

Bo, I'm not sure, if that makes sense. What you're suggesting is, 
that this should be possible:

	(read/binary %file1) - (read/binary %file2)


So it's like looking at a long sequence of binary data as a number? 
And if the series are of different length, they should be right aligned. 
Is that really useful? :)

Arithmetic on series ... like arithmetic on strings!? Funny language, 
that do things like that.

R2 can use strings in AND, OR and XOR, like binary!, but they're 
not right aligned.

R2 and R3 works the same in this:

>> (to integer! #{1111}) or (to integer! #{22})
== 4403
>> to integer! #{1111} or #{22}
== 13073

I guess, that's expected behaviour?

I would say so.  The great thing about datatypes is that they can 
save us a lot of work doing manipulations.

The downside to datatypes is that it is hard for the developer to 
determine proper behavior of different operations on the different 
datatypes.  Like, what should happen when you add a char! and an 
integer!...  My opinion would be that because your first argument 
is a char!, you want to increment/decrement it by the value of the 
integer!.  This could be useful in some situations.

I would expect 'or to be right-aligned on binary.

I would expect 'or to be right-aligned on binary.

My example above is not right-aligned. This:

>> to integer! (#{1111} or #{22})
== 13073

This is right-aligned:

>> to integer! (#{1111} or #{0022})
== 4403

I was agreeing with you that 'or should be right aligned, even though 
it isn't.

Is there a GUI that currently works with Carl's last r3 alpha?

is there another repository that is more up to date than the rebol/r3 
repo on github?  I really need to get the best sources ASAP.

need help compiling the R3 code base.   I must use GCC so can't use 
the microsoft vanilla :-(

in theory, I've got everything installed, using MinGW, with msysgit.

You could try to follow the Syllable build description

sure!   have a link?

http://syllable.cvs.sourceforge.net/viewvc/syllable/syllable/system/apps/utils/Builder/packages/REBOL-Core--current/

good thing is that I've got a VM running XP all setup, so I don't 
mind hacking it up to make it work... :-)

is the community source repo public?

ah ... its all in the file  :-)

Everything is public on GitHub - except if you pay them

Here are some optional environment variables that you may have to 
set for a Windows build:

http://syllable.cvs.sourceforge.net/viewvc/syllable/syllable/system/apps/utils/Builder/packages/Syllable/REBOL-Core--current/

is this a file type for some batch processing app, or just a hand 
written  note for  memory sake?

The former

It's a formal file for my build system. A build dialect