[Axiom-developer] Re: 1: %

[Ralf Hemmecke]

> if we were to consider implementation details, then descending to the
> foam level would suffice :-)
>
> However, I was really thinking of the abstract model -- no
> implementation involved yet.

I think you are more of an expert in this business. I am just a poor 
mathematician with some programming knowledge. ;-)


> | However, this behaviour is exactly, the difference between a constant
> | and a nullary function in Aldor.

> The difference is not that between a constant and a nullary function
> -- btw, anything defined with "==" is a constant in Aldor :-)

Yes. As I said. "y" is constant "y()" is not.

> if your nullary function y evaluates to the *same* value for same
> argument each time, then  it would do just fine.

I agree, but it does not evaluate to the same thing. And Aldor allows 
this. I understand that mathematically a constant and a nullary function 
is not much of a difference. I would also conceptually agree if we speak 
about functional languages where there are no side effects. But Aldor 
allows side-effects.

> You won't see any difference.

Except, maybe for the running time if the compiler is not smart enough 
to remove
the function call and just replace it with the value.

>  The real difference in your program is that of *binding time*.

Of course, I agree, that "x" and "y()" can be treated as constants if 
"y" where a function in the mathematical sense (returning the same value 
for the same input). In that case it is just different "binding time".

But in the example I gave in my previous mail. "y" is not a function 
that returns the same value in each invocation. And you don't think that 
is a difference?

> | Aldor computes the value for x at the time the domain is
> | instantiated. So it is constant over the lifetime of the domain
> | (unless some dirty tricks change that value). For y it is
> | different. That is a function constant. But a constant of type ()->%
> | not of type %. Now, of course, if you say "y()", you get something of
> | type %. But each time you call y() you might get a differen element of
> | %.
> | 
> | I guess, you know all this stuff.
>
> yes, thanks.   I'm still puzzled as to why you're collapsing binding time
> distinction with constant vs. nullary function.

Maybe, I don't have enough knowledge here. If you could enlighten me, 
would be nice...

Ralf