เมธอด __copyinit__

When a value is copied, Mojo calls a special method named __copyinit__. It builds a fresh instance from an existing one. 📋

Every time a copy happens, like plain assignment, __copyinit__ fires. It is the hook that defines what copying your type means.

It takes the new instance to fill and a read-only existing value to copy from. You set each field on the new one.

Inside __copyinit__ your job is to give the new instance valid values for all of its fields, usually mirrored from existing.

For heap data you decide: copy the pointer, or allocate and clone the buffer. A true deep copy gives full independence.

A correct __copyinit__ ensures the copy owns its own data. Then editing the copy never reaches back and changes the original.

You rarely write it by hand. Marking a type Copyable lets Mojo synthesize a field-by-field __copyinit__ automatically.

Hand-write __copyinit__ only when the default is wrong, like when you manage a raw buffer that needs cloning.

This method is literally what makes your type copyable. Without it, Mojo cannot duplicate your value on assignment.

A good __copyinit__ is correct first and lean second. Copy only what you must so duplication stays affordable.

Together with moves, __copyinit__ gives Mojo its predictable value semantics. You control exactly how data is duplicated.

Lets check the copy initializer.

__copyinit__ defines how your type copies itself, building an independent instance. Mojo often derives it, but you can customize it. 🎯