World: r3wp

A lot of the time I do my dialect processing with functors, functions 
that create functions. Sometimes these functors run in pre-rebol, 
some at runtime function creation time. Then the actual work is done 
by the generated functions. This gives me the advantages of dialects 
without the drawbacks. On the other hand, dialects like draw are 
examples of my principle of low overhead in proportion to the that 
of the work performed - the dialect overhead isn't that much different 
to that of a series of function calls in the do dialect.

Adding things like this to path notation hides a lot of compuational 
complexity. Sometimes that's a very good thing, and sometimes it's 
not. And consider what should happen in the case that "my-block/[2 
3]" refers to a two-dimensional array, or a block of name value pairs; 
what should the result be? Something like that fits very well in 
a dialect where the power is leveraged, and the domain is tightly 
constrained. That's where we get power and safety combined.

http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-display-thread.r?m=rmlGGHC

for shortness, we can use short function-names, sl: :slice  sl string 
2 4 .
If we play with extensions, i propose an operator '..
  s/2 .. 4

I suggest we just adopt the Python syntax for slicing strings, and 
accept that this is a dialect for handling string slicing, and not 
2 or more dimensional arrays.

And other one dimensional series.

Is there any way to send email in such a manner as to cause a window 
to pop up on the recepient's email client requesting confimation 
that they received the email?

Yes, and I presume that it is one of the X- type fields.

Do you have a link to some how to info?

nope .. do a google search.

Thanks.

I think that slice is much more general than the single string domains. 
So if introuduce it needs to be with care. Beside Graham if you are 
using a lot of substrings just create your own func it will make 
your code more explicit to your problem domain.

Record: [a b c d e f g h i]
foreach mold Record SeriesBlock [
   print record
]

Can someone tell me how to define a block (as in Record) and then 
use that variable in the foreach loop?
Although the array has values, nothing is printed in the loop.

When I remove the 'mold' statement, 'Record' contains just one value 
('a') not 9 (a b c d e f g h i).

>> foreach letter record [print letter]
a
b
c
d
e
f
g
h
i

okay?

Where is the 'block' argument?

>> help foreach
USAGE:
    FOREACH 'word data body

DESCRIPTION:
     Evaluates a block for each value(s) in a series.
     FOREACH is a native value.

ARGUMENTS:

     word -- Word or block of words to set each time (will be local) (Type: 
     get-word word block
)
     data -- The series to traverse (Type: series)
     body -- Block to evaluate each time (Type: block)

In this example,
WORD is letter
DATA is record
Body is [print letter]

I want to use two block arguments.  One for word (value that gets 
set each time) and of course the 'data' block.

Oh wait...

you can't with foreach!

actually you can.  Working example to follow

foreach [a b c d e f g h i] Datablock [ print [a b c d e f g h i]]

This traverses the datablock and sets each of the 9 values and prints 
them as a record.

However, I want to be able to set a variable instead of hardcoding 
"[a b c d e f g h i]"

ex: Record: array 9

then
foreach record datablock [ print record]

but when I do that, record doesn't contain an array of values

Sorry I don't understand what you want to do :-\

Oups, cross post

!> w: [a b]
== [a b]
!> foreach :w [1 2 3 4][? a ? b]
A is an integer of value: 1
B is an integer of value: 2
A is an integer of value: 3
B is an integer of value: 4

me too, and wrong.

okay just a minute

Ok, you want dynamic block of word to set, right?

Yiu can't have one variable -- you need a set of them, eg:
foreach [key data] ["a" 1232 "c" 7737 "z" 777] [print [key data]]
But you can fake it something like this......

data:  ["a" 1232 "c" 7737 "z" 777]
for nn 1 length? data 2 [print [pick data nn pick data nn + 1]]

record-sort: func [record [block!] num [integer!]] [
    tmp: copy []
    new: copy []
    foreach [a b c d] record [append/only tmp reduce [a b c d]]
    sort-method: func [a b] [(at a num) < (at b num)]
    foreach rec sort/compare tmp :sort-method [append new rec]
    return new
]


Here is the record-sort example given in the docs.  Problem is this 
only works for records that have four items.

the easier way is forskip. 'foreach needs a binding-trick

build the code then do it :)

Sunanda: Thanks for the example.  I'll play with your example and 
see what I can do.

Volker: Thanks.  I'll take a look at using forskip

why must it be in words?

The goal is to rewrite the record-sort function so that the number 
of elements is not hard coded into the function.

I want to be able to pass the function another value which equals 
the number of elements in a record and then do something like Record: 
array {Elements}

within the function.  This would make the function more universal.

>> print-n: func [record words] [do compose/deep [ foreach [(words)] 
record [print [(words)]]]]

>> print-n [1 2 3 4 5 6 7 8 9] [a b c]
1 2 3
4 5 6
7 8 9

forskip record 4 [append/only tmp copy/part record 4]

Humm.  That looks like it will work.

does sort/skip directly do what you want?

I'm not sure.  I don't think so but I can't remember why not.

Something about reordering the records makes sort/skip not suitable.