World: r3wp

and its not of any help with /deep  I often use /deep when creating 
objects which use words which are the same as values within the code 
creating it.  same thing for dynamic view layouts.

Yeah, with /deep you have to use nested calls to compose and to-paren.

I'm all for Build. I find it very comfortable.

I think reduce/only works backwards
 - me too

 'ins and 'only don't jump out visibly as much

 - 'ins and 'only are not "real keywords". Using the /with refinement 
 you can use any keywords you like. Actually, BUILD [...] is defined 
 as:

    build/with [...] [
        ins: func [x [any-type!]] [get/any 'x]
        only: func [x [any-type!]] [
            head insert/only copy [] get/any 'x
        ]
    ]

So they are just handy defaults. I think they're as well-named as 
they can be, probably.

When constantly having to convert from one currency to another is 
it best to not use the money! datatype? If I change for Rp. to $ 
and then back to Rp. I lose a few Rp.

Is decimal! best?

that sounds like a serious flaw in the money! datatype. if it can't 
be used for financial calculations, why is it there?

It happens because there are only 2 point of precision, I think.

point = points

I'm using decimal in my money program.

about the above discussion before money, maybe a reduce/with could 
do the opposite of reduce/only.

(Skipping a lot discussions)
    build [1 [/ins 3 + 2 /ins now]]
    build [1 /only reduce [3 + 2 now]]

and i would like it. Or, because lit-wrds mean exeptions in parse, 
    build [1 ['ins 3 + 2 'ins now]]
    build [1 'only reduce [3 + 2 now]]

Money is like decimal! internally afaik.

Back to money, it seems to work fine at the console:

>> x: 9220
== 9220
>> type? x
== integer!
>> r: 777777
== 777777
>> d: to-money r / x
== $84.36
>> d * x
== $777777.00
>>

But in my script, the conversion back to Rp gives me 22.2 Rp too 
many.

What kind of mony program are you making, Anton?

Oh I've just got a very basic and customized accounting program. 
It basically just runs through all my transactions, subtracting expenditures 
and adding incomes.

It can plot a graph of the balance over the last year, so I can see 
the patterns and trends.

Is it double entry?

No, I check the balance manually occasionally.

It's really basic. What are you trying to do ?

Responding privately.

I don't understand this:

>> x: "9220"
== "9220"
>> r: "777777"
== "777777"
>> x: to-integer x
== 9220
>> r: to-money r
== $777777.00
>> d: r / x
== $84.36
>> d * x
== $777777.00
>> d * 9220
== $777777.00
>> $84.36 * 9220
== $777799.20
>> d
== $84.36
>>

What is happening there?

I had to post that before I go to sleep. I'll probably have to get 
up sometime through the night to see the answer.

BUILD - 'ins and 'only are good words, it's just that plain words, 
mixed with a lot of other plain words, don't catch your eye, so using 
any other word doesn't solve it for me. That's why I used the set-word! 
syntax in my COLLECT function if you recall. I would probably end 
up using "special" words or marker values, e.g. puting special chars 
around the words, like ~ins~ or *only*, or just using special start/end 
markers. Basically, synthesizing a paren alternative or looking for 
words that are "marked up" in a ceratin way. e.g.

    build [1 [|_ 3 + 2 _| |_ now _|]]		; |_ val _|  = ins val

    build [1 ||_ reduce [3 + 2 now] _|| ]		; ||_ val _|| - only val

    build [1 *this* and *that* but not these] 	; marked words, e.g. *-modified, 
    are reduced

Louis - what you are describing is a MOLD issue - MOLD shows you 
only two decimal digits for the MONEY! datatype

(which looks like less than you expect, doesn't it?)

on the other hand, the "full precision" is used for computing, that 
is why you see the difference

I am afraid, that you may be unable to use the current MONEY! datatype 
implementation for accounting purposes, because you probably don't 
know when you need to take care

(I don't think, you would be able to do better with DECIMAL! either 
due to the same issues)

Ladislav wrote: "you probably don't know when you need to take care." 
 You are right, but I am going to have to learn. I have written a 
double-entry fund accounting program which we are using for our non-profit 
organization for several years. I have just modified it to convert 
rupiahs to dollars. But it also has to be able to convert the dollars 
back to rupiahs properly. Are there any documents I might read to 
educate myself?

Here is samle data showing the problem:

>> d: make object! [
[        reconciled-d: "o"
[        reconciled-c: "o"
[        trans-num: "1232"
[        trans-date: 14-Oct-2006
[        check-num: ""
[        vender: ""
[        debit-fund: "GF"
[        debit-acc: "5003"
[        debit-amount: $84.36
[        debit-desc: ""
[        credit-fund: "GF"
[        credit-acc: "1001"
[        credit-amount: $84.36
[        credit-desc: ""
[        date-entered: 14-Oct-2006
[        user: "LAT"
[        rp-per-dollar: "9220"
[    ]
>> d/debit-amount
== $84.36
>> d/debit-amount * 9220
== $777799.20
>>


The result should be $777777.00, so I am getting 22.2 rupiah too 
many.

the problem you are struggling with isn't REBOL-specific

that is why you cannot find the solution in REBOL documentation

Mathematical rules:
1) do not expect, that a result "exists" unless you know it does

in the case you are describing we get:

$84.35 * 9220 ; == $777707.00
$84.36 * 9220 ; == $777799.20

we can conclude, that there is *no amount* expressible in dollars 
and cents that has got the properties you want it to have

The solution is up to you - you need to know what you really want 
and how to get it.

I guess that if you will be able to describe what you really want, 
there will be no problem to get it

If you're dealing with $777,777  - then I suggest a professional 
accounting package is more appropriate.

I disagree, even when using a professional accounting package we 
need to know what we want to get

graham, my guess is that they are rupiahs, not dollars :)

Louis: Ladislav is right, the money shows you just 2 decimals digits 
and rounds as you can see:
>>  777777 / 9220
== 84.3575921908894
>> to-money 777777 / 9220
== $84.36
>> (to-money 777777 / 9220) * 1000
== $84357.59
>> (to-money 777777 / 9220) * 1000000
== $84357592.19

What is suprise for me is, that it's not possible convert money to 
decimal using:    to-decimal $84.36

I think, that money datatype is almost useless

For example why is not working this?
>> $10 * $10
** Script Error: Expected one of: number! - not: money!
** Near: $10.00 * $10.00
Money is not a number?

The specified unit ($) would also have to be multiplied to be consistent 
there. We had this discussion before when talking about the proposed 
Rebol v3 deci! datatype...  Anyway, I agree there are problems, but 
this works:
>> 10 * $10
== $100.00

Oldes - you *can* convert money! to decimal as follows: second  $84.36 
; == 84.36