An object is polymorphic when its specific type may vary.
The types a specific value may take, is called class.

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

int x;
int y = x;
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.

The task: let a polymorphic object contain an instance of some specific type S derived from a type T.
The type T is known.
The type S is possibly unknown until run time.
The objective is to create an exact copy of such polymorphic object (not to create a reference, nor a pointer to).
Let further the type T have a method overridden by S.
This method is to be called on the copy to demonstrate that the specific type of the copy is indeed S.

 
(lib 'types)
(lib 'struct)
 
(struct T (integer:x)) ;; super class
(struct S T (integer:y)) ;; sub class
(struct K (T:box)) ;; container class, box must be of type T, or derived 
 
(define k-source (K (S 33 42)))
(define k-copy (copy k-source))
 
k-source
    → #<K> (#<S> (33 42)) ;; new container, with a S in box
k-copy
    → #<K> (#<S> (33 42)) ;; copied S type
 
(set-S-y! (K-box k-source) 666) ;; modify k-source.box.y
 
k-source
    → #<K> (#<S> (33 666)) ;; modified
k-copy
    → #<K> (#<S> (33 42))  ;; unmodified
 
(K "string-inside") ;; trying to put a string in the container box
😡 error: T : type-check failure : string-inside → 'K:box'
 