axiom-developer
[Top][All Lists]

## Re: [Axiom-developer] Cleaning issues

 From: Gabriel Dos Reis Subject: Re: [Axiom-developer] Cleaning issues Date: 26 May 2007 21:34:14 -0500

```Waldek Hebisch <address@hidden> writes:

| I have looked at older issues in Issue Tracker and it seems that
| there are significant number of issues which are just users not
| understanding what Axiom is doing and expecting different result.
|
| For example issue 165 the user clearly do not understand that
| that Axiom blindly performs specified computations and that
|
|   [j for j in 4.. | j < 10 ]
|
| simply is an infinite loop.

This one is indeed "paradoxical" at first sight, but is indeed
an infinite computation.  What can we do about it?
Fo course we can tell user that he/she does not understand.
Can we help with warnings from the interpreter or compiler?  Maybe we
should.

|  Correct stream computation work
| because they eventually produce some output and compuation
| is aborted when sufficently many elements are produced, but
| this one just loops without producing any output.

That is not what I call "work" :-)

|
| BTW, my impression is that this issue is a duplicate.
|
|
| Simiarly 335 sort! drops list elements is just example of
|
| (1) -> bb := [3, 4, 1, 2]
|
|    (1)  [3,4,1,2]
|                                                    Type: List PositiveInteger
| (2) -> bs := sort! bb
|
|    (2)  [1,2,3,4]
|                                                    Type: List PositiveInteger
| (3) -> bb
|
|    (3)  [3,4]
|                                                    Type: List PositiveInteger
| (4) -> bs
|
|    (4)  [1,2,3,4]
|                                                    Type: List PositiveInteger
| (5) -> bb.1 := 7
|
|    (5)  7
|                                                         Type: PositiveInteger
| (6) -> bs
|
|    (6)  [1,2,7,4]
|                                                    Type: List PositiveInteger
| (7) ->
|
| should be, or maybe already is in the tutoral, as an ilustration
| that what was a first element of the list after reorganization
| may point inside.

reference semantics and non referential transparent computations are
not things people usually grasp from first reading.  I don't know what
can be done apart from an FAQ entry under the heading
"reference semantics" and "referential transparent computations".

-- Gaby

```