World: r3wp

btw, using "the-tableau" , Are you from the French connection somehow 
?

No, tableau is a term I seem to recall from an old According to Hoyle 
card rules book, meaning the layout of the cards to be played.

Yeah but still, it's French.
It's like doing your coming out :-)

Rien ne va plus!

I had French in HS... couple semesters in college... Can't read that. 
 I do have great admiration for the French, though.

That's enough, you're officially adopted by the French community.

Tres bien!

Posted the question at Stackoverflow also: http://stackoverflow.com/questions/4073722/rebol-view-how-to-assign-images-to-layout-already-created

I'm working on it.

Note I added a bit of meat to the do-events topic raised by Graham, 
as an extra answer.

and yes... it would be swell if you rate the answer as the final 
one  (shameless I know, but worth the time and effort Me thinks  
;-)

Is there a way to make objects a and b such that operations like 
a + b make sense? Like a complex number object.

Geomol has done a complex number library.....Discussion is here:

   http://www.rebol.org/aga-display-posts.r?offset=0&post=r3wp381x1804

Thanks, Sunanda.

Geomol's complex number library represents a workable approach to 
implementing a large integer math library. But has anyone already 
implemented one? That is, bc's ability to do +, -, *, and / on very 
large numbers? I've been trying to call bc from REBOL using the CALL 
stmt, but success has so far eluded me.

I have an old string-math lib. I don't remember how complete it is, 
but the basic ops should work. May no be applicable to what you want 
to do.

There is this:
   http://www.rebol.org/view-script.r?script=bignumbers.r

But (from a quick squint) it handles numbers as strings. That may 
be less effective than the usual bignum approach [which, in REBOL 
terms, might be a block of 32-bit binaries]

Isn't there a libbc?

The block of binaries would give better performance, but the string 
approach might be fast enough. I'll take a look at it. Thx.

The application involves arithmetic associated with disk addresses 
which can be beyond 2 terrabytes.

Strings are probably fine for 12 or 13 digit numbers.

REBOL3 has 64-bit integers, so that is well within range of a native 
REBOL 3 INT.
Is R3 a possibility for your project?

Yes, it is. Native would be great. I just tried some simple stuff 
on R3 so I'll experiment further. Thanks a lot.

R3 is a little wierd in its handling of large hex numbers - it displays 
them in scientific notation with limited precision instead of as 
integers.

>> 0x3333333333333 
== 0x3.333333e12

That's not a hex number.
It's a REBOL pair.
For hex, try this:
  to-hex 333333333333

Which exposes a nice bug in A110. There is no longer an issue! type 
which can be used for arbitrary base literal numbers.

So to-hex is actually rather misleading.

(And should probably be removed.)

First of all, we never had a type that could be used for arbitrary 
base literal numbers, except the string types.

Next, TO-HEX should probably not be removed, but it should return 
a string! instead.

how would that differ from to-binary?

A binary is only formatted with hex characters (if the binary-base 
is 16). A string would actually containthe hex characters themselves.

So to-hex would be shortcut for enbase/base to-binary num 16. Rather 
useless.

But my, why not.

I expect that TO-HEX is a formatting function that is definitely 
not useless for web work, for example.

That usage would require that we keep the issue-generating feature 
though, even if we couldn't convert back easily.

Or you stop being lazy and add the # manually.

TO-HEX is a convenience function. Being lazy in a common situation 
is the whole point to convenience functions.

Being lazy means that there's no point to this discussion.

a nice bug in A110
 - And which bug is that, exactly? Has it been reported?

Nevermind.

Trying to find out the bug is why I spoke up in the first place. 
I am trying to get the bugs reported so they can be fixed, as appropriate. 
It's amazing how often bugs go unreported and thus unfixed.

No bug. TO-HEX works as designed. Nothing to see here, move on people.

Ah, OK then. The change in issue! has brought up a lot of issues, 
so to speak. We are hoping to collect them all and come up with a 
set of tweaks and enhancements that can make things work. It should 
be possible to make them work a lot like they did before, with only 
minor changes (like being non-modifiable). You can replicate a lot 
of the behavior of a series type in a non-series type by simply having 
the series functions also work on the other type, as closely as appropriate. 
Good examples of these are SELECT and APPEND on objects and maps.

I should have given the example:
    to-binary 33333333

As the above discussion suggests, creating an issue! is a bit of 
a dead end in this case. A binary! is much more usable.....That is 
true in R2 as well as R3.

A function like:                                                 
                              

                                                                                               

[code]                                                           
                              

func [x] [subtract 6 x]                                          
                              

[/code]                                                          
                              

                                                                                               

strikes me as being a lot like an anonymous function or lambda   
                              

expression. Is that correct?                                     
                              

                                                                                               

How would I execute the above function from Rebol CLI? I keep getting 
                         
error messages, so I'm not getting a piece of the puzzle.

>> do func [x] [subtract 6 x] 1 
== 5
>> apply func [x] [6 - x] [1] 
== 5

I'd say, yes, those are anonymous functions - in the sense that they 
aren't assigned to a word. But in the stricter sense of a "named" 
function, REBOL doesn't have that concept at all. You can assign 
a function to one word, some words, or no words at all.

Easy to see for example in code so simple as

>> a: b: c: func [ ] [print "What's my name?"]
>> do [a b c]

I consider them to be the same as anonymous functions/lambdas, due 
to how I was introduced to that concept in Scheme - and a similar 
ability to have multiple words/names reference the same function, 
as ChristianE shows in Rebol:
(define foo (lambda () (print "Hi"))
(define bar foo)

@Christian E. Thanks for the examples! In the first one, it just 
dawned on me that perhaps Rebol is a stack-based language - a bit 
like Forth et al. Didn't you just put "5" on the stack, then the 
"apply func" simply pops the the stack for its parameters?