World: r3wp

split-text: func [txt [string!] n [integer!]
    /local frag fraglet bl frag-rule bs ws
][  ws: charset [#" " #"^-" #"^/"]
    bs: complement ws
    bl: copy []
    frag-rule: [
        any ws
        [copy frag [n skip]
         [opt[copy fraglet some bs  (insert tail frag fraglet)]
        ]
       |[copy frag to end]
       (insert tail bl frag)
    ]
    parse/all txt [some frag-rule]
    bl
]

untries

Ladislav, that doesn't work.

tom, untried fails :)

this is being done to try and format and wrap text of course.

>> n: 5 parse "" [copy frag [n skip | to end] (frag: any [frag ""])]
== true
>> frag
== ""

this is a little tricky for such a simple function.

that is why I am saying that the NONE issue is annoying

Did you get a chance to talk to Carl?

yes, I did, he accepted all my proposals - more than 600 lines of 
text when written

Ladislav - could you post it, please? :-)

or at least pointers to some older articles already written, which 
were accepted by Carl?

(but this one deserves to be put to Rambo too - do you want me to 
put it there?)

yes.

Do we have a final function that works yet?

it might be easier to to a parse/all txt #" " and then build up the 
lines one at a time.

I can get rid of the infinate nones by making an error ...

but that dosent really count

split-text: func [
	txt n 
	/local frag result bl stop-rule
][
    bl: copy []
    result: copy ""
    stop-rule: none
    end-rule: [to end (stop-rule: [end skip])]
    frag-rule: [

  copy frag [n skip | end-rule] (frag: any [frag ""] print frag append 
  result frag)

  copy frag [to #" " | end-rule] (frag: any [frag ""] print frag append 
  result frag append bl copy result clear result)]
    parse/all txt [some [frag-rule stop-rule]]
    bl
]

split-text: func [txt [string!] n [integer!]
    /local frag fraglet bl frag-rule bs ws
][  ws: charset [#" " #"^-" #"^/"]
    bs: complement ws
    bl: copy []
    frag-rule: [
        any ws
        copy frag [
            [1 n skip 
                opt[copy fraglet some bs]
            ]
            | to end skip
        ]
        (all [fraglet join frag fraglet]
         insert tail bl frag 
         print frag
        )
    ]
    parse/all txt [some frag-rule]
    bl
]

I have to say Tomc is a winner !

it was the copy frag 1 n skip

Unspecified .. but tom's function removes leading white space as 
well.  Ladislav's preserves whitespace.

yes

should stick both up on the library ..

can easily commont out the any ws line if that is not desired  ... 
or make it a refinement

good night thanks for the puzzle

thanks for the input.

and thanks both for the solution.

good night, Tom

Next Devcon they should set aside a few mins for some programming 
contests :)

and virtual spectators being allowed to compete.

Not a half bad idea.

Word on the street is that you're offering to host this next one.

hi Ammon, missed you in Italy

Hello.  I missed you all as well.

well, if people want to come to Wellington .. I'll see what I can 
do.

I checked RAMBO and the discussed issue seems to be there: #3579 
by Piotr.

Gabriele: the [copy frag [n skip | to end] (insert tail result any 
[frag""])] looks too complicated for the PARSE setting words to NONE 
justification, I would at least prefer to add it to the ticket as 
an example.

I just found out that I can't do the following:
s: "a b c"
s: "a c b"
parse s ["a" to ["b" | "c"] to end]


The two strings should only symbolize that b and c can alternate. 
But 'to and 'thru don't work with subrules. It's not even stated 
in the documentation that it should but wouldn't it be natural ? 
Or am I missing some complication for the parser if it would support 
this (in the general case indefinite look-ahead necessary for the 
parser - is this the problem?) ? How are other people doing things 
like this - what if you want to parse something like "a bla bla bla 
c" or "a bla bla bla d" if you are interested in the "bla bla bla" 
which might be arbitrary text and thus can't be put into rules ?

Carl mentioned performance-problems. Although everyone asks for it.

i use 
 "a" any[ "b" | "c" | skip ] to end
Even slower and less elegantly, but works.

OK, thanks. Didn't know this. But this solution will work for me 
as well. In a sense this is interesting, as skip isn't a real token, 
but a command - but it's treated as a token. :-)

Volker, that will return true for "a" as well as "a b c".

I tend to use charsets for this, though again, there is probably 
a performance cost...

true. never thought about that.

'some would do half the trick. except if nothing is found, it eats 
all and counts as true here.

non-bc: complement charset "bc"
parse "a b c" ["a" any non-bc ["b" | "c"] to end]

but if it is longer, like "be", every "bi" would fail to.

In that case, you need to elaborate a little.