bad errormessage: There are no library operations named ADEF

[Michael Becker-4]

    Hi,


(1) -> (1,2)
(1) ->
   (1)  [1,2]
                                                  Type: Tuple PositiveInteger
(2) -> select ((1,2),0)
(2) ->
   (2)  1
                                                        Type: PositiveInteger
(3) -> (x +-> select(x,0)) ((1,2)::Tuple INT)
(3) ->
   (3)  1
                                                        Type: PositiveInteger
(4) -> ((x : (Tuple INT)):INT +-> select(x,0))  ((1,2))
   There are no library operations named ADEF
      Use HyperDoc Browse or issue
                                )what op ADEF
      to learn if there is any operation containing " ADEF " in its
      name.

   Cannot find a definition or applicable library operation named ADEF
      with argument type(s)
                               PositiveInteger
                               PositiveInteger

      Perhaps you should use "@" to indicate the required return type,
      or "$" to specify which version of the function you need.


   



    -- Michael



  ps:  same result in fricas or open-axiom.

   








------------------------------------------------------------------------------------
Diese Nachricht könnte vertrauliche und/oder rechtlich
geschützte Informationen enthalten. Wenn Sie nicht der
Adressat dieser Email sind oder nicht autorisiert sind, diese
für den Adressaten entgegenzunehmen, so ist es untersagt,
diese Nachricht oder in ihr enthaltene Informationen zu nutzen,
zu kopieren, offen zu legen oder anderweitig weiterzuverarbeiten.
Sollten Sie diese Nachricht fälschlicherweise erhalten haben,
verständigen Sie den Absender bitte unverzüglich per Antwort auf
diese Mail und löschen sie diese anschließend.
Vielen Dank für Ihre Kooperation.
------------------------------------------------------------------------------------
This message may contain confidential and/or privileged
information. If you are not the addressee or authorized
to receive this for the addressee, you must not use, copy,
disclose or take any action based on this message or any
information herein. If you have received this message in
error, please advise the sender immediately by reply e-mail
and delete this message. Thank you for your co-operation.
------------------------------------------------------------------------------------
We make your business move.




_______________________________________________
Axiom-developer mailing list
Axiom-developer@...
http://lists.nongnu.org/mailman/listinfo/axiom-developer

[William Sit-2]

Dear Michael:

The following works, but we shouldn't have to use such
"unnatural" transformation, since (1,2) is a Tuple object
(or, is it, always? see below). I also agree the error
message is bad, but that is neither news nor where the
problem seems to lie.

((x : (Tuple INT)):INT +-> select(x,0)) ((1,2)::Tuple INT)

or simpler:

((x : (Tuple INT)):INT +-> select(x,0)) [1,2]

Axiom transcript:

(6) -> ((x:(TUPLE INT)):INT+->select(x,0)) [1,2]

   (6) 1
                                                        Type:
PositiveInteger
(7) -> ((x:(TUPLE INT)):INT+->select(x,0)) (1,2)

   There are no library operations named ADEF
      Use HyperDoc Browse or issue
                                )what op ADEF
      to learn if there is any operation containing " ADEF
" in its
      name.

   Cannot find a definition or applicable library
operation named ADEF
      with argument type(s)
                               PositiveInteger
                               PositiveInteger

      Perhaps you should use "@" to indicate the required
return type,
      or "$" to specify which version of the function you
need.
(7) -> (1,2)

   (7) [1,2]
                                                  Type:
Tuple PositiveInteger

(8) -> [1,2]

   (8) [1,2]
                                                   Type:
List PositiveInteger

Note that the outputform of a tuple uses square brackets.

An examination of the code for Tuple.spad shows that a
tuple can be input only from a "PrimitiveArray S" which
inherits from "OneDimensionalArrayAggregate(S)". However,
the way the Interpreter accepts tuples as input is
inconsistent:

select((1,2),0) succeeds, but select([1,2],0) fails.

Further investigation shows that the problem has nothing
to do with anonymous functions. It appears that the
Interpreter treats (...) differently for unary from binary
or higher arity functions. For unary function, the
parenthesis is ignored, while for binary or higher arity
functions, it is treated as delimiters for a tuple. The
[1,2] construction forces the Interpreter to view this
more favorably as a single argument.

This problem survives from Nag Axiom 2.3. If the
observations above are correct, to fix it, it would would
require the Interpreter to search by interpreting (...)
first as a tuple, and failing that, as a single argument;
or in the reverse order.


(1) -> f==((x:(TUPLE INT)):INT+->select(x,0))
   Function declaration f : Tuple Integer -> Integer has
been added to
      workspace.
                                                           
       Type: Void
(2) -> )set mess bot on
(2) -> f (1,2,3) -- treated as 3 arguments, same as
f(1,2,3)

Function Selection for f
      Arguments: (PI,PI,PI)
   -> no function f found for arguments (PI,PI,PI)
   There are no library operations named f
      Use HyperDoc Browse or issue
                                 )what op f
      to learn if there is any operation containing " f "
in its name.

   Cannot find a definition or applicable library
operation named f
      with argument type(s)
                               PositiveInteger
                               PositiveInteger
                               PositiveInteger

      Perhaps you should use "@" to indicate the required
return type,
      or "$" to specify which version of the function you
need.
(2) -> f ((1,2,3)) --treated as 3 arguments, same as
f(1,2,3)

Function Selection for f
      Arguments: (PI,PI,PI)
   -> no function f found for arguments (PI,PI,PI)
   There are no library operations named f
      Use HyperDoc Browse or issue
                                 )what op f
      to learn if there is any operation containing " f "
in its name.

   Cannot find a definition or applicable library
operation named f
      with argument type(s)
                               PositiveInteger
                               PositiveInteger
                               PositiveInteger

      Perhaps you should use "@" to indicate the required
return type,
      or "$" to specify which version of the function you
need.
(2) -> f (1,2,3)::Tuple INT -- wrong association, still
treated as f(1,2,3)

Function Selection for f
      Arguments: (PI,PI,PI)
   -> no function f found for arguments (PI,PI,PI)
   There are no library operations named f
      Use HyperDoc Browse or issue
                                 )what op f
      to learn if there is any operation containing " f "
in its name.

   Cannot find a definition or applicable library
operation named f
      with argument type(s)
                               PositiveInteger
                               PositiveInteger
                               PositiveInteger

      Perhaps you should use "@" to indicate the required
return type,
      or "$" to specify which version of the function you
need.
(2) -> f ((1,2,3)::Tuple INT) -- forces (1,2,3) as a
single argument

Function Selection for f
      Arguments: TUPLE INT

Function Selection for select
      Arguments: (TUPLE INT,NNI)
      Target type: INT

[1] signature: (TUPLE INT,NNI) -> INT
      implemented: slot (Integer)$(NonNegativeInteger)
from TUPLE INT

   Compiling function f with type Tuple Integer -> Integer

[1] signature: TUPLE INT -> INT
      implemented: local function *1;f;1;initial


   (2) 1
                                                        Type:
PositiveInteger
(3) -> f [1,2,3] -- a simpler way to force as single
argument

Function Selection for construct
      Arguments: (PI,PI,PI)
      Target type: TUPLE INT
   -> no function construct found for arguments (PI,PI,PI)

Function Selection for f
      Arguments: TUPLE INT

[1] signature: TUPLE INT -> INT
      implemented: local function *1;f;1;initial


   (3) 1
                                                        Type:
PositiveInteger
(4) -> select ((1,2,3),0) -- (1,2,3) treated as first of
two arguments

Function Selection for select
      Arguments: (TUPLE PI,NNI)

[1] signature: (TUPLE PI,NNI) -> PI
      implemented: slot
(PositiveInteger)$(NonNegativeInteger) from TUPLE PI


   (4) 1
                                                        Type:
PositiveInteger
(5) -> select ([1,2,3],0) -- Interpreter does not coerce
List to Tuple in higher arity

Function Selection for select
      Arguments: (LIST PI,NNI)
   -> no function select found for arguments (LIST PI,NNI)

Function Selection for select
      Arguments: (LIST NNI,INT)
   -> no function select found for arguments (LIST
NNI,INT)

Function Selection for select
      Arguments: (LIST INT,SINT)
   -> no function select found for arguments (LIST
INT,SINT)

Function Selection for select
      Arguments: (LIST SINT,SINT)
   -> no function select found for arguments (LIST
SINT,SINT)
   There are 4 exposed and 1 unexposed library operations
named select
      having 2 argument(s) but none was determined to be
applicable.
      Use HyperDoc Browse, or issue
                             )display op select
      to learn more about the available operations.
Perhaps
      package-calling the operation or using coercions on
the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library
operation named
      select with argument type(s)
                            List PositiveInteger
                             NonNegativeInteger

      Perhaps you should use "@" to indicate the required
return type,
      or "$" to specify which version of the function you
need.



William

On Sat, 25 Jul 2009 01:43:22 +0200
  Michael Becker <Michael.Becker@...> wrote:

>
>
>     Hi,
>
>
>(1) -> (1,2)
>(1) ->
>    (1)  [1,2]
>                                                   Type:
>Tuple PositiveInteger
>(2) -> select ((1,2),0)
>(2) ->
>    (2)  1
>                                                         Type:
>PositiveInteger
>(3) -> (x +-> select(x,0)) ((1,2)::Tuple INT)
>(3) ->
>    (3)  1
>                                                         Type:
>PositiveInteger
>(4) -> ((x : (Tuple INT)):INT +-> select(x,0))  ((1,2))
>    There are no library operations named ADEF
>       Use HyperDoc Browse or issue
>                                 )what op ADEF
>       to learn if there is any operation containing "
>ADEF " in its
>       name.
>
>    Cannot find a definition or applicable library
>operation named ADEF
>       with argument type(s)
>                                PositiveInteger
>                                PositiveInteger
>
>       Perhaps you should use "@" to indicate the
>required return type,
>       or "$" to specify which version of the function
>you need.
>
>
>    
>
>
>
>     -- Michael
>
>
>
>   ps:  same result in fricas or open-axiom.
>
>    
>
>
>
>
>
>
>
>
>------------------------------------------------------------------------------------
>Diese Nachricht könnte vertrauliche und/oder rechtlich
>geschützte Informationen enthalten. Wenn Sie nicht der
>Adressat dieser Email sind oder nicht autorisiert sind,
>diese
>für den Adressaten entgegenzunehmen, so ist es untersagt,
>diese Nachricht oder in ihr enthaltene Informationen zu
>nutzen,
>zu kopieren, offen zu legen oder anderweitig
>weiterzuverarbeiten.
>Sollten Sie diese Nachricht fälschlicherweise erhalten
>haben,
>verständigen Sie den Absender bitte unverzüglich per
>Antwort auf
>diese Mail und löschen sie diese anschließend.
>Vielen Dank für Ihre Kooperation.
>------------------------------------------------------------------------------------
>This message may contain confidential and/or privileged
>information. If you are not the addressee or authorized
>to receive this for the addressee, you must not use,
>copy,
>disclose or take any action based on this message or any
>information herein. If you have received this message in
>error, please advise the sender immediately by reply
>e-mail
>and delete this message. Thank you for your co-operation.
>------------------------------------------------------------------------------------
>We make your business move.
>
>
>
>
>_______________________________________________
>Axiom-developer mailing list
>Axiom-developer@...
>http://lists.nongnu.org/mailman/listinfo/axiom-developer

William Sit, Professor Emeritus
Mathematics, City College of New York                  
Office: R6/202C Tel: [phone]
Home Page: http://scisun.sci.ccny.cuny.edu/~wyscc/


_______________________________________________
Axiom-developer mailing list
Axiom-developer@...
http://lists.nongnu.org/mailman/listinfo/axiom-developer