Hello,
On Tue, 16 May 2006 00:35:36 +0200, Ralf Hemmecke
<[EMAIL PROTECTED]> wrote:
| System(): with {
| timestamp: Integer;
| cpuTemperature: Integer;
| } == add {
| timestamp: Integer == { obtain the timestamp somehow }
| cpuTemperature: Integer == { obtain the timestamp somehow }
| }
[...]
| | System: with {
| grabData: () -> %
| timestamp: % -> Integer;
| cpuTemperature: % -> Integer;
| } == add {
| macro Rep == Record( ts: Integer, temp: Integer );
| | grabData(): % == {
| per record( obtain the timestamp somehow, obtain the
temperature | somehow );
| }
| | timestamp( a: % ): Integer == { (rep a) . ts; };
| cpuTemperature( a: % ): Integer == { (rep a) . temp; };
| }
I would also claim the second is better. Christian, if you call the
first System() only once then you wouldn't make it a function, but you
certainly like to call System() several times.
Yes, certainly. Consider the following piece of code:
printSystemStats(): () == {
import from System(), ...;
stdout << cpuTemperature << " " << timestamp << newline;
}
monitor(): () == {
repeat {
printSystemStats();
some code to sleep 10 seconds
}
}
There, System() would get called again and again. Every ten seconds a new
instance.
| To determine the given temperature and timestamp for the system
involves 1 | Function call for non functional Domains and 3 for
functional Domains.
I guess you are wrong.
In the first case, each time you want a time-temperature pair you must
do like...
S == System();
t := timeStamp$S;
T := cpuTemperature$S;
in the second case it is
d := grabData()$System;
t := timeStamp(d)$System;
T := cpuTemperature(d)$System;
So what do you gain?
Again: The first piece of code has one function call ... namely System().
Then obtaining timeStamp and cpuTemperature is getting constants and not
calling functions.
1 function call.
In the second case, grabData() is "calling a function". Same holds for
timeStamp(d) and cpuTemperature.
3 function calls.
In a general setting, calling functions is slow, so we do not want to do
it often.
Again. I am not saying, this is the way to go ... It is just an example,
where non functionality might be usefull.
If I do not have a functional type system, how am I supposed to do
"separate compilation"? How am I supposed to do calls?
[ Ralf clairifying how it can be done ]
Also have in mind, that "with" statements are a anonymous. You can check
whether
Dom: with {
f:() -> ();
g:() -> ();
}
has the f function by
Dom has with { f:() -> (); }
Note that these are two completely different with statements!
But it has to be discussed what "equality of arguments" actually means
in order to be able to speak about the functionality property, since not
every type exports "=: (%, %) -> %".
This is the main point to the whole discussion and the main drawback of
functionality. "How to check equality"?
Even and if everything exports "=", we do not know about the semantics of
"=". We would have to bind them :(.
The interesting part is that with in a purely functional setting we will
also run into troubles soon, when using pointer comparison:
DomA( a: List Integer ):with {...} == add {...}
a: List Integer := [ 1, 2, 3 ];
R == DomA( a );
a . 2 := 300;
S == DomA( a );
a still refers to the same memory location, but it is different. Would R
equal S?
--
Kind regards,
Christian
_______________________________________________
Axiom-developer mailing list
[email protected]
http://lists.nongnu.org/mailman/listinfo/axiom-developer
