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

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -1,5 +1,5 @@
 from itertools import chain
-from typing import TYPE_CHECKING, Generic
+from typing import TYPE_CHECKING, Generic, Optional
 
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -34,13 +34,24 @@ class DeclarativeCallEmitter(
 
         if self._is_function_purely_declarative(
             function
-        ) and self._are_args_purely_declarative(args):
+        ) and self._are_args_purely_declarative(args, function.name):
             self._interpreter.add_purely_declarative_function(function)
             return False
 
         return True
 
-    def _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
+    def _is_function_purely_declarative(
+        self, function: FunctionClosure, seen_funcs: Optional[set[str]] = None
+    ) -> bool:
+        if seen_funcs is None:
+            seen_funcs = set()
+        if function.name in seen_funcs:
+            return True
+        seen_funcs.add(function.name)
+
+        if function.is_atomic:
+            return True
+
         if function.name not in QMODULE.native_defs:
             return False
 
@@ -56,9 +67,9 @@ class DeclarativeCallEmitter(
             return False
 
         dependencies = QMODULE.function_dependencies[function.name]
-        return self._are_identifiers_purely_declarative(dependencies)
+        return self._are_identifiers_purely_declarative(dependencies, seen_funcs)
 
-    def _are_args_purely_declarative(self, args: list[Evaluated]) -> bool:
+    def _are_args_purely_declarative(self, args: list[Evaluated], caller: str) -> bool:
         values = [arg.value for arg in args]
         function_inputs: list[FunctionClosure] = list(
             chain.from_iterable(
@@ -78,10 +89,13 @@ class DeclarativeCallEmitter(
         if any(func.is_lambda for func in function_inputs):
             return False
         dependencies = [func.name for func in function_inputs if not func.is_lambda]
-        return self._are_identifiers_purely_declarative(dependencies)
+        return self._are_identifiers_purely_declarative(dependencies, {caller})
 
-    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
-        return not any(
-            isinstance(self._current_scope[dep].value, GenerativeClosure)
+    def _are_identifiers_purely_declarative(
+        self, dependencies: list[str], seen_funcs: set[str]
+    ) -> bool:
+        return all(
+            self._is_function_purely_declarative(self._current_scope[dep].value)
             for dep in dependencies
+            if seen_funcs is None or dep not in seen_funcs
         )

classiq/model_expansions/quantum_operations/emitter.py

@@ -15,6 +15,11 @@ from classiq.interface.debug_info.debug_info import (
     DebugInfoCollection,
 )
 from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    CLASSICAL_ATTRIBUTES,
+    SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS,
+    SUPPORTED_PYTHON_BUILTIN_FUNCTIONS,
+)
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
@@ -30,7 +35,11 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBinding
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    NestedHandleBinding,
+)
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
@@ -172,12 +181,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
             self._capture_classical_var(var_name, var_type)
 
     def _update_captured_vars(self, op: QuantumOperation) -> None:
-        handles = (
-            [(handle, PortDeclarationDirection.Input) for handle in op.inputs]
-            + [(handle, PortDeclarationDirection.Output) for handle in op.outputs]
-            + [(handle, PortDeclarationDirection.Inout) for handle in op.inouts]
-        )
-        for handle, direction in handles:
+        for handle, direction in op.handles_with_directions:
             self._capture_handle(handle, direction)
 
     def _capture_handle(
@@ -220,9 +224,17 @@ class Emitter(Generic[QuantumStatementT], ABC):
         handles = dict.fromkeys(
             handle
             for handle in vrc.var_handles
-            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+            if handle.name
+            not in SUPPORTED_PYTHON_BUILTIN_FUNCTIONS
+            | SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS
+            and isinstance(self._current_scope[handle.name].value, QuantumSymbol)
         )
-        return [self._interpreter.evaluate(handle).value for handle in handles]
+        return [
+            self._interpreter.evaluate(handle).value
+            for handle in handles
+            if not isinstance(handle, FieldHandleBinding)
+            or handle.field not in CLASSICAL_ATTRIBUTES
+        ]
 
     def _get_classical_vars_in_expression(
         self, expr: Expression

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -49,13 +49,14 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
             raise ClassiqInternalExpansionError(
                 f"Unexpected lambda list type {type(funcs).__name__!r}"
             )
-        self._interpreter.emit(self._create_recursive_if(call, index, len(funcs)))
+        for stmt in self._create_recursive_if(call, index, len(funcs)):
+            self._interpreter.emit(stmt)
         return True
 
     @staticmethod
     def _create_recursive_if(
         call: QuantumFunctionCall, index: ClassicalScalarProxy, num_funcs: int
-    ) -> QuantumStatement:
+    ) -> list[QuantumStatement]:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)
         stmt: list[QuantumStatement] = []
@@ -74,7 +75,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
                     else_=stmt,
                 )
             ]
-        return stmt[0]
+        return stmt
 
 
 class DeclarativeQuantumFunctionCallEmitter(

classiq/model_expansions/scope.py

@@ -22,7 +22,9 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
+    GeneralHandle,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -39,10 +41,17 @@ T = TypeVar("T")
 
 
 @dataclass(frozen=True)
-class QuantumSymbol:
-    handle: HandleBinding
+class QuantumVariable:
     quantum_type: QuantumType
 
+    def emit(self) -> GeneralHandle:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class QuantumSymbol(QuantumVariable):
+    handle: HandleBinding
+
     @property
     def is_subscript(self) -> bool:
         return isinstance(self.handle, (SubscriptHandleBinding, SlicedHandleBinding))
@@ -66,8 +75,6 @@ class QuantumSymbol:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if TYPE_CHECKING:
-            assert self.quantum_type.length is not None
         if isinstance(start, int) and isinstance(end, int) and start >= end:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} slice '{self.handle}[{start}:{end}]' "
@@ -75,6 +82,7 @@ class QuantumSymbol:
             )
         if (isinstance(start, int) and start < 0) or (
             isinstance(end, int)
+            and self.quantum_type.length is not None
             and self.quantum_type.length.is_constant()
             and end > self.quantum_type.length_value
         ):
@@ -100,19 +108,23 @@ class QuantumSymbol:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if TYPE_CHECKING:
-            assert self.quantum_type.length is not None
         if isinstance(index, int) and (
             index < 0
             or (
-                self.quantum_type.length.is_constant()
+                self.quantum_type.length is not None
+                and self.quantum_type.length.is_constant()
                 and index >= self.quantum_type.length_value
             )
         ):
+            length_suffix = (
+                f" (of length {self.quantum_type.length})"
+                if self.quantum_type.length is not None
+                else ""
+            )
             raise ClassiqExpansionError(
                 f"Index {index} is out of bounds for "
-                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
-                f"length {self.quantum_type.length})"
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r}"
+                f"{length_suffix}"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(
@@ -137,6 +149,47 @@ class QuantumSymbol:
             for field_name, field_type in quantum_type.fields.items()
         }
 
+    def __str__(self) -> str:
+        return str(self.handle)
+
+
+@dataclass(frozen=True)
+class QuantumSymbolList(QuantumVariable):
+    handles: list[HandleBinding]
+
+    @staticmethod
+    def from_symbols(
+        symbols: list[Union[QuantumSymbol, "QuantumSymbolList"]],
+    ) -> "QuantumSymbolList":
+        handles = list(
+            itertools.chain.from_iterable(
+                (
+                    symbol.handles
+                    if isinstance(symbol, QuantumSymbolList)
+                    else [symbol.handle]
+                )
+                for symbol in symbols
+            )
+        )
+        if len(handles) == 0:
+            raise ClassiqExpansionError("Empty concatenation expression")
+        length: Optional[Expression]
+        if any(not symbol.quantum_type.has_size_in_bits for symbol in symbols):
+            length = None
+        else:
+            length = Expression(
+                expr=str(sum(symbol.quantum_type.size_in_bits for symbol in symbols))
+            )
+        return QuantumSymbolList(
+            handles=handles, quantum_type=QuantumBitvector(length=length)
+        )
+
+    def emit(self) -> HandlesList:
+        return HandlesList(handles=self.handles)
+
+    def __str__(self) -> str:
+        return str(self.handles)
+
 
 @singledispatch
 def evaluated_to_str(value: Any) -> str:
@@ -180,7 +233,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     def emit(self) -> ArgValue:
         from classiq.model_expansions.closure import FunctionClosure
 
-        if isinstance(self.value, (QuantumSymbol, FunctionClosure)):
+        if isinstance(self.value, (QuantumVariable, FunctionClosure)):
             return self.value.emit()
         if isinstance(self.value, list) and all(
             isinstance(item, FunctionClosure) for item in self.value

classiq/model_expansions/sympy_conversion/arithmetics.py

@@ -47,3 +47,21 @@ class BitwiseNot(Function):
             return ~a
 
         return None
+
+
+class RShift(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a >> b
+
+        return None
+
+
+class LShift(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a << b
+
+        return None

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -23,6 +23,8 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
         ast.BitAnd: "BitwiseAnd",
         ast.BitXor: "BitwiseXor",
         ast.Div: "do_div",
+        ast.RShift: "RShift",
+        ast.LShift: "LShift",
     }
 
     UNARY_OPERATORS: dict[type[ast.AST], str] = {

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -17,6 +17,9 @@ from sympy.printing.pycode import PythonCodePrinter
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 
 from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 
@@ -24,7 +27,9 @@ from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 def sympy_to_python(
     value: Any, locals: Optional[dict[str, ExpressionValue]] = None
 ) -> ExpressionValue:
-    if isinstance(value, Integer):
+    if isinstance(value, AnyClassicalValue):
+        pass
+    elif isinstance(value, Integer):
         value = int(value)
     elif isinstance(value, Float):
         value = float(value)
@@ -66,6 +71,8 @@ class SympyToQuantumExpressionTranslator(PythonCodePrinter):
         "BitwiseOr": "|",
         "BitwiseXor": "^",
         "LogicalXor": "^",
+        "RShift": ">>",
+        "LShift": "<<",
     }
     UNARY_BITWISE_OPERATORS_MAPPING = {"BitwiseNot": "~"}
 
@@ -117,6 +124,8 @@ class SympyToBoolExpressionTranslator(SympyToQuantumExpressionTranslator):
 
 
 def translate_sympy_quantum_expression(expr: Basic, preserve_bool_ops: bool) -> str:
+    if isinstance(expr, AnyClassicalValue):
+        return str(expr)
     if preserve_bool_ops:
         return SympyToBoolExpressionTranslator().doprint(expr)
     else:

classiq/model_expansions/transformers/model_renamer.py

@@ -2,8 +2,10 @@ import ast
 import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
+from functools import cmp_to_key
 from typing import TypeVar, cast
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.handle_binding import HandleBinding
@@ -23,6 +25,39 @@ def _replace_full_word(pattern: str, substitution: str, target: str) -> str:
     )
 
 
+def _handle_contains_handle(handle: HandleBinding, other_handle: HandleBinding) -> int:
+    if str(other_handle) in str(handle) or other_handle.qmod_expr in handle.qmod_expr:
+        return 1
+    if str(handle) in str(other_handle) or handle.qmod_expr in other_handle.qmod_expr:
+        return -1
+    return 0
+
+
+class ExprNormalizer(ast.NodeTransformer):
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        if not isinstance(node.func, ast.Name):
+            return self.generic_visit(node)
+        if node.func.id == "get_field":
+            if (
+                len(node.args) != 2
+                or not isinstance(node.args[1], ast.Constant)
+                or not isinstance(node.args[1].value, str)
+            ):
+                raise ClassiqInternalExpansionError("Unexpected 'get_field' arguments")
+            return ast.Attribute(
+                value=self.visit(node.args[0]), attr=node.args[1].value
+            )
+        if node.func.id == "do_subscript":
+            if len(node.args) != 2:
+                raise ClassiqInternalExpansionError(
+                    "Unexpected 'do_subscript' arguments"
+                )
+            return ast.Subscript(
+                value=self.visit(node.args[0]), slice=self.visit(node.args[1])
+            )
+        return self.generic_visit(node)
+
+
 @dataclass(frozen=True)
 class HandleRenaming:
     source_handle: HandleBinding
@@ -39,26 +74,29 @@ SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 def _rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
+    normalized_expr = ExprNormalizer().visit(ast.parse(expression.expr))
     vrc = VarRefCollector(
         ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
     )
-    vrc.visit(ast.parse(expression.expr))
+    vrc.visit(normalized_expr)
 
     handle_names = {
         part.source_handle: part.target_var_handle
         for parts in symbol_mapping.values()
         for part in parts
     }
-    new_expr_str = expression.expr
-    for handle in vrc.var_handles:
+    new_expr_str = ast.unparse(normalized_expr)
+    sorted_handles = sorted(
+        vrc.var_handles,
+        key=cmp_to_key(  # type:ignore[misc]
+            lambda handle, other_handle: _handle_contains_handle(other_handle, handle)
+        ),
+    )
+    for handle in sorted_handles:
         new_handle = handle.collapse()
         for handle_to_replace, replacement in handle_names.items():
             new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
         new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
-        if handle.qmod_expr != str(handle):
-            new_expr_str = _replace_full_word(
-                str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
-            )
 
     new_expr = Expression(expr=new_expr_str)
     new_expr._evaluated_expr = expression._evaluated_expr

classiq/model_expansions/utils/handles_collector.py

@@ -18,7 +18,7 @@ class _HandlesCollector(Visitor):
         self.handles.append(handle)
 
     def visit_Expression(self, expression: Expression) -> None:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(expression.expr))
         self.handles.extend(vrc.var_handles)
 

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -62,9 +62,9 @@ class SymbolicParamInference(ModelVisitor):
     def __init__(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: (
-            list[NamedParamsQuantumFunctionDeclaration] | None
-        ) = None,
+        additional_signatures: Optional[
+            list[NamedParamsQuantumFunctionDeclaration]
+        ] = None,
     ) -> None:
         self._functions = nameables_to_dict(functions)
         self._additional_signatures = (

classiq/model_expansions/visitors/variable_references.py

@@ -95,16 +95,25 @@ class VarRefCollector(ast.NodeVisitor):
     def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
         return self._get_field_handle(node.value, node.attr)
 
-    def visit_Call(self, node: ast.Call) -> Optional[FieldHandleBinding]:
-        if (
-            not isinstance(node.func, ast.Name)
-            or node.func.id != "get_field"
-            or len(node.args) != 2
-            or not isinstance(node.args[1], ast.Constant)
-            or not isinstance(node.args[1].value, str)
-        ):
+    def visit_Call(self, node: ast.Call) -> Optional[HandleBinding]:
+        if not isinstance(node.func, ast.Name):
             return self.generic_visit(node)
-        return self._get_field_handle(node.args[0], node.args[1].value)
+        if node.func.id == "get_field":
+            if (
+                len(node.args) != 2
+                or not isinstance(node.args[1], ast.Constant)
+                or not isinstance(node.args[1].value, str)
+            ):
+                raise ClassiqInternalExpansionError("Unexpected 'get_field' arguments")
+            return self._get_field_handle(node.args[0], node.args[1].value)
+        if node.func.id == "do_subscript":
+            if len(node.args) != 2:
+                raise ClassiqInternalExpansionError(
+                    "Unexpected 'do_subscript' arguments"
+                )
+            self.visit(node.args[1])
+            return self._get_subscript_handle(node.args[0], node.args[1])
+        return self.generic_visit(node)
 
     def _get_field_handle(
         self, subject: ast.expr, field: str
@@ -121,6 +130,33 @@ class VarRefCollector(ast.NodeVisitor):
             self._var_handles[handle] = True
         return handle
 
+    def _get_subscript_handle(
+        self, subject: ast.expr, subscript: ast.expr
+    ) -> Optional[HandleBinding]:
+        with self.set_nested():
+            base_handle = self.visit(subject)
+        if base_handle is None:
+            return None
+        handle: HandleBinding
+        if isinstance(subscript, ast.Slice):
+            if subscript.lower is None or subscript.upper is None:
+                raise ClassiqExpansionError(
+                    f"{str(base_handle)!r} slice must specify both lower and upper bounds"
+                )
+            handle = SlicedHandleBinding(
+                base_handle=base_handle,
+                start=Expression(expr=ast.unparse(subscript.lower)),
+                end=Expression(expr=ast.unparse(subscript.upper)),
+            )
+        else:
+            handle = SubscriptHandleBinding(
+                base_handle=base_handle,
+                index=Expression(expr=ast.unparse(subscript)),
+            )
+        if not self._is_nested:
+            self._var_handles[handle] = True
+        return handle
+
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
         if not self._ignore_sympy_symbols and node.id in set(
             SYMPY_SUPPORTED_EXPRESSIONS

classiq/open_library/functions/lookup_table.py

@@ -39,7 +39,7 @@ def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
         The quantum result of applying func to targets
 
     Notes:
-        Must be called inside a generative function (`@qfunc(generative=True)`)
+        Must be called inside a generative function (`@qfunc`)
     """
     if len(targets) == 0:
         raise ClassiqValueError("No targets specified")

classiq/open_library/functions/state_preparation.py

@@ -334,7 +334,7 @@ def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
     return 1 / np.sqrt(len(arr)) * np.array(sympy.fwht(np.array(arr)))
 
 
-@qfunc(generative=True)
+@qfunc
 def _load_phases(
     phases: list[float],
     target: QArray[QBit, Literal["log(get_field(phases, 'len'), 2)"]],

classiq/qmod/builtins/functions/allocation.py

@@ -2,11 +2,11 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QFree
 
 
 @qfunc(external=True)
-def free(in_: Input[QArray[QBit]]) -> None:
+def free(in_: QFree[Input[QArray[QBit]]]) -> None:
     """
     [Qmod core-library function]
 

classiq/qmod/builtins/functions/arithmetic.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CBool, CReal
-from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
+from classiq.qmod.qmod_variable import Const, Output, QArray, QBit, QFree, QNum
 
 
 @qfunc(external=True)
@@ -24,13 +24,15 @@ def unitary(
 
 @qfunc(external=True)
 def add(
-    left: QNum,
-    right: QNum,
-    result: Output[
-        QNum[
-            Literal["result_size"],
-            Literal["result_is_signed"],
-            Literal["result_fraction_places"],
+    left: Const[QNum],
+    right: Const[QNum],
+    result: QFree[
+        Output[
+            QNum[
+                Literal["result_size"],
+                Literal["result_is_signed"],
+                Literal["result_fraction_places"],
+            ]
         ]
     ],
     result_size: CReal,
@@ -41,20 +43,20 @@ def add(
 
 
 @qfunc(external=True)
-def modular_add(left: QArray[QBit], right: QArray[QBit]) -> None:
+def modular_add(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
     pass
 
 
 @qfunc(external=True)
-def modular_add_constant(left: CReal, right: QNum) -> None:
+def modular_add_constant(left: CReal, right: QFree[QNum]) -> None:
     pass
 
 
 @qfunc(external=True)
-def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
+def integer_xor(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
     pass
 
 
 @qfunc(external=True)
-def real_xor_constant(left: CReal, right: QNum) -> None:
+def real_xor_constant(left: CReal, right: QFree[QNum]) -> None:
     pass