World: r3wp

Yes, this was meant to illustrate that it's very likely some kind 
of MOLD issue.

Without the MOLD I see: 
  399405529304859.î

That decimal fraction part appears differently between alpha 110 
and alpha 109...Not tested in older versions.
   399405529304859.?   ;; alpha 109

>> mold tangent 89.99999999999986
== "399405529304859.$"

I have a question.

Somwhere, between Rebol Wiki and BLOG appeared an article about OBJECT 
creation and what is copied and what is shared.
Do you remember the exact position ?

Don't Mind. I have found the link: http://www.rebol.net/w/index.php?title=Copy_Semantics&redirect=no

hmm, we are preparing for the beta - finally! Carl is working on 
the Projects/Roadmap site, the list is gone and we will get new one. 
I wonder if we will be able to influence that. My bet is that we 
will kind of rush for beta, so things like tasking will be postponed 
for 3.1 :-)

where does it say this?

http://www.rebol.com/roadmap.html

Expect the community to take over the things it can improve on its 
own.

Yes, I can fear that "excuses" already, as it happened in the past 
too :-) E.g. tasking being part of host, and hence delegating the 
responsibility to the community, while that thing is absolutly fundamental 
to being designed properly, not just hacked-in ...

Excuses

 is the total wrong word and interpretation. We had this topic over-and-over 
 again: A lot say "Rebol is bad because it's not open-source.", well 
 I want to ask: "How many of you have contributed to the parts that 
 you can work on now?"

Taling is easy, doing is hard.

And doing is different than designing imo, and that is my point - 
some things should still be under the supervision of RT, especially 
things that need to be designed very carefully and precisely. I have 
nothing against various experiments done by the community ....

My list of what needs to be fixed/done before we can consider beta, 
in CureCure tickets: #539 (likely as definitional return), #851, 
#1509, #1515, #1518, #1519, #1520, #1742, #1743, maybe #1744, #1758, 
#1759. Plus all the PROTECT bugs. There isn't a single one of those 
that isn't more important than tasking or a new codec model.

And yes, I even have the numbers memorized. That is how important 
they are.

And now you can add #1760 to that list.

OK, so will you talk those tickets with Carl? Because - I might surprise 
you, but I prefer consistency and bugs fixed, instead of new features 
added (of course if adding those features later will not break things 
:-)

And #1521 (which is a side-effect of #1509 getting fixed).

I'll try to get in touch with Carl over this.

This one is a poll question everyone should not have trouble to answer. 
In R2, the USE function initialized the local values to #[unset!] 
for better user protection. In R3 (implementation quirk) the local 
USE variables are initialized to #[none!]. Which alternative do you 
prefer?

I, personally, do not mind much, but, depending on the result of 
this poll, I intend to adjust my policy when judging other cases, 
e.g. new functions, that are not yet implemented.

I think it should be the same, as if you were to use those values 
local to a function. Aren't they set to #[none] there too?

I sometimes have a tendency to write code like:

use [blah] [...body...]

and later move that code to:

func [/local blah] [...body...]

and it would be nice not to have to change the body.

Aha, OK, so 1 for the current R3 implementation.

thanks

+1 hanrik

(henrik)

USE3:USE2 = 2:0

But I have no problems with #[unset!] as well. But as Henrik says, 
better to be consistent with the function initialization.

As long as they use the same start value, I'm OK with either #[unset!] 
or #[none].

they use the same start value

 - so, I understand it, that what you actually want is the consistency 
 between "initialization of function locals" and "initialization of 
 USE locals"

(not minding much what value it actually is)

yes. the end-goal would be to not need to change the body.

thanks, leaving the score as is, but making a note for myself

Good argument, Henrik.

Ladislav, you wrote "the USE function initialized the local values 
to #[unset!] for better user protection."

Better protection than what? Or what is the protection? (Or do you 
just mean USE creating locals is the protection?)

Sorry, improving the formulation:


In R2, the USE function initialized the local values to #[unset!] 
for better user protection against uninitialized variables (variables 
not initialized by the user).

At least I have been told, that was the main reason for the existence 
of the #[unset!] value

Which means, that a variable being intitialized to #[unset!] behaves 
like being "uninitialized"

I hope it is clear now

Aha, that makes sense.

I have a slight preference for unset!, but the consistency argument 
overpowers it.

Which means, if I understood you well, that your favourite behaviour 
is:

    use [a] [type? get/any 'a] ; == unset!

as well as

    do has [a] [type? get/any 'a] ; == unset!

, the current behaviour

    use [a] [type? get/any 'a] ; == none!

and

    do has [a] [type? get/any 'a] ; == none!

being the second best only?

and

type?

(sorry for the cut'n paste mess at the end)

... Yes... but, if on a scale of 0 to 100, where 0 is unset! is my 
exclusive favourite and 100 is none! is my exclusive favourite, then 
my preference is about 49, with an uncertainty of ±10.
So I don't think my vote should count for much. :)

+1 for consistency between /local and USE. Do not care much if the 
initialisation value used is none! or unset!.

So, assuming that it is "impossible to change the FUNC variable initialization 
convention", I count: USE3:USE2 = 4:0

Please don't make REBOL into Haskell ;-)

Am I to understand, that some of the USE3/USE2 variants would do 
that?

Or, did you mean another property?

+1 for R3's USE. Uninitialized variables aren't really as much of 
a problem when:
- They are declared right there where you can see them.

- They are initialized to a known value that you can rely on or test 
for.