Polymorphic copy: Difference between revisions

 

It is trivial to copy an object if its type is known:

Here x is not polymorphic, so y is declared of same type (''int'') as x.

But if the specific type of x were unknown, then y could not be declared of any specific type.

 

=={{header|Ada}}==

 

procedure Test_Polymorphic_Copy is

Put_Line ("Cloned " & Object_3.all.Name);

Put_Line ("Cloned " & Object_4.all.Name);

The procedure Copier does not know the specific type of its argument.

Nevertheless it creates an object Duplicate of exactly same type.

=={{header|Aikido}}==

Aikido has a native <code>clone</code> function that creates a (deep or shallow) clone of any variable of any type.

class T {

public function print {

scopy.print()

 

{{out}}

before copy

that are procedures. The following shows how the task can be accomplished by using structre instances with

different values of the procedures.

# Algol 68 doesn't have classes and inheritence as such, however structures #

# can contain procedures and different instances of a structure can have #

PRINT z1; print( ( newline ) );

PRINT z2; print( ( newline ) )

{{out}}

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

REM Create parent class T:

result% = FN(mycopy.retval)(RunTimeSize%)

PRINT result%

{{out}}

<pre>

The code in "main" would also be a separate source file which would include Dog.h and Ferret.h header files (which would thems elves include the BaseObj.h header file.)

A better example of object oriented support in 'C' can be found in the source for the XtIntrinsics library of X11.

#include <stdlib.h>

#include <string.h>

ObjDestroy(o1);

return 0;

 

=={{header|C sharp|C#}}==

 

class T

Console.WriteLine(clone.Name());

}

{{out}}

 

=={{header|C++}}==

 

class T

X copy = original; // copy it,

copy.identify_member(); // and check what type of member it contains

 

=={{header|Common Lisp}}==

With structures, <code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_cp_stu.htm copy-structure]</code> performs the right kind of copy. The object and its copy are compared under <code>eq</code>, <code>eql</code>, <code>equal</code>, and <code>equalp</code> to demonstrate that "The objective is to create an exact copy of such polymorphic object (not to create a reference, nor a pointer to)."

 

 

(defstruct (sub (:include super)) bar)

(defmethod frob ((sub sub))

(format t "~&Sub has foo = ~w, bar = ~w."

 

<pre>> (let* ((sub1 (make-sub :foo 'foo :bar 'bar))

The same technique works for <code>[http://www.lispworks.com/documentation/HyperSpec/Body/t_seq.htm sequence]</code> and its subclasses (e.g., <code>[http://www.lispworks.com/documentation/HyperSpec/Body/t_string.htm string]</code>, <code>[http://www.lispworks.com/documentation/HyperSpec/Body/t_seq.htm list]</code>) when <code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_cp_seq.htm copy-seq]</code> is used rather than <code>copy-structure</code>.

 

(format t "~&sequence has ~w elements" (length sequence)))

 

(defmethod frob ((string string))

 

<pre>> (let* ((hw1 "hello world")

 

If we assume there are no data members, this will be quite short and simple:

override string toString() { return "I'm the instance of T"; }

T duplicate() { return new T; }

writeln(orig);

writeln(copy);

{{out}}

<pre>I'm the instance of S

However this doesn't happen often in reality. If we want to copy data fields we should have something like copy constructor, that will

do the deep copy.

this(T t = null) {} // Constructor that will be used for copying.

 

orig.writeln;

copy.writeln; // Should have 'X' at the beginning.

{{out}}

<pre>I'm the instance of S p: Y23

=={{header|Delphi}}==

{{trans|C#}}

 

type

begin

Main;

{{out}}

 

=={{header|E}}==

In E, a generic copy for all objects can be built out of the serialization facility, by connecting an object recognizer to an object builder without even using any intermediate serialized form:

 

 

def copy(object) {

return deSubgraphKit.recognize(object, deSubgraphKit.makeBuilder())

 

Since E does not have any static dispatch, this cannot be non-polymorphic without also being non-generic.

An example showing that it does indeed make copies follows. (For the task description, let <var>S</var> be the type of all serializable E objects, <var>T</var> be the <code>[http://wiki.erights.org/wiki/FlexList FlexList]</code> type (result of <code>diverge</code>), and the overriden method be <code> [http://wiki.erights.org/wiki/FlexList#push/1 push]</code>.

 

# value: [1].diverge()

 

 

? b

 

See also: [[Deepcopy#E]]

 

=={{header|EchoLisp}}==

(lib 'types)

(lib 'struct)

(K "string-inside") ;; trying to put a string in the container box

😡 error: T : type-check failure : string-inside → 'K:box'

 

=={{header|Elena}}==

ELENA 4.x :

class T

console.printLine(original.Name);

console.printLine(clone.Name)

{{out}}

<pre>

.NET objects have a protected method <code>MemberwiseClone</code>. This method creates a shallow copy of an object. Value type members are copied, i.e. not shared between clones. Reference type members, on the other hand, will reference the same objects after cloning.

 

// expose protected MemberwiseClone method (and downcast the result)

member x.Clone() = x.MemberwiseClone() :?> T

let s = new S()

let s2 = s.Clone() // the static type of s2 is T, but it "points" to an S

 

=={{header|Factor}}==

 

Pasting the following in a repl:

TUPLE: A ;

TUPLE: C < A ;

C new

[ clone ]

{{out}}

C

{{trans|Aikido}}

There are numerous, mutually incompatible object oriented frameworks for Forth. This one works with the FOOS preprocessor extension of [[4tH]].

include 4pp/lib/foos.4pp

( a1 -- a2)

." after copy" cr

tcopy => print \ use "print" methods

 

 

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

 

:class T

 

obj-t print-container \ class is S

 

=={{header|Fortran}}==

Tested with GNU gfortran 5.2.1 and INTEL ifort 16.

!-----------------------------------------------------------------------

!Module polymorphic_copy_example_module

 

end program test

 

=={{header|Go}}==

You can see in the output that interface values of type r access t's identify method.

Values of type s would as well, except s has it's own identify method which takes precedence.

 

import (

fmt.Println("i2c:", i2c, "/", i2c.identify(), "/", reflect.TypeOf(i2c))

fmt.Println("i3c:", i3c, "/", i3c.identify(), "/", reflect.TypeOf(i3c))

{{out}}

<pre>

{{trans|Java}} (more or less)

Solution:

String property

String name() { 'T' }

class S extends T {

@Override String name() { 'S' }

 

Test:

S obj2 = new S(property: 'meh')

 

 

println "objA:: name: ${objA.name()}, property: ${objA.property}"

 

{{out}}

The deepcopy procedure is identical in both languages.

 

method a(); write("This is T's a"); end

end

}

return .cache[A]

 

Sample run:

If this pattern is followed, the calls will eventually pass all the way up to <code>Object</code>'s <code>clone()</code> method, which performs a polymorphic copy.

If you do not follow this pattern, and simply use a constructor, like <code>new T()</code>, then the copy won't be polymorphic.

public String name() { return "T"; }

public T copy() {

System.out.println(copier(obj2).name()); // prints "S"

}

 

=={{header|JavaScript}}==

Copied from [http://keithdevens.com/weblog/archive/2007/Jun/07/javascript.clone here]:

if (obj == null || typeof(obj) != 'object')

return obj;

temp[key] = clone(obj[key]);

return temp;

 

=={{header|Julia}}==

To perform as required in the exercise, mutable structs must be used to keep the deepcopy

procedure from being optimized away as a mere reference to the first struct.

abstract type Jewel end

 

 

testtypecopy()

a is a Jewel? true

b is a Jewel? true

 

=={{header|Kotlin}}==

 

open class Animal(val name: String, var age: Int) {

println("Dog 'b' = $b") // ditto

println("Dog 'a' is ${if (a === b) "" else "not"} the same object as Dog 'b'")

 

{{out}}

Dog 'a' is not the same object as Dog 'b'

</pre>

 

=={{header|MiniScript}}==

T.foo = function()

return "This is an instance of T"

copy.bar = 2

print "instance.bar: " + instance.bar

{{out}}

<pre>instance.foo: This is an S for sure

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref savelog symbols binary

 

method name returns String

return S.class.getSimpleName

 

=={{header|Nim}}==

T = ref object of RootObj

myValue: string

u.myValue = "Yellow"

u.speak

{{out}}

<pre>creating initial objects of types S1, S2, and T.

If your parent class already implements <code>NSCopying</code>, and you wish to customize the copying of your class's fields, then you should get a copy from your parent object's <code>copyWithZone:</code> method, and then perform custom initialization on the copy.

 

- (void)identify;

@end

}

return 0;

 

Analogously, there is a <code>mutableCopy</code> method to get a mutable copy of the current object (e.g. if you have an NSArray object and you want an NSMutableArray with the same contents).

=={{header|OCaml}}==

I decided not to use classes and inheritance here because structural subtyping is more natural in OCaml. Oo.copy is polymorphic over all object types.

object

method name = "T"

let () =

print_endline (Oo.copy obj1)#name; (* prints "T" *)

 

=={{header|ooRexx}}==

All ooRexx objects have a copy method inherited from the object class that performs a shallow copy of the object state.

s = .s~new

s2 = s~copy -- makes a copy of the first

::method name

return "S"

 

=={{header|OxygenBasic}}==

'======

class T

 

del objA : del objB

 

=={{header|Oz}}==

We need to derive from the class <code>ObjectSupport.reflect</code> in order to have a <code>clone</code> method.

class T from ObjectSupport.reflect

meth init

{Obj setA(13)}

{Copy setA(14)}

 

Oz is not a pure object-oriented language. In fact, most values are not objects.

 

=={{header|Perl}}==

sub new {

my $cls = shift;

$x->set_data('totally different');

print "\$x is: ";

 

=={{header|Phix}}==

 

For this demonstration (not that this really proves much), our types T and S (overkill really) are just going to contain a string name and a method (routine_id).

 

 

{{out}}

<pre>

Not recommended or formally supported, but these sort of low-level things are perfectly possible.<br>

Note the result from get_struct_fields() is not documented and liable to change between releases.<br>

 

 

{{out}}

<pre>

 

=={{header|PHP}}==

class T {

function name() { return "T"; }

echo $obj3->name(), "\n"; // prints "T"

echo $obj4->name(), "\n"; // prints "S"

 

=={{header|PicoLisp}}==

Any object can be copied by transferring the value and the property list.

If we create an object 'A':

-> $385603635

 

attr2 "def"

attr1 123

Then we can easily copy it to a new object 'B':

Inspecting 'B':

$385346595 (+Cls1 +Cls2)

attr1 123

attr3 (4 2 0)

attr4

 

=={{header|Python}}==

 

class T:

u.myValue = "Yellow"

u.speak()

{{out}}

<pre>

Under Python this would best be done with the ''pickle'' or ''cPickle'' standard modules.

 

 

source = {'a': [1, 2.0, 3, 4+6j],

'c': None}

 

 

In this example we use the ''cPickle'' module which is an implementation of the pickle features coded in C for optimal performance.

For the simplest cases one can use simple Python introspection to copy simple objects:

 

if hasattr(source, 'items') and callable(source.items):

for key,value in source.items:

target = source[:]

else: # Following is not recommended. (see below).

 

This example handles dictionaries (and anything that implements a sufficiently dictionary like interface to support the ''items()'' method along with the ''__setitem__()'' method. (statements of the form '''''x[y] = z''''' in Python are implicitly calling the ''__setitem__()'' method of the "x" object, passing it a key of "y" and a value of "z."

===Using prefab structures===

This method is useful only for prefab structures.

 

(define (copy-prefab-struct str)

[copied (copy-prefab-struct original)])

(displayln copied)

{{out}}

<pre>#s(struct:point 0 0)

 

It’s also possible to copy other structures using generics or structure-type-properties to implement a “magic”-like generic method.

 

(define (copy-struct str)

[copied (copy-struct original)])

(displayln copied)

{{out}}

<pre>#s(struct:point 0 0)

===Using classes===

There is no build-in clone method, so the class (or the interface) must implement it.

 

(define point%

(init-field color)

(define/override (clone) (new this% [x x] [y y] [color color]))

{{out}}

<pre>(#<class:point%> 0 0)

(formerly Perl 6)

{{works with|Rakudo|2020.08.1}}

my Cool $y = $x.clone;

{{out}}

<pre>I'm a cool Rat+{Fink}!</pre>

In the REXX language, every variable is a string &nbsp; (whether or not they contain characters or numerals).

<br>However, a variables' type (by REXX's definition) can be determined/inferred from it's attributes (datatypes).

b= 'old value.'

a= 123.45

if a==b then say "copy did work."

else say "copy didn't work." /*didn't work, maybe ran out of storage*/

Programming note: &nbsp; Most REXXes will raise a syntax error if an assignment (copy) fails, but it's not guaranteed to do so.<br><br>

 

All Ruby objects inherit two methods for copying themselves: "clone" and "dup".

I don't really understand the difference between them.

def name

"T"

obj2 = S.new

puts obj1.dup.name # prints "T"

 

=={{header|Scala}}==

 

def main(args: Array[String]) {

}

 

 

=={{header|Sidef}}==

''Object.dclone()'' makes a deep clone of any mutable object and returns it to the caller.

method display {

say value;

obj1.display; # prints "foo"

obj2.display; # prints "bar"

 

=={{header|Slate}}==

There is also a <tt>copy</tt> method which is universal and overridden to perform deep copies as appropriate - copying continues via recursion through slot values and should be modified on any type where equality (<tt>=</tt>) is overridden.

 

 

define: #S &parents: {Cloneable}.

 

obj1 printName.

 

=={{header|Swift}}==

required init() { } // constructor used in polymorphic initialization must be "required"

func identify() {

let another : T = original.copy()

println(original === another) // prints "false" (i.e. they are different objects)

 

=={{header|Tcl}}==

Tcl values are logically immutable, and are passed around by reference with copies being taken as and when it is necessary to do so to maintain the immutable model.

Hence an effective copy of any value is just:

With objects, slightly more work is required because they are normally passed around by name/reference.

<br>

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

method clone {{name {}}} {

# Make a bare, optionally named, copy of the object

$obj2 rename "Hocus Pocus"

$obj2 print

{{out}} (object names might vary if you run it):

<pre>

this is Abracadabra in ::oo::Obj5, stepped 2 times

</pre>

 

=={{header|Wren}}==

 

There is no built in 'copy' method - you need to write your own for any class that needs it.

construct new(name, age) {

_name = name

System.print("Dog 'a' -> %(a)") // implicitly calls a's toString method

System.print("Dog 'b' -> %(b)") // ditto

 

{{out}}