classiq 0.75.0__py3-none-any.whl → 0.77.0__py3-none-any.whl

classiq/model_expansions/evaluators/classical_type_inference.py

@@ -1,6 +1,9 @@
 from typing import Any, Union
 
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
 )
@@ -17,6 +20,7 @@ from classiq.interface.generator.functions.classical_type import (
 )
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.backward_compatibility import zip_strict
 
 
 def infer_classical_type(val: Any, classical_type: ClassicalType) -> ClassicalType:
@@ -33,7 +37,7 @@ def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> Classica
     decl = val.struct_declaration
     new_fields = {
         field_name: infer_classical_type(field_val, field_type)
-        for (field_name, field_val), field_type in zip(
+        for (field_name, field_val), field_type in zip_strict(
             val.fields.items(),
             decl.variables.values(),
             strict=True,
@@ -49,13 +53,20 @@ def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> Classica
 def _infer_classical_array_type(
     val: Any, classical_type: Union[ClassicalArray, ClassicalList]
 ) -> ClassicalType:
-    if isinstance(val, list):
-        val_length = len(val)
-    elif isinstance(val, ClassicalArrayProxy):
+    if isinstance(val, ClassicalArrayProxy):
         val_length = val.length
+    elif isinstance(val, list):
+        val_length = len(val)
+    elif isinstance(val, AnyClassicalValue):
+        return classical_type
     else:
         raise ClassiqExpansionError(f"Array expected, got {str(val)!r}")
-    if isinstance(classical_type, ClassicalArray) and val_length != classical_type.size:
+    if (
+        isinstance(classical_type, ClassicalArray)
+        and isinstance(val_length, int)
+        and isinstance(classical_type.size, int)
+        and val_length != classical_type.size
+    ):
         raise ClassiqExpansionError(
             f"Type mismatch: Argument has {val_length} items but "
             f"{classical_type.size} expected"
@@ -63,7 +74,7 @@ def _infer_classical_array_type(
     return ClassicalArray(
         element_type=(
             infer_classical_type(val[0], classical_type.element_type)
-            if val_length > 0
+            if not isinstance(val_length, int) or val_length > 0
             else classical_type.element_type
         ),
         size=val_length,

classiq/model_expansions/evaluators/parameter_types.py

@@ -1,10 +1,15 @@
-from typing import TypeVar, Union
+from typing import Optional, TypeVar, Union
+
+import sympy
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -15,6 +20,7 @@ from classiq.interface.generator.functions.type_name import (
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
@@ -41,7 +47,12 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
     set_length,
     set_size,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumVariable,
+    Scope,
+)
 
 
 def evaluate_parameter_types_from_args(
@@ -78,10 +89,10 @@ def _update_scope(
         return
     if parameter.direction is PortDeclarationDirection.Output:
         return
-    quantum_symbol = argument.as_type(QuantumSymbol)
+    quantum_var = argument.as_type(QuantumVariable)
     casted_argument = _cast(
         parameter.quantum_type,
-        quantum_symbol,
+        quantum_var.quantum_type,
         parameter.name,
     )
     closure.scope[parameter.name] = Evaluated(
@@ -115,12 +126,12 @@ def _update_operand_signature_environment(
 
 
 def _cast(
-    quantum_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
 ) -> QuantumSymbol:
-    updated_quantum_type = quantum_type.model_copy()
-    _inject_quantum_arg_info_to_type(updated_quantum_type, quantum_symbol, param_name)
+    updated_quantum_type = parameter_type.model_copy()
+    _inject_quantum_arg_info_to_type(updated_quantum_type, argument_type, param_name)
     return QuantumSymbol(
-        handle=quantum_symbol.handle, quantum_type=updated_quantum_type
+        handle=HandleBinding(name=param_name), quantum_type=updated_quantum_type
     )
 
 
@@ -143,7 +154,9 @@ def _evaluate_type_from_arg(
     )
     if parameter.direction != PortDeclarationDirection.Output:
         updated_quantum_type = _inject_quantum_arg_info_to_type(
-            updated_quantum_type, argument.as_type(QuantumSymbol), parameter.name
+            updated_quantum_type,
+            argument.as_type(QuantumVariable).quantum_type,
+            parameter.name,
         )
     return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
@@ -178,7 +191,8 @@ def _evaluate_qarray_in_quantum_symbol(
             "length",
             param_name,
         )
-        set_length(type_to_update, new_length)
+        if new_length is not None:
+            set_length(type_to_update, new_length)
     return type_to_update
 
 
@@ -194,7 +208,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "sign",
             param_name,
         )
-        type_to_update.is_signed = Expression(expr=str(new_is_sign))
+        if new_is_sign is not None:
+            type_to_update.is_signed = Expression(expr=str(new_is_sign))
     if type_to_update.fraction_digits is not None:
         new_fraction_digits = _eval_expr(
             type_to_update.fraction_digits,
@@ -204,7 +219,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "fraction digits",
             param_name,
         )
-        type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
+        if new_fraction_digits is not None:
+            type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     if type_to_update.size is not None:
         new_size = _eval_expr(
             type_to_update.size,
@@ -214,7 +230,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "size",
             param_name,
         )
-        set_size(type_to_update, new_size, param_name)
+        if new_size is not None:
+            set_size(type_to_update, new_size, param_name)
     return type_to_update
 
 
@@ -228,17 +245,21 @@ def _eval_expr(
     type_name: str,
     attr_name: str,
     param_name: str,
-) -> _EXPR_TYPE:
+) -> Optional[_EXPR_TYPE]:
     val = evaluate_classical_expression(expression, scope).value
     if expected_type is int and isinstance(val, float):
         val = int(val)
-    if not isinstance(val, expected_type):
-        raise ClassiqExpansionError(
-            f"When inferring the type of parameter {param_name!r}: "
-            f"{type_name} {attr_name} must be {expected_type.__name__}, got "
-            f"{str(val)!r}"
-        )
-    return val
+    if isinstance(val, expected_type):
+        return val
+    if isinstance(val, AnyClassicalValue) or (
+        isinstance(val, sympy.Basic) and len(val.free_symbols) > 0
+    ):
+        return None
+    raise ClassiqExpansionError(
+        f"When inferring the type of parameter {param_name!r}: "
+        f"{type_name} {attr_name} must be {expected_type.__name__}, got "
+        f"{str(val)!r}"
+    )
 
 
 def _evaluate_qstruct_in_quantum_symbol(
@@ -267,11 +288,11 @@ def evaluate_types_in_quantum_symbols(
 
 
 def _inject_quantum_arg_info_to_type(
-    parameter_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
 ) -> QuantumType:
-    if quantum_symbol.quantum_type.has_size_in_bits:
+    if argument_type.has_size_in_bits:
         copy_type_information(
-            quantum_symbol.quantum_type,
+            argument_type,
             parameter_type,
             param_name,
         )

classiq/model_expansions/expression_evaluator.py

@@ -1,7 +1,7 @@
 import ast
 from collections.abc import Mapping
 from enum import EnumMeta
-from typing import Any, Optional
+from typing import Any
 
 from sympy import SympifyError, sympify
 
@@ -50,11 +50,25 @@ def evaluate_constants_as_python(constants: list[Constant]) -> dict[str, Any]:
     }
 
 
+def _quick_eval(expr: str) -> Any:
+    try:
+        return int(expr)
+    except ValueError:
+        pass
+    try:
+        return float(expr)
+    except ValueError:
+        pass
+    return None
+
+
 def evaluate(
-    expr: Expression,
-    locals_dict: Mapping[str, EvaluatedExpression],
-    uninitialized_locals: Optional[set[str]] = None,
+    expr: Expression, locals_dict: Mapping[str, EvaluatedExpression]
 ) -> EvaluatedExpression:
+    val = _quick_eval(expr.expr)
+    if val is not None:
+        return EvaluatedExpression(value=val)
+
     model_locals: dict[str, ExpressionValue] = {}
     model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
     model_locals.update(
@@ -65,15 +79,14 @@ def evaluate(
     )
     # locals override builtin-functions
     model_locals.update({name: expr.value for name, expr in locals_dict.items()})
-    uninitialized_locals = uninitialized_locals or set()
 
-    _validate_undefined_vars(expr.expr, model_locals, uninitialized_locals)
+    _validate_undefined_vars(expr.expr, model_locals)
 
     sympy_expr = translate_to_sympy(expr.expr)
     try:
         sympify_result = sympify(sympy_expr, locals=model_locals)
     except (TypeError, IndexError) as e:
-        raise ClassiqExpansionError(str(e)) from None
+        raise ClassiqExpansionError(str(e)) from e
     except AttributeError as e:
         if isinstance(e.obj, EnumMeta):
             raise ClassiqExpansionError(
@@ -95,11 +108,8 @@ def evaluate(
 
 
 def _validate_undefined_vars(
-    expr: str,
-    model_locals: dict[str, ExpressionValue],
-    uninitialized_locals: Optional[set[str]],
+    expr: str, model_locals: dict[str, ExpressionValue]
 ) -> None:
-    uninitialized_locals = uninitialized_locals or set()
     id_visitor = _VarsCollector()
     id_visitor.visit(ast.parse(expr))
     identifiers = id_visitor.vars
@@ -108,7 +118,6 @@ def _validate_undefined_vars(
         - model_locals.keys()
         - set(SYMPY_SUPPORTED_EXPRESSIONS)
         - set(symbolic.__all__)
-        - uninitialized_locals
     )
 
     if len(undefined_vars) == 1:

classiq/model_expansions/function_builder.py

@@ -11,12 +11,15 @@ from classiq.interface.generator.compiler_keywords import (
 from classiq.interface.generator.functions.builtins.internal_operators import (
     WITHIN_APPLY_NAME,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
 from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
+from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -212,6 +215,7 @@ class OperationBuilder:
         self, function_context: FunctionContext, params: Sequence[PositionalArg]
     ) -> NativeFunctionDefinition:
         name = self._get_expanded_function_name(function_context)
+        self._override_type_qualifier(function_context, params)
 
         return NativeFunctionDefinition(
             name=name,
@@ -244,3 +248,44 @@ class OperationBuilder:
             raise ClassiqInternalExpansionError("Could not allocate function name")
 
         return name
+
+    def _override_type_qualifier(
+        self, function_context: FunctionContext, params: Sequence[PositionalArg]
+    ) -> None:
+        """
+        The type qualifier can be changed according to the operand passed to the
+        function. For example,
+        apply_to_all(X, q) --> q will be QFree after expansion
+        apply_to_all(H, q) --> q will be Quantum after expansion
+        This also holds for the intermediate lambda created during the expansion.
+
+        We don't override the type qualifier if it's explicitly specified (QFree or
+        Const), neither in the function declaration nor in the operand declaration.
+        """
+
+        if function_context.is_lambda:
+            self._update_type_qualifiers(params)
+            return
+
+        orig_name = function_context.name
+        if orig_name == MAIN_FUNCTION_NAME or orig_name not in self.current_scope:
+            return
+
+        orig_func = self.current_scope[orig_name].value
+        if not any(
+            isinstance(param_decl, QuantumOperandDeclaration)
+            for param_decl in orig_func.positional_arg_declarations
+        ):
+            return
+
+        self._update_type_qualifiers(params)
+
+    @staticmethod
+    def _update_type_qualifiers(params: Sequence[PositionalArg]) -> None:
+        # only override the qualifier if it's unspecified (not QFree or Const)
+        for param in params:
+            if (
+                isinstance(param, PortDeclaration)
+                and param.type_qualifier is TypeQualifier.Quantum
+            ):
+                param.type_qualifier = TypeQualifier.Inferred

classiq/model_expansions/generative_functions.py

@@ -16,7 +16,7 @@ from classiq.interface.generator.expressions.proxies.classical.utils import (
     get_proxy_type,
 )
 from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.helpers.datastructures import get_sdk_compatible_python_object
+from classiq.interface.helpers.datastructures import LenList
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -31,16 +31,18 @@ from classiq.model_expansions.closure import (
     FunctionClosure,
     GenerativeClosure,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CParamStruct, create_param
-from classiq.qmod.qmod_variable import _create_qvar_for_qtype
+from classiq.qmod.qmod_variable import QScalar, _create_qvar_for_qtype
 from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
 from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
+from classiq.qmod.symbolic_expr import SymbolicExpr, SymbolicSubscriptAndField
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.generative_interpreter import (
@@ -65,36 +67,61 @@ def _unwrap_traceback_frame(e: Exception) -> Exception:
     return e.with_traceback(back_tb)
 
 
-def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
-    if isinstance(param, PortDeclaration):
-        quantum_symbol = evaluated.as_type(QuantumSymbol)
-        return _create_qvar_for_qtype(
-            quantum_symbol.quantum_type, quantum_symbol.handle
+class SymbolicList(LenList):
+    def __getitem__(self, index: Any) -> Any:
+        if isinstance(index, (QScalar, SymbolicExpr)) or (
+            isinstance(index, slice)
+            and any(
+                isinstance(slice_part, (QScalar, SymbolicExpr))
+                for slice_part in (index.start, index.stop, index.step)
+            )
+        ):
+            return SymbolicSubscriptAndField(
+                qmod_val_to_expr_str(self), is_quantum=False
+            )[index]
+        try:
+            return super().__getitem__(index)
+        except (IndexError, TypeError) as e:
+            raise _unwrap_traceback_frame(e) from None
+
+
+def translate_classical_ast_arg_to_python_qmod(value: Any) -> Any:
+    if isinstance(value, QmodStructInstance):
+        return QmodStructInstance(
+            value.struct_declaration,
+            {
+                field_name: translate_classical_ast_arg_to_python_qmod(field_value)
+                for field_name, field_value in value.fields.items()
+            },
         )
+    if isinstance(value, list):
+        return SymbolicList(
+            [translate_classical_ast_arg_to_python_qmod(item) for item in value]
+        )
+    if isinstance(value, ClassicalProxy):
+        return create_param(str(value.handle), get_proxy_type(value), QMODULE)
+
+    return value
+
+
+def translate_ast_arg_to_python_qmod(param: PositionalArg, value: Any) -> Any:
+    if isinstance(param, PortDeclaration):
+        return _create_qvar_for_qtype(value.quantum_type, value.handle)
     if isinstance(param, QuantumOperandDeclaration):
         if not param.is_list or not param.is_generative:
             return QTerminalCallable(param)
         inner_decl = param.model_copy(update={"is_list": False})
-        func_list: list[FunctionClosure] = evaluated.as_type(list)
-        return [
-            QTerminalCallable(inner_decl, index_=idx) for idx in range(len(func_list))
-        ]
-    classical_value = evaluated.value
-    if isinstance(classical_value, QmodStructInstance):
-        if param.classical_type.is_purely_declarative:
-            return CParamStruct(
-                expr=param.name,
-                struct_type=Struct(name=classical_value.struct_declaration.name),
-                qmodule=QMODULE,
-            )
-        else:
-            return get_sdk_compatible_python_object(dict(classical_value.fields))
-    if isinstance(classical_value, ClassicalProxy):
-        return create_param(
-            str(classical_value.handle), get_proxy_type(classical_value), QMODULE
+        return [QTerminalCallable(inner_decl, index_=idx) for idx in range(len(value))]
+    if (
+        isinstance(value, QmodStructInstance)
+        and param.classical_type.is_purely_declarative
+    ):
+        classical_type = Struct(name=value.struct_declaration.name)
+        classical_type.set_classical_struct_decl(value.struct_declaration)
+        return CParamStruct(
+            expr=param.name, struct_type=classical_type, qmodule=QMODULE
         )
-
-    return get_sdk_compatible_python_object(classical_value)
+    return translate_classical_ast_arg_to_python_qmod(value)
 
 
 class _InterpreterExpandable(QFunc):
@@ -107,7 +134,7 @@ class _InterpreterExpandable(QFunc):
         dummy_function = NativeFunctionDefinition(
             name=current_operation.name,
             positional_arg_declarations=current_operation.positional_arg_declarations,
-            body=self._interpreter._builder._current_statements + [stmt],
+            body=[stmt],
         )
         declarative_functions = {
             name: func
@@ -140,14 +167,14 @@ class _InterpreterExpandable(QFunc):
                     name=name,
                     positional_arg_declarations=value.positional_arg_declarations,
                 )
-            elif (
-                isinstance(value, list)
-                and len(value) > 0
-                and isinstance(value[0], FunctionClosure)
-            ):
+                continue
+            op_param = self._interpreter._builder.current_function.parameters_dict.get(
+                name
+            )
+            if isinstance(op_param, QuantumOperandDeclaration):
                 scope_func_decls[name] = QuantumFunctionDeclaration(
                     name=name,
-                    positional_arg_declarations=value[0].positional_arg_declarations,
+                    positional_arg_declarations=op_param.positional_arg_declarations,
                 )
         return (
             nameables_to_dict(self._interpreter._get_function_declarations())
@@ -161,7 +188,7 @@ def emit_generative_statements(
     args: list[Evaluated],
 ) -> None:
     python_qmod_args = [
-        translate_ast_arg_to_python_qmod(param, arg)
+        translate_ast_arg_to_python_qmod(param, arg.value)
         for param, arg in zip(operation.positional_arg_declarations, args)
     ]
     with _InterpreterExpandable(interpreter):

classiq/model_expansions/interpreters/base_interpreter.py

@@ -6,7 +6,6 @@ from contextlib import nullcontext
 from functools import singledispatchmethod
 from typing import Any, cast
 
-import sympy
 from pydantic import ValidationError
 
 from classiq.interface.debug_info.debug_info import (
@@ -17,11 +16,15 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    CLASSICAL_ATTRIBUTES,
+)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -49,7 +52,12 @@ from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumSymbolList,
+    Scope,
+)
 from classiq.model_expansions.scope_initialization import (
     add_entry_point_params_to_scope,
     init_builtin_types,
@@ -57,11 +65,13 @@ from classiq.model_expansions.scope_initialization import (
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.qmod.builtins.constants import __all__ as builtin_constants
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.validation.model_validation import validate_model
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
 class BaseInterpreter:
@@ -126,7 +136,11 @@ class BaseInterpreter:
             classical_execution_code=self._model.classical_execution_code,
             execution_preferences=self._model.execution_preferences,
             functions=list(self._expanded_functions.values()),
-            constants=self._model.constants,
+            constants=[
+                const
+                for name, const in QMODULE.constants.items()
+                if name not in builtin_constants
+            ],
             enums=[
                 enum_decl
                 for name, enum_decl in QMODULE.enum_decls.items()
@@ -157,14 +171,17 @@ class BaseInterpreter:
     @evaluate.register
     def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
         expr = evaluate_classical_expression(expression, self._builder.current_scope)
-        if not isinstance(expr.value, sympy.Basic):
-            return expr
         vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(str(expr.value)))
+        vrc.visit(ast.parse(qmod_val_to_expr_str(expr.value)))
         for handle in vrc.var_handles:
             if handle.name in self._builder.current_scope and isinstance(
-                self._builder.current_scope[handle.name], QuantumSymbol
+                self._builder.current_scope[handle.name].value, QuantumSymbol
             ):
+                if (
+                    isinstance(handle, FieldHandleBinding)
+                    and handle.field in CLASSICAL_ATTRIBUTES
+                ):
+                    handle = handle.base_handle
                 self.evaluate(handle)
         return expr
 
@@ -222,6 +239,14 @@ class BaseInterpreter:
             )
         return Evaluated(value=fields[field_name])
 
+    @evaluate.register
+    def evaluate_handles_list(self, handles_list: HandlesList) -> Evaluated:
+        return Evaluated(
+            value=QuantumSymbolList.from_symbols(
+                [self.evaluate(handle).value for handle in handles_list.handles]
+            )
+        )
+
     @abstractmethod
     def emit(self, statement: QuantumStatement) -> None:
         pass

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -1,10 +1,12 @@
 import inspect
 import os
+from typing import Optional
 
 from pydantic import ValidationError
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -16,6 +18,7 @@ from classiq.model_expansions.closure import FunctionClosure, GenerativeFunction
 from classiq.model_expansions.interpreters.generative_interpreter import (
     GenerativeInterpreter,
 )
+from classiq.model_expansions.quantum_operations import BindEmitter
 from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
@@ -31,15 +34,18 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
     def infer_symbolic_parameters(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: (
-            list[NamedParamsQuantumFunctionDeclaration] | None
-        ) = None,
+        additional_signatures: Optional[
+            list[NamedParamsQuantumFunctionDeclaration]
+        ] = None,
     ) -> None:
         SymbolicParamInference(functions, additional_signatures).infer()
 
     def emit_allocate(self, allocate: Allocate) -> None:
         AllocateEmitter(self, allow_symbolic_size=True).emit(allocate)
 
+    def emit_bind(self, bind: BindOperation) -> None:
+        BindEmitter(self, allow_symbolic_size=True).emit(bind)
+
     def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
         DeclarativeQuantumFunctionCallEmitter(self).emit(call)