World: r3wp

Trim is also taken

BrianH, I actually didn't want tilde expansion for that case (an 
actual directory in the public cache), so R3's behaviour would have 
been good for me. Just wondering if anyone has any thoughts about 
the issue in R2.

Where is KEEP used? Under R3 it may still be in the COLLECT spec, 
but I don't recall it in R2.

What about FIT ?

I was also thinking of fit

clear-at

discard

COLLECT will be back-ported to R2. At the time of the 2.7.6 release 
the function was still under discussion - now it is finalized. We 
only backport final functions. I'm thinking that FOLD will probably 
make it too :)

How about TRIM-LENGTH ?

Graham;  'only  'lop 'betail  'amputate  'pare  ''shorten  ''abscind 
     load up the dict protocol demo and >> thes truncate for more

oohoo, truncate's good.

I like truncate.

And just to place credit where it belongs ... Our good Chris was 
first with truncate   ... I was simply using it as a good launch 
point for a thesaurus scan.

how about 'lose

never seen that word used in a REBOL script!  :)

'lop is pretty good, because it (probably) implies a fixed length. 
eg. a forester might lop the tops off some trees.

how about  trim/integer  ?  example

abbrev:  trim/3 month

trim/-n  could keep the last n chars

Tom, that wouldn't work with REBOL's evaluation rules. Native or 
not, you can't write a function that way.

picky  picky    
mth:  trim/lenght  month 3

trim/to perhaps

Cut
Keep
Fit
Clear-at
Constrain

Discard
Trim-length
Truncate
Lose
Lop
Trim/to

In this sense, CUT would mean split in two parts, I think. TRUNCATE 
is accurate, but TRIM/TO is a little shorter.

clear-at (its what it does)
truncate (its what it seems to do)

in that case, I would use trunc :)

One thing I do is to remove the outer characters eg. "[Something]" 
=> "Something"

Python has good tools for dealing with these functions.

That's where a range! datatype would come in handy:

copy/part "[Something]" 1..-1

Yep

this is Gregg's substr function


substring: func [
    [catch]
    source [string!]
    spec [block!]
    /local start stop rule
][
    rule: [set start integer! '.. set stop integer!]
    unless parse spec rule [
        throw make error! "Invalid range spec."
    ]
    copy/part skip source start stop
]

You could produce a 'truncate function that uses a pair! to similar 
effect...

truncate: func [string limit [pair! integer!]][
	if integer? limit [limit: 1x0 * limit]
	string: copy string
	case [
		negative? limit/x [remove/part string skip tail string limit/x]
		positive? limit/x [remove/part string limit/x]
		negative? limit/y [clear skip tail string limit/y]
		positive? limit/x [clear skip string limit/y]
	]
	string
]

the ".." is syntactic sugar.

the dialect doesn't cope with negative offsets it seems

; This works!:

truncate: func [string limit [pair! integer!]][
	if integer? limit [limit: 1x0 * limit]
	string: copy string
	case/all [
		negative? limit/x [limit/x: limit/x + length? string]
		negative? limit/y [limit/y: limit/y + length? string]
	]
	clear skip string limit/y
	remove/part string limit/x
]

>> truncate "[abc]" 1x-1 
== "abc"

cool

I think these sorts of series maniplulations should be native

Quite, except with range! instead of pair!

copy/part "[abc]" 1..-1
remove/part "[abcd]" 1..-1

They are native, just without any unnecessary extra syntax. This 
isn't Perl, you know.

but perl rulz!

the power of a language lies partly in it's ability to express things 
concisely

>> str: "[abc]"    
 
== "[abc]

>> copy/part skip str 1 back tail str

== 
abc"

str appears twice

it's annoying

three times, if you do 

str: copy/part skip str 1 back tail str

instead of 'truncate, how about 'peel ?

If you are removing characters from both ends of a string 'strip 
would appear to be a more precise description.

Hmm.  You can strip the inner lining of something, but normally you 
only peel the outer layers :)

If that's you definition of stripping it's no wonder you live in 
NZ.