World: r3wp

Oops -- I should put the IF at New Name line at the end of the loop, 
or put the capture of the name in that part.

Yes Patrick you have it right. The rules I gave would fail 
since you have multiple names/members

I would try to get away from the line by line mentality 
and try to break it into your conceptual record groupings
file, pages, sections, and details...

One trick I use is to replace a string delimiter for a record 
with a single char so parse returns a block of that record type. 

this is good because then when you work on each item in the block 
in turn
you know any fields you find do belong to this record and that 

you have not accidently skipped to a similar field in a later record.

something like this 


pages: read %file
replace/all/case pages "PAGE" "^L"
pages: parse/all pages "^L"

foreach page pages[
	p: first page
	page: find page newline
	replace/all/case page "NAME" "^L"
	sections: parse page "^L"
	foreach sec section [
		s: first section
		sec: find sec newline
		parse sec [
			any [thru "Member" copy detail to newline 
				newline (print [p tab s tab detail])
			]
		]
	]
]

I am a little confused about PORTS.  I want to control how much information 
is loaded into a block but I am not sure how to determine if data 
remains in a port.  Example:

In-port:	open/lines In-file
 while [not tail? In-port] [
	print In-port
	In-port:	next In-port
	]

 close In-port

This is not doing what I want.  

I want it to continue to run through all  lines of a file and print 
it

My goal is to be able to control how much of a file is loaded into 
a block then process the block and then go after the next set of 
data.  That is why I am using PORT to do this function instead of 
reading everything into memory etc.

Change the print line to:
print first In-port

I think, your code print the port specs and everything.

Yes, It does dump a lot of stuff that I don't kow about!!!

Ports are nifty little objects.  :)  And if you just type
>> In-port
 you get back nothing, just another prompt.
>>

The interpreter does not display the internals of objects, but print 
does, so what you are seeing is the object! that is In-port.  Well, 
I'm lying...In-port is a port!  not an object!  Close but not the 
same.  ports emulate a series! wrapped in object! wrapped in enigma. 
 Or is it an object! wrapped in a series! disguised as a sphynx? 
 :)


first In-port is a REBOL reflective property feature that when you 
get it, you'll go "Ahhhh" as you step closer to the Zen of REBOL.

For fun with a really big object!  try >> print system

Oh, by the way...we added to the %form-date.r script in the library. 
  See I'm New for details.

Another question -- I know to use escape to insert things like a 
tab as in ^(tab) into a string.
What can I use to insert a newline?  ^(newline) doesn't work.

str: ""
insert str newline

If you just write NEWLINE in the prompt, you'll see how it's defined. 
You can specify a newline in a string as
str: "a string with a newline: ^/"

A tab can also be specified as: "^-"

Perfect!   ^/ works just great!

It's a bit strange, that ^(newline) doesn't work, now that ^(tab) 
does. Maybe it was just forgotten.

As a newbie, it seemed natural to try ^(newline), but the shortcut 
^/ works for me too.

Unfortunately there are some strange things in the corners of REBOL, 
but you'll learn to live with it.

:-)

Now you're at it, check http://www.rebol.com/docs/core23/rebolcore-16.html#section-2.11
and http://www.rebol.com/docs/core23/rebolcore-8.html
for info about strings in REBOL.

Just what I needed!!!

Ah, there's the explanation, a newline can be specified as ^(line)
(for some reason)

Ahhhhh

More reference info here: http://www.rebol.com/docs/core23/rebolcore-16.html#section-3.1

And you also have the words CR, LF, and CRLF available.

My teachers,  I have an array ( block (of "lines") within a block 
(of values) ) that I would like to convert to a block (of "lines") 
with all values joined with an embedded tab.  What is the best way 
to achieve this?  See example: 


In-array:      [   [   {Col A1}     {Col B1}   ]        <-- I have 
this
                          [   {2}              {3}             ]
                          [   {line "3"}    {col "b"}    ]   ]


Out-block:   [   {Col A1^(tab)Col B1}             <-- I want this 
                         {2^(tab)3}
                         {line "3"^(tab)col "b"}         ]

>> out-block: copy []
== []

>> foreach line in-array [append out-block rejoin [line/1 "^-" line/2]]
== ["Col A1^-Col B1" "2^-3" {line "3"^-col "b"}]

in-array: [["Col A1" "Col B1"]["2" "3"][{line "3"} {col "b"}]]

out-block: copy [] 
foreach blk in-array [
	line: copy "" 
	repeat n -1 + length? blk [append append line blk/:n tab]
	if not empty? blk [append line last blk]
	append out-block line
]

new-line/all out-block on
== [
    "Col A1^-Col B1"
    "2^-3"
    {line "3"^-col "b"}
]

Anton, what does the new-line/all do.  I gather it inserts newlines 
after each value.  Is that right?

it cleans up rebol-listings

Forgive me,  how does it do that?

else all strings would be on one line. only interesting for probing 
rebol-code, does not change the strings itself

there is a hidden markerin values, for newline

So if i read you right, then if I didn't do new-line/all, and tried 
to probe Out-block, it would show the entire contents as one large 
string, whereas new-line/all will allow probe to show each value 
as a spearate line.  Right?

as lots of strings in one line

and with the new-line all strings in own lines

I see how it works now  -- Thank you Anton and Volker!!

Thank you Reblek  -- didn't see your answer at first!

My teachers, Anton and Rebolek have submitted two answers.  The difference 
between them is that Anton's answer will insert a tab between varying 
numbers of  values per line, where Rebolek will insert a tab in-between 
col 1 and col2 (assuming only 2 columns in the array).  Is that a 
correct interpretation?

Anton, I understand Rebolek answer, but I want to understand your 
answer too.

 I'm wondering about the line: repeat N -1 + length? Blk [append append 
 Line Blk/:N tab]  

does Rebol do the inner append first  (in math expressions) like 
this:  [append ( append Line Blk/:N ) tab]
and then do this for the number of "lines" in the array
N	Out-block
0	[]
1	"Col A1^-Col B1"
2	"Col A1^-Col B1"	"2^-3"
3	"Col A1^-Col B1"	"2^-3"	{line "3"^-col "b"}


I think I see the above progression, but not sure about Blk [append 
Line last Blk]  Is this advancing the starting position within In-array?

...insert a tab between varying numbers of  values per line <versus> 
... insert a tab in-between col 1 and col2
 -- Correct.


On new-line, it's kind of advanced because it doesn't insert a newline 
(CR/LF), but rather a hidden marker between values that REBOL uses 
when molding blocks.

Hi Gregg -- Is that primarily for display purposes, or could it be 
used for other things?

On "append append", yes. You could also do it like this: "append 
line join blk/:n tab", the difference being that APPEND modifies 
its series argument, and JOIN does not.


REPEAT is 1-based, not zero, Anton is using "-1 + length? blk" rather 
than "(length? blk) - 1" or "subtract length? blk 1". The first of 
those cases requires the paren because "-" is an op! which will be 
evaluated before the length? func, so REBOL would see it like this 
"length? (blk - 1)", which doesn't work.

For display or formatted output. It's *very* useful when generating 
code for example.

Sounds like more advanced stuff than I'm understanding right now. 
 I'll read up on the terms. 

When I get REBOL code solution, I'd like to understand how Rebol 
is processing the code.  What it does logically first, and logically 
second... I think I get confused about when Rebol does the evaluations.

You shouldn't have to worry about new-line at all. It's actually 
relatively new, so we all lived without it for a long time.

It can be confusing at times, and even once you know what you're 
doing, you sometimes have to think about it a bit. The up-side is 
that you have a great deal of control once you know how to use it.

I should point out that NEW-LINE, as Anton used it, is a handy shortcut 
that takes the place of foreach+print for simple console display.

I am looking forward for the Rebol lightbult to go on full power!!! 
 I think it just takes me playing around with rebol more to get there!