World: r3wp

Henrik,  Your suggestion did achomplish the task of trapping an error 
when it happened so it is better than nothing -- see resutls:

Rebol []
echo  %VT-Results.txt
print {Results below generated from %VT-Script.r}
          print {unset [x]}
                 unset [x]
           print {print x}

set/any 'err try [print x] if error? err [ disarm err print "** error"]
print ""
           print {print x}

set/any 'err try [print x] if error? err [ disarm err print "** error"]
print ""
print {See results stored in %VT-Results.txt file}
echo off
halt

will generate:

Results below generated from %VT-Script.r
unset [x]
print x
print x
See results stored in %VT-Results.txt file

oops, wrong cut and paste -- here is the revised results:

Results below generated from %VT-Script.r
unset [x]
print x
** error

print x
** error

See results stored in %VT-Results.txt file

If only there was a way to "capture" the specific error message at 
the time of disarm err, and print those results 
Could that be done?

of course.. just do:
 probe disarm err

I'm ussing:
attempt: func [value][
    either error? set/any 'value try :value [
        print parse-error disarm value none
    ] [get/any 'value]
]
parse-error: func [
    error [object!]
    /local type id arg1 arg2 arg3 wh
][
    type: error/type
    id: error/id
    wh: mold get/any in error 'where
    either any [
        unset? get/any in error 'arg1
        unset? get/any in error 'arg2
        unset? get/any in error 'arg3
    ] [
        arg1: arg2: arg3: "(missing value)"
    ] [
        arg1: error/arg1
        arg2: error/arg2
        arg3: error/arg3
    ]

    rejoin ["** " system/error/:type/type ": " reduce either block? system/error/:type/:id 
    [
            bind to-block system/error/:type/:id 'arg1
        ] [
            form system/error/:type/:id
        ]
        newline

        reform ["** Where: " wh newline "** Near: " mold error/near newline]
    ]
]

Now when I see the code (which is probably not mine), the handling 
of args is not correct as any missing arg will now set all of them 
as "(missing value)". But at least you can have an idea, how to work 
with the disarmed error!

Anyway, I use modified append to be able see if there is an error 
somewhere (where is unexpected) without stoping the execution. If 
I know, that somewhere can be an error, then I use just simple  error? 
try []

*append = attempt

Thanks Oldes, I'll play with it!

Wrap your tests in a block, then you can do at least in R2
until [ 
	either error? set/any 'err try [
		t:  do/next tests
	] [
		print disarm err
		tests: next tests
	] [
		tests: second t
	]
	empty? tests
]
 
Unfortunately it does not work with R3. .(

There you have to wrap every statement in a block  inside the main 
block.
Then you can do them one  by one.

if I have rebol object  R2 >>


A: make object [ add: func [ ] [ .... ]   remove: func [ ] [ ....... 
]  parse-rule: [ ..... ] ]
B: make A [ change: func [ ] [ .... ] ]

<< 

and if I make 100 objects like B from A ... does this mean each of 
them has it's own "add remove parse-rules" copy in memory or there 
is just one copy of these functions/blocks that they share it?

it seems it makes copies

I believe you are correct. There is no separate "prototype" in Rebol.

You can use this method, if you don't want to get copies

 A: make object! [ add: func [ ] [ .... ]     sub: make object! [parse-rule: 
 [ ..... ] ]]
then the elements in the subobject are just references.

I was away... I tested on these 3 cases... started new rebol each 
time, it took 13MB of ram at start


A: make object! [ a: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 
b: [ 123 1231 13 123 12313 1

2312 3123 123123 12 231 21 312 12 123 31231231 2312 312 1231 2123 
123 12 3123 12 312 312 312 312 31 23 123 123 12 312 31 23 123 12 
312 312 3 123 12 312 31 23

123 12 312 3 123 12 31 3 123 13 12  123 123 12 3 123 1231 23 123 
123 12 312 3 123 12 312 3 123 12 312 3 123 12 31 23 123 12 31 23 
123 1 23 123 12 31 2 23 12 3
1 3 12 312 3 123 12 3 ] ] AS: copy []
loop 100000 [ append AS make A [ ] ]

went to 250MB RAM
-- 



A: make object! [ a: does [ print "something" a: 2 + 3 + 5 loop 10 
[ print "a" ] ] ] AS: copy []
loop 100000 [ append AS make A [ ] ]

went to 50MB of ram
--

A: make object! [ a: "" ] AS: copy []
loop 100000 [ append AS make A [ ] ]

went to 25MB of ram
--

sqlab - I will try what you say.. I asked because at the actor lib 
I am making each actor/thread is one object so I want to have them 
as lightweight as possible

( It is understandable why is this , block (like parse block or block 
of code) , and also func in rebol body is just "data" and you can 
change it in each instance ) ..

sqlab - bravo! your trick works..  


A: make object! [ proto: make object! [ a: does [ print "something" 
a: 2 + 3 + 5 loop 10 [ print "a" ] ] ] ] AS: copy []
loop 100000 [ append AS make A [ ] ]

went to 21MB ram
 
---

I have to see what this means to inheritance and other things

I also tried this but it works the same as if I define block in object 

A-a: [ print "something" a: 2 + 3 + 5 loop 10 [ print "a" ] ]
A: make object! [ a: does A-a ] AS: copy []
loop 100000 [ append AS make A [ ] ]

sqlab: hm.. but do you know for a way that subobject could access 
parent's objects data?

You have to give the parent object as a parameter to the functions 
in the sub objects, then you can acces the elements as 
pobj/name

I tried this.. but self in that context is the subobject ... 

actor-static!: make object! [ 
	parent: none
	act-match: copy []
	act: [ match-do take mbox act-match ]
	test: [ print parent/mbox ]
	mode: 'm
]

actor: make object! [ 
	mbox: copy []
	vars: copy []
	static: make actor-static! [ parent: self ]
]

hm.. but act are blocks of code .. not functions right now so they 
don't have params

so they can be used like this... this is how it currently worked 
(without static)  ... 

cat-boss: make actor [ 
	act-match: [

   [ still-seeking ] [ print "cat boss: our cat agent is still seeking!!" 
   ]
			[ found-fish ] [ print "cat boss: yeey, we found a fish!!" ]
	]
]


... anyway, thanks for your help so far a lot! I need to start my 
brain, it seems it doesn't work very well today

aha, this works, thanks to your ideas.

actor-static!: make object! [ 
	parent: none
	act-match: copy []
	act: [ match-do take parent/mbox act-match ]
	test: [ print parent/mbox ]
	mode: 'm
]

actor: make object! [ 
	S: self
	mbox: copy []
	vars: copy []
	static: make actor-static! [ parent: S ]
]

ah, I am stupid is actor-static is just one for 100 copires than 
parent can't only point to one parent so this won't work

Unfortunately i do not understand, what you do with your actors.

http://itmmetelko.com/blog/2009/04/12/playing-with-making-an-actor-like-distributed-system-in-rebol/
 ... I am thinking that I won't change it all and make usage more 
ugly becase right now I don't even know If I will ever need to have 
100000 actors running..  so for now I will continue using object 
and try to make it elegant without worying about this

(again , it hot distorted) ... I am thinking that I won't change 
it all and make usage more ugly becase right now I don't even know 
If I will ever need to have 100000 actors running..  so for now I 
will continue using object and try to make it elegant without worying 
about this

hot = got

I need to see more how this is used before I start optimising, I 
thought I can make some optimisation without complicating it all 
up and make it less elegant to use and extend

hi janko,

have you seen the erlang concept of concurrent distributed programming? 
http://erlang.org/doc/getting_started/part_frame.html
perhaps you can find there some additional ideas.
A robust and complete p2p component in rebol would be fantastic.

TomBon ... yes , erlangs actors are the inspiration for this, although 
I don't have plan to mimic them entirelly .. actors/processes there 
are main building blocks of app in erlang, you can have many thousands 
of them , spawn them all the time etc..  here so far my goal is more 
to use them for distributted computing part, communication between 
various processes/computers ( I have servers that need to talk to 
bots etc.. and back)

Do I understand that you want to send actors a message and they should 
act upon the elements of an objects of the sending process?

no no,... upthere I was trying to make actors lighter... each actor 
is a object now , and each carries around code in it's methods so 
it's not as lightweight as it could be.. but this is more of a theoretical 
probem for now.. as I said I am more interested in them for distributted 
programming so I maybe won't be spawning and having 100 000 actors 
around like in erlang for ecample

I will post new version with some updates in few days, it will have 
some similar pattern matching/deconstruction for messages, remote 
actor spawning too, actors could remove themselves, and hopefully 
some solution for addressing actors more elegantly by then

interesting project janko, will follow your updates.

thanks Tom, I hope something ok will come out of it :)

if we would need really lighweight actors they would have to be made 
with blocks so that they would hold just data , .. rebol creates 
1.000.000 blocks with key and empty string in 4 sec and 70MB, but 
it is question if this is really needed, with objects you can very 
nicely as normal objects extend them into new types of actors

for this small overhead you buy objects which are much better and 
flexible.

I am not sure if this can help, but you can get objects with references 
instead of copies, when you modify them after creation.
maybe like this
>> template: make object! [
[     a: 1
[     b: 3
[     c:  "times"
[    ]
>>
>> obj1: make template [
[     a: 2
[     b: 4
[     c: none
[     f: does [print [ a c b "gives" a * b] ]
[    ]
>>
>> obj1/c: template/c
== "times"
>>
>> obj1/f
2 times 4 gives 8

here c is just a reference, not a copy
>>

It is not 'everytime' wise to look for the smallest possible. funcionality 
is the key here in my opinion.

sqlab .. you are a real object magician :) ... not sure either if 
this can help me right now but good to know for this

On 19-Feb-2009 in this group I said that Tiny C Compiler (TCC) had 
problems. Well, I tried again using the latest version from git repository 
and successfully created a shared object library which can be accessed 
by Rebol. So, Vladimir's tunel.r code, which I ported to C, can now 
be compiled using TCC (as well as GCC). This is good because TCC 
is much smaller (and faster) than GCC and can hopefully be integrated 
in nice, small cross-platform packages.

Nice anton, I hope we'll see your work soon...

Is that the answer to rebcode in R3?

I doubt that, unless it is available to all the platforms. Also - 
Anton - how "big" it is in terms of KBs it would add to REBOL executable? 
Is it under 100KB? :-) Because if not, Carl might not consider it 
:-) But who knows, R3 is going to have plug-ins, so it might be as 
kind of  external "rebcode" engine. The first thing I woudl probably 
do is I would consider ASM/JIT, Blit/JIT addition (not sure it is 
cross-plaform either though)

I wonder what would be the option? REBOL would found out there is 
a "rebcode" in it, it would be a C code, and then your app would 
have to compile and link it in order for being able to execute it? 
Could there be a precompiled (or compile at first run) option? Because 
if not, then it would be slow, no?

Well, the TCC binary here is 129ko. I don't think Carl will be adding 
it to the Rebol executable, anyway.

The trick, I think, is to have a simple set of instructions to install 
TCC ready to use with Rebol.

After that, I suppose it could grow into a plugin.