World: r3wp

So, my sugggestion is that the number of displayed places should 
always be consistent

Does 11:16:00 look less readable than 11:16 ?
 - Yes.

not less readable to a web service though

The default formatter is pretty much for situations where you don't 
need that kind of inflexibility. Most people don't need the whole 
gamut of different formatting options, since only a small percentage 
of them are used in any given situation. It would be useful to have 
a library of date formatting routines that could support all of the 
many standards. If you need to talk to a service that requires a 
particular format, use a particular formatter.

MOLD only has to be compatible with REBOL syntax, and the more human-readable 
subset at that. To be compatible with less flexible data formats, 
use formatting functions that are specific to those formats.

My point is that I think it's an optimization that has bitten more 
than a few people

Maarten's S3 lib has a bug on this account.

Date formats have that effect throughout the industry, mostly due 
to the vast number of incompatible formats to choose between. Whatever 
format you choose will be bad for most of the rest of the world.

As long as it works for my world and web services

That is not what MOLD is for, that is a job for custom formatting 
functions.

So, what do you suggest?

>> d: 15-may-2011/12:00:00.00
== 15-May-2011/12:00
>> d/time
== 12:00

I think I'd like to see a flag or something that sets the number 
of decimal places for decimals, and number of places for time.

Given that the "missing" parts of the precision aren't actually missing, 
sure, that works. And the standard allows those portions to be not 
depicted, just assumed. If you have to generate something less flexible, 
that is a *different* standard, so a different formatting function 
is appropriate.

Maybe that different formatting should be standard

Keep in mind that times in REBOL and most other systems are fixed-point, 
not floating point. There is no loss of precision.

Having something that changes the display depending on what time 
it is ... is ... annoying

That diferent formatting should not be standard. Generating code 
that is more complex than it needs to be is just a waste of space. 
Remember that MOLD output need only be compatible with REBOL code, 
not with any other syntax processor, and you see that it isn't a 
problem.

Decimals aren't output with 17 zeroes either, because that would 
be a waste of space.

True, we just get unintelligble scientific notation

>> 1.00000000000000000
== 1.0
What you are suggesting is this, but for dates:
>> 1.0
== 1.00000000000000000

>> d: .01
== 1E-2

Keep in mind that the main intended purpose of MOLD is to generate 
REBOL source code. You are suggesting that it generate more complex, 
larger source code.

Yes, I'm suggesting that a system wide flag should control the display

I just can't imagine any scenario when the above example is useful

ie. 1E-2

Settable system-wide flags that affect MOLD are a bad idea, since 
they mean that you have to put wrapper code around every call to 
MOLD to make sure that it matches what your code expects. This makes 
very call to MOLD more complex and less task-safe.

R2 has no tasks

Recursion-safe then, or async-safe, whatever. Yes, this includes 
system/options/decimal-digits.

That is why there is a proposal for R3 to make all such options be 
specified at the point of call, not globally. Any global option like 
that would be protected from modification, or else it wouldn't be 
allowed.

This would mean that you would replace this code:
    saved: system/options/binary-base
    system/options/binary-base: 64  ; or 16, whatever
    output: mold data
    system/options/binary-base: saved
with this:
    output: mold/with data [binary-base: 64]


This saves code since you can't trust that any global option will 
remain even its default value without data flow analysis unless it's 
protected.

In any case, you were still leaving parts out of your date formatting. 
If you left it all in it would look like this:
>> 15-may-2011/12:00:00.00
>> 15-May-2011/12:00:00.000000+00:00

Sorry, I forgot 3 zeroes: 15-May-2011/12:00:00.000000000+00:00

I'd prefer that

I can always reduce the numbers for display

It's much more work to increase the numbers

Not for source code output you wouldn't, especially since those extra 
zeroes don't add any information. It's no work at all to increase 
the numbers, since all of those zeroes are there in the original 
date value. So if need less flexible formatters, they're easy to 
write.

What you want isn't MOLD, it's a different formatting function. MOLD 
is for REBOL source, not for S3.

If you do MOLD output and then reduce the number of zeroes output, 
it requires parsing MOLD's output. Working straight from date! values 
means no parsing required.

this who "binary" talk is quite fucked, btw. as if carl never worked 
w low-level stuff... but after seeing a whole nation (singaporeans) 
calling the desktop machine CPU, im not surprised... just disappointed..
wtf does binary-base mean? binary already means number-base 2...

if it's a date with no time portion, then date/date gives you an 
error.


It works for me. Or maybe I'm doing it differently. A date! always 
has a time value, correct, though it may be none? And if it's none, 
that affects the default formatting.


While I've had a few times that the trimming of zeros from time values 
annoyed me, it isn't high on my priority list. If I don't like REBOL's 
default format, or if I have to send data to another process, I just 
know I need to format it.

The default format will never be right for all uses.

and now that we have now/utc, a lot of the pain is gone, IMHO.

Gregg ... now it doesn't give me an error!

either Rebol is non-deterministic, or, I'm having a bad day

The issue is that web apis using different languages don't use datatypes 
in the same way.

I'd be okay if I only used Rebol web apis!

Having QUOTE, would it be an idea to have CITE like this?

cite: func ['word] [:word]


Only difference, I think, is when passing any-function! types to 
it:

>> type? quote next
== action!
>> type? cite next 
== word!

All other types seem to return the same for QUOTE and CITE.

Passing an unset word to QUOTE will return unset! in R2, and will 
return the word in R3. CITE returns the word.

Graham, have a look at http://www.rebol.org/view-script.r?script=form-date.r

Geomol, in R2 when you pass a word to a get-word parameter, the value 
assigned to that word is passed instead. There may have been a good 
reason for this initially, but in the long run it turned out to be 
a bad design choice, and was fixed in R3. It has nothing to do with 
the any-function! types.