World: r3wp

/joke-mode-on
Sorry guys, REBOL 3.0 is delayed another year! ;-)
/joke-mode-off

Hi! Why use pairs for idexing thats what paths are for. What is wrong 
with M/2/2/2   ?

we should stay with path imo ...

although we got overvoted for rebcode, which uses dot ;-)

since pairs are only integers not decimals vector and matrix could 
be replacement for draw dialect coordinates, AGG has subpixel accuracy

Karol: You can do 2x2 with pair! but not 2/2 with path!

like this: a: [ [ 0 1] [ 2.2 3.1]]  a/2/1

Geomol: "So pairs need to be extended somehow into a datatype, which 
is like a vector, but with integers instead of decimals." --- decimal! 
is better in my opinion. It's consistent with current behaviour whre 
you can do 
>> block/4.5
and decimal part is truncated.

but with matrix we can     a: make matrix! [ [ 0 1] [ 2.2 3.1]]  
a/2/1

if pair will be extended it overloads 16 byte limit for slot and 
become a series datatype, something complety different. there can 
be only 10 bytes per value ( I don't know exacly but tuples can have 
only 10 bytes not more)

during a bath, I thought up a Grand Master Plan:


1. Build a dialect that could handle scientific/symbolic math on 
the hard core level

2. Make it possible to take an equation and draw it up correctly 
with DRAW, a pretty print equation display. The same dialect would 
be used as above.

3. Use that to display pretty equations inline in makedoc2/3 documents!

4. Some people are working on a postscript dialect which hopefully 
eventually will be able to use DRAW blocks as an input, thereby allowing 
you to create equations on the console and convert it to DRAW or 
PS at the same time as having the ability to do calculations. That 
would be powerful.

Say:

calculate [2 [m] / 3 [cm]] ; would return the result as needed
calculate/draw [2 [m] / 3 [cm]] ; would return a DRAW block

postscript calculate/draw [2 [m] / 3 [cm]] ; would convert that DRAW 
block to postscript

now there is just the problem of doing symbolic math in such a block. 
you'd need specific functions for that, I think.

this is probably something that is best suited in another group...

Karol, I think, you're right. Path is ok with matrices too. M/2/2/2 
means the same as M/2x2x2, so no need for this new way.

Another application for matrices can be signal processing with native 
operators it could be possible to make things like jpeg compression, 
audio effects etc in plain rebol

And I think we have them already in Rebol ............ in AGG

Is it just me or does it seem Carl is trying to switch many things 
around in favor of newbies only?

:)

does it seem clear to me that the first thing rebol needs is more 
documentation?

We ALL are....

more in the sense of tutorials, guides and stuff... not references.

in a sense, I feel, some proposals from Carl stray away from rebol's 
current orthogonality ?

I mean anyone can re-implement first, second, third as pick 1, pick 
2, pick 3 if they want.   its dead easy.

No...you hit first....newbies....

No...nothing is easy, most people are stupid, and most peoplehere 
on Rebol3 are in teh 98+ percentile...  It just "feels" easy to you.

:)

can I propose something then?

Always....

I am driving so my responses are going to get really simple.

switches to maintain some of the compatibility with older scripts.

I find that many issues Carl is trying to solve ignore the fact that 
most people stop using rebol not because its syntax is different 
or because of return types... those are things we learn when we use 
any language...

most people stop when they actually try to do a concrete application 
within constrains and realise many things within the implementation 
of this or that... well, just falls short of working.

and the one reason we continue using rebol is because we are of the 
type of people who WILL download an RFC and fix the http, ftp, proxy, 
xml, (whatever) protocol ourselves.

rebol claims a lot of things... but falls short in general.   for 
my latest project, I had to re-implement http posting, and xml parsing 
myself and I'm still not finished.

don't get me wrong, I live and breath by rebol, but people who are 
interested, quickly get annoyed at little things missing under the 
hood.

rebol feels like a hybrid car.  Almost, but note quite enough to 
get new people out of their cosy stylish cars.   Its got a lot of 
promise, but at what cost.

I just though I'd share my stake on several years of trying (and 
finally succeeding) to use rebol commecially.

I agree...

I hate those - but ... me too!

I mean, I hoate those "me too" postings :-)

hate, of course

Feature request:  I propose SELECT's arguments should reversed, to 
be like SWITCH. I remember SWITCH being implemented and arguing to 
put the VALUE argument before the CASES block to make it easy to 
find.

are you on a mission to disable all scripts in the world  ;-)

So, for a SELECT, you won't have to search around with your eyes 
for the VALUE argument, as in this example from the FTP scheme which 
I am currently looking at:

net-utils/net-log join "Type: " type: any [
	    all [new-dir? 'new-dir] 
	    all [new? 'new] 
	    all [dir-read? port 'dir] 

     all [port/state/flags and system/standard/port-flags/open-append 
     <> 0 'app] 
	    'file
	] 
	do select [
	    file [

  confirm-cmd port either port/algorithm = 'nlst [nlst-check] [list-check] 
		accept-connect port type 
		parse-dir-list port 
		if tmp: select locals/dir-cache to-file port/target [
		    port/status: first tmp 
		    port/date: third tmp 

      if any [none? port/size: second tmp 1024 > port/size] [port/size: 
      0]
		] 
		data-connect port 
		confirm-cmd port binary-type-check 
		if 0 < cmd-port/state/index: port/state/index [
		    confirm-cmd port restart-check
		] 
		confirm-cmd port read-check
	    ] 
	    new [confirm-cmd port write-check] 
	    new-dir [confirm-cmd port mkdir-check] 

     dir [confirm-cmd port either port/algorithm = 'nlst [nlst-check] 
     [list-check]] 
	    app [confirm-cmd port append-check]
	] type 
	accept-connect port type 
	if type = 'dir [
	    port/size: port/state/tail: parse-dir-list port
	]
    ] 
    port
]
close: func [port /local cmd-port cache-size][
    cmd-port: port/locals/cmd-port 
    if not dir-read? port [error-try? [confirm-transfer port]] 

    net-utils/net-log reform ["Caching cmd-port" cmd-port/host cmd-port/local-port 
    cmd-port/remote-port] 
    cmd-port/host: cmd-port/locals/tuple

See the first SELECT ? Now find the variable which is its VALUE argument.... 
 :-)

Maxim, now's the time to fix some things, no ?

I agree with the select (I was just joking, cause you know how serious 
this will have an effect on code :-)

But this raises again, the issue of trying to get backwards compatibility 
and is it even possible?  with so much changes in the air?

I sacrifice backwards compatibility, we have got incompatibilities 
already in the past and so what? Especially to View changes ....