tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/_data/runtime/cpp/include/tpy/frame_slot.hpp

@@ -0,0 +1,120 @@
+/**
+ * TurboPython Runtime - frame_slot
+ *
+ * Uninitialized aligned storage for a single T, used as a generator /
+ * coroutine state-machine frame field. Defers T's construction until
+ * the source code's first assignment (vs. C++'s default behavior of
+ * default-constructing every non-static member of a struct).
+ *
+ * TPy sema enforces no-read-before-write, so the slot only needs to
+ * worry about destruction correctness: a runtime `alive_` flag tracks
+ * whether the payload exists, and the slot's destructor runs `~T()`
+ * iff alive.
+ *
+ * Not copyable; move-constructible (required so coro structs can be
+ * wrapped into `Adapter<...>` via `make_unique<Adapter<...>>(std::move(coro))`);
+ * not move-assignable. Move-construct transfers the alive payload and
+ * leaves the source dead.
+ */
+
+#pragma once
+
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "core.hpp"
+
+namespace tpy {
+
+template <typename T>
+class frame_slot {
+public:
+    frame_slot() noexcept = default;
+
+    frame_slot(const frame_slot&) = delete;
+    frame_slot& operator=(const frame_slot&) = delete;
+    frame_slot& operator=(frame_slot&&) = delete;
+
+    // Move ctor is required: async coro structs get wrapped into an
+    // `Adapter<...>` via `make_unique<Adapter<...>>(std::move(coro))`
+    // which forwards through inner's move ctor; if any frame field's
+    // move ctor is deleted the whole coro struct becomes immovable.
+    // Transfers the live payload and leaves the source dead.
+    frame_slot(frame_slot&& other)
+        noexcept(std::is_nothrow_move_constructible_v<T>) {
+        if (other.alive_) {
+            ::new (static_cast<void*>(&storage_)) T(std::move(*other.ptr()));
+            alive_ = true;
+            other.ptr()->~T();
+            other.alive_ = false;
+        }
+    }
+
+    ~frame_slot() {
+        if (alive_) {
+            ptr()->~T();
+        }
+    }
+
+    template <typename... Args>
+    T& emplace(Args&&... args) {
+        if (alive_) {
+            ptr()->~T();
+            // Mark dead between destroy and placement-new so a throwing
+            // T ctor doesn't leave alive_=true over destroyed storage
+            // (would cause the dtor to double-destroy).
+            alive_ = false;
+        }
+        ::new (static_cast<void*>(&storage_)) T(std::forward<Args>(args)...);
+        alive_ = true;
+        return *ptr();
+    }
+
+    // No operator= for arbitrary T values. Codegen emits explicit
+    // `name.emplace(expr)` for every assignment to a frame slot --
+    // makes the first-init vs rebind invariant visible in the source,
+    // and avoids the `name = {}` ambiguity that plagues template
+    // overload resolution against deleted copy/move assigns.
+
+    void reset() {
+        if (alive_) {
+            ptr()->~T();
+            alive_ = false;
+        }
+    }
+
+    bool has_value() const noexcept { return alive_; }
+    explicit operator bool() const noexcept { return alive_; }
+
+    T& get() & {
+#ifndef NDEBUG
+        if (!alive_) {
+            tpy_panic("frame_slot::get on dead slot");
+        }
+#endif
+        return *ptr();
+    }
+    const T& get() const & {
+#ifndef NDEBUG
+        if (!alive_) {
+            tpy_panic("frame_slot::get on dead slot");
+        }
+#endif
+        return *ptr();
+    }
+
+    T& operator*() & { return get(); }
+    const T& operator*() const & { return get(); }
+    T* operator->() { return &get(); }
+    const T* operator->() const { return &get(); }
+
+private:
+    T* ptr() noexcept { return std::launder(reinterpret_cast<T*>(&storage_)); }
+    const T* ptr() const noexcept { return std::launder(reinterpret_cast<const T*>(&storage_)); }
+
+    alignas(T) unsigned char storage_[sizeof(T)];
+    bool alive_ = false;
+};
+
+} // namespace tpy

tpyc/_data/runtime/cpp/include/tpy/generator.hpp

@@ -0,0 +1,47 @@
+/**
+ * TurboPython Runtime - Generator Wrapper
+ *
+ * Wraps a callable returning optional<T> into an iterator with __next__()
+ * and __iter__(), used for generator expressions.
+ *
+ * Depends on: <optional>, <expected>
+ */
+
+#pragma once
+
+#include "core.hpp"
+#include "next_iter.hpp"
+
+#include <expected>
+#include <optional>
+
+namespace tpy {
+
+// Generator expression wrapper: stores a mutable callable returning optional<T>,
+// provides __next__() and __iter__() so it integrates with direct __next__() loops.
+// Inherits begin()/end() from next_iter_mixin so C++ range-for works too.
+template<typename T, typename F>
+class generator_wrapper : public next_iter_mixin<generator_wrapper<T, F>, T> {
+    F fn_;
+public:
+    explicit generator_wrapper(F&& fn) : fn_(std::move(fn)) {}
+
+    std::expected<T, StopIteration> __next__() {
+        auto opt = fn_();
+        if (opt.has_value()) return *std::move(opt);
+        return tpy::make_unexpected(StopIteration{});
+    }
+
+    generator_wrapper& __iter__() { return *this; }
+
+    friend std::ostream& operator<<(std::ostream& os, const generator_wrapper&) {
+        return os << "<generator>";
+    }
+};
+
+template<typename T, typename F>
+generator_wrapper<T, F> make_generator(F&& fn) {
+    return generator_wrapper<T, F>(std::forward<F>(fn));
+}
+
+} // namespace tpy

tpyc/_data/runtime/cpp/include/tpy/iterable_ops.hpp

@@ -0,0 +1,122 @@
+/**
+ * TurboPython Runtime - Iterable Operations
+ *
+ * Non-range overloads for container operations (list_extend, str_join, etc.)
+ * that accept Iterable types (types with tpy::__iter__() but no begin()/end()).
+ *
+ * Uses tpy::__iter__() + __next__() to iterate non-range types.
+ * The primary (range-based) overloads live in container_ops.hpp and format.hpp.
+ */
+
+#pragma once
+
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "container_ops.hpp"
+#include "dunder.hpp"
+#include "ordered_map.hpp"
+
+namespace tpy {
+
+// Forwarding-ref overloads: accept both lvalue containers (user iterables)
+// and rvalue temporaries (generator expressions).  The requires clause
+// excludes standard ranges so these never compete with the primary overloads
+// in container_ops.hpp / format.hpp.
+
+// -- list_extend for non-range iterables ------------------------------------
+
+template<typename T, typename Container>
+    requires (!std::ranges::input_range<std::remove_reference_t<Container>>)
+void list_extend(std::vector<T>& v, Container&& other) {
+    auto __iter = tpy::__iter__(other);
+    for (;;) {
+        auto __r = __iter.__next__();
+        if (!__r.has_value()) break;
+        v.push_back(unwrap_ref(*__r));
+    }
+}
+
+// -- list_set_slice for non-range iterables ---------------------------------
+
+template<typename T, typename Container>
+    requires (!std::ranges::input_range<std::remove_reference_t<Container>>)
+void list_set_slice(std::vector<T>& vec, BasicSlice sl, Container&& other) {
+    std::vector<T> tmp;
+    auto __iter = tpy::__iter__(other);
+    for (;;) {
+        auto __r = __iter.__next__();
+        if (!__r.has_value()) break;
+        tmp.push_back(unwrap_ref(*__r));
+    }
+    list_set_slice(vec, sl, tmp);
+}
+
+// -- list_set_stepped_slice for non-range iterables -------------------------
+
+template<typename T, typename Container>
+    requires (!std::ranges::input_range<std::remove_reference_t<Container>>)
+void list_set_stepped_slice(std::vector<T>& vec, Slice sl, Container&& other) {
+    std::vector<T> tmp;
+    auto __iter = tpy::__iter__(other);
+    for (;;) {
+        auto __r = __iter.__next__();
+        if (!__r.has_value()) break;
+        tmp.push_back(unwrap_ref(*__r));
+    }
+    list_set_stepped_slice(vec, sl, tmp);
+}
+
+// -- str_join for non-range iterables ---------------------------------------
+
+template<typename Container>
+    requires (!std::ranges::input_range<std::remove_reference_t<Container>>)
+inline std::string str_join(std::string_view sep, Container&& items) {
+    std::string result;
+    bool first = true;
+    auto __iter = tpy::__iter__(items);
+    for (;;) {
+        auto __r = __iter.__next__();
+        if (!__r.has_value()) break;
+        if (!first) result.append(sep);
+        result.append(std::string_view(unwrap_ref(*__r)));
+        first = false;
+    }
+    return result;
+}
+
+// -- from_range for non-range iterables -------------------------------------
+
+template<typename Container, typename Iterable>
+    requires (!std::ranges::input_range<std::remove_reference_t<Iterable>>)
+Container from_range(Iterable&& iterable) {
+    Container result;
+    auto __iter = tpy::__iter__(iterable);
+    for (;;) {
+        auto __r = __iter.__next__();
+        if (!__r.has_value()) break;
+        result.push_back(unwrap_ref(*__r));
+    }
+    return result;
+}
+
+// -- dict_from_pairs for non-range iterables --------------------------------
+
+template<typename K, typename V, typename Iterable>
+    requires (!std::ranges::input_range<std::remove_reference_t<Iterable>>)
+ordered_map<K, V> dict_from_pairs(Iterable&& iterable) {
+    ordered_map<K, V> result;
+    auto __iter = tpy::__iter__(iterable);
+    for (;;) {
+        auto __r = __iter.__next__();
+        if (!__r.has_value()) break;
+        auto&& __item = unwrap_ref_move(*__r);
+        result.insert_or_assign(std::get<0>(std::move(__item)), std::get<1>(std::move(__item)));
+    }
+    return result;
+}
+
+} // namespace tpy