World: r3wp

and staying small enough, i think

well, the exact definition is, all functions in Rebol which are not 
natives are mezzanines :)

But it''s Carl who makes the choice.

aha :) so it's more analog thing

Final definition:

All functions in Rebol that Carl don't want code as natives are called 
"mezzanines"

:))

Perhaps a new group "Bash Carl" should be more convenient

O don't want to be in that group :)

all functions written in rebol, *shipped with rebol* are mezzanines.

Janko: http://hmkdesign.dk/rebol/files/385cc7420409fa08f768a537a52ce4d8-76.html

thanks guys, very nice article Henrik!

very ugly link:]

That's RapidWeaver. :-)

Good short article, Henrik. The link to me is outdated. You can use 
http://john.niclasen.name/, if it's needed.

Nice article. The Google ads are funny too :)

You missed op! functions, but that is probably OK.

Hi, I am puzzling over this and would really appreciate some pointers 
please.  How do I get from this:
d1: "random1"
d2: "data2"

;;to this?
b1: [random1 ["data2"]]

so I can reference the data2 by its association with random1 e.g.
b1/random1/1

well:

b1: reduce [to-word d1 reduce [d2]]

ah, nice. Thanks.  I was looking here http://www.rebol.com/docs/core23/rebolcore-16.html#section-3.10
which for once looks like it was the right area. Thank you.

I was hoping to get something like this working with the data structure 
Henric helped me with above.
foreach bb b1 [ print b1/:bb/1]

but the foreach itterates all the vlaues, not just the words.

I have been thinking about this for a week or so, but dont really 
know how to get any further with it.


I suspect that if I had the right structure I could use it to store 
my data, then add additional details when I find some more, and finaly 
export the whole lot, grouped together by the key value (that I will 
only know when the script is running).


Im aproaching this in the right sort of way?  Or is there a recognised 
way to create these sort of structures please?

Sorry about my typing Henrik. I know how to spell your name really.

foreach [key val] b1 [print val]

That is just what I wanted, thanks Brian. Is this a recognised way 
to deal with data that is presented in a different order to the output 
requirement?

No, it's just a way to treat a block as fixed records, this time 
of two values each.

If you want variable records you either put the data in an inner 
block (as you have), or use a distinct datatype for the keys ans 
search for values of that datatype to find the next key.

I think I need to learn more before I can use this to the effect 
I need.   I was expecting your construct to all me to do this:
foreach [key val] b1 [print b1/:val/1]

I don't get what you want to do. Perhaps some sample data and the 
desired output?

probe b1
[random3 ["data4"] random1 ["data2"]]
probe b1/random1/1
data2


but as I dont know what random1 is I want to enumerate the values 
from the data structure.

Are you trying to get a specific data* or to enumerate all of random*?

Ah I think I am being a numpty. your structure already returns the 
data, but I need to be able to print the keys with the associated 
data.

foreach [r d] b1 [print [r d]]

You can do some formatting in the print statement, but it is that 
easy.

I will have different numbers of data elements in different keys, 
so I also need to keep track of which data is stored where, perhaps 
I need an array as the data element.

Your data already has an array as the data element, except we call 
them blocks.

b1: [random3 ["data1" "data2"] random1 ["data3"]]

foreach [r d] b1 [print [r mold d]]

I need to know what type of data I have put in data3.  It might be 
the same type as in data1 or data2, or something different again. 
 any one of maybe 10 types.   The actual data will be IP addresses 
& interface details & remote connection information.

You can specify ip addresses directly, as data of the tuple! type. 
Or you could have the data be doubles of strings and type flags.

Or if you would have at most one of each type, you could name the 
potential fields and have the data be name value pairs.

*a block of* name value pairs.

most of my different types will be strings I am expecting. 

Sometimes there will be up to about 4 of the same type (addresses 
& secondary addresses mostly)

[key [flags ["flag1" "flag2"] ips ["127.0.0.1" "192.168.1.1"]]

Sorry, missing a last ]

The pairs idea sounds productive, so it is a highly structured array 
with named groups?

Or you could go positional for the different types of data, instead 
of including the flags and ips words all of the time.
dat: [key [["flag1" "flag2"] ["127.0.0.1" "192.168.1.1"]]]
foreach [key val] dat [set [flags ips] val  ...]

Structured data makes things easier.

Thank you very much for you time & help.  I will need a while to 
digest this & make it work with my existing code.

I think this type of structure is going to be the core of most of 
the data extraction I need to do, so I must get to understand it 
very well. I have a section that uses an array, but some of the more 
interesting data manipulation needs to cope with more varied keys. 
Thanks.

This a pretty standard way for REBOL to do lightweight data structures. 
Blocks are lighter-weight than objects. Enjoy :)

.

Hi, is there an easy way to make this sort of structure work please?

data: [bike [wheels [2] owner [john]] pig [legs [4] owner [roger]]]

foreach [thing content] data [print [data/:thing/owner "~" data/:thing/wheels 
"~" data/:thing/legs]]

I want the invalid references (e.g. data/bike/legs) to return nothing 
so the list is printed for both things