Deepcopy: Difference between revisions

* Suitable links to external documentation for common libraries.

<br><br>

 

=={{header|Aime}}==

 

# Lists are heterogeneous:

o_text(l_query(l_query(L2, 2), 1));

o_text(l_query(l_query(L1, 2), 1));

{{out}}

<pre>deepcopy

deepcopy</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey L}}

http://www.autohotkey.com/board/topic/85201-array-deep-copy-treeview-viewer-and-more/

{

If !Objs

: DeepCopy(Val,Objs) ; Otherwise, clone this sub-array

Return Obj

 

=={{header|Babel}}==

Here is an example of shallow-copy - modifying one object modifies both because they are really just references to one underlying object:

 

---TOS---

[val 0x7 0x2 0x3 ]

[val 0x7 0x2 0x3 ]

 

Deep-copy is proved by the ability to separately modify two objects:

 

---TOS---

[val 0x7 0x2 0x3 ]

[val 0x1 0x2 0x3 ]

 

You can deep-copy any pure-Babel object with cp. Here is a list-of-lists, we copy it using cp:

 

babel> {lsnum !} each

( 1 2 )

( 3 4 )

 

Here is a list-of-maps, we copy it using cp:

 

babel> 2 ith "bar" lumap ! itod say !

 

Here is Babel code, we copy it using cp:

 

babel> eval

 

 

namespace prog

}

}

 

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

For instance <code>#42=(a b)</code> denotes the list <code>(a b)</code> and furthermore, it associates it with the number 42. Then, later in the same form, #42# denotes an additional occurence of the same <code>(a b)</code> object. So for instance, a cons cell whose <code>car</code> is 1, and whose <code>cdr</code> points back to that cons cell is written <code>#1=(1 . #1#)</code>.

 

[1]> (setf *print-circle* t)

T

#1=(1 . #1#)

[3]> (read-from-string "#1=(1 . #1#)") ;; read it from a string

 

=={{header|Déjà Vu}}==

 

(copy-action)!list obj cache:

 

!. C

{{out}}

<pre>{ :foo [ "bar" ] [ ] [ & 1 2 & 3 4 ] }

[ [ [ [ [...] 7 ] 7 ] 7 ] 7 ]

[ [ [ [ [...] ] ] ] ]</pre>

 

=={{header|E}}==

In E, serialization is generalized to transforming object graphs from one representation to another. Deep copying, therefore, consists of transforming a live object graph into a live object graph, by connecting <code>deSubgraphKit</code>'s output to its input. No intermediate serialized form is needed.

 

def deepcopy(x) {

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

 

As befits a serialization system, this deep copy may operate on any serializable structure, whether standard or user-defined, and the structure may contain cycles.

 

# value: ["a" => 1, "b" => [<***CYCLE***>].diverge()]

 

 

? x["b"][0] == x

 

(<code>.diverge()</code> produces mutable data structures, and <code>&lt;***CYCLE***></code> is what is printed when printing some object meets itself again.)

 

=={{header|Erlang}}==

{{out}}

<pre>

</pre>

 

=={{header|Go}}==

Go does not have direct support for deep copy. To make deep copies of specific data structures, it is most efficient to write your own copy function and just copy what needs to be copied.

 

import "fmt"

fmt.Println(c1) // show changes

fmt.Println(c2) // show copy unaffected

Output:

<pre>

&{1 one [117 110 105 116] map[1:true]}

</pre>

 

import (

// show that copy is unaffected

fmt.Println(l2)

Output:

<pre>

(a b)

</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

The code requires modification to run under Icon as Unicon extended key(X) to operate on lists and records not just tables.

 

local k

 

}

return .cache[A]

 

The following code demonstrates deepcopy usage and that the resulting structure is different from the original by comparing assignment, copy, and deepcopy.

 

 

procedure main()

procedure showequiv(x,y) #: show (non-)equivalence of two values

return printf(" %i %s %i\n",x,if x === y then "===" else "~===",y)

 

{{libheader|Unicon Code Library}}

L11[7] := R_Class1__state_2

...</pre>

 

=={{header|J}}==

J uses pass by value semantics (typically implemented as copy on write) so Deepcopy is trivial -- values inside the language are immutable.

 

b=: 3 (2)} b NB. modify one of the arrays

b

2 2 3 2 2

a

 

That said, J can reference values outside the language. But Deepcopy of those values is, by definition, outside the scope of the language. Usually, bringing the values into the language is sufficient.

 

Another possible exception would be classes and objects (which are not values but collections of references to values). But as a general rule copying of an object should be delegated to the object itself rather than imposed from the outside. Also, "deepcopy" violates the Law of Demeter as well as the concept of black-box reuse -- if you need deepcopy in J, you probably should not be representing your data structure as objects.

 

=={{header|JavaScript}}==

You can use JSON for ordinary objects.

var deepcopy = function(o){

return JSON.parse(JSON.stringify(src));

var dst = deepcopy(src);

print(JSON.stringify(src));

You can go further if you have <code>uneval()</code>. You can even deep copy objects with cyclic references.

var deepcopy = function(o){

return eval(uneval(o));

var dst = deepcopy(src);

print(uneval(src));

=={{header|jq}}==

The distinction between "deep" and "shallow" copying is as irrelevant in a jq program as in elementary arithmetic. There is only one "equality" operator in jq and it is defined in terms of equality of values.

 

merely emits [[1,2], 2].

 

=={{header|Lasso}}==

Every Lasso type has an ascopy and ascopydeep method.

 

 

=={{header|Lingo}}==

case ilk(var) of

#list, #propList, #image:

return var.duplicate()

#instance:

copy = var.script.rawNew()

repeat with i = 1 to var.count

end repeat

return copy

return var

end case

 

=={{header|Lua}}==

===Recursive===

 

if type(o) ~= 'table' then

function deepcopy(o)

return _deepcopy(o, {})

 

{{out}}

====Breadth-first====

 

 

if type(o) ~= 'table' then

 

return new_t

 

<pre>> q = {}

is copied. Then, the context is restored and copying of the parent table continues.

 

 

if type(o) ~= 'table' then

 

return tables[o] -- return the copy corresponding to the root table `o`

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Everything in Mathematica is a value type.

"deep" -> {# +

1 &, {{"Mathematica"}, {{"is"}, {"a"}}, {{{"cool"}}}, \

a[[3, 1, 1, 1]] = #^2 &;

Print[a];

{{out}}

<pre>{foo, -3 + π, {<|deep -> {#1^2 &, {{Mathematica}, {{is}, {a}}, {{{cool}}}, {{programming}, {language!}}}}|>}}

 

=={{header|Nim}}==

For example with binary trees:

Node[T] = ref TNode[T]

TNode[T] = object

 

echo "Tree:"

Output:

<pre>Tree2:

This code is just provided in order to achieve this task, but an OCaml programmer wouldn't use this kind of code, because this <code>copy</code> function is made generic due to the use of the [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Obj.html <code>Obj</code>] module, and it is not recommanded to use it.

 

if Obj.is_int t then t else

let tag = Obj.tag t in

end else failwith "copy" ;;

 

 

OCaml programmers will prefer to use specialised copy functions for each mutable types. For base types like strings and arrays, the standard library provides copy functions: <code>String.copy</code> and <code>Array.copy</code>. For mutable user-defined data structures, we will create a copy function based on these previous copy functions. For example in the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Hashtbl.html <code>Hashtbl</code>], the type is a record containing an integer and an array, so the copy function is defined as below:

{ size = h.size;

 

=={{header|PARI/GP}}==

In PARI, this is accomplished with the command <code>gcopy</code> rather than <code>shallowcopy</code> or <code>leafcopy</code>. The function takes and returns a <code>GEN</code>. See section 10.6 of the [http://pari.math.u-bordeaux.fr/pub/pari/manuals/2.5.0/libpari.pdf User's Guide to the PARI Library].

 

 

use [http://search.cpan.org/perldoc?Storable Storable]; <code>Storable::dclone()</code> is exactly what you are looking for.

 

#!/usr/bin/perl

use strict;

print Dumper($src);

print Dumper($dst);

 

{{out}}

<pre>

</pre>

 

 

{{out}}

<pre>

</pre>

 

 

PHP provides the <code>clone</code> operator ([http://www.php.net/manual/en/language.oop5.cloning.php docs]) for shallow copying, and allows you to hook into a magic class method called <code>__clone()</code> in your classes to do some of the lifting to create deeper copies, but this method won't create a true deep copy if you don't write the code to manage it in each of the child classes.

 

class Foo

{

echo "Object contains {$object->some_value}, child contains {$object->child->some_value}\n",

"Clone of object contains {$deepcopy->some_value}, child contains {$deepcopy->child->some_value}\n";

 

 

Automatically generated deep copies can be created in any situation where your object graph can be serialized (i.e. does not contain any Closures or resources like DB connections or file handles):

 

 

// stdClass is a default PHP object

 

echo "Object contains {$object->some_value}, child contains {$object->child->some_value}\n",

 

=={{header|PicoLisp}}==

 

For a known depth, it might be used in combination with other list functions. For example, to copy a non-cyclic structure of depth 2 with '[http://software-lab.de/doc/refM.html#mapcar mapcar]':

Copying non-cyclic structures of arbitrary depth and list-termination could be handled with a custom function (using '[http://software-lab.de/doc/refC.html#cons cons]'):

(if (atom X)

X

Test:

-> ((a . b) (c d e) f g . e)

 

 

: (== (cadr A) (cadr B))

For cyclic structures, the above 'deepCopy' function could be extended, to remember already visited structures and their copies in a mark list:

(let Mark NIL

(recur (X)

(push 'Mark (cons X @))

(set @ (recurse (car X)))

Test:

-> (a b .)

: A

 

: (== A B)

 

=={{header|Python}}==

 

=={{header|Racket}}==

to get a new copy:

 

#lang racket

 

(printf "both: ~s\n" (list x (deepcopy x)))))

(try (shared ([x (cons 1 x)]) (list x x)))

 

Output:

deepcopy: (#0=(1 . #0#) #0#)

both: ((#0=(1 . #0#) #0#) (#1=(1 . #1#) #1#))

</pre>

 

Rubyists can hack a deep copy by using the core class Marshal. The intermediate form of <code>Marshal.load(Marshal.dump object)</code> saves the object and any descendant objects.

 

orig = { :num => 1, :ary => [2, 3] }

orig[:cycle] = orig # _orig_ also contains itself.

p [(orig.equal? orig[:cycle]),

(copy.equal? copy[:cycle]),

 

Marshal cannot dump an object that relates to the system (like Dir or IO), relates to the program (like MatchData or Thread), uses an anonymous class or module, or has a singleton method. (<code>ri Marshal.dump</code> documents this restriction.) If Marshal encounters any such object, then the deep copy fails.

 

Marshal can dump internal objects, but never copies them. The internal objects are <code>nil</code>, <code>false</code>, <code>true</code> and instances of Fixnum or Symbol. For example, <code>Marshal.load(Marshal.dump :sym)</code> returns the original <code>:sym</code>, not a copy. <blockquote style="font-size: smaller;">The internal objects are almost immutable, so there is almost no reason to copy them. Yet, there are esoteric ways to modify them. For example, <code>nil.instance_eval { @i = 1 }</code> would modify <code>nil</code>. A program cannot have another copy of <code>nil</code> to escape such modification. If there was a deep copy of some object that contains <code>nil</code>, then such modification would also affect <code>nil</code> inside such copy.</blockquote>

 

=={{header|Sidef}}==

''Object.dclone()'' returns a deep clone of any mutable object.

 

# Add a cyclic reference

# The address of dst

say dst.object_id

{{out}}

<pre>

=={{header|Tcl}}==

Tcl uses an immutable value model that is implemented as copy-on-write at the low level, so deep copies are generally not required. However, they can be achieved by simply appending a letter to the value and stripping it off again:

For objects (as introduced in Tcl 8.6), there is a command to create a copy:

 

{{omit from|Haskell}}

{{omit from|GUISS}}

{{omit from|PureBasic}}