These error messages indicate some serious problems with the Axiom Tuple domain:

  System error: The function |Domain| is undefined.
  The constructor Tuple takes 1 argument and you have given  2

Axiom allows functions to have a tuple as input but it fails if a function generates two or more outputs.

For example:

f:(INT,INT)->INT

g:INT->(INT,INT)

   The constructor Tuple takes 1 argument and you have given  2  .

(INT,INT)

 LISP output:
(UNPRINTABLE UNPRINTABLE)

Tuple Any should work in a similar way to List Any and DirectProduct(2,Any).

List Any

(1)

DirectProduct(2,Any)

(2)

Tuple Any

 LISP output:
(UNPRINTABLE)

Axiom's non-homogeneous Record and Union domains are functionally superior to the tuple construct but it makes functional notation awkward. See SandBox Direct Product

a:Tuple INT

a:=(1,2,3,4)

(3)

dom:=Tuple Any

(4)

b:dom:=(1::INT, 2::FLOAT,3::POLY INT)

(5)

h:INT->Tuple INT

h(x)==(x, 2+x)

h(5)

Compiling function h with type Integer -> Tuple Integer

(6)

f1:INT->Tuple INT

f1(x)==(x,2+x)

f2:(INT,INT)->INT

f2(x,y)==x*y

f2(f1(4))

Compiling function f1 with type Integer -> Tuple Integer 
   There are no library operations named f2 
      Use HyperDoc Browse or issue
                                 )what op f2
      to learn if there is any operation containing " f2 " in its name.

   Cannot find a definition or applicable library operation named f2 
      with argument type(s) 
                                Tuple Integer

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.
f3:Tuple INT -> INT

f3(x) == *(x)

f3(f1(5))

   There are no library operations named * having 1 argument(s) though
      there are 34 exposed operation(s) and 23 unexposed operation(s)
      having a different number of arguments. Use HyperDoc Browse, or
      issue
                                 )what op *
      to learn what operations contain " * " in their names, or issue
                                )display op *
      to learn more about the available operations.
   Cannot find a definition or applicable library operation named *
      with argument type(s)
                                Tuple Integer

      Perhaps you should use "@" to indicate the required return type,
      or "$" to specify which version of the function you need.
   FriCAS will attempt to step through and interpret the code.

Compiling function f3 with type Tuple Integer -> Integer 
   There are no library operations named * having 1 argument(s) though 
      there are 34 exposed operation(s) and 23 unexposed operation(s) 
      having a different number of arguments. Use HyperDoc Browse, or 
      issue
                                 )what op *
      to learn what operations contain " * " in their names, or issue
                                )display op *
      to learn more about the available operations.

   Cannot find a definition or applicable library operation named * 
      with argument type(s) 
                                Tuple Integer

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

The following works (not as neat as it should be, of course)

f1:INT->Tuple INT

   Compiled code for f1 has been cleared.

f1(x)==(x,2+x)

   1 old definition(s) deleted for function or rule f1

f2:(INT,INT)->INT

f2(x,y)==x*y

   1 old definition(s) deleted for function or rule f2

a:=f1(4)

Compiling function f1 with type Integer -> Tuple Integer

(7)

f2(select(a,0), select(a,1))

Compiling function f2 with type (Integer,Integer) -> Integer

(8)

f3:Tuple INT -> INT

   Compiled code for f3 has been cleared.

f3(x) == reduce(*,[select(x,i::NNI) for i in 0..length(x)-1])

   1 old definition(s) deleted for function or rule f3

f3(a)

Compiling function f3 with type Tuple Integer -> Integer

Compiling function G1490 with type Integer -> Boolean

(9)

f3(f1(5))

(10)

f3((1,2,3,4)::Tuple INT)

(11)

f3 [1,2,3,4]

(12)

f4:Tuple INT -> List INT

f4 x == concat(x::List INT, x::List INT)

f4(f1(5))

Compiling function f4 with type Tuple Integer -> List Integer

(13)

Note that neither f3(1,2,3,4) nor f3((1,2,3,4)) works, even though tuples are lists without the square brackets, essentially. In both cases, the reason is probably the parser treats the arities differently. Recall that the Interpreter (and Axiom) treats parenthesis as "applied to" (so f3 (1,2,3,4) is the same as applying f3 to 4 distinct arguments and f3(a) is f3 a). I do think the second form should have worked without the explicit coercion.

I do not know why in the design of Tuple S, the parts are not to be referenced with just the usual list method like a.i and must use select. Also the indexing in Tuple S starts with 0. In the very old days of Scratchpad, all aggregates indexing was zero based. Most are converted to one-based and you can have a choice. Somehow, Tuple S was not updated to reflect this.

One final puzzle: In axiom output messages for (9) above, what is the G1433 (or whatever) function from Integer->Boolean? I tried

)clear all

   All user variables and function definitions have been cleared.
f3:Tuple INT->INT

f3 x == reduce(*,[select(x,i::NNI) for i in 0..length(x)-1])

a:Tuple INT:=(2,3)

(14)

f3 a

Compiling function f3 with type Tuple Integer -> Integer

(15)

f3(a)

(16)

and there is no such function. Also, f3 a actually works.

William

I prefer to read (2,3) or 2,3 for tuple, and [2,3] only for lists.

Students and I make errors when the display is the same, even if there is a type information.

There seems to be some bug in the display, because the code in Tuple (array1.spad) uses parenthesis, not brackets.

coerce(a)$Tuple INT

(17)

coerce(a)@PRIMARR INT

(18)

This "bug" may be due to the Interpreter coercing Tuple INT to PRIMARR INT and then to OutputForm, which perhaps uses the List output. The order of coercion may be governed by the conditional on coerce to Outputform in Tuple S (S needs to be of SetCategory).

William

See related discussion: Tuples Products And Records

)clear all

   All user variables and function definitions have been cleared.
g:=[(1,2),(3,4)]

(19)

[(a:=e;(a,a)) for e in g]

(20)

[((a,b):=(select(e,0),select(e,1));(a,a,b,c)) for e in g]

(21)

f:=g.1

(22)

(a,b):=f

   If there is a tuple on the left-hand side of an assignment then
      there must also be one on the right-hand side.

On my system, the following message finally:

   >> System error:
   The storage for CONS is exhausted.
   Currently, 85895 pages are allocated.
   Use ALLOCATE to expand the space.

It's clearly an infinite loop.