World: r3wp

Rod.   Classic.  Not as classic as Starting Forth, but hey.   Marcel 
Hendrix has posted Starting Forth as well, but had trouble with the 
cartoons, and the replacements are not quite as "fun".  And just 
so ya know, only Marcel was given the right to copy, explicity only 
Marcel, by Forth Inc.   http://home.iae.nl/users/mhx/sf.html

Whoa.  Elizabeth has posted a much nicer reprint on the forth.com 
site.    http://www.forth.com/starting-forth/
Nice!

Thanks Brian, will check out starting forth as well.

Most of had Starting Forth and Thinking Forth so our bosses bought 
us great huge fat Thesauri  thinking it would make us better  coders. 
 We laughed at first, then our dictionary grew to the 100,000 word 
mark and they started to get  dog eared.  :)

Hah, I can already appreciate that view, even with just a little 
reading and applying it to some work concepts I found the desire 
for words exploading!

Yeah; I think I was on my ninth or tenth version of "READ" when I 
started going with foreign languages.  And being forthers, you wouldn't 
want to write TROUBLE-REPORT over and over again, so we got used 
to TRP and FLD and got really good at pronouncing just about any 
random collection of letters.  TERP and FLUD (field) for the former. 
 It's why I don't use the expression SeQueL   It's SQEEL!     :) 
 Ahh, fun with words.

I have this reduce statement, that's supposed to form a block for 
later processing. Now I want to include in that a switch to add some 
more stuff if a variable is not none. However it seems like the if-statement 
returns a none which gets included in the result block :(

block: reduce [
	'aword "blah blah"
	if var [ 'avariable var ]
]

block: reduce ['aword "blahblah" either var [['avariable var]][[]]]

seems to include the rest as a block

better one:
block: compose ['aword "blahblah" (if var [['avariable var]])]

remember the extra block inside the if statement, otherwise only 
'var will be returned from it

I still seem to get a none in the block if the varable isn't available

block: compose ['aword "blahblah" (either var [['avariable var]][[]])]

It works! :) thanks alot

what is the best way to convert this 4E-2 to 0.004 ?

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 #"."
]

>> formDecimal 4E-2 4
== "0.0400"

>> formDecimal (4E-2 / 10) 3
== "0.004"

hm.. maybe not the best as there is this issue: 
formDecimal 4E-3 2
== "0.00"

it depends what do you need... if is important the value or how the 
rounded value looks like

thank you Oldes, I thought there was a native or mezz for that

a little bit late

form-dec: func [
	number [decimal!] 
] [
	form case  [
		number > 1 [number]
		number > 0 [
			join "0" at form number + 1 2
		]
		number > -1 [
			join "-0" at form number - 1 3
		]
		true [number]
	]
]

why does join 'a 'b return "ab" instead of 'ab ?

join always returns a string unless the first value is of type? series.
>> join 1 2
== "12"
Try
   source join
to see the actual code.

JohanAR, use this instead:

attach: func [a b][to type? a join a b]

thanks!

On to the next question :) Why is '= valid but '< or '> aren't?

My guess is, that it's becuase < and > are part of tag type, like 
<tag>. So it's a restriction to make value evaluation easier internally.

>> blk: [=]
== [=]
>> blk: [<]
** Syntax Error: Invalid tag -- <
** Near: (line 1) blk: [<]
>> blk: [<tag>]
== [<tag>]

>> type? first [<]
** Syntax Error: Invalid tag -- <
** Near: (line 1) type? first [<]
>> type? first [ < ]
== word!

hehe, funny! :)

I guess it is special-cased in the loader.

>> attempt [[<]]
** Syntax Error: Invalid tag -- <
** Near: (line 1) attempt [[<]]
>> attempt [load "[<]"]
== none

This relates to the sandboxing discussion I was just having with 
Paul.

The first error isn't caught because the load happens before the 
attempt is called.

you can ofcourse use to-word "<" but it's not very good looking if 
you have to cover all of <, <=, >, >=, <> etc.. managed to avoid 
the case by using compose instead of reduce though

Is it possible to define a function, which takes another function 
as argument and that the argument func must take exactly two arguments 
in it's turn?

This is how you can pass a function to a function:

>> a: func [a [function!]] [ print a 1 2]
>> b: func [x [integer!] 
y [integer!]] [add x y]
>> a :b
3

Sorry about the formatting; let my try again:
>> a: func [a [function!]] [ print a 1 2]

>> b: func [x [integer!] y [integer!]] [add x y]

>> a :b

3

I think you will need to "manually" check that the supplied function 
uses the correct number of arguments

>> c: func [a [function!]] [if 2 = length? first :a [print a 1 2]]
 
>> c :b
3

>> d: func [][print "no args"]
>> c :d

== none

Mm, I ended up writing something similar to that. Found out that 
I also have to check if third first :a is /local, which would also 
be a valid function

getargs: function [
	:fun "Get arguments from this function"
][
	out pblock
][
	out: make block! 10
	parse third :fun [
		some [
			string!		; Strip comments
			|

   [ [word! | get-word! | lit-word!] (pblock: [any-type!]) opt [string!] 
   opt [set pblock block!] opt [string!] (append/only out pblock) ]
		]
	]
	out
]

a little messy, but it appears to work :)

You don't have to manually check to see if the function takes two 
arguments; this is good, because doing so is awkward. All you really 
need to do is call the function in parentheses ( ) or at the end 
of a code block, so that it can't take more than two arguments even 
if it tries. If it takes less than two arguments, who cares?

Be sure to assign the use or assign the result of the function call 
inside the parentheses, rather than outside them, in case the function 
takes less than the number of arguments you are expecting it to.

Do
    source replace
in REBOL 2.7.6 for an example of this - look for the parentheses.

The ARRAY function in 2.7.6 does the end-of-the-code-block method 
for function value arguments.

If the datatypes the function value is expecting don't match the 
data that your function is passing to it, no problem: A nice error 
message will be generated at runtime that the developer of the function 
value can use to fix their function value. :)

assign the use
 -> "use"