.. _comptime-struct-migration:

Migrating from ``comptime_struct`` and ``@concat_structs``
==========================================================

.. note::

   The ``comptime_struct`` type and the ``@concat_structs`` builtin were removed in
   SDK 2.10.0 (see :ref:`v2-10-0`). This guide explains how to migrate existing code
   to use named ``struct`` types instead.

For a full reference on struct types in CSL, see :ref:`language-types`.

Replacing ``comptime_struct`` with ``struct``
---------------------------------------------

As a consequence of the removal of ``comptime_struct``, ``@concat_structs`` can
no longer be used.

**Before (removed):**

.. code-block:: csl

    // Error: `comptime_struct` is no longer supported in CSL
    const structA: comptime_struct;
    const structB: comptime_struct;
    const structC = @concat_structs(structA, structB);

**After:**

CSL now requires ``struct`` types to be declared explicitly. These can be used at both
compile time and runtime. The following code serves the equivalent function to the
above example:

.. code-block:: csl

    const structA = struct {...};
    const structB = struct {...};

    const structC = struct {
       a: structA,
       b: structB,
    };

Partial initialization
----------------------

Another key difference between ``comptime_struct`` and ``struct`` is that
all fields must be declared and set. No partial initialization can be done,
sometimes requiring the use of temporary placeholders.

**Before (removed):**

.. code-block:: csl

    var mystruct: comptime_struct = .{ .foo = true };
    mystruct = @concat_struct(mystruct, .{ .bar = 42 });

**After:**

.. code-block:: csl

    const mystruct_t = struct {
        foo: bool,
        bar: u16,
    };
    var mystruct: mystruct_t = .{
        .foo = true,
        .bar = 0, // Temporary placeholder value
    };
    mystruct.bar = 42;

Parameterized structs
---------------------

Sometimes, the members of a given ``struct`` need to vary based on compile-time
parameters or constants. This can be achieved by writing a comptime function that
returns a ``type``. The returned type is a ``struct`` whose fields depend on the
arguments passed to the function.

For example, a function that returns a point type whose coordinate type depends
on the scale type requested:

.. code-block:: csl

    // Functions returning a type must have comptime arguments only.
    fn point_type(comptime scalar_type: type) type {
        return struct {
            x: scalar_type,
            y: scalar_type,
        };
    }

    fn make_point(x_val: anytype) point_type(@type_of(x_val)) {
        return .{ .x = x_val, .y = 0 };
    }

See also the :ref:`parameterized struct types example <parameterized-struct-types-example>`
in the Language Guide for additional patterns.