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

classiq/interface/debug_info/debug_info.py

@@ -1,5 +1,5 @@
-from collections.abc import Mapping
-from typing import Optional, Union
+from collections.abc import Mapping, Sequence
+from typing import Optional, Union, cast
 from uuid import UUID
 
 from pydantic import BaseModel, Field
@@ -10,6 +10,10 @@ from classiq.interface.generator.generated_circuit_data import (
     StatementType,
 )
 from classiq.interface.model.block import Block
+from classiq.interface.model.handle_binding import ConcreteHandleBinding
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 
 ParameterValue = Union[float, int, str, None]
@@ -98,3 +102,13 @@ def new_function_debug_info_by_node(
         name="",
         node=node._as_back_ref(),
     )
+
+
+def calculate_port_to_passed_variable_mapping(
+    arg_decls: Sequence[PositionalArg], args: Sequence[Union[ArgValue, None]]
+) -> dict[str, str]:
+    return {
+        arg_decl.name: str(cast(ConcreteHandleBinding, arg))
+        for arg_decl, arg in zip(arg_decls, args)
+        if isinstance(arg_decl, PortDeclaration)
+    }

classiq/interface/executor/user_budget.py

@@ -0,0 +1,56 @@
+import datetime
+from collections import defaultdict
+from typing import Optional
+
+import pydantic
+from pydantic import ConfigDict, Field
+
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class UserBudget(VersionedModel):
+    provider: str
+    currency_code: str
+    organization: Optional[str] = Field(default=None)
+    available_budget: float
+    used_budget: float
+    last_allocation_date: datetime.datetime
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class UserBudgets(VersionedModel):
+    budgets: list[UserBudget] = pydantic.Field(default=[])
+
+    def print_budgets(self) -> None:
+        def format_header() -> str:
+            return f"| {'Provider':<20} | {'Available Budget':<18} | {'Used Budget':<18} | {'Currency':<8} |"
+
+        def format_row(
+            provider: str, available: float, used: float, currency: str
+        ) -> str:
+            return f"| {provider:<20} | {available:<18.0f} | {used:<18.0f} | {currency:<8} |"
+
+        table_data: dict = defaultdict(
+            lambda: {"used": 0.0, "available": 0.0, "currency": "USD"}
+        )
+
+        for budget in self.budgets:
+            provider = budget.provider
+            table_data[provider]["available"] += budget.available_budget
+            table_data[provider]["used"] += budget.used_budget
+            table_data[provider]["currency"] = budget.currency_code
+
+        line = "=" * 77
+        print(line)  # noqa: T201
+        print(format_header())  # noqa: T201
+        print(line)  # noqa: T201
+
+        for provider, values in table_data.items():
+            print(  # noqa: T201
+                format_row(
+                    provider, values["available"], values["used"], values["currency"]
+                )
+            )
+
+        print(line)  # noqa: T201

classiq/interface/generator/application_apis/finance_declarations.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -55,11 +56,13 @@ def _generate_finance_function(
                     )
                 ),
                 direction=PortDeclarationDirection.Inout,
+                type_qualifier=TypeQualifier.Quantum,
             ),
             PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
                 quantum_type=QuantumBit(),
                 direction=PortDeclarationDirection.Inout,
+                type_qualifier=TypeQualifier.Quantum,
             ),
         ],
     )

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -15,6 +15,7 @@ SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
+    "mod_inverse",
 }
 
 SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
@@ -23,6 +24,8 @@ SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "BitwiseNot",
     "BitwiseOr",
     "LogicalXor",
+    "RShift",
+    "LShift",
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/interface/generator/expressions/proxies/classical/any_classical_value.py

@@ -1,135 +1,41 @@
+import inspect
 from typing import Any
 
+import sympy
 
-class AnyClassicalValue:
-    def __init__(self, expr: str) -> None:
-        self._expr = expr
+_SYMPY_MEMBERS = [name for name, _ in inspect.getmembers(sympy.Symbol)] + ["precedence"]
 
-    def __str__(self) -> str:
-        return self._expr
 
-    def __repr__(self) -> str:
-        return str(self)
+def subscript_to_str(index: Any) -> str:
+    if not isinstance(index, slice):
+        return str(index)
+    expr = ""
+    if index.start is not None:
+        expr += str(index.start)
+    expr += ":"
+    if index.stop is not None:
+        expr += str(index.stop)
+    if index.step is not None:
+        expr += f":{index.step}"
+    return expr
 
-    def __getitem__(self, item: Any) -> "AnyClassicalValue":
-        if isinstance(item, slice):
-            subscript = ""
-            if item.start is not None:
-                subscript += str(item.start)
-            subscript += ":"
-            if item.stop is not None:
-                subscript += str(item.stop)
-            if item.step is not None:
-                subscript += f":{item.stop}"
-            item = subscript
-        return AnyClassicalValue(f"{self}[{item}]")
-
-    @staticmethod
-    def _binary_op(lhs: Any, rhs: Any, op: str) -> "AnyClassicalValue":
-        return AnyClassicalValue(f"{lhs} {op} {rhs}")
-
-    @staticmethod
-    def _unary_op(arg: Any, op: str) -> "AnyClassicalValue":
-        return AnyClassicalValue(f"{op}({arg})")
-
-    def __add__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "+")
-
-    def __sub__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "-")
-
-    def __mul__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "*")
-
-    def __truediv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "/")
-
-    def __floordiv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "//")
-
-    def __mod__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "%")
-
-    def __pow__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "**")
-
-    def __lshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<<")
-
-    def __rshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">>")
-
-    def __and__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "&")
-
-    def __xor__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "^")
-
-    def __or__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "|")
-
-    def __radd__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "+")
-
-    def __rsub__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "-")
 
-    def __rmul__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "*")
+class AnyClassicalValue(sympy.Symbol):
 
-    def __rtruediv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "/")
+    is_commutative = None
+    is_infinite = None
+    is_finite = None
+    is_extended_real = None
 
-    def __rfloordiv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "//")
-
-    def __rmod__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "%")
-
-    def __rpow__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "**")
-
-    def __rlshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "<<")
-
-    def __rrshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, ">>")
-
-    def __rand__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "&")
-
-    def __rxor__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "^")
-
-    def __ror__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "|")
-
-    def __lt__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<")
-
-    def __le__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<=")
-
-    def __eq__(self, other: Any) -> "AnyClassicalValue":  # type:ignore[override]
-        return AnyClassicalValue._binary_op(self, other, "==")
-
-    def __ne__(self, other: Any) -> "AnyClassicalValue":  # type: ignore[override]
-        return AnyClassicalValue._binary_op(self, other, "!=")
-
-    def __gt__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">")
-
-    def __ge__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">=")
-
-    def __neg__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "-")
-
-    def __pos__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "+")
+    def __getitem__(self, item: Any) -> "AnyClassicalValue":
+        if isinstance(item, slice):
+            return AnyClassicalValue(f"{self}[{subscript_to_str(item)}]")
+        return AnyClassicalValue(f"do_subscript({self}, {item})")
 
-    def __abs__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "abs")
+    def __getattribute__(self, attr: str) -> Any:
+        if attr.startswith("_") or attr in _SYMPY_MEMBERS:
+            return super().__getattribute__(attr)
+        return AnyClassicalValue(f"get_field({self}, '{attr}')")
 
-    def __invert__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "~")
+    def __len__(self) -> "AnyClassicalValue":
+        return self.len

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -1,11 +1,16 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Union
 
+import sympy
 from sympy import Integer
+from typing_extensions import TypeGuard
 
 from classiq.interface.exceptions import ClassiqIndexError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -22,9 +27,20 @@ if TYPE_CHECKING:
     )
 
 
+def _is_int(val: Any) -> TypeGuard[Union[int, sympy.Basic]]:
+    if isinstance(val, AnyClassicalValue):
+        return False
+    if isinstance(val, sympy.Basic):
+        return val.is_Number
+    return isinstance(val, int)
+
+
 class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
     def __init__(
-        self, handle: HandleBinding, element_type: "ConcreteClassicalType", length: int
+        self,
+        handle: HandleBinding,
+        element_type: "ConcreteClassicalType",
+        length: "ExpressionValue",
     ) -> None:
         super().__init__(handle)
         self._element_type = element_type
@@ -39,39 +55,47 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
         return "Array"
 
     @property
-    def length(self) -> int:
+    def length(self) -> "ExpressionValue":
         return self._length
 
-    def __getitem__(self, key: Union[slice, int, Integer]) -> ClassicalProxy:
+    def __getitem__(
+        self, key: Union[slice, int, Integer, ClassicalProxy]
+    ) -> ClassicalProxy:
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
         )
 
     def _get_slice(self, slice_: slice) -> ClassicalProxy:
-        start = int(slice_.start)
-        stop = int(slice_.stop)
-        if start >= stop:
-            raise ClassiqIndexError("Array slice has non-positive length")
-        if start < 0 or stop > self._length:
-            raise ClassiqIndexError("Array slice is out of bounds")
+        start_ = slice_.start
+        stop_ = slice_.stop
+        if _is_int(start_) and _is_int(stop_):
+            start = int(start_)
+            stop = int(stop_)
+            if start >= stop:
+                raise ClassiqIndexError("Array slice has non-positive length")
+            if start < 0 or (isinstance(self._length, int) and stop > self._length):
+                raise ClassiqIndexError("Array slice is out of bounds")
         return ClassicalArrayProxy(
             SlicedHandleBinding(
                 base_handle=self.handle,
-                start=Expression(expr=str(start)),
-                end=Expression(expr=str(stop)),
+                start=Expression(expr=str(start_)),
+                end=Expression(expr=str(stop_)),
             ),
             self._element_type,
-            stop - start,
+            stop_ - start_,
         )
 
-    def _get_subscript(self, index_: Union[int, Integer]) -> ClassicalProxy:
-        index = int(index_)
-        if index < 0:
-            raise ClassiqIndexError(
-                "Array index is out of bounds (negative indices are not supported)"
-            )
-        if index >= self._length:
-            raise ClassiqIndexError("Array index is out of bounds")
+    def _get_subscript(
+        self, index_: Union[int, Integer, ClassicalProxy]
+    ) -> ClassicalProxy:
+        if _is_int(index_):
+            index = int(index_)
+            if index < 0:
+                raise ClassiqIndexError(
+                    "Array index is out of bounds (negative indices are not supported)"
+                )
+            if isinstance(self._length, int) and index >= self._length:
+                raise ClassiqIndexError("Array index is out of bounds")
         return self._element_type.get_classical_proxy(
             SubscriptHandleBinding(
                 base_handle=self._handle, index=Expression(expr=str(index_))

classiq/interface/generator/expressions/proxies/classical/qmod_struct_instance.py

@@ -25,6 +25,13 @@ class QmodStructInstance:
     def fields(self) -> Mapping[str, Any]:
         return types.MappingProxyType(self._fields)
 
+    def __getattr__(self, item: str) -> Any:
+        if item == "_fields":
+            return super().__getattribute__(item)
+        if item in self._fields:
+            return self._fields[item]
+        return super().__getattribute__(item)
+
     def __str__(self) -> str:
         return repr(self)
 

classiq/interface/generator/expressions/proxies/classical/utils.py

@@ -13,6 +13,7 @@ from classiq.interface.generator.expressions.proxies.classical.classical_struct_
 )
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
+    ClassicalList,
     ClassicalType,
 )
 from classiq.interface.generator.functions.type_name import Struct
@@ -20,15 +21,15 @@ from classiq.interface.generator.functions.type_name import Struct
 
 def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
     if isinstance(proxy, ClassicalScalarProxy):
-        classical_type = proxy._classical_type
-    elif isinstance(proxy, ClassicalArrayProxy):
-        classical_type = ClassicalArray(
-            element_type=proxy._element_type, size=proxy.length
-        )
-    elif isinstance(proxy, ClassicalStructProxy):
+        return proxy._classical_type
+    if isinstance(proxy, ClassicalArrayProxy):
+        if not isinstance(proxy.length, int):
+            return ClassicalList(element_type=proxy._element_type)
+        return ClassicalArray(element_type=proxy._element_type, size=proxy.length)
+    if isinstance(proxy, ClassicalStructProxy):
         classical_type = Struct(name=proxy._decl.name)
-    else:
-        raise ClassiqInternalExpansionError(
-            f"Unrecognized classical proxy {type(proxy).__name__}"
-        )
-    return classical_type
+        classical_type.set_classical_struct_decl(proxy._decl)
+        return classical_type
+    raise ClassiqInternalExpansionError(
+        f"Unrecognized classical proxy {type(proxy).__name__}"
+    )

classiq/interface/generator/expressions/proxies/quantum/qmod_qarray_proxy.py

@@ -1,7 +1,7 @@
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, Union
 
-from sympy import Integer
+import sympy
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
@@ -28,22 +28,20 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
         self,
         handle: HandleBinding,
         element_type: "QuantumType",
-        element_size: int,
-        length: int,
+        element_size: Union[int, sympy.Basic],
+        length: Union[int, sympy.Basic],
     ) -> None:
         super().__init__(handle, element_size * length)
         self._length = length
         self._element_type = element_type
         self._element_size = element_size
 
-    def __getitem__(self, key: Union[slice, int, Integer]) -> "QmodSizedProxy":
+    def __getitem__(self, key: Any) -> "QmodSizedProxy":
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
         )
 
-    def _get_subscript(self, index: Union[int, Integer]) -> "QmodSizedProxy":
-        if isinstance(index, Integer):
-            index = int(index)
+    def _get_subscript(self, index: Any) -> "QmodSizedProxy":
         return self._element_type.get_proxy(
             SubscriptHandleBinding(
                 base_handle=self.handle,
@@ -54,13 +52,6 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
     def _get_slice(self, slice_: slice) -> "QmodSizedProxy":
         if slice_.step is not None:
             raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
-        if isinstance(slice_.start, Integer):
-            slice_ = slice(int(slice_.start), slice_.stop)
-        if isinstance(slice_.stop, Integer):
-            slice_ = slice(slice_.start, int(slice_.stop))
-        if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
-            raise ClassiqValueError(ILLEGAL_SLICE_MSG)
-
         return QmodQArrayProxy(
             SlicedHandleBinding(
                 base_handle=self.handle,
@@ -77,7 +68,7 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
         return "Quantum array"
 
     @property
-    def len(self) -> int:
+    def len(self) -> Union[int, sympy.Basic]:
         return self._length
 
     @property

classiq/interface/generator/expressions/proxies/quantum/qmod_qscalar_proxy.py

@@ -1,7 +1,9 @@
 from collections.abc import Mapping
-from typing import Any
+from typing import Any, Optional, Union
 
+import sympy
 from sympy import Symbol
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
@@ -12,11 +14,17 @@ from classiq.interface.model.handle_binding import HandleBinding
 
 class QmodQScalarProxy(Symbol, QmodSizedProxy):
     def __new__(cls, handle: HandleBinding, **assumptions: bool) -> "QmodQScalarProxy":
-        return super().__new__(cls, str(handle), **assumptions)
+        return super().__new__(cls, handle.qmod_expr, **assumptions)
 
     def __init__(self, handle: HandleBinding, size: int) -> None:
         super().__init__(handle, size)
 
+    def __copy__(self) -> Self:
+        return self
+
+    def __deepcopy__(self, memo: Optional[dict]) -> Self:
+        return self
+
 
 class QmodQBitProxy(QmodQScalarProxy):
     def __init__(self, handle: HandleBinding) -> None:
@@ -29,10 +37,18 @@ class QmodQBitProxy(QmodQScalarProxy):
 
 class QmodQNumProxy(QmodQScalarProxy):
     def __init__(
-        self, handle: HandleBinding, size: int, fraction_digits: int, is_signed: bool
+        self,
+        handle: HandleBinding,
+        size: Union[int, sympy.Basic],
+        fraction_digits: Union[int, sympy.Basic],
+        is_signed: Union[bool, sympy.Basic],
     ) -> None:
         super().__init__(handle, size)
-        if fraction_digits > size:
+        if (
+            isinstance(fraction_digits, int)
+            and isinstance(size, int)
+            and fraction_digits > size
+        ):
             raise ClassiqValueError(
                 f"Quantum numeric of size {size} cannot have {fraction_digits} "
                 f"fraction digits"
@@ -45,11 +61,11 @@ class QmodQNumProxy(QmodQScalarProxy):
         return "Quantum numeric"
 
     @property
-    def fraction_digits(self) -> int:
+    def fraction_digits(self) -> Union[int, sympy.Basic]:
         return self._fraction_digits
 
     @property
-    def is_signed(self) -> bool:
+    def is_signed(self) -> Union[bool, sympy.Basic]:
         return self._is_signed
 
     @property

classiq/interface/generator/expressions/proxies/quantum/qmod_sized_proxy.py

@@ -1,21 +1,26 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Union
+
+import sympy
 
 if TYPE_CHECKING:
     from classiq.interface.model.handle_binding import HandleBinding
 
 
 class QmodSizedProxy:
-    def __init__(self, handle: "HandleBinding", size: int) -> None:
+    def __init__(self, handle: "HandleBinding", size: Union[int, sympy.Basic]) -> None:
         self._handle = handle
         self._size = size
 
     @property
-    def size(self) -> int:
+    def size(self) -> Union[int, sympy.Basic]:
         return self._size
 
     def __str__(self) -> str:
-        return str(self.handle)
+        return self.handle.qmod_expr
+
+    def __repr__(self) -> str:
+        return str(self)
 
     @property
     def type_name(self) -> str:

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -33,6 +33,7 @@ MATHEMATICAL_FUNCTIONS: list[str] = [
     "Max",
     "Min",
     "mod_inverse",
+    "Mod",
 ]
 SPECIAL_FUNCTIONS: list[str] = [
     "erf",

classiq/interface/generator/functions/classical_type.py

@@ -6,6 +6,9 @@ from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
 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.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
 )
@@ -94,7 +97,9 @@ class ClassicalList(ClassicalType):
         return values_with_discriminator(values, "kind", "list")
 
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        raise NotImplementedError
+        return ClassicalArrayProxy(
+            handle, self.element_type, AnyClassicalValue(f"get_field({handle}, 'len')")
+        )
 
     @property
     def expressions(self) -> list[Expression]:

classiq/interface/generator/functions/type_name.py

@@ -9,6 +9,9 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
     ClassicalStructProxy,
 )
@@ -109,8 +112,10 @@ class TypeName(ClassicalType, QuantumType):
         self._classical_struct_decl = decl
 
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        if self._classical_struct_decl is None:
-            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
+        if self.is_enum:
+            return ClassicalScalarProxy(handle, self)
+        if TYPE_CHECKING:
+            assert self._classical_struct_decl is not None
         return ClassicalStructProxy(handle, self._classical_struct_decl)
 
     @property