World: r3wp

I'll give it another go.

copy frag n skip should be perfectly OK

hmm.  that works.  except I miss the last piece of the text as if 
last piece less than n, it doesn't get copied.

example of what you get and what want?

split-text "this is a sentence" 11
[]

I want [ "this is a sentence" ]

how about:

    copy frag [to #" " | to end]

yah! that works.

I tried putting in an alternate rule of " | copy frag to end " but 
that hung the parser.

this should work too:

    [copy frag #" " | copy frag to end]

rather:  [copy frag to #" " | copy frag to end]

Hmm.  It's failing when the text is less than n.

strange

[ copy frag n | copy frag to end ]

at the beginning I guess

aha, this one, yes, right

[ copy frag n skip | copy frag to end ]

or copy frag [n skip | to end]

nope.

if append "" none works as it does, then it is a problem with the 
none value

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] (print frag)
        opt[copy fraglet some bs  (print fraglet)]
        (insert tail bl join frag fraglet)
    ]
    parse/all txt [some frag-rule]
    bl
]

will prolly fail on tezt < n as well

it does fail.

simpler to just check the size of the string before it gets worked 
on.

yep

but the last  line being less than n is the same thing

I must say, that the NONE issue is quite annoying/inconsistent (IMO)

yeah .. it is.

how about this one?: copy frag [n skip | to end] (frag: any [frag 
""])

maybe we should put it to RAMBO as an enhancement request?

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
]