World: r3wp

Alan;  You can try  var: load/header/next   first var will be the 
header as object, second var will be the rest of the script as a 
string.   var/1/version should be your tuple!  (assuming you use 
tuple).  In terms of the evaluation it is deemed "light", values 
but not code.  So   version: 3.2.1 ok,  version: to tuple! [3 2 1] 
 won't be a tuple, var/1/version will be 'to   So Anton is correct.


Another thing to check out the mezzanines (from View)  load-thru 
  read-thru  and the source for exists-thru?  These may have some 
hints for what you want.

Is there an opposite function to SUFFIX? like PREFIX? or so to get 
the filename without extension?

head clear find/last copy a #"."

to file! head clear find/last copy %prefix.suffix #"."

copy/part f -1 + index? find f "."

to file! first parse f "."

If it wasn't for that extra TO-FILE in SUFFIX?, you'd just use COPY/PART:


>> suffix?: func [path [any-string!] "Return the suffix (ext) of 
a filename or url, else NONE."] [if all [path: find/last path %. 
not find path #"/"] [path]]
>> file: %my.test.file.txt
== %my.test.file.txt
>> copy/part file suffix? file
== %my.test.file

AMacleod, I found my version? function in
http://anton.wildit.net.au/rebol/library/dir-utils.r
(after remembering where my website is)

I'm just curious if there is a way to make a function think an argument 
was passed to it even though an argument wasn't passed to it.

a: func [b [word! unset!]] []

but could B be used if needed

inside the function?

I haven't tested, but perhaps you can test for 'value?

yes

that might work Henrick, I'm trying a few things now.

Yep that will work.  Thanks Henrik

no problem

Thanks, Anton. I think it is just what I'm looking for.

no worries.

Is there any script which can convert for example -1.8E-5 to -0.000018 
?

formDecimal: func[
	number [decimal!]
	digits [integer!]
	/local negative? p result
][
	if digits <= 0 [return form to-integer 0.5 + number]
	if negative?: number < 0 [number: - number]
	p: power 10 digits
	result: form to-integer number * p + 0.5
	if number < 1 [
		insert/dup result "0" (1 + digits - length? result)
	]
	if negative? [ insert result "-" ]
	head insert skip tail result negate digits #"."
]

should have a native that does this

There was an old one from Eric Long, that might be in REBOL.org. 
I don't think I ever tackled that with my FORMAT function.

i have one i've used for a long time too... also adds ' every three 
digits... i added support for scientific notation recently (because 
form always gives sci notation on Wine)

how is it again that I can rebind a function to a different context?

>> c1: context [var: "orig" f: func [][print var]]
>> c1/f
orig
>> c2: context [var: "hello"]
>> bind second get in c1 'f c2
== [print var]
>> c1/f
hello

it seems not to work, if the function starts out as global

>> a: does [print b] 
>> c: make object! [b: 4]
>> a

** Script Error: b has no value
** Where: a
** Near: print b
>> bind second :a 'c

== [print b]
>> a
** Script Error: b has no value
** Where: a

** Near: print b

solved with:

bind second :a c

thanks, Anton

Can someone explain the reason why bind would work but bind/copy 
wouldn't?

You don't rebind the function, you rebind its code block - not quite 
the same thing. Bind/copy wouldn't work because it creates a copy 
rather than rebinding the original block. You can alter the contents 
of the code block of a (R2) function, but you can't change the function's 
reference to that block to point to another block.

If you can create a new function, you can use bind/copy. It is occasionally 
possible to arrange your algorithm so that it is possible to replace 
a function without worrying about aliased references, but usually 
not.

yeah I understand that but why would bind/copy ever fail where bind 
itself worked?

bind/copy goes deep.

yeah

shouldn't it still work regardless

I think I remember, bind/copy is just a short equivalent to bind 
copy/deep.

but if bind works and then you try the same code with bind/copy should 
it cause an error?

Just used when you don't want to modify the bindings of the original.

yeah that is the way I understand it also which is why it suprised 
me in my code that bind works but when I simply add bind/copy in 
then it breaks the code.

Well, probably no error straight after binding, but if some other 
code rebinds it perhaps causes error later.

It depends on the situation. What is the situation you are in ?

yeah that might be it

What is the deal with mod and modulo?   What should   mod 10 3   
 mod 10 -3    mod -10 3   mod -10 -3   return?  Not what REBOL returns 
... what's the math of it supposed to be.


I accept  1 and 2, but -4 (mod -10 -3) freaks me out.  I don't use 
mod very often (and never with negative divisors or dividends), but 
it came up in a conversation with some student programmers (and I'm 
trying to convince them to give REBOL a try).

http://en.wikipedia.org/wiki/Modulo_operation

There is no single definition.

I do not have a mental model of what a modulo < 2 could be never 
mind less than zero.  until is has an accepted definition in mathematics 
programming languages ought steer clear

Thanks.  I just needed to source mod to see where it was coming from. 
 REBOL's mod does make mathematical sense, just needed to get my 
head round it.    Things like  mod -10 -11 being -21.


And Tom, yep.  :)  But I think I've grown to like REBOL's definition. 
  And I would expect anyone that needs negative divisors for a modulo 
calculation will understand the implications.

>> ?? mod
mod: func [
    "Compute a nonnegative remainder of A divided by B."
    [catch]
    a [number! money! time!]
    b [number! money! time!] "Must be nonzero."
    /local r
][
    all [negative? r: a // b r: r + b]
    a: abs a
    either all [a + r = (a + b) positive? r + r - b] [r - b] [r]
]
>> ?? modulo
modulo: func [

    {Wrapper for MOD that handles errors like REMAINDER. Negligible
^-^-values (compared to A and B) are rounded to zero.}
    [catch]
    a [number! money! time!]
    b [number! money! time!] "Absolute value will be used"
    /local r
][
    throw-on-error [
        any [number? a b: make a b]
        r: mod a abs b
        either any [a - r = a r + b = b] [make r 0] [r]
    ]
]