classiq 0.89.0__py3-none-any.whl → 0.91.0__py3-none-any.whl

classiq/evaluators/expression_evaluator.py

@@ -1,144 +1,48 @@
-import ast
-from collections.abc import Mapping
-from enum import EnumMeta
+from enum import Enum
 from typing import Any
 
-from sympy import SympifyError, sympify
+import sympy
 
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.expressions.evaluated_expression import (
-    EvaluatedExpression,
-)
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.expression_types import ExpressionValue
-from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.generator.expressions.sympy_supported_expressions import (
-    SYMPY_SUPPORTED_EXPRESSIONS,
+from classiq.interface.generator.expressions.expression_types import RuntimeConstant
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
 )
 
-from classiq.model_expansions.atomic_expression_functions_defs import (
-    ATOMIC_EXPRESSION_FUNCTIONS,
-    qmod_val_to_python,
-)
-from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
-    translate_to_sympy,
-)
-from classiq.model_expansions.sympy_conversion.sympy_to_python import sympy_to_python
-from classiq.qmod import symbolic
-from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
-from classiq.qmod.model_state_container import QMODULE
+from classiq.evaluators.classical_expression import evaluate_classical_expression
+from classiq.model_expansions.scope import Evaluated, Scope
+
+
+def qmod_val_to_python(val: RuntimeConstant) -> Any:
+    if isinstance(val, (int, float, bool, complex, Enum)):
+        return val
+    if isinstance(val, list):
+        return [qmod_val_to_python(item) for item in val]
+    if isinstance(val, QmodStructInstance):
+        return {
+            field_name: qmod_val_to_python(field_val)
+            for field_name, field_val in val.fields.items()
+        }
+    if isinstance(val, sympy.Expr):
+        return val.evalf()
+    raise ClassiqInternalExpansionError(
+        f"Could not convert Qmod value {str(val)!r} of type {type(val).__name__} to Python"
+    )
 
 
-def evaluate_constants(constants: list[Constant]) -> dict[str, EvaluatedExpression]:
-    result: dict[str, EvaluatedExpression] = {}
+def evaluate_constants(constants: list[Constant]) -> Scope:
+    result = Scope()
     for constant in constants:
-        result[constant.name] = evaluate(constant.value, result)
+        expr_val = evaluate_classical_expression(constant.value, result).value
+        result[constant.name] = Evaluated(value=expr_val)
+
     return result
 
 
 def evaluate_constants_as_python(constants: list[Constant]) -> dict[str, Any]:
     evaluated = evaluate_constants(constants)
     return {
-        constant.name: qmod_val_to_python(
-            evaluated[constant.name].value, constant.const_type
-        )
+        constant.name: qmod_val_to_python(evaluated[constant.name].value)
         for constant in constants
     }
-
-
-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]
-) -> 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(
-        {
-            enum_decl.name: enum_decl.create_enum()
-            for enum_decl in (QMODULE.enum_decls | BUILTIN_ENUM_DECLARATIONS).values()
-        }
-    )
-    # locals override builtin-functions
-    model_locals.update({name: expr.value for name, expr in locals_dict.items()})
-
-    _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 e
-    except AttributeError as e:
-        if isinstance(e.obj, EnumMeta):
-            raise ClassiqExpansionError(
-                f"Enum {e.obj.__name__} has no member {e.name!r}. Available members: "
-                f"{', '.join(e.obj.__members__)}"
-            ) from e
-        raise
-    except SympifyError as e:
-        expr = e.expr
-        if isinstance(expr, QmodSizedProxy) and isinstance(expr, NonSymbolicExpr):
-            raise ClassiqExpansionError(
-                f"{expr.type_name} {str(expr)!r} does not support arithmetic operations"
-            ) from e
-        raise
-
-    return EvaluatedExpression(
-        value=sympy_to_python(sympify_result, locals=model_locals)
-    )
-
-
-def _validate_undefined_vars(
-    expr: str, model_locals: dict[str, ExpressionValue]
-) -> None:
-    id_visitor = _VarsCollector()
-    id_visitor.visit(ast.parse(expr))
-    identifiers = id_visitor.vars
-    undefined_vars = (
-        identifiers
-        - model_locals.keys()
-        - set(SYMPY_SUPPORTED_EXPRESSIONS)
-        - set(symbolic.__all__)
-    )
-
-    if len(undefined_vars) == 1:
-        undefined_var = undefined_vars.__iter__().__next__()
-        raise ClassiqExpansionError(f"Variable {undefined_var!r} is undefined")
-    elif len(undefined_vars) > 1:
-        raise ClassiqExpansionError(f"Variables {list(undefined_vars)} are undefined")
-
-
-class _VarsCollector(ast.NodeTransformer):
-    def __init__(self) -> None:
-        self.vars: set[str] = set()
-
-    def visit_Name(self, node: ast.Name) -> None:
-        self.vars.add(node.id)
-
-    def visit_Call(self, node: ast.Call) -> None:
-        func = node.func
-        self.visit(func)
-        if not isinstance(func, ast.Name) or func.id != "struct_literal":
-            for arg in node.args:
-                self.visit(arg)
-        for kw in node.keywords:
-            self.visit(kw)

classiq/evaluators/parameter_types.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, NoReturn, TypeVar, Union
 
 import sympy
 
@@ -6,14 +6,17 @@ 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.expressions.evaluated_expression import (
+    EvaluatedExpression,
 )
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import RuntimeConstant
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
     ClassicalTuple,
     ClassicalType,
+    Integer,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
@@ -22,12 +25,14 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
+from classiq.interface.helpers.backward_compatibility import zip_strict
 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 (
+    AnonQuantumOperandDeclaration,
     PositionalArg,
     QuantumOperandDeclaration,
 )
@@ -38,71 +43,62 @@ from classiq.interface.model.quantum_type import (
     QuantumType,
 )
 
-from classiq.evaluators.arg_type_match import check_type_match
 from classiq.evaluators.classical_expression import (
     evaluate_classical_expression,
 )
-from classiq.evaluators.classical_type_inference import (
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType, get_sympy_val
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
     infer_classical_type,
+    inject_classical_type_attributes,
 )
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes,
+    validate_quantum_type_attributes,
 )
+from classiq.evaluators.type_type_match import check_signature_match
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.scope import (
+    ClassicalSymbol,
     Evaluated,
     QuantumSymbol,
     QuantumVariable,
     Scope,
 )
+from classiq.model_expansions.visitors.symbolic_param_inference import (
+    set_generative_recursively,
+)
 
 
 def evaluate_parameter_types_from_args(
-    closure: FunctionClosure, signature_scope: Scope, arguments: list[Evaluated]
+    closure: FunctionClosure, arguments: list[Evaluated]
 ) -> list[PositionalArg]:
     parameters = closure.positional_arg_declarations
-    function_name = closure.name
-    check_type_match(parameters, arguments, function_name)
+    if len(parameters) != len(arguments):
+        raise ClassiqExpansionError(
+            f"Function {closure.name!r} takes {len(parameters)} arguments but "
+            f"{len(arguments)} were given"
+        )
+
+    for parameter, argument in zip_strict(parameters, arguments, strict=True):
+        if isinstance(parameter, ClassicalParameterDeclaration):
+            arg_val = argument.value
+            if not isinstance(arg_val, QmodAnnotatedExpression):
+                closure.scope[parameter.name] = argument
 
-    for parameter, argument in zip(parameters, arguments):
-        _update_scope(parameter, argument, closure)
+    evaluated_params = [
+        _evaluate_type_from_arg(parameter, argument, closure)
+        for parameter, argument in zip_strict(parameters, arguments, strict=True)
+    ]
 
     parameter_names = {parameter.name for parameter in parameters}
-    for parameter in parameters:
+    for parameter, argument in zip_strict(parameters, arguments, strict=True):
         if isinstance(parameter, QuantumOperandDeclaration):
-            parameter_value = closure.scope[parameter.name].value
             _update_operand_signature_environment(
-                parameter_value, parameter_names, closure
+                argument.value, parameter_names, closure
             )
 
-    return [
-        _evaluate_type_from_arg(
-            parameter,
-            argument,
-            Scope(parent=closure.scope | signature_scope),
-            closure.name,
-        )
-        for parameter, argument in zip(parameters, arguments)
-    ]
-
-
-def _update_scope(
-    parameter: PositionalArg, argument: Evaluated, closure: FunctionClosure
-) -> None:
-    if not isinstance(parameter, PortDeclaration):
-        closure.scope[parameter.name] = argument
-        return
-    if parameter.direction is PortDeclarationDirection.Output:
-        return
-    quantum_var = argument.as_type(QuantumVariable)
-    casted_argument = _cast(
-        parameter.quantum_type,
-        quantum_var,
-        parameter.name,
-    )
-    closure.scope[parameter.name] = Evaluated(
-        value=casted_argument, defining_function=closure
-    )
+    return evaluated_params
 
 
 NestedFunctionClosureT = Union[FunctionClosure, list["NestedFunctionClosureT"]]
@@ -130,60 +126,162 @@ def _update_operand_signature_environment(
     )
 
 
-def _cast(
-    parameter_type: QuantumType, argument: QuantumVariable, param_name: str
-) -> QuantumSymbol:
-    updated_type = inject_quantum_type_attributes(argument.quantum_type, parameter_type)
-    if updated_type is None:
-        raise ClassiqExpansionError(
-            f"Argument {str(argument)!r} of type "
-            f"{argument.quantum_type.qmod_type_name} is incompatible with parameter "
-            f"{param_name!r} of type {parameter_type.qmod_type_name}"
-        )
-    return QuantumSymbol(
-        handle=HandleBinding(name=param_name), quantum_type=updated_type
-    )
-
-
 def _evaluate_type_from_arg(
     parameter: PositionalArg,
     argument: Evaluated,
-    inner_scope: Scope,
-    function_name: str,
+    closure: FunctionClosure,
 ) -> PositionalArg:
     # FIXME: Remove suzuki_trotter overloading (CLS-2912)
-    if function_name == "suzuki_trotter" and parameter.name == "pauli_operator":
+    if closure.name == "suzuki_trotter" and parameter.name == "pauli_operator":
         return parameter
     if isinstance(parameter, ClassicalParameterDeclaration):
-        updated_classical_type = evaluate_type_in_classical_symbol(
-            parameter.classical_type.model_copy(), inner_scope, parameter.name
-        )
-        return ClassicalParameterDeclaration(
-            name=parameter.name,
-            classical_type=infer_classical_type(argument.value, updated_classical_type),
+        return _evaluate_classical_type_from_arg(parameter, argument, closure)
+    if isinstance(parameter, PortDeclaration):
+        return _evaluate_quantum_type_from_arg(parameter, argument, closure)
+    if TYPE_CHECKING:
+        assert isinstance(parameter, QuantumOperandDeclaration)
+    if parameter.is_list:
+        return _evaluate_op_list_type_from_arg(parameter, argument, closure)
+    else:
+        return _evaluate_op_type_from_arg(parameter, argument, closure)
+
+
+def _evaluate_classical_type_from_arg(
+    parameter: ClassicalParameterDeclaration,
+    argument: Evaluated,
+    closure: FunctionClosure,
+) -> ClassicalParameterDeclaration:
+    unified_scope = closure.scope | closure.signature_scope
+    updated_classical_type = evaluate_type_in_classical_symbol(
+        parameter.classical_type.model_copy(), unified_scope, parameter.name
+    )
+    arg_val = argument.value
+    if isinstance(arg_val, QmodAnnotatedExpression):
+        arg_type = arg_val.get_classical_type(arg_val.root)
+    else:
+        arg_type = infer_classical_type(arg_val)
+    injected_classical_type = inject_classical_type_attributes(
+        arg_type.without_symbolic_attributes(), updated_classical_type
+    )
+    if injected_classical_type is None:
+        _raise_argument_type_error(
+            arg_val, arg_type, parameter.name, updated_classical_type
         )
+    if parameter.classical_type.is_purely_generative:
+        set_generative_recursively(injected_classical_type)
+    closure.scope[parameter.name] = Evaluated(
+        value=(
+            ClassicalSymbol(
+                handle=HandleBinding(name=parameter.name),
+                classical_type=injected_classical_type,
+            )
+            if isinstance(arg_val, QmodAnnotatedExpression)
+            else arg_val
+        ),
+        defining_function=closure,
+    )
+    return ClassicalParameterDeclaration(
+        name=parameter.name, classical_type=injected_classical_type
+    )
 
-    if not isinstance(parameter, PortDeclaration):
-        return parameter
 
+def _evaluate_quantum_type_from_arg(
+    parameter: PortDeclaration,
+    argument: Evaluated,
+    closure: FunctionClosure,
+) -> PortDeclaration:
+    unified_scope = closure.scope | closure.signature_scope
     updated_quantum_type: QuantumType = evaluate_type_in_quantum_symbol(
-        parameter.quantum_type.model_copy(), inner_scope, parameter.name
+        parameter.quantum_type.model_copy(), unified_scope, parameter.name
     )
     if parameter.direction != PortDeclarationDirection.Output:
         arg_type = argument.as_type(QuantumVariable).quantum_type
         updated_output_quantum_type = inject_quantum_type_attributes(
-            arg_type, updated_quantum_type
+            arg_type.without_symbolic_attributes(), updated_quantum_type
         )
         if updated_output_quantum_type is None:
-            raise ClassiqExpansionError(
-                f"Argument {str(argument.value)!r} of type "
-                f"{arg_type.qmod_type_name} is incompatible with parameter "
-                f"{parameter.name!r} of type {updated_quantum_type.qmod_type_name}"
+            _raise_argument_type_error(
+                argument.value, arg_type, parameter.name, updated_quantum_type
             )
         updated_quantum_type = updated_output_quantum_type
+    validate_quantum_type_attributes(updated_quantum_type)
+    closure.scope[parameter.name] = Evaluated(
+        value=QuantumSymbol(
+            handle=HandleBinding(name=parameter.name), quantum_type=updated_quantum_type
+        ),
+        defining_function=closure,
+    )
     return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
 
+def _evaluate_op_list_type_from_arg(
+    parameter: QuantumOperandDeclaration, argument: Evaluated, closure: FunctionClosure
+) -> QuantumOperandDeclaration:
+    arg_val = argument.value
+    if not isinstance(arg_val, list) or any(
+        not isinstance(op, FunctionClosure) for op in arg_val
+    ):
+        if isinstance(arg_val, FunctionClosure):
+            _raise_argument_type_error(
+                "<lambda>",
+                arg_val.as_operand_declaration(is_list=False),
+                parameter.name,
+                parameter,
+            )
+        raise ClassiqInternalExpansionError("Non-lambda argument to lambda parameter")
+    for idx, operand in enumerate(arg_val):
+        check_signature_match(
+            parameter.positional_arg_declarations,
+            operand.positional_arg_declarations,
+            f"operand #{idx + 1} in parameter {parameter.name!r} "
+            f"in function {closure.name!r}",
+        )
+    return parameter
+
+
+def _evaluate_op_type_from_arg(
+    parameter: QuantumOperandDeclaration, argument: Evaluated, closure: FunctionClosure
+) -> QuantumOperandDeclaration:
+    arg_val = argument.value
+    if not isinstance(arg_val, FunctionClosure):
+        if isinstance(arg_val, list):
+            if len(arg_val) == 0:
+                _raise_argument_type_error(
+                    arg_val,
+                    AnonQuantumOperandDeclaration(is_list=True),
+                    parameter.name,
+                    parameter,
+                )
+            first_lambda = arg_val[0]
+            if isinstance(first_lambda, FunctionClosure):
+                _raise_argument_type_error(
+                    arg_val,
+                    first_lambda.as_operand_declaration(is_list=True),
+                    parameter.name,
+                    parameter,
+                )
+        raise ClassiqInternalExpansionError("Non-lambda argument to lambda parameter")
+    check_signature_match(
+        parameter.positional_arg_declarations,
+        arg_val.positional_arg_declarations,
+        f"operand {parameter.name!r} in function {closure.name!r}",
+    )
+    return parameter
+
+
+def _raise_argument_type_error(
+    arg_val: Any,
+    arg_type: Union[QmodType, AnonQuantumOperandDeclaration],
+    param_name: str,
+    param_type: Union[QmodType, AnonQuantumOperandDeclaration],
+) -> NoReturn:
+    raise ClassiqExpansionError(
+        f"Argument {str(arg_val)!r} of type "
+        f"{arg_type.qmod_type_name} is incompatible with parameter "
+        f"{param_name!r} of type {param_type.qmod_type_name}"
+    )
+
+
 def evaluate_type_in_quantum_symbol(
     type_to_update: QuantumType, scope: Scope, param_name: str
 ) -> ConcreteQuantumType:
@@ -206,16 +304,15 @@ def _evaluate_qarray_in_quantum_symbol(
     )
     type_to_update.element_type = new_element_type
     if type_to_update.length is not None:
-        new_length = _eval_expr(
+        type_to_update.length = _eval_expr(
             type_to_update.length,
             scope,
             int,
+            Integer,
             type_to_update.type_name,
             "length",
             param_name,
         )
-        if new_length is not None:
-            type_to_update.length = Expression(expr=str(new_length))
     return type_to_update
 
 
@@ -224,73 +321,74 @@ def _evaluate_qnum_in_quantum_symbol(
 ) -> QuantumNumeric:
     if type_to_update.size is None:
         return type_to_update
-    new_size = _eval_expr(
+    type_to_update.size = _eval_expr(
         type_to_update.size,
         scope,
         int,
+        Integer,
         type_to_update.type_name,
         "size",
         param_name,
     )
-    if new_size is not None:
-        type_to_update.size = Expression(expr=str(new_size))
 
     if type_to_update.is_signed is not None:
-        new_is_sign = _eval_expr(
+        type_to_update.is_signed = _eval_expr(
             type_to_update.is_signed,
             scope,
             bool,
+            Bool,
             type_to_update.type_name,
             "sign",
             param_name,
         )
-        if new_is_sign is not None:
-            type_to_update.is_signed = Expression(expr=str(new_is_sign))
     else:
         type_to_update.is_signed = Expression(expr="False")
 
     if type_to_update.fraction_digits is not None:
-        new_fraction_digits = _eval_expr(
+        type_to_update.fraction_digits = _eval_expr(
             type_to_update.fraction_digits,
             scope,
             int,
+            Integer,
             type_to_update.type_name,
             "fraction digits",
             param_name,
         )
-        if new_fraction_digits is not None:
-            type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     else:
         type_to_update.fraction_digits = Expression(expr="0")
 
     return type_to_update
 
 
-_EXPR_TYPE = TypeVar("_EXPR_TYPE")
+_EXPR_TYPE = TypeVar("_EXPR_TYPE", bound=RuntimeConstant)
 
 
 def _eval_expr(
     expression: Expression,
     scope: Scope,
     expected_type: type[_EXPR_TYPE],
+    expected_qmod_type: type,
     type_name: str,
     attr_name: str,
     param_name: str,
-) -> Optional[_EXPR_TYPE]:
-    val = evaluate_classical_expression(expression, scope).value
-    if expected_type is int and isinstance(val, float):
+) -> Expression:
+    val = evaluate_classical_expression(Expression(expr=expression.expr), scope).value
+    if isinstance(val, sympy.Basic):
+        val = get_sympy_val(val)
+    if expected_type is int and isinstance(val, float) and int(val) == val:
         val = int(val)
-    if isinstance(val, expected_type):
-        return val
-    if isinstance(val, AnyClassicalValue) or (
-        isinstance(val, sympy.Basic) and len(val.free_symbols) > 0
+    if not isinstance(val, expected_type) and (
+        not isinstance(val, QmodAnnotatedExpression)
+        or not isinstance(val.get_type(val.root), expected_qmod_type)
     ):
-        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}"
-    )
+        raise ClassiqExpansionError(
+            f"When inferring the type of parameter {param_name!r}: "
+            f"{type_name} {attr_name} must be {expected_qmod_type.__name__}, got "
+            f"{str(val)!r}"
+        )
+    expr = Expression(expr=str(val))
+    expr._evaluated_expr = EvaluatedExpression(value=val)
+    return expr
 
 
 def _evaluate_qstruct_in_quantum_symbol(
@@ -325,11 +423,9 @@ def evaluate_type_in_classical_symbol(
     if isinstance(type_to_update, ClassicalArray):
         length = type_to_update.length
         if length is not None:
-            new_length = _eval_expr(
-                length, scope, int, "classical array", "length", param_name
+            length = _eval_expr(
+                length, scope, int, Integer, "classical array", "length", param_name
             )
-            if new_length is not None:
-                length = Expression(expr=str(new_length))
         updated_type = ClassicalArray(
             element_type=evaluate_type_in_classical_symbol(
                 type_to_update.element_type, scope, param_name

classiq/evaluators/qmod_annotated_expression.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Union, cast
 
+import sympy
+
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
@@ -50,7 +52,7 @@ def qmod_val_to_str(val: Any) -> str:
         return f"[{', '.join(qmod_val_to_str(item) for item in val)}]"
     if isinstance(val, Enum):
         return Enum.__str__(val)
-    if isinstance(val, (int, float, bool, complex)):
+    if isinstance(val, (int, float, bool, complex, sympy.Basic)):
         return str(val)
     raise ClassiqInternalExpansionError(
         f"Unrecognized value {str(val)!r} of type {type(val)}"