Deepcopy: Difference between revisions

=={{header|6502 Assembly}}==

Deep copying is very simple on the 6502 - just load a value from memory and store it somewhere else.

 

Now, anything you do to the byte at <tt>$00</tt> won't affect the byte at <tt>$20</tt>.

STA $20 ;store it at memory address $20

INC $00 ;add 1 to the original

CMP $00 ;compare the copy to the original (we could have done LDA $20 first but they're the same value so why bother)

 

There is no built-in <code>memcpy()</code> function but it doesn't take much effort to create one. This version can copy up to 256 bytes of memory:

;$00,$01 = pointer to source

;$07,$08 = pointer to destination

dex

bne memcpy_again

 

 

=={{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

=={{header|Arturo}}==

 

name: "John"

surname: "Doe"

 

print ["Name of first person:" x\name]

 

{{out}}

{{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|AWK}}==

AWK's only data structure is the associative array, and it doesn't allow nested associative arrays (POSIX). Thus:

for (elem in original)

copied[elem] = original[elem]

 

=={{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

 

=={{header|C}}==

===Structures without pointers===

Structures without pointers can be copied like ''standard'' C variables such as int, float, char etc. The level of nesting is irrelevant. As the following implementation shows, a simple assignment is enough :

#include<stdio.h>

 

return 0;

}

Output:

<pre>

===Structures with pointers===

Structures with pointers which are usually used to represent data structures such as Linked lists, Stacks, Trees, Graphs etc. have to be copied element by element. A simple assignment as in the above example will not be a copy at all. It will be two pointers pointing towards the same memory location.

#include<stdlib.h>

#include<stdio.h>

return 0;

}

Output:

<pre>

 

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

 

namespace prog

}

}

 

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

any pointers.

 

#include <array>

#include <iostream>

std::cout << mapCopy[3][0][1] << "\n";

std::cout << mapCopy[7][1][2] << "\n";

{{out}}

<pre>the original values:

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 ] }

=={{header|Delphi}}==

{{libheader| System.TypInfo}}

program DeepCopyApp;

 

Writeln(b.value4);

readln;

{{out}}

<pre>Value of "a":

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.)

It's possible to create deep copies with <code>[ clone ] deep-map</code>, though this suffers from the limitation that it will hang indefinitely on circularities. We can even do this with tuples, since named tuples allow tuples to be treated like arrays. The following is a demonstration of deep copying an object in this manner.

{{works with|Factor|0.99 2019-10-06}}

sequences sequences.deep ;

 

 

! print them both again

{{out}}

<pre>

 

Another way to make deep copies is by serializing an object to a byte array and then deserializing it back to an object. This has the advantage of preserving circularities, but it doesn't work on non-serializable objects (such as continuations).

V{ 1 2 3 } V{ 4 5 6 } [ clone ] bi@ foo boa

 

[ -99 suffix! ] change-bar

 

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|PureBasic}}

Type DeepCopy

value1 As Integer

End With

Sleep

{{out}}

<pre>

 

'''Heterogeneous:'''

 

import "fmt"

fmt.Println(c1) // show changes

fmt.Println(c2) // show copy unaffected

Output:

<pre>

 

DIY here requires you to code a traversal algorithm.

 

import "fmt"

fmt.Println("original:")

c.list()

{{out}}

<pre>

 

If you still want a generalized deep copy, one can be cobbled with an os.Pipe and the gob package, which does type safe serialization. The deepcopy function shown below works on arbitrary data with a few limitations. It handles data types with recursive or cyclic definitions, but does not handle cycles in the data itself. For example, it handles a linked list, but not a ring data structure. Another limitation is that struct fields must be exported. (That is, fields must start with an upper case letter. This makes the field visible outside the package.)

 

import (

// show that copy is unaffected

fmt.Println(l2)

Output:

<pre>

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}}

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.

 

Copy constructor, object serialization, and object clone are demonstrated below.

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

}

}

 

{{out}}

=={{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}}==

 

=={{header|Julia}}==

 

 

=={{header|Kotlin}}==

 

The serialization approach is used below.

 

import java.io.Serializable

p3 = deepCopy(p1)

printDetails(p1, null, p3!!, null)

 

{{out}}

Every Lasso type has an ascopy and ascopydeep method.

 

 

=={{header|Lingo}}==

on deepcopy (var, cycleCheck)

case ilk(var) of

return var

end case

put deepcopy(val)

-- [#foo: 42, "bar": [1, 2, 3, "Hello world!"]]

val.foo = 42

val.bar = [1, 2, 3, "Hello world!"]]

 

=={{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}}==

Works with Nim 1.4.0:

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|OxygenBasic}}==

'DEEP COPY FOR A RECURSIVE TREE STRUCTURE

 

del bc

del br

 

 

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);

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

Handled natively. Phix uses reference counting with copy-on-write semantics; the initial copy is fast even for huge complex and deeply nested structures (copying a single machine-word-sized reference and incrementing a single machine-word-sized reference count), and when a shared object (anything with a refcount>1) is modified, an internal clone of the minimum necessary levels occurs, with all the rest of the structure remaining shared, but obviously still properly protected in the same way.

<span style="color: #004080;">object</span> <span style="color: #000000;">a<span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span>

<span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #000000;">2<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">}<span style="color: #0000FF;">,<span style="color: #008000;">"four"<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #000000;">5.6<span style="color: #0000FF;">,<span style="color: #000000;">7<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #000000;">8.9<span style="color: #0000FF;">}<span style="color: #0000FF;">}<span style="color: #0000FF;">}</span>

<span style="color: #0000FF;">?<span style="color: #000000;">a</span>

<span style="color: #0000FF;">?<span style="color: #000000;">b

{{out}}

<pre>

 

However, JavaScript has pass-by-sharing semantics, and since 1.0.0 when pwa/p2js (the Phix to JavaScript transpiler) was introduced, a simple "with js" (which works identically to "with javascript_semantics") effectively disables '''both''' underlying semantic mechanisms simultaneously, and causes desktop/Phix to raise fatal runtime errors ("p2js violation: relies on copy on write semantics") indicating where a deep_copy() is needed, which is now a builtin (see builtins\repeat.e for the actual) and is a bit like this:

<span style="color: #008080;">function</span> <span style="color: #000000;">deep_copy<span style="color: #0000FF;">(<span style="color: #004080;">object</span> <span style="color: #000000;">o<span style="color: #0000FF;">)</span>

<span style="color: #004080;">object</span> <span style="color: #000000;">res</span>

<span style="color: #004080;">object</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">deep_copy<span style="color: #0000FF;">(<span style="color: #000000;">b<span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?<span style="color: #000000;">c

It is worth pointing out that "with js" and deep_copy() have proved ''staggeringly'' effective and nowhere near as painful as first feared. In just a few months (1.0.0 was released in July 2021) I have tested, fixed where necessary, and marked as javascript compatible ''[https://www.rosettacode.org/mw/index.php?title=Special%3ASearch&search=phixonline some 450 rosettacode entries]'' for Phix, and only ''[https://www.rosettacode.org/mw/index.php?title=Special%3ASearch&search=notonline one tenth]'' of that as incompatible.

 

Or you ''could'' just serialize and deserialize, though it would probably be quite a bit slower:

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins<span style="color: #0000FF;">\<span style="color: #000000;">serialize<span style="color: #0000FF;">.<span style="color: #000000;">e</span>

<span style="color: #004080;">object</span> <span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">deserialize<span style="color: #0000FF;">(<span style="color: #000000;">serialize<span style="color: #0000FF;">(<span style="color: #000000;">a<span style="color: #0000FF;">)<span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?<span style="color: #000000;">d

{{out}}

<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|PureBasic}}==

PrintN(Str(StrucVal#\value1))

PrintN(Chr(StrucVal#\value2))

PrintN("Value of 'b':") : PrintStruc(b)

Input()

{{out}}<pre>Value of 'a':

20

 

=={{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:

* Descends only into <tt>Iterable</tt> collections (like <tt>Array</tt>/<tt>Hash</tt>), which means that a <tt>Pair</tt> or a typical custom object would be considered a leaf node.

 

my %y = %x.deepmap(*.clone);

 

%x<bar>[1]++;

say %x;

 

{{out}}

* Doesn't work correctly if the data structure contains elements that can't be properly serialized, such as closures or file handles.

 

my %y = %x.raku.EVAL;

 

%x<bar>[1]++;

say %x;

 

{{out}}

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.

This is what the <code>Clone</code> trait exists for although the depth of the copy is arbitrary and up to the type that implements the trait.

 

#[derive(Clone)]

struct Tree<T> {

 

let newtree = tree.clone();

 

=={{header|Scheme}}==

(define (deep-copy-1 exp)

;; basic version that copies an arbitrary tree made up of pairs

;> (deep-copy-2 t4)

;(#0=(#0#) #1=(#1#))

 

=={{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:

 

=={{header|Wren}}==

 

In the following example, we attempt to deep-copy a custom type, MyMap, which wraps the built-in generic Map type. This succeeds here because of the types of values used but wouldn't succeed if a Map value were, say, some user-defined type which didn't have a clone() method.

import "/seq" for Lst

 

System.print("\nAfter changes to my2:")

System.print(" my = %(my)")

 

{{out}}

=={{header|Z80 Assembly}}==

There is no built-in type checking, so there's no way to tell apart pointers from actual data without knowing it in advance. Other than that, a deep copy is very easy to perform. A single byte or word can be copied by loading it from memory and writing it to a new location.

 

For copying a string or record, the <code>LDIR</code> command makes this very easy, provided you know the size (in bytes) of the data you wish to copy. Label arithmetic is the easiest way to do this for fixed-size data.

 

LD DE,UserRam

LD BC,MyString_End-MyString ;the difference between these two addresses is the byte count.

 

UserRam: