classiq 0.45.1__py3-none-any.whl → 0.46.1__py3-none-any.whl

classiq/qmod/create_model_function.py

@@ -0,0 +1,190 @@
+from typing import TYPE_CHECKING, Dict, List, Optional, Union, cast
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.generator.model.constraints import Constraints
+from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedModel
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+
+from classiq.model_expansions.interpreter import Interpreter
+from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
+from classiq.qmod.classical_function import CFunc
+from classiq.qmod.generative import (
+    is_generative_expansion_enabled,
+    set_frontend_interpreter,
+)
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.qfunc import DEC_QFUNCS, GEN_QFUNCS
+from classiq.qmod.quantum_expandable import _prepare_args
+from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
+from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
+from classiq.qmod.write_qmod import write_qmod
+
+GEN_MAIN_NAME = "_gen_main"
+
+
+def create_model(
+    entry_point: Union[QFunc, GenerativeQFunc],
+    constraints: Optional[Constraints] = None,
+    execution_preferences: Optional[ExecutionPreferences] = None,
+    preferences: Optional[Preferences] = None,
+    classical_execution_function: Optional[CFunc] = None,
+    out_file: Optional[str] = None,
+) -> SerializedModel:
+    """
+    Create a serialized model from a given Qmod entry function and additional parameters.
+
+    Args:
+        entry_point: The entry point function for the model, which must be a QFunc named 'main'.
+        constraints: Constraints for the synthesis of the model. See Constraints (Optional).
+        execution_preferences: Preferences for the execution of the model. See ExecutionPreferences (Optional).
+        preferences: Preferences for the synthesis of the model. See Preferences (Optional).
+        classical_execution_function: A function for the classical execution logic, which must be a CFunc (Optional).
+        out_file: File path to write the Qmod model in native Qmod representation to (Optional).
+
+    Returns:
+        SerializedModel: A serialized model.
+
+    Raises:
+        ClassiqError: If the entry point function is not named 'main'.
+    """
+
+    if entry_point.func_decl.name != MAIN_FUNCTION_NAME:
+        raise ClassiqError(
+            f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
+        )
+
+    user_gen_functions = {
+        gen_func._py_callable.__name__ for gen_func in GEN_QFUNCS
+    } - set(BUILTIN_FUNCTION_DECLARATIONS.keys())
+    if len(user_gen_functions) > 0 and is_generative_expansion_enabled():
+        model = _expand_generative_model(
+            (
+                entry_point
+                if isinstance(entry_point, QFunc)
+                else QFunc(entry_point._py_callable)
+            ),
+            constraints,
+            execution_preferences,
+            preferences,
+            classical_execution_function,
+        )
+    else:
+        if TYPE_CHECKING:
+            assert isinstance(entry_point, QFunc)
+        model = entry_point.create_model(
+            constraints,
+            execution_preferences,
+            preferences,
+            classical_execution_function,
+        )
+    result = model.get_model()
+
+    if out_file is not None:
+        write_qmod(result, out_file)
+
+    return result
+
+
+def _expand_generative_model(
+    gen_main: QFunc,
+    constraints: Optional[Constraints] = None,
+    execution_preferences: Optional[ExecutionPreferences] = None,
+    preferences: Optional[Preferences] = None,
+    classical_execution_function: Optional[CFunc] = None,
+) -> Model:
+    @QFunc
+    def _dummy() -> None:
+        pass
+
+    model = _dummy.create_model(
+        constraints,
+        execution_preferences,
+        preferences,
+        classical_execution_function,
+    )
+    generative_functions = _get_generative_functions(gen_main)
+    model.functions = generative_functions
+    model.types = list(QMODULE.type_decls.values())
+    model.enums = list(QMODULE.enum_decls.values())
+    model.qstructs = list(QMODULE.qstruct_decls.values())
+    return model
+
+
+def _get_generative_functions(gen_main: QFunc) -> List[NativeFunctionDefinition]:
+    # The Interpreter accepts a model and a list of generative functions.
+    # Since the main function is generative, it can only be expanded using the
+    # Interpreter.
+    # To solve this deadlock, we create a wrapper model
+    # `qfunc main(...) { _gen_main(...); }` and rename `main` to `_gen_main` before
+    # passing them to the Interpreter.
+    gen_model = _get_wrapper_main(gen_main)
+    gen_functions = _get_all_model_functions_as_generative_functions()
+    functions_dict = _interpret_generative_model(gen_model, gen_functions)
+    return list(functions_dict.values())
+
+
+def _get_wrapper_main(gen_main: QFunc) -> Model:
+    return Model(
+        functions=[
+            NativeFunctionDefinition(
+                name=MAIN_FUNCTION_NAME,
+                positional_arg_declarations=gen_main.func_decl.positional_arg_declarations,
+                body=[
+                    QuantumFunctionCall(
+                        function=GEN_MAIN_NAME,
+                        positional_args=_prepare_args(
+                            gen_main.func_decl,
+                            gen_main._get_positional_args(),
+                            {},
+                        ),
+                    ),
+                ],
+            ),
+        ],
+    )
+
+
+def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
+    gen_functions = list(GEN_QFUNCS) + [
+        GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
+        for dec_func in DEC_QFUNCS
+    ]
+    return [
+        (
+            gen_func
+            if gen_func.func_decl.name != MAIN_FUNCTION_NAME
+            else GenerativeQFunc(
+                gen_func._py_callable,
+                gen_func.func_decl.copy(update={"name": GEN_MAIN_NAME}),
+            )
+        )
+        for gen_func in gen_functions
+        if gen_func.func_decl.name not in BUILTIN_FUNCTION_DECLARATIONS
+    ]
+
+
+def _interpret_generative_model(
+    gen_model: Model, gen_functions: List[GenerativeQFunc]
+) -> Dict[str, NativeFunctionDefinition]:
+    resolve_function_calls(
+        gen_model,
+        {gen_func.func_decl.name: gen_func.func_decl for gen_func in gen_functions},
+    )
+    interpreter = Interpreter(gen_model, gen_functions)
+    set_frontend_interpreter(interpreter)
+    functions_dict = nameables_to_dict(interpreter.expand().functions)
+
+    # Inline _gen_main call in main
+    expanded_gen_main_name = cast(
+        QuantumFunctionCall, functions_dict[MAIN_FUNCTION_NAME].body[0]
+    ).func_name
+    functions_dict[MAIN_FUNCTION_NAME] = functions_dict[expanded_gen_main_name].copy(
+        update={"name": MAIN_FUNCTION_NAME}
+    )
+    functions_dict.pop(expanded_gen_main_name)
+
+    return functions_dict

classiq/qmod/declaration_inferrer.py

@@ -1,5 +1,4 @@
 import dataclasses
-import inspect
 import sys
 from enum import EnumMeta
 from typing import (
@@ -19,22 +18,12 @@ from typing import (
 from typing_extensions import _AnnotatedAlias
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.functions.classical_type import (
-    Bool,
-    ClassicalArray,
-    ClassicalList,
-    Integer,
-    Real,
-)
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_name import Enum
-from classiq.interface.generator.types.enum_declaration import (
-    EnumDeclaration,
-    declaration_from_enum,
-)
+from classiq.interface.generator.types.enum_declaration import declaration_from_enum
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
 )
@@ -46,10 +35,12 @@ from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
 )
 
-from classiq import Struct, StructDeclaration
+from classiq.model_expansions.model_tables import SymbolTable
+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 ModelStateContainer
-from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
-from classiq.qmod.qmod_variable import QVar, get_type_hint_expr
+from classiq.qmod.python_classical_type import PythonClassicalType
+from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallableList
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
@@ -57,67 +48,45 @@ if sys.version_info[0:2] >= (3, 9):
     from typing import Annotated
 
 
+class _PythonClassicalType(PythonClassicalType):
+    def __init__(self, qmodule: Optional[ModelStateContainer]):
+        super().__init__()
+        self.qmodule = qmodule
+
+    def register_enum(self, py_type: EnumMeta) -> None:
+        if (
+            self.qmodule is None
+            or py_type.__name__ in BUILTIN_ENUM_DECLARATIONS
+            or py_type.__name__ in self.qmodule.enum_decls
+        ):
+            return
+
+        enum_decl = declaration_from_enum(py_type)
+        self.qmodule.enum_decls[py_type.__name__] = enum_decl
+        SymbolTable.enum_table[py_type.__name__] = enum_decl
+
+    def register_struct(self, py_type: type) -> None:
+        if (
+            self.qmodule is None
+            or py_type.__name__ in BUILTIN_STRUCT_DECLARATIONS
+            or py_type.__name__ in self.qmodule.type_decls
+        ):
+            return
+
+        struct_decl = StructDeclaration(
+            name=py_type.__name__,
+            variables={
+                f.name: self.convert(f.type) for f in dataclasses.fields(py_type)
+            },
+        )
+        self.qmodule.type_decls[py_type.__name__] = struct_decl
+        SymbolTable.type_table[py_type.__name__] = struct_decl
+
+
 def python_type_to_qmod(
-    py_type: type, *, qmodule: ModelStateContainer
+    py_type: type, *, qmodule: Optional[ModelStateContainer]
 ) -> Optional[ConcreteClassicalType]:
-    if py_type is int or py_type is CInt:
-        return Integer()
-    elif py_type in (float, complex) or py_type is CReal:
-        return Real()
-    elif py_type is bool or py_type is CBool:
-        return Bool()
-    elif get_origin(py_type) is list:
-        element_type = python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
-        if element_type is not None:
-            return ClassicalList(element_type=element_type)
-    elif get_origin(py_type) is CArray:
-        array_args = version_portable_get_args(py_type)
-        if len(array_args) == 1:
-            return ClassicalList(
-                element_type=python_type_to_qmod(array_args[0], qmodule=qmodule)
-            )
-        elif len(array_args) == 2:
-            return ClassicalArray(
-                element_type=python_type_to_qmod(array_args[0], qmodule=qmodule),
-                size=get_type_hint_expr(array_args[1]),
-            )
-        raise ClassiqValueError(
-            "CArray accepts one or two generic parameters in the form "
-            "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
-        )
-    elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
-        _add_qmod_struct(py_type, qmodule=qmodule)
-        return Struct(name=py_type.__name__)
-    elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
-        _add_qmod_enum(py_type, qmodule=qmodule)
-        return Enum(name=py_type.__name__)
-    return None
-
-
-def _add_qmod_enum(py_type: EnumMeta, *, qmodule: ModelStateContainer) -> None:
-    if (
-        py_type.__name__ in EnumDeclaration.BUILTIN_ENUM_DECLARATIONS
-        or py_type.__name__ in qmodule.enum_decls
-    ):
-        return
-
-    qmodule.enum_decls[py_type.__name__] = declaration_from_enum(py_type)
-
-
-def _add_qmod_struct(py_type: Type, *, qmodule: ModelStateContainer) -> None:
-    if (
-        py_type.__name__ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS
-        or py_type.__name__ in qmodule.type_decls
-    ):
-        return
-
-    qmodule.type_decls[py_type.__name__] = StructDeclaration(
-        name=py_type.__name__,
-        variables={
-            f.name: python_type_to_qmod(f.type, qmodule=qmodule)
-            for f in dataclasses.fields(py_type)
-        },
-    )
+    return _PythonClassicalType(qmodule).convert(py_type)
 
 
 def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
@@ -137,13 +106,15 @@ def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration
 
 
 def _extract_operand_decl(
-    name: Optional[str], py_type: Any, qmodule: ModelStateContainer
+    name: Optional[str], py_type: Any, qmodule: Optional[ModelStateContainer]
 ) -> AnonQuantumOperandDeclaration:
     is_list = (get_origin(py_type) or py_type) is QCallableList
     if get_origin(py_type) is list:
         is_list = True
-        py_type = version_portable_get_args(py_type)
+        py_type = version_portable_get_args(py_type)[0]
     type_args = version_portable_get_args(py_type)
+    if len(type_args) > 0 and isinstance(type_args[0], list):  # Callable support
+        type_args = tuple(type_args[0])
     param_decls = [_extract_operand_param(arg_type) for arg_type in type_args]
     param = AnonQuantumOperandDeclaration(
         name=name,
@@ -181,20 +152,20 @@ def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
 
 @overload
 def _extract_positional_args(
-    args: Sequence[Tuple[str, Any]], qmodule: ModelStateContainer
+    args: Sequence[Tuple[str, Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[PositionalArg]:
     pass
 
 
 @overload
 def _extract_positional_args(
-    args: Sequence[Tuple[Optional[str], Any]], qmodule: ModelStateContainer
+    args: Sequence[Tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[AnonPositionalArg]:
     pass
 
 
 def _extract_positional_args(
-    args: Sequence[Tuple[Optional[str], Any]], qmodule: ModelStateContainer
+    args: Sequence[Tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[AnonPositionalArg]:
     result: List[AnonPositionalArg] = []
     for name, py_type in args:
@@ -218,7 +189,7 @@ def _extract_positional_args(
 
 
 def infer_func_decl(
-    py_func: Callable, qmodule: ModelStateContainer
+    py_func: Callable, qmodule: Optional[ModelStateContainer] = None
 ) -> NamedParamsQuantumFunctionDeclaration:
     return NamedParamsQuantumFunctionDeclaration(
         name=unmangle_keyword(py_func.__name__),

classiq/qmod/expression_query.py

@@ -13,6 +13,22 @@ def get_expression_numeric_attributes(
     expr: SymbolicTypes,
     machine_precision: int = MAXIMAL_MACHINE_PRECISION,
 ) -> Tuple[int, bool, int]:
+    """
+    Computes and returns the numeric attributes of a given symbolic expression.
+
+    Args:
+        vars: A list of `QNum` variables used in the symbolic expression.
+        expr: The symbolic expression for which numeric attributes are to be computed.
+        machine_precision: The precision level of the machine for the computation. Defaults to MAXIMAL_MACHINE_PRECISION = 20.
+
+    Returns:
+        Tuple[int, bool, int]:
+            A tuple containing the following numeric attributes:
+            - The size in bits (int) required to represent the result.
+            - A boolean indicating whether the result is signed (bool).
+            - The number of fraction digits (int) in the result.
+
+    """
     res_type = compute_arithmetic_result_type(
         expr_str=str(expr),
         var_types={str(var.get_handle_binding()): var.get_qmod_type() for var in vars},

classiq/qmod/generative.py

@@ -0,0 +1,48 @@
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Iterator, Optional
+
+from classiq.interface.exceptions import ClassiqError
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreter import Interpreter
+
+_GENERATIVE_ENABLED_SWITCH: bool = True
+_GENERATIVE_MODE: bool = False
+_FRONTEND_INTERPRETER: Optional["Interpreter"] = None
+
+
+def is_generative_mode() -> bool:
+    return _GENERATIVE_MODE
+
+
+@contextmanager
+def generative_mode_context(generative: bool) -> Iterator[None]:
+    global _GENERATIVE_MODE
+    previous = _GENERATIVE_MODE
+    _GENERATIVE_MODE = generative
+    yield
+    _GENERATIVE_MODE = previous
+
+
+@contextmanager
+def enable_generative_expansion(enabled: bool) -> Iterator[None]:
+    global _GENERATIVE_ENABLED_SWITCH
+    previous = _GENERATIVE_ENABLED_SWITCH
+    _GENERATIVE_ENABLED_SWITCH = enabled
+    yield
+    _GENERATIVE_ENABLED_SWITCH = previous
+
+
+def is_generative_expansion_enabled() -> bool:
+    return _GENERATIVE_ENABLED_SWITCH
+
+
+def set_frontend_interpreter(interpreter: "Interpreter") -> None:
+    global _FRONTEND_INTERPRETER
+    _FRONTEND_INTERPRETER = interpreter
+
+
+def get_frontend_interpreter() -> "Interpreter":
+    if _FRONTEND_INTERPRETER is None:
+        raise ClassiqError("Interpreter was not set")
+    return _FRONTEND_INTERPRETER

classiq/qmod/model_state_container.py

@@ -3,10 +3,9 @@ from typing import Dict
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 
-from classiq import StructDeclaration
-
 
 class ModelStateContainer:
     enum_decls: Dict[str, EnumDeclaration]

classiq/qmod/native/pretty_printer.py

@@ -3,7 +3,11 @@ from typing import Dict, List, Mapping, Optional, Union
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
+    ClassicalList,
+    Integer,
+    Real,
 )
 from classiq.interface.generator.functions.concrete_types import (
     ConcreteClassicalType,
@@ -15,6 +19,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -68,17 +73,8 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq import (
-    Bool,
-    ClassicalList,
-    Integer,
-    Real,
-    StructDeclaration,
-)
 from classiq.qmod.native.expression_to_qmod import transform_expression
-from classiq.qmod.semantics.static_semantics_visitor import (
-    static_semantics_analysis_pass,
-)
+from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
@@ -97,7 +93,7 @@ class DSLPrettyPrinter(Visitor):
 
     def visit_Model(self, model: Model) -> str:
         # FIXME - CAD-20149: Remove this line once the froggies are removed, and the visit of lambdas can be done without accessing the func_decl property (with rename_params values only).
-        static_semantics_analysis_pass(model, None)
+        resolve_function_calls(model, model.function_dict)
         enum_decls = [self.visit(enum_decl) for enum_decl in model.enums]
         struct_decls = [self.visit(struct_decl) for struct_decl in model.types]
         qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]

classiq/qmod/pretty_print/pretty_printer.py

@@ -5,7 +5,11 @@ import black
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
+    ClassicalList,
+    Integer,
+    Real,
 )
 from classiq.interface.generator.functions.concrete_types import (
     ConcreteClassicalType,
@@ -17,6 +21,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -72,13 +77,7 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.interface.model.within_apply_operation import WithinApply
 
 import classiq
-from classiq import (
-    Bool,
-    ClassicalList,
-    Integer,
-    Real,
-    StructDeclaration,
-)
+from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
@@ -147,10 +146,7 @@ class PythonPrettyPrinter(Visitor):
         return res
 
     def visit_Model(self, model: Model) -> str:
-        self._functions = {
-            **model.function_dict,
-            **QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS,
-        }
+        self._functions = {**model.function_dict, **BUILTIN_FUNCTION_DECLARATIONS}
         enum_decls = [self.visit(decl) for decl in model.enums]
         struct_decls = [self.visit(decl) for decl in model.types]
         qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]

classiq/qmod/python_classical_type.py

@@ -0,0 +1,67 @@
+import dataclasses
+import inspect
+import sys
+from enum import EnumMeta
+from typing import (
+    Optional,
+    get_args,
+    get_origin,
+)
+
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalList,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import Enum, Struct
+
+from classiq.qmod.cparam import CArray, CBool, CInt, CReal
+from classiq.qmod.qmod_variable import get_type_hint_expr
+from classiq.qmod.utilities import version_portable_get_args
+
+if sys.version_info[0:2] >= (3, 9):
+    pass
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+
+
+class PythonClassicalType:
+    def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
+        if py_type is int or py_type is CInt:
+            return Integer()
+        elif py_type in (float, complex) or py_type is CReal:
+            return Real()
+        elif py_type is bool or py_type is CBool:
+            return Bool()
+        elif get_origin(py_type) is list:
+            element_type = self.convert(get_args(py_type)[0])
+            if element_type is not None:
+                return ClassicalList(element_type=element_type)
+        elif get_origin(py_type) is CArray:
+            array_args = version_portable_get_args(py_type)
+            if len(array_args) == 1:
+                return ClassicalList(element_type=self.convert(array_args[0]))
+            elif len(array_args) == 2:
+                return ClassicalArray(
+                    element_type=self.convert(array_args[0]),
+                    size=get_type_hint_expr(array_args[1]),
+                )
+            raise ClassiqValueError(
+                "CArray accepts one or two generic parameters in the form "
+                "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
+            )
+        elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
+            self.register_struct(py_type)
+            return Struct(name=py_type.__name__)
+        elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
+            self.register_enum(py_type)
+            return Enum(name=py_type.__name__)
+        return None
+
+    def register_struct(self, py_type: type) -> None:
+        pass
+
+    def register_enum(self, py_type: EnumMeta) -> None:
+        pass

classiq/qmod/qfunc.py

@@ -1,8 +1,20 @@
-from typing import Callable, Literal, Optional, Union, overload
+from typing import Callable, List, Literal, Optional, Union, overload
 
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_function import ExternalQFunc, GenerativeQFunc, QFunc
 
+GEN_QFUNCS: List[GenerativeQFunc] = []
+DEC_QFUNCS: List[QFunc] = []
+
+
+def set_discovered_functions(
+    dec_funcs: List[QFunc], gen_funcs: List[GenerativeQFunc]
+) -> None:
+    DEC_QFUNCS.clear()
+    DEC_QFUNCS.extend(dec_funcs)
+    GEN_QFUNCS.clear()
+    GEN_QFUNCS.extend(gen_funcs)
+
 
 @overload
 def qfunc(func: Callable) -> QFunc: ...
@@ -21,11 +33,14 @@ def qfunc(
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
     def wrapper(func: Callable) -> QCallable:
         if generative:
-            return GenerativeQFunc(func)
+            gen_qfunc = GenerativeQFunc(func)
+            GEN_QFUNCS.append(gen_qfunc)
+            return gen_qfunc
         if external:
             return ExternalQFunc(func)
-
-        return QFunc(func)
+        dec_qfunc = QFunc(func)
+        DEC_QFUNCS.append(dec_qfunc)
+        return dec_qfunc
 
     if func is not None:
         return wrapper(func)