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

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

@@ -0,0 +1,302 @@
+/**
+ * TurboPython Runtime - Collection Printing
+ *
+ * Python-style printing for containers: [a, b, c]
+ */
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <optional>
+#include <ranges>
+#include <span>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+#include "bigint.hpp"
+#include "dunder.hpp"
+#include "format.hpp"
+
+namespace tpy {
+
+// Forward declarations for nested container printing
+template<typename T> class ordered_set;
+template<typename K, typename V> class ordered_map;
+
+// --- Collection printing (Python-style: [a, b, c]) ---
+
+template <typename T>
+struct ListPrinter {
+    const T& value;
+    explicit ListPrinter(const T& v) : value(v) {}
+};
+
+namespace detail {
+
+// Forward declare for recursive nested container support
+template <typename Iter>
+void print_list_contents(std::ostream& os, Iter begin, Iter end);
+
+// Forward declare tuple overload so nested containers (e.g. list[tuple]) resolve correctly
+template <typename... Ts>
+void print_element(std::ostream& os, const std::tuple<Ts...>& t);
+
+// Forward declare ordered_set overload (defined in set_ops.hpp)
+template <typename T>
+void print_element(std::ostream& os, const ordered_set<T>& elem);
+
+// Forward declare ordered_map overload (defined in dict_ops.hpp)
+template <typename K, typename V>
+void print_element(std::ostream& os, const ordered_map<K, V>& elem);
+
+// Forward declare Any overload (defined in any.hpp). The forward decl
+// must precede the generic `print_element<T>` template so two-phase
+// lookup picks the non-template Any overload at template-definition
+// time even when any.hpp is included after dict_ops.hpp / set_ops.hpp.
+}  // namespace detail
+struct Any;
+namespace detail {
+void print_element(std::ostream& os, const ::tpy::Any& a);
+
+// Container element printing goes through tpy::repr_of so containers emit
+// the repr form (Python: `print([rec])` uses __repr__, not __str__).
+// Specific overloads above cover bool/double/string/BigInt; this generic
+// is the fallback for user records and other types.
+template <typename T>
+void print_element(std::ostream& os, const T& elem) {
+    os << ::tpy::repr_of(elem);
+}
+
+inline void print_element(std::ostream& os, bool elem) {
+    os << (elem ? "True" : "False");
+}
+
+inline void print_element(std::ostream& os, double elem) {
+    os << format_float(elem);
+}
+
+inline void print_element(std::ostream& os, const std::string& elem) {
+    os << repr_quote_string(elem);
+}
+
+inline void print_element(std::ostream& os, std::string_view elem) {
+    os << repr_quote_string(elem);
+}
+
+inline void print_element(std::ostream& os, const BigInt& elem) {
+    os << elem.to_string();
+}
+
+// std::vector<bool> uses proxy refs so the bool overload won't match via iterators
+inline void print_element(std::ostream& os, const std::vector<bool>& elem) {
+    os << '[';
+    for (std::size_t i = 0; i < elem.size(); ++i) {
+        if (i > 0) os << ", ";
+        print_element(os, static_cast<bool>(elem[i]));
+    }
+    os << ']';
+}
+
+// Forward declarations for variant/optional (defined after all other overloads)
+template <typename... Ts>
+void print_element(std::ostream& os, const std::variant<Ts...>& elem);
+template <typename T>
+void print_element(std::ostream& os, const std::optional<T>& elem);
+inline void print_element(std::ostream& os, std::monostate);
+
+// Overloads for nested containers
+template <typename T>
+void print_element(std::ostream& os, const std::vector<T>& elem) {
+    print_list_contents(os, elem.begin(), elem.end());
+}
+
+template <typename T, std::size_t N>
+void print_element(std::ostream& os, const std::array<T, N>& elem) {
+    print_list_contents(os, elem.begin(), elem.end());
+}
+
+template <typename Iter>
+void print_list_contents(std::ostream& os, Iter begin, Iter end) {
+    os << '[';
+    bool first = true;
+    for (auto it = begin; it != end; ++it) {
+        if (!first) os << ", ";
+        first = false;
+        print_element(os, *it);
+    }
+    os << ']';
+}
+
+// Definitions for variant/optional/monostate (after all other print_element
+// overloads so std::visit can find container overloads during instantiation).
+template <typename... Ts>
+void print_element(std::ostream& os, const std::variant<Ts...>& elem) {
+    std::visit([&os](const auto& v) { print_element(os, v); }, elem);
+}
+
+inline void print_element(std::ostream& os, std::monostate) {
+    os << "None";
+}
+
+template <typename T>
+void print_element(std::ostream& os, const std::optional<T>& elem) {
+    if (elem.has_value()) {
+        print_element(os, *elem);
+    } else {
+        os << "None";
+    }
+}
+
+} // namespace detail
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const ListPrinter<std::vector<T>>& p) {
+    detail::print_list_contents(os, p.value.begin(), p.value.end());
+    return os;
+}
+
+// std::vector<bool> uses proxy refs, so the generic iterator path won't pick up
+// the bool overload of print_element. Handle it explicitly.
+inline std::ostream& operator<<(std::ostream& os, const ListPrinter<std::vector<bool>>& p) {
+    os << '[';
+    for (std::size_t i = 0; i < p.value.size(); ++i) {
+        if (i > 0) os << ", ";
+        detail::print_element(os, static_cast<bool>(p.value[i]));
+    }
+    os << ']';
+    return os;
+}
+
+template <typename T, std::size_t N>
+std::ostream& operator<<(std::ostream& os, const ListPrinter<std::array<T, N>>& p) {
+    detail::print_list_contents(os, p.value.begin(), p.value.end());
+    return os;
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const ListPrinter<std::span<T>>& p) {
+    detail::print_list_contents(os, p.value.begin(), p.value.end());
+    return os;
+}
+
+// Generic fallback for any iterable container (e.g. repeat_range)
+template <typename C>
+    requires std::ranges::input_range<C>
+             && (!requires { typename std::tuple_size<C>::type; })  // exclude array
+std::ostream& operator<<(std::ostream& os, const ListPrinter<C>& p) {
+    detail::print_list_contents(os, std::ranges::begin(p.value), std::ranges::end(p.value));
+    return os;
+}
+
+// --- Generic value printing for type parameters ---
+
+/**
+ * ValuePrinter<T> - Prints values handling both scalars and containers.
+ *
+ * Used for generic type parameters where T might be a value type (int32_t)
+ * or a container type (std::vector). Uses ListPrinter for ranges.
+ */
+template<typename T>
+struct ValuePrinter {
+    const T& value;
+    explicit ValuePrinter(const T& v) : value(v) {}
+};
+
+template<typename T>
+std::ostream& operator<<(std::ostream& os, const ValuePrinter<T>& p) {
+    // String types are ranges but should print as strings, not char lists
+    if constexpr (std::is_same_v<T, std::string_view> ||
+                  std::is_same_v<T, std::string> ||
+                  std::is_same_v<T, const char*>) {
+        return os << p.value;
+    } else if constexpr (std::is_same_v<T, bool>) {
+        return os << (p.value ? "True" : "False");
+    } else if constexpr (std::is_same_v<T, double>) {
+        return os << format_float(p.value);
+    } else if constexpr (std::ranges::range<T>) {
+        return os << ListPrinter(p.value);
+    } else {
+        return os << p.value;
+    }
+}
+
+// --- Tuple printing (Python-style: (a, b) or (a,) for single-element) ---
+
+namespace detail {
+
+template <typename Tuple, std::size_t... Is>
+void print_tuple_elements(std::ostream& os, const Tuple& t, std::index_sequence<Is...>) {
+    ((Is == 0 ? (void)(os) : (void)(os << ", "),
+      print_element(os, std::get<Is>(t))), ...);
+}
+
+template <typename... Ts>
+void print_element(std::ostream& os, const std::tuple<Ts...>& t) {
+    os << '(';
+    print_tuple_elements(os, t, std::index_sequence_for<Ts...>{});
+    if constexpr (sizeof...(Ts) == 1) {
+        os << ',';
+    }
+    os << ')';
+}
+
+} // namespace detail
+
+template <typename... Ts>
+struct TuplePrinter {
+    const std::tuple<Ts...>& value;
+    explicit TuplePrinter(const std::tuple<Ts...>& v) : value(v) {}
+};
+
+// Deduction guide
+template <typename... Ts>
+TuplePrinter(const std::tuple<Ts...>&) -> TuplePrinter<Ts...>;
+
+template <typename... Ts>
+std::ostream& operator<<(std::ostream& os, const TuplePrinter<Ts...>& p) {
+    os << '(';
+    detail::print_tuple_elements(os, p.value, std::index_sequence_for<Ts...>{});
+    if constexpr (sizeof...(Ts) == 1) {
+        os << ',';
+    }
+    os << ')';
+    return os;
+}
+
+// --- to_str helpers for str()/repr()/f-string on containers ---
+
+template <typename T>
+std::string list_to_str(const T& c) {
+    std::ostringstream oss;
+    oss << ListPrinter(c);
+    return oss.str();
+}
+
+template <typename... Ts>
+std::string tuple_to_str(const std::tuple<Ts...>& t) {
+    std::ostringstream oss;
+    oss << TuplePrinter(t);
+    return oss.str();
+}
+
+// --- __str__ / __repr__ overloads for std::tuple ---
+
+template <typename... Ts>
+std::string __str__(const std::tuple<Ts...>& t) {
+    return tuple_to_str(t);
+}
+
+template <typename... Ts>
+std::string __repr__(const std::tuple<Ts...>& t) {
+    return tuple_to_str(t);
+}
+
+} // namespace tpy

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

@@ -0,0 +1,61 @@
+/**
+ * TurboPython Runtime - Protocols
+ *
+ * C++ concepts for marker protocols that have no structural methods.
+ * These are referenced by name from @native protocol definitions in
+ * lib/tpy/tpy/__init__.py (e.g. @native("tpy::NativeIterable")).
+ *
+ * Structural protocols (Truthy, Comparable, Hashable, etc.) are now
+ * generated by the compiler from .py protocol definitions and live in
+ * the tpystd::tpy namespace.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <iterator>
+#include <ranges>
+#include <type_traits>
+
+#include "dunder.hpp"
+#include "ranges.hpp"
+
+namespace tpy {
+
+/**
+ * NativeIterable concept - types that support C++ range-based for loops
+ *
+ * A type is NativeIterable<ElemT> if it supports begin()/end() iteration
+ * and dereferencing yields ElemT. This is the "native" C++ iteration pattern.
+ */
+template<typename T, typename ElemT>
+concept NativeIterable = requires(const T& t) {
+    { std::ranges::begin(t) } -> std::input_or_output_iterator;
+    { std::ranges::end(t) } -> std::sentinel_for<decltype(std::ranges::begin(t))>;
+    { *std::ranges::begin(t) } -> std::convertible_to<ElemT>;
+};
+
+/**
+ * NativeRangeConstructible concept - types that can be constructed from a range
+ *
+ * A type is NativeRangeConstructible<ElemT> if from_range<T> can construct it.
+ * This requires an iterator-pair constructor (begin, end).
+ */
+template<typename T, typename ElemT>
+concept NativeRangeConstructible = requires(repeat_range<ElemT> r) {
+    T(std::ranges::begin(r), std::ranges::end(r));
+};
+
+/**
+ * Fixed-width integer concepts - constrain generic functions to fixed-int types
+ */
+template<typename T>
+concept AnyFixedInt = std::is_integral_v<T> && !std::is_same_v<T, bool>;
+
+template<typename T>
+concept AnyFixedSigned = AnyFixedInt<T> && std::is_signed_v<T>;
+
+template<typename T>
+concept AnyFixedUnsigned = AnyFixedInt<T> && std::is_unsigned_v<T>;
+
+} // namespace tpy

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

@@ -0,0 +1,115 @@
+/**
+ * TurboPython Runtime - Range
+ *
+ * Python-style range() as an immutable, reusable container with begin/end.
+ * Depends on: core.hpp (raise<E>), fixed_int.hpp
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <iostream>
+#include <limits>
+#include <type_traits>
+#include "fixed_int.hpp"
+
+namespace tpy {
+
+// Upfront overflow check for range loops with fixed-width integer types.
+// Verifies that stepping through [start, stop) with the given step will never
+// overflow T, so the loop body can use unchecked += for maximum speed.
+// For step ±1 this is unnecessary (stop is already a valid T value).
+// All arithmetic uses unsigned to avoid signed overflow UB in the check itself.
+//
+// The check computes the exact exit value (the value of i after the final
+// increment) and verifies it fits in T.  When step evenly divides
+// (stop - start), the exit value is exactly `stop` (always representable).
+// Otherwise the exit value overshoots by (step - remainder), and we check
+// that overshoot against T's bounds.
+template<typename T>
+void range_check_overflow(T start, T stop, T step) {
+    static_assert(std::is_integral_v<T> && sizeof(T) <= 8);
+    using U = std::make_unsigned_t<T>;
+    if (step > T{0}) {
+        if (start >= stop) return;  // empty range
+        U d = static_cast<U>(stop) - static_cast<U>(start);
+        U ustep = static_cast<U>(step);
+        U rem = d % ustep;
+        if (rem == 0) return;  // exit value is exactly stop, always safe
+        // Exit value = stop + (step - rem).  Need: stop + (step - rem) <= T::max.
+        U overshoot = ustep - rem;
+        U room = static_cast<U>(std::numeric_limits<T>::max()) - static_cast<U>(stop);
+        if (overshoot > room) {
+            raise_fixedint_overflow("range() would overflow on iteration");
+        }
+    } else if constexpr (std::is_signed_v<T>) {
+        if (step < T{0}) {
+            if (start <= stop) return;  // empty range
+            U d = static_cast<U>(start) - static_cast<U>(stop);
+            U abs_step = static_cast<U>(0) - static_cast<U>(step);
+            U rem = d % abs_step;
+            if (rem == 0) return;  // exit value is exactly stop, always safe
+            // Exit value = stop - (abs_step - rem).  Need: stop - (abs_step - rem) >= T::min.
+            U overshoot = abs_step - rem;
+            U room = static_cast<U>(stop) - static_cast<U>(std::numeric_limits<T>::min());
+            if (overshoot > room) {
+                raise_fixedint_overflow("range() would overflow on iteration");
+            }
+        }
+    }
+}
+
+// Raises ValueError when `step == 0`. Shared by Range<T>::Range(T,T,T)
+// and the codegen-emitted inline range loops in statements.py / expressions.py
+// so the message lives in one place.
+template<typename T>
+inline void range_check_step_nonzero(T step) {
+    if (step == T{}) raise_value_error("range() arg 3 must not be zero");
+}
+
+template<typename T>
+class Range {
+    T start_;
+    T end_;
+    T step_;
+public:
+    Range() : start_{}, end_{}, step_(1) {}
+    Range(T end) : start_{}, end_(std::move(end)), step_(1) {}
+    Range(T start, T end) : start_(start), end_(std::move(end)), step_(1) {}
+    Range(T start, T end, T step) : start_(start), end_(std::move(end)), step_(std::move(step)) {
+        range_check_step_nonzero(step_);
+        if constexpr (std::is_integral_v<T> && sizeof(T) <= 8)
+            range_check_overflow<T>(start_, end_, step_);
+    }
+
+    struct Iterator {
+        using value_type = T;
+        using difference_type = std::ptrdiff_t;
+        using iterator_category = std::input_iterator_tag;
+        T current_, end_, step_;
+        T operator*() const { return current_; }
+        Iterator& operator++() {
+            current_ += step_;
+            if (step_ > T{} ? !(current_ < end_) : !(current_ > end_))
+                current_ = end_;
+            return *this;
+        }
+        Iterator operator++(int) { auto t = *this; ++(*this); return t; }
+        bool operator==(const Iterator& o) const { return current_ == o.current_; }
+        bool operator!=(const Iterator& o) const { return !(current_ == o.current_); }
+    };
+
+    Iterator begin() const {
+        bool empty = step_ > T{} ? !(start_ < end_) : !(start_ > end_);
+        return {empty ? end_ : start_, end_, step_};
+    }
+    Iterator end() const { return {end_, end_, step_}; }
+
+    friend std::ostream& operator<<(std::ostream& os, const Range& r) {
+        os << "range(" << r.start_ << ", " << r.end_;
+        if (r.step_ != T{1}) os << ", " << r.step_;
+        return os << ")";
+    }
+};
+
+} // namespace tpy

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

@@ -0,0 +1,212 @@
+/**
+ * TurboPython Runtime - Range Utilities
+ *
+ * Utilities for list repetition and range-based construction.
+ */
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <iterator>
+#include <ranges>
+#include <type_traits>
+#include <vector>
+
+#include "next_iter.hpp"
+
+namespace tpy {
+
+/**
+ * repeat_range<T> - A range that yields elements from a sequence N times.
+ *
+ * Used to implement Python's list repetition: [a, b] * 3 -> [a, b, a, b, a, b]
+ * Satisfies std::ranges::input_range for use with C++23 std::from_range constructors.
+ * Negative counts are treated as 0 (Python semantics).
+ */
+template<typename T>
+class repeat_range {
+    std::vector<T> elements_;
+    std::size_t count_;
+
+public:
+    repeat_range(int32_t count, std::initializer_list<T> elements)
+        : elements_(elements), count_(count > 0 ? static_cast<std::size_t>(count) : 0) {}
+
+    class iterator {
+        const repeat_range* parent_;
+        std::size_t rep_;
+        std::size_t idx_;
+
+    public:
+        using iterator_category = std::input_iterator_tag;
+        using value_type = T;
+        using difference_type = std::ptrdiff_t;
+        // For T=bool we must return by value: vector<bool>::operator[] returns
+        // a proxy, and a `const bool&` return would bind to a temporary bool
+        // created from the proxy and dangle past the function return. For all
+        // other T we keep zero-copy `const T&` so std::string/etc. don't pay
+        // an extra copy on every dereference.
+        using reference = std::conditional_t<std::is_same_v<T, bool>, T, const T&>;
+        using pointer = std::conditional_t<std::is_same_v<T, bool>, void, const T*>;
+
+        iterator() : parent_(nullptr), rep_(0), idx_(0) {}
+        iterator(const repeat_range* p, std::size_t r, std::size_t i)
+            : parent_(p), rep_(r), idx_(i) {}
+
+        reference operator*() const { return parent_->elements_[idx_]; }
+
+        iterator& operator++() {
+            if (++idx_ >= parent_->elements_.size()) {
+                idx_ = 0;
+                ++rep_;
+            }
+            return *this;
+        }
+
+        iterator operator++(int) { auto t = *this; ++(*this); return t; }
+
+        bool operator==(const iterator& o) const {
+            return rep_ == o.rep_ && idx_ == o.idx_;
+        }
+        bool operator!=(const iterator& o) const { return !(*this == o); }
+    };
+
+    iterator begin() const {
+        if (count_ == 0 || elements_.empty()) return end();
+        return iterator(this, 0, 0);
+    }
+    iterator end() const { return iterator(this, count_, 0); }
+
+    std::size_t size() const { return count_ * elements_.size(); }
+
+    // Support tpy::__len__() for len() calls on lazy repeat ranges
+    int32_t __len__() const { return static_cast<int32_t>(size()); }
+};
+
+/**
+ * Convert a range to std::vector.
+ * Used for list repetition when std::from_range is unavailable (GCC < 14).
+ * Pre-allocates if the range has a size() method.
+ */
+template<typename T, std::ranges::input_range R>
+std::vector<T> to_vector(R&& range) {
+    std::vector<T> result;
+    if constexpr (requires { range.size(); }) {
+        result.reserve(static_cast<std::size_t>(range.size()));
+    }
+    for (auto&& elem : range) {
+        result.push_back(elem);
+    }
+    return result;
+}
+
+/**
+ * Construct a vector from move-only elements (avoids std::initializer_list copy).
+ * Uses a C++17 fold expression to emplace each element.
+ */
+template<typename T, typename... Args>
+std::vector<T> make_vector(Args&&... args) {
+    std::vector<T> v;
+    v.reserve(sizeof...(args));
+    (v.emplace_back(std::forward<Args>(args)), ...);
+    return v;
+}
+
+// Trait to detect std::array specializations
+template<typename T> struct is_std_array : std::false_type {};
+template<typename T, std::size_t N> struct is_std_array<std::array<T, N>> : std::true_type {};
+
+/**
+ * from_range<Container> - Construct a container from a range.
+ *
+ * Constructs container using iterator-pair constructor (begin, end).
+ * If container supports reserve() and range has known size, reserves first.
+ * For std::array (aggregate, no iterator-pair ctor), fills element-by-element.
+ * Works with std::vector, std::array, and any container with
+ * an iterator-pair constructor.
+ *
+ * Usage: tpy::from_range<std::vector<int>>(some_range)
+ *        tpy::from_range<std::array<int, 5>>(some_range)
+ */
+template<typename Container, std::ranges::input_range R>
+Container from_range(R&& range) {
+    if constexpr (is_std_array<Container>::value) {
+        constexpr auto N = std::tuple_size<Container>::value;
+        Container result{};
+        std::size_t i = 0;
+        for (auto&& elem : range) {
+            if (i >= N) { raise_value_error("from_range: range size exceeds array capacity"); }
+            result[i++] = std::move(elem);
+        }
+        if (i != N) { raise_value_error("from_range: range size does not match array size"); }
+        return result;
+    } else if constexpr (requires(Container& c) { c.reserve(std::size_t{}); } &&
+                  std::ranges::sized_range<R>) {
+        Container result;
+        result.reserve(static_cast<std::size_t>(std::ranges::size(range)));
+        result.assign(std::ranges::begin(range), std::ranges::end(range));
+        return result;
+    } else {
+        return Container(std::ranges::begin(range), std::ranges::end(range));
+    }
+}
+
+/**
+ * collect<Container> - Collect elements from an iterator into a container.
+ *
+ * Calls __next__() repeatedly until exhaustion, pushing elements
+ * into the container. Used for list(iterator) where iterator is a
+ * user-defined iterator (not NativeIterable).
+ */
+template<typename Container, typename Iter>
+Container collect(Iter&& iter) {
+    Container result;
+    for (;;) {
+        auto __r = iter.__next__();
+        if (!__r.has_value()) break;
+        result.push_back(unwrap_ref_move(*__r));
+    }
+    return result;
+}
+
+/**
+ * construct<Container> - Unified container construction from any iterable.
+ *
+ * Dispatches at compile time: uses begin/end iteration for types that
+ * satisfy std::ranges::input_range, falls back to __next__() protocol
+ * for user-defined iterators.
+ *
+ * Usage: tpy::construct<std::vector<int>>(some_iterable)
+ */
+template<typename Container, typename Arg>
+Container construct(Arg&& arg) {
+    if constexpr (std::ranges::input_range<std::remove_cvref_t<Arg>>) {
+        return from_range<Container>(std::forward<Arg>(arg));
+    } else {
+        return collect<Container>(std::forward<Arg>(arg));
+    }
+}
+
+/**
+ * extend - Append elements from an iterable to an existing container.
+ * Dual-dispatch on input_range vs __next__() protocol, matching `construct`.
+ * Uses the container's iterator-pair insert for ranges (memcpy for
+ * trivially-copyable payloads).
+ */
+template<typename Container, typename Arg>
+void extend(Container& c, Arg&& arg) {
+    if constexpr (std::ranges::input_range<std::remove_cvref_t<Arg>>) {
+        c.insert(c.end(), std::ranges::begin(arg), std::ranges::end(arg));
+    } else {
+        for (;;) {
+            auto __r = arg.__next__();
+            if (!__r.has_value()) break;
+            c.push_back(unwrap_ref_move(*__r));
+        }
+    }
+}
+
+} // namespace tpy