# new -- new objects and new types

## Description

In this reference section we discuss how to make new types of object and new objects of those types.

## installing a new method for new-of-from

• Usage:
new AA of BB from C := (A,B,c) -> ...
• Inputs:
• AA,
• BB,
• C,
• (A,B,c) -> ..., a function of 3 arguments: AA will be an ancestor of A, BB will be an ancestor of B, and C will be an ancestor of the class of c. Alternatively, A will be a type of AA, B will be a type of BB, and c will be an instance of C.
• Outputs:
• the function is returned as the value of the expression
• Consequences:
• the function will be installed as the method for new AA of BB from C. It will be stored under the key (NewOfFromMethod,AA,BB,C) in the youngest of the hash tables AA, BB, and C.

In this example we install a creation method for new types of types from functions. The function is used to construct the method for converting instances of the new type to nets for display.

 i1 : new Type of BasicList from Function := (A,B,f) -> hashTable { net => f };

The hash tables AA, BB, and C will normally be instances of Type.

## new-of-from

• Usage:
new A of B from c
• Inputs:
• A,
• B,
• c, an instance of C
• Outputs:
• the new object of class A and with parent B described above
• Consequences:
• the function previously installed as the method for new A of B from C will be called with arguments (A,B,c).
• if no such method has been installed, then ancestors of A, B, and C, will be consulted, searching lexicographically for a method; see inheritance.
• if no method is found by searching the ancestors, then the function (A,B,c) -> c will be used
• the value returned by the function, (or c, if no method was found), will have its class set to A and its parent set to B; see newClass.

We use the creation method installed above to create a new type of list.

 i2 : f = s -> "--list of type X--" o2 = f o2 : FunctionClosure i3 : X = new Type of List from f o3 = X o3 : Type i4 : class X o4 = Type o4 : Type i5 : parent X o5 = List o5 : Type i6 : peek X o6 = Type of List{net => f}

Now we use new to create a new list of type X from a list. The system knows how to convert lists to lists of type X, so no creation method need be installed for new X from List.

 i7 : x = new X from {1,3,11,12} o7 = --list of type X-- o7 : X i8 : class x o8 = X o8 : Type i9 : parent x o9 = Nothing o9 : Type i10 : peek x o10 = {1, 3, 11, 12}

## installing a new method for new-of

• Usage:
new AA of BB := (A,B) -> ...
• Inputs:
• AA,
• BB,
• (A,B) -> ..., a function of 2 arguments: AA will be an ancestor of A, and BB will be an ancestor of B. Alternatively, A will be a type of AA, and B will be a type of BB.
• Outputs:
• the function is returned as the value of the expression
• Consequences:
• the function will be installed as the method for new AA of BB. It will be stored under the key (NewOfMethod,AA,BB) in the younger of the hash tables AA and BB.

This operation turns out to be needed infrequently, because there is no from-clause to provide data for initializing the instance of A.

 i11 : new Type of BasicList := (type,array) -> ( stderr << "--new " << type << " of " << array << " being made" << endl; new MutableHashTable) o11 = -*Function[stdio:11:39-14:25]*- o11 : FunctionClosure

## new-of

• Usage:
new A of B
• Inputs:
• A,
• B,
• Outputs:
• the new object of class A and parent B described above
• Consequences:
• the function previously installed as the method for new A of B will be called with arguments (A,B).
• if no such method has been installed, then ancestors of A and B will be consulted, searching lexicographically for a method; see inheritance.
• the value returned by the function will have its class set to A and its parent set to B; see newClass.
• if no method is found by searching the ancestors, then a new empty instance of A with parent B will be created

We illustrate this operation by making a new type of basic list, and then by making a list of that type.

 i12 : M = new Type of BasicList --new Type of BasicList being made o12 = M o12 : Type i13 : m = new M from {3,4,5} o13 = M{3, 4, 5} o13 : M i14 : class m o14 = M o14 : Type i15 : m#1 o15 = 4

Now let's define a method for reversing the elements of a list of class M, using the unary operator -.

 i16 : - M := reverse o16 = reverse o16 : CompiledFunction i17 : - m o17 = M{5, 4, 3} o17 : M

## installing a new method for new-from

• Usage:
new AA from C := (A,c) -> ...
• Inputs:
• AA,
• C, a type
• (A,c) -> ..., a function of 2 arguments: AA will be an ancestor of A, and C will be an ancestor of the class of c. Alternatively, A will be a type of AA and c will be an instance of C.
• Outputs:
• the function is returned as the value of the expression
• Consequences:
• the function will be installed as the method for new AA from C. It will be stored under the key (NewFromMethod,AA,C) in the younger of the hash tables AA and C.

Let's use the class M defined above, and introduce a method for creating lists of class M from integers. Then we use it in the subsection below.

 i18 : new M from ZZ := (M',i) -> 0 .. i o18 = -*Function[stdio:21:25-21:33]*- o18 : FunctionClosure

## new-from

• Usage:
new A from c
• Inputs:
• A,
• c, an instance of C
• Outputs:
• the new object of class A initialized from c described above
• Consequences:
• the function previously installed as the method for new A from C will be called with arguments (A,c).
• if no such method has been installed, then ancestors of A and C, will be consulted, searching lexicographically for a method; see inheritance.
• if no method is found by searching the ancestors, then the function (A,c) -> c will be used
• the value returned by the function, (or c, if no method was found), will have its class set to A and its parent retained; see newClass

We use the new-from method for new M from ZZ installed above.

 i19 : n = new M from 13 o19 = M{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} o19 : M i20 : - n o20 = M{13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0} o20 : M

## installing a new method for new

• Usage:
new AA := (A) -> ...
• Inputs:
• AA,
• (A) -> ..., a function of 1 argument: AA will be an ancestor of A. Alternatively, A will be a type of AA.
• Outputs:
• the function is returned as the value of the expression
• Consequences:
• the function will be installed as the method for new AA. It will be stored under the key NewMethod in the hash table AA.

We use the class M introduced above, and install a method for new M, and we use it in the next subsection.

 i21 : new M := (M') -> {"a","b","c"} o21 = -*Function[stdio:24:15-24:15]*- o21 : FunctionClosure

## new

• Usage:
new A
• Inputs:
• A,
• Outputs:
• the new object of class A described above
• Consequences:
• the function previously installed as the method for new A will be called with argument A.
• if no such method has been installed, then ancestors of A will be consulted, searching for a method; see inheritance.
• the value returned by the function will have its class set to A; see newClass
• if no method is found by searching the ancestors, then a new empty instance of A will be created, if possible

We use the method for new M installed above.

 i22 : new M o22 = M{a, b, c} o22 : M

## For the programmer

The object new is .