World: r3wp

mezzanines are functions written in Rebol as opposed to C

In the Rebol console, look at the help for, for example, Foreach 
and Forall.


Under the description of Foreach, it says "FOREACH is a native value" 
- this means it is implemented directly in C in the interpreter. 
 FORALL says "FORALL is a function value" - it is written using other 
Rebol commands, and you can see the source of it using "source forall". 
 Mezzanine refers to this second type.

mezzanines vs native functions

does that mean something in English ?, because in French it does

hmm... same meaning

then all functions that I make when I program REBOL in REBOL are 
mezzanines? I thought there is something special about them

they just must have an abstract polymorphic usage

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 ]