classiq 0.68.0__py3-none-any.whl → 0.69.0__py3-none-any.whl

classiq/model_expansions/scope_initialization.py

@@ -3,10 +3,6 @@ from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.expressions.expression_constants import (
-    CPARAM_EXECUTION_SUFFIX,
-    RESERVED_EXPRESSIONS,
-)
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
@@ -129,12 +125,6 @@ def init_builtin_types() -> None:
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
 
 
-def _rename_exec_param(param_name: str) -> str:
-    if param_name in RESERVED_EXPRESSIONS:
-        return param_name
-    return param_name + CPARAM_EXECUTION_SUFFIX
-
-
 def _add_exec_param_parts_to_scope(param_val: Any, scope: Scope) -> None:
     if not isinstance(param_val, list):
         scope[str(param_val)] = Evaluated(value=param_val)
@@ -145,21 +135,17 @@ def _add_exec_param_parts_to_scope(param_val: Any, scope: Scope) -> None:
 
 def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalType]:
     if model.execution_parameters is not None:
-        exec_params = {
-            param_name: (param_name, param_type)
-            for param_name, param_type in model.execution_parameters.items()
-        }
+        exec_params = model.execution_parameters
     else:
         exec_params = {
-            param.name: (_rename_exec_param(param.name), param.classical_type)
+            param.name: param.classical_type
             for param in model.function_dict.get(
                 "_dec_main", model.main_func
             ).param_decls
         }
-    for param_name, (param_rename, param_type) in exec_params.items():
-        param_val = param_type.as_symbolic(param_rename)
+    for param_name, param_type in exec_params.items():
+        param_val = param_type.as_symbolic(param_name)
         scope[param_name] = Evaluated(value=param_val)
-        scope[param_rename] = Evaluated(value=param_val)
         if isinstance(param_val, list):
             _add_exec_param_parts_to_scope(param_val, scope)
-    return dict(exec_params.values())
+    return exec_params

classiq/open_library/functions/amplitude_amplification.py

@@ -73,11 +73,9 @@ def exact_amplitude_amplification(
 
     extended_qvars: QArray = QArray()
     within_apply(
-        lambda: [  # type:ignore[arg-type]
+        lambda: [
             allocate(aux),
-            bind(
-                [aux, packed_qvars], extended_qvars
-            ),  # type:ignore[func-returns-value]
+            bind([aux, packed_qvars], extended_qvars),
         ],
         lambda: amplitude_amplification(
             k,
@@ -85,9 +83,7 @@ def exact_amplitude_amplification(
                 qvars_[0] == 0, lambda: oracle(qvars_[1 : qvars_.size])
             ),
             lambda qvars_: [
-                space_transform(  # type:ignore[func-returns-value]
-                    qvars_[1 : qvars_.size]
-                ),
+                space_transform(qvars_[1 : qvars_.size]),
                 RY(rot_phase, qvars_[0]),
             ],
             extended_qvars,

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -30,9 +30,9 @@ def _qct_d_operator(x: QNum, q: QBit) -> None:
 def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
     control(
         q == 1,
-        lambda: [  # type:ignore[arg-type]
+        lambda: [
             apply_to_all(X, x),
-            inplace_add(1, x),  # type:ignore[arg-type, func-returns-value]
+            inplace_add(1, x),  # type:ignore[arg-type]
         ],
     )
 
@@ -70,7 +70,7 @@ def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
 
 
 def _j_operator(q: QBit) -> None:
-    within_apply(lambda: Z(q), lambda: (S(q), H(q), S(q)))  # type:ignore[arg-type]
+    within_apply(lambda: Z(q), lambda: (S(q), H(q), S(q)))
 
 
 def _b_t_operator(q: QBit) -> None:
@@ -179,6 +179,6 @@ def qst_type2(x: QArray[QBit]) -> None:
     """
     q = QBit()
     within_apply(
-        lambda: (allocate(q), X(q)),  # type:ignore[arg-type]
+        lambda: (allocate(q), X(q)),
         lambda: qct_qst_type2(x, q),
     )

classiq/open_library/functions/grover.py

@@ -42,7 +42,7 @@ def phase_oracle(
     """
     aux = QBit()
     within_apply(
-        within=lambda: (allocate(aux), X(aux), H(aux)),  # type:ignore[arg-type]
+        within=lambda: (allocate(aux), X(aux), H(aux)),
         apply=lambda: predicate(target, aux),
     )
 
@@ -68,7 +68,7 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     lsb = QBit()
     bind(packed_vars, [msbs, lsb])
     within_apply(
-        lambda: (X(lsb), H(lsb)),  # type:ignore[arg-type]
+        lambda: (X(lsb), H(lsb)),
         lambda: control(msbs == 0, lambda: X(lsb)),
     )
     bind([msbs, lsb], packed_vars)

classiq/open_library/functions/hea.py

@@ -58,8 +58,8 @@ def full_hea(
     """
     repeat(
         reps,
-        lambda r: [  # type:ignore[arg-type]
-            repeat(  # type:ignore[func-returns-value]
+        lambda r: [
+            repeat(
                 operands_1qubit.len,
                 lambda i1: repeat(
                     num_qubits,
@@ -77,7 +77,7 @@ def full_hea(
                     ),
                 ),
             ),
-            repeat(  # type:ignore[func-returns-value]
+            repeat(
                 operands_2qubit.len,
                 lambda i2: repeat(
                     connectivity_map.len,

classiq/open_library/functions/modular_exponentiation.py

@@ -70,23 +70,17 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
     aux = QBit()
 
     within_apply(
-        lambda: (  # type:ignore[arg-type]
+        lambda: (
             allocate(aux),
-            bind([c1, c2], ctrl),  # type:ignore[func-returns-value]
+            bind([c1, c2], ctrl),
         ),
-        lambda: (  # type:ignore[arg-type]
-            control(  # type:ignore[func-returns-value]
-                ctrl, lambda: qft_space_add_const(a, phi_b)
-            ),
-            invert(  # type:ignore[func-returns-value]
-                lambda: qft_space_add_const(n, phi_b)
-            ),
+        lambda: (
+            control(ctrl, lambda: qft_space_add_const(a, phi_b)),
+            invert(lambda: qft_space_add_const(n, phi_b)),
             _check_msb(1, phi_b, aux),
-            control(  # type:ignore[func-returns-value]
-                aux, lambda: qft_space_add_const(n, phi_b)
-            ),
+            control(aux, lambda: qft_space_add_const(n, phi_b)),
             within_apply(
-                lambda: invert(  # type:ignore[func-returns-value]
+                lambda: invert(
                     lambda: control(ctrl, lambda: qft_space_add_const(a, phi_b))
                 ),
                 lambda: _check_msb(0, phi_b, aux),
@@ -160,14 +154,10 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
 
     within_apply(
         lambda: allocate(x.len + 1, b),
-        lambda: (  # type:ignore[arg-type]
+        lambda: (
             c_modular_multiply(n, a, b, x, ctrl),
-            control(  # type:ignore[func-returns-value]
-                ctrl, lambda: multiswap(x, b)
-            ),
-            invert(  # type:ignore[func-returns-value]
-                lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)
-            ),
+            control(ctrl, lambda: multiswap(x, b)),
+            invert(lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)),
         ),
     )
 

classiq/open_library/functions/qft_functions.py

@@ -18,9 +18,9 @@ def qft_no_swap(qbv: QArray[QBit]) -> None:
     """
     repeat(
         qbv.len,
-        lambda i: (  # type:ignore[arg-type]
+        lambda i: (
             H(qbv[i]),
-            repeat(  # type:ignore[func-returns-value]
+            repeat(
                 qbv.len - i - 1,
                 lambda j: CPHASE(
                     theta=pi / (2 ** (j + 1)),

classiq/open_library/functions/qsvt.py

@@ -97,8 +97,8 @@ def qsvt(
     if_(
         condition=phase_seq.len % 2 == 1,
         then=lambda: IDENTITY(qvar),
-        else_=lambda: (  # type:ignore[arg-type]
-            u(qvar),  # type:ignore[func-returns-value]
+        else_=lambda: (
+            u(qvar),
             projector_controlled_phase(
                 phase_seq[phase_seq.len - 1],
                 proj_cnot_2,
@@ -297,8 +297,8 @@ def qsvt_lcu(
         condition=phase_seq_odd.len > phase_seq_even.len,
         then=lambda: control(
             lcu == 0,
-            lambda: [  # type:ignore[arg-type]
-                u(qvar),  # type:ignore[func-returns-value]
+            lambda: [
+                u(qvar),
                 projector_controlled_phase(
                     phase_seq_odd[phase_seq_odd.len - 1], proj_cnot_2, qvar, aux
                 ),
@@ -307,8 +307,8 @@ def qsvt_lcu(
     )
     if_(
         condition=phase_seq_odd.len < phase_seq_even.len,
-        then=lambda: (  # type:ignore[arg-type]
-            u(qvar),  # type:ignore[func-returns-value]
+        then=lambda: (
+            u(qvar),
             projector_controlled_double_phase(
                 phase_seq_even[phase_seq_even.len - 1],
                 phase_seq_odd[phase_seq_odd.len - 1],
@@ -319,8 +319,8 @@ def qsvt_lcu(
             ),
             control(
                 lcu,
-                lambda: [  # type:ignore[arg-type]
-                    invert(lambda: u(qvar)),  # type:ignore[func-returns-value]
+                lambda: [
+                    invert(lambda: u(qvar)),
                     projector_controlled_phase(
                         phase_seq_even[phase_seq_even.len - 1], proj_cnot_1, qvar, aux
                     ),

classiq/open_library/functions/utility_functions.py

@@ -79,8 +79,8 @@ def modular_increment(a: CInt, x: QNum) -> None:
     )
     array_cast: QArray = QArray()
     within_apply(
-        lambda: (  # type:ignore[arg-type]
-            bind(x, array_cast),  # type:ignore[func-returns-value]
+        lambda: (
+            bind(x, array_cast),
             qft(array_cast),
         ),
         lambda: repeat(

classiq/qmod/builtins/classical_functions.py

@@ -12,19 +12,25 @@ def qft_const_adder_phase(
     value: CInt,
     reg_len: CInt,
 ) -> CReal:
-    return symbolic_function(bit_index, value, reg_len, return_type=CReal)
+    return symbolic_function(
+        bit_index, value, reg_len, return_type=CReal  # type:ignore[type-abstract]
+    )
 
 
 def fock_hamiltonian_problem_to_hamiltonian(
     problem: FockHamiltonianProblem,
 ) -> CArray[PauliTerm]:
-    return symbolic_function(problem, return_type=CArray[PauliTerm])
+    return symbolic_function(
+        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
+    )
 
 
 def molecule_problem_to_hamiltonian(
     problem: MoleculeProblem,
 ) -> CArray[PauliTerm]:
-    return symbolic_function(problem, return_type=CArray[PauliTerm])
+    return symbolic_function(
+        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
+    )
 
 
 def grid_entangler_graph(
@@ -33,14 +39,19 @@ def grid_entangler_graph(
     grid_randomization: CBool,
 ) -> CArray[CArray[CInt]]:
     return symbolic_function(
-        num_qubits, schmidt_rank, grid_randomization, return_type=CArray[CArray[CInt]]
+        num_qubits,
+        schmidt_rank,
+        grid_randomization,
+        return_type=CArray[CArray[CInt]],  # type:ignore[type-abstract]
     )
 
 
 def hypercube_entangler_graph(
     num_qubits: CInt,
 ) -> CArray[CArray[CInt]]:
-    return symbolic_function(num_qubits, return_type=CArray[CArray[CInt]])
+    return symbolic_function(
+        num_qubits, return_type=CArray[CArray[CInt]]  # type:ignore[type-abstract]
+    )
 
 
 def gaussian_finance_post_process(
@@ -49,7 +60,10 @@ def gaussian_finance_post_process(
     probability: CReal,
 ) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=CReal
+        finance_model,
+        estimation_method,
+        probability,
+        return_type=CReal,  # type:ignore[type-abstract]
     )
 
 
@@ -59,7 +73,10 @@ def log_normal_finance_post_process(
     probability: CReal,
 ) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=CReal
+        finance_model,
+        estimation_method,
+        probability,
+        return_type=CReal,  # type:ignore[type-abstract]
     )
 
 

classiq/qmod/builtins/enums.py

@@ -149,6 +149,7 @@ class Optimizer(IntEnum):
     L_BFGS_B = 3
     NELDER_MEAD = 4
     ADAM = 5
+    SLSQP = 6
 
 
 class Pauli(IntEnum):

classiq/qmod/builtins/functions/__init__.py

@@ -64,6 +64,7 @@ CORE_LIB_DECLS = [
         inplace_prepare_state,
         inplace_prepare_amplitudes,
         single_pauli_exponent,
+        commuting_paulis_exponent,
         suzuki_trotter,
         qdrift,
         exponentiation_with_depth_constraint,
@@ -129,6 +130,7 @@ __all__ = [  # noqa: RUF022
     "randomized_benchmarking",
     "real_xor_constant",
     "single_pauli_exponent",
+    "commuting_paulis_exponent",
     "suzuki_trotter",
     "unitary",
     "RESET",

classiq/qmod/builtins/functions/exponentiation.py

@@ -28,6 +28,30 @@ def single_pauli_exponent(
     pass
 
 
+@qfunc(external=True)
+def commuting_paulis_exponent(
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    qbv: QArray[
+        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
+    ],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Exponentiates the specified commutative Pauli operator.
+    As all the Pauli operator's terms commute, the exponential of the whole operator
+    is exactly the product of exponentials of each term.
+    Calling this funciton with a non-commutative Pauli operator will issue an error.
+
+    Args:
+        pauli_operator: The Pauli operator to be exponentiated.
+        evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
 @qfunc(external=True)
 def suzuki_trotter(
     pauli_operator: CArray[PauliTerm],

classiq/qmod/builtins/operations.py

@@ -48,7 +48,7 @@ from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QScalar, QVa
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
-from classiq.qmod.utilities import get_source_ref
+from classiq.qmod.utilities import Statements, get_source_ref, suppress_return_value
 
 _MISSING_VALUE: Final[int] = -1
 
@@ -63,6 +63,7 @@ def allocate(out: Output[QVar]) -> None:
     pass
 
 
+@suppress_return_value
 def allocate(*args: Any, **kwargs: Any) -> None:
     """
     Initialize a quantum variable to a new quantum object in the zero state:
@@ -106,6 +107,7 @@ def allocate(*args: Any, **kwargs: Any) -> None:
     )
 
 
+@suppress_return_value
 def bind(
     source: Union[Input[QVar], list[Input[QVar]]],
     destination: Union[Output[QVar], list[Output[QVar]]],
@@ -125,10 +127,11 @@ def bind(
     )
 
 
+@suppress_return_value
 def if_(
     condition: Union[SymbolicExpr, bool],
-    then: Union[QCallable, Callable[[], None]],
-    else_: Union[QCallable, Callable[[], None], int] = _MISSING_VALUE,
+    then: Union[QCallable, Callable[[], Statements]],
+    else_: Union[QCallable, Callable[[], Statements], int] = _MISSING_VALUE,
 ) -> None:
     _validate_operand(then)
     if else_ != _MISSING_VALUE:
@@ -149,10 +152,11 @@ def if_(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 
+@suppress_return_value
 def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
-    stmt_block: Union[QCallable, Callable[[], None]],
-    else_block: Union[QCallable, Callable[[], None], None] = None,
+    stmt_block: Union[QCallable, Callable[[], Statements]],
+    else_block: Union[QCallable, Callable[[], Statements], None] = None,
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -170,6 +174,7 @@ def control(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
+@suppress_return_value
 def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Initialize a scalar quantum variable using an arithmetic expression.
@@ -194,6 +199,7 @@ def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Perform an amplitude-encoding assignment operation on a quantum variable and a
@@ -216,6 +222,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Add an arithmetic expression to a quantum variable.
@@ -238,6 +245,7 @@ def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Bitwise-XOR a quantum variable with an arithmetic expression.
@@ -260,9 +268,10 @@ def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def within_apply(
-    within: Callable[[], None],
-    apply: Callable[[], None],
+    within: Callable[[], Statements],
+    apply: Callable[[], Statements],
 ) -> None:
     _validate_operand(within)
     _validate_operand(apply)
@@ -279,7 +288,10 @@ def within_apply(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(within_apply_stmt)
 
 
-def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) -> None:
+@suppress_return_value
+def repeat(
+    count: Union[SymbolicExpr, int], iteration: Callable[[int], Statements]
+) -> None:
     _validate_operand(iteration)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -310,9 +322,10 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(repeat_stmt)
 
 
+@suppress_return_value
 def power(
     exponent: Union[SymbolicExpr, int],
-    stmt_block: Union[QCallable, Callable[[], None]],
+    stmt_block: Union[QCallable, Callable[[], Statements]],
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -327,7 +340,8 @@ def power(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(power_stmt)
 
 
-def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
+@suppress_return_value
+def invert(stmt_block: Union[QCallable, Callable[[], Statements]]) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -339,6 +353,7 @@ def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 
+@suppress_return_value
 def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -402,7 +417,7 @@ def _get_operand_hint(
 
 
 def _operand_to_body(
-    callable_: Union[QCallable, Callable[[], None]], param_name: str
+    callable_: Union[QCallable, Callable[[], Statements]], param_name: str
 ) -> StatementBlock:
     op_name = sys._getframe(1).f_code.co_name
     if (

classiq/qmod/cparam.py

@@ -1,4 +1,5 @@
 import sys
+from abc import ABC, abstractmethod
 from typing import (  # type: ignore[attr-defined]
     TYPE_CHECKING,
     Any,
@@ -9,6 +10,8 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec
 
+from classiq.interface.exceptions import ClassiqValueError
+
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
 if TYPE_CHECKING:
@@ -21,18 +24,34 @@ else:
 
 class CParam(SymbolicSuperclass):
     def __init__(self, expr: str) -> None:
-        super().__init__(expr, False)
+        super().__init__(expr, is_quantum=False)
+
+
+class CParamAbstract(ABC, CParam):
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "CParamAbstract":
+        raise ClassiqValueError(
+            f"{cls.__name__} is a Qmod type hint for a classical parameter and it cannot be instantiated. "
+            f"Use regular Pythonic values as arguments instead. "
+            f"Example:\n\n"
+            f"def foo(val: {cls.__name__}) -> None: ...\n\n"
+            f"foo({_EXAMPLE_VALUES[cls.__name__]})  # Correct\n"
+        )
 
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
 
-class CInt(CParam):
+
+class CInt(CParamAbstract):
     pass
 
 
-class CReal(CParam):
+class CReal(CParamAbstract):
     pass
 
 
-class CBool(CParam):
+class CBool(CParamAbstract):
     pass
 
 
@@ -47,7 +66,7 @@ class ArrayBase(Generic[_P]):
             return _GenericAlias(cls, args)
 
 
-class CArray(CParam, ArrayBase[_P]):
+class CArray(CParamAbstract, ArrayBase[_P]):
     if TYPE_CHECKING:
 
         @property
@@ -62,3 +81,11 @@ Array = CArray
 class CParamScalar(CParam, SymbolicExpr):
     def __hash__(self) -> int:
         return hash(str(self))
+
+
+_EXAMPLE_VALUES: dict[str, Any] = {
+    CInt.__name__: 1,
+    CReal.__name__: 1.0,
+    CBool.__name__: True,
+    CArray.__name__: [1, 2],
+}

classiq/qmod/python_classical_type.py

@@ -30,16 +30,22 @@ CARRAY_ERROR_MESSAGE = (
 
 class PythonClassicalType:
     def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
-        if py_type is int or py_type is CInt:
+        if py_type is int:
+            return Integer().set_generative()
+        elif py_type is CInt:
             return Integer()
-        elif py_type in (float, complex) or py_type is CReal:
+        elif py_type in (float, complex):
+            return Real().set_generative()
+        elif py_type is CReal:
             return Real()
-        elif py_type is bool or py_type is CBool:
+        elif py_type is bool:
+            return Bool().set_generative()
+        elif py_type is CBool:
             return Bool()
         elif get_origin(py_type) is list:
             element_type = self.convert(get_args(py_type)[0])
             if element_type is not None:
-                return ClassicalList(element_type=element_type)
+                return ClassicalList(element_type=element_type).set_generative()
         elif get_origin(py_type) is CArray:
             array_args = version_portable_get_args(py_type)
             if len(array_args) == 1:

classiq/qmod/quantum_callable.py

@@ -21,7 +21,7 @@ from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.source_reference import SourceReference
 
 from classiq.qmod.cparam import CInt
-from classiq.qmod.utilities import get_source_ref
+from classiq.qmod.utilities import get_source_ref, suppress_return_value
 
 if TYPE_CHECKING:
     from classiq.qmod.quantum_expandable import QTerminalCallable
@@ -48,6 +48,7 @@ class QCallable(Generic[P], ABC):
     CURRENT_EXPANDABLE: ClassVar[Optional[QExpandableInterface]] = None
     FRAME_DEPTH = 1
 
+    @suppress_return_value
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         assert QCallable.CURRENT_EXPANDABLE is not None
         source_ref = get_source_ref(sys._getframe(self.FRAME_DEPTH))

classiq/qmod/quantum_function.py

@@ -24,10 +24,11 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 
 from classiq.qmod.classical_function import CFunc
+from classiq.qmod.cparam import CParamAbstract
 from classiq.qmod.declaration_inferrer import infer_func_decl
 from classiq.qmod.generative import set_frontend_interpreter
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import CArray, CParam
+from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
@@ -308,7 +309,7 @@ def _validate_no_gen_params(annotations: dict[str, Any]) -> None:
         for name, annotation in annotations.items()
         if not (
             name == "return"
-            or (isclass(annotation) and issubclass(annotation, CParam))
+            or (isclass(annotation) and issubclass(annotation, CParamAbstract))
             or (isclass(annotation) and is_dataclass(annotation))
             or (isclass(annotation) and isinstance(annotation, EnumMeta))
             or get_origin(annotation) is CArray