Format

.clang-format

----
 Language: Cpp
 BasedOnStyle: LLVM
 IndentWidth: 2
 UseTab: Never
\ No newline at end of file
----
\ No newline at end of file

rt/include/python/builtins.hpp

@@ -5,51 +5,43 @@
 #ifndef TYPON_BUILTINS_HPP
 #define TYPON_BUILTINS_HPP
 
-#include <ostream>
 #include <iostream>
 #include <optional>
+#include <ostream>
 #include <string>
 
 using namespace std::literals;
 
+// typon_len
 
-
-template<typename T>
+template <typename T>
 concept PyIterator = requires(T t) {
   { t.py_next() } -> std::same_as<std::optional<T>>;
 };
 
-template<typename T>
+template <typename T>
 concept PyIterable = requires(T t) {
   { t.py_iter() } -> PyIterator;
 };
 
-template<PyIterable T, PyIterator U>
-U iter(const T &t) {
-    return t.py_iter();
-}
+template <PyIterable T, PyIterator U> U iter(const T &t) { return t.py_iter(); }
 
-template<typename T>
+template <typename T>
 concept PyLen = requires(const T &t) {
   { t.py_len() } -> std::same_as<size_t>;
 };
 
-template<PyLen T>
-size_t len(const T &t) {
-    return t.py_len();
-}
-
+template <PyLen T> size_t len(const T &t) { return t.py_len(); }
 
-bool is_cpp() {
-    return true;
-}
+bool is_cpp() { return true; }
 
 #include "builtins/bool.hpp"
 #include "builtins/complex.hpp"
 #include "builtins/dict.hpp"
 #include "builtins/list.hpp"
 #include "builtins/print.hpp"
+#include "builtins/range.hpp"
 #include "builtins/set.hpp"
 #include "builtins/str.hpp"
 
-#endif //TYPON_BUILTINS_HPP
+#endif // TYPON_BUILTINS_HPP

rt/include/python/builtins/bool.hpp

@@ -9,9 +9,8 @@
 
 #include "print.hpp"
 
-template<>
-void print_to<bool>(const bool &x, std::ostream &s) {
+template <> void print_to<bool>(const bool &x, std::ostream &s) {
   s << (x ? "True" : "False");
 }
 
-#endif //TYPON_BOOL_HPP
+#endif // TYPON_BOOL_HPP

rt/include/python/builtins/complex.hpp

@@ -12,16 +12,11 @@
 
 using PyComplex = std::complex<double>;
 
-PyComplex operator+(int a, const PyComplex &b) {
-    return PyComplex(a) + b;
-}
+PyComplex operator+(int a, const PyComplex &b) { return PyComplex(a) + b; }
 
-PyComplex operator-(int a, const PyComplex &b) {
-    return PyComplex(a) - b;
-}
+PyComplex operator-(int a, const PyComplex &b) { return PyComplex(a) - b; }
 
-template<>
-void print_to<PyComplex>(const PyComplex &x, std::ostream &s) {
+template <> void print_to<PyComplex>(const PyComplex &x, std::ostream &s) {
   if (x.real() == 0) {
     s << x.imag() << "j";
   } else {
@@ -29,4 +24,4 @@ void print_to<PyComplex>(const PyComplex &x, std::ostream &s) {
   }
 }
 
-#endif //TYPON_COMPLEX_HPP
+#endif // TYPON_COMPLEX_HPP

rt/include/python/builtins/dict.hpp

@@ -7,12 +7,14 @@
 
 #include <unordered_map>
 
-template<typename K, typename V>
+template <typename K, typename V>
 class PyDict : public std::unordered_map<K, V> {
 public:
-    PyDict(std::unordered_map<K, V> &&m) : std::unordered_map<K, V>(std::move(m)) {}
+  PyDict(std::unordered_map<K, V> &&m)
+      : std::unordered_map<K, V>(std::move(m)) {}
 
-    PyDict(std::initializer_list<std::pair<const K, V>> m) : std::unordered_map<K, V>(m) {}
+  PyDict(std::initializer_list<std::pair<const K, V>> m)
+      : std::unordered_map<K, V>(m) {}
 
   operator std::unordered_map<K, V>() const {
     return std::unordered_map<K, V>(this->begin(), this->end());
@@ -22,13 +24,9 @@ public:
     return *reinterpret_cast<std::unordered_map<K, V> *>(this);
   }
 
-    std::size_t py_len() const {
-        return this->size();
-    }
+  std::size_t py_len() const { return this->size(); }
 
-    bool py_contains(const K &k) const {
-        return this->find(k) != this->end();
-    }
+  bool py_contains(const K &k) const { return this->find(k) != this->end(); }
 
   class iterator {
   public:
@@ -51,29 +49,19 @@ public:
       return tmp;
     }
 
-        bool operator==(const iterator &rhs) const {
-            return _it == rhs._it;
-        }
+    bool operator==(const iterator &rhs) const { return _it == rhs._it; }
 
-        bool operator!=(const iterator &rhs) const {
-            return _it != rhs._it;
-        }
+    bool operator!=(const iterator &rhs) const { return _it != rhs._it; }
 
-        const std::pair<K, V> &operator*() const {
-            return *_it;
-        }
+    const std::pair<K, V> &operator*() const { return *_it; }
 
-        const std::pair<K, V> *operator->() const {
-            return &*_it;
-        }
+    const std::pair<K, V> *operator->() const { return &*_it; }
 
   private:
     typename std::unordered_map<K, V>::iterator _it;
   };
 
-    iterator py_iter() const {
-        return this->begin();
-    }
+  iterator py_iter() const { return this->begin(); }
 
   void py_print(std::ostream &s) const {
     s << '{';
@@ -92,8 +80,7 @@ public:
   }
 };
 
-template<typename K, typename V>
+template <typename K, typename V>
 PyDict(std::initializer_list<std::pair<K, V>>) -> PyDict<K, V>;
 
-
-#endif //TYPON_DICT_HPP
+#endif // TYPON_DICT_HPP

rt/include/python/builtins/list.hpp

@@ -5,11 +5,12 @@
 #ifndef TYPON_LIST_HPP
 #define TYPON_LIST_HPP
 
-#include <vector>
 #include <ostream>
+#include <vector>
 
-template<typename T>
-class PyList : public std::vector<T> {
+// TODO: Hyrum's Law, maybe consider using composition instead to not expose
+// that this is a std::vector?
+template <typename T> class PyList : public std::vector<T> {
 public:
   PyList(std::vector<T> &&v) : std::vector<T>(std::move(v)) {}
 
@@ -23,9 +24,7 @@ public:
     return *reinterpret_cast<std::vector<T> *>(this);
   }
 
-    size_t py_len() const {
-        return this->size();
-    }
+  size_t py_len() const { return this->size(); }
 
   void py_print(std::ostream &s) const {
     s << '[';
@@ -57,9 +56,8 @@ public:
   }
 };
 
-template<typename T>
-PyList<T> list(std::initializer_list<T> &&v) {
+template <typename T> PyList<T> list(std::initializer_list<T> &&v) {
   return PyList<T>(std::move(v));
 }
 
-#endif //TYPON_LIST_HPP
+#endif // TYPON_LIST_HPP

rt/include/python/builtins/print.hpp

@@ -8,50 +8,44 @@
 #include <iostream>
 #include <ostream>
 
-template<typename T>
+template <typename T>
 concept Streamable = requires(const T &x, std::ostream &s) {
-{ s << x } -> std::same_as<std::ostream &>;
+  { s << x } -> std::same_as<std::ostream &>;
 };
 
-template<Streamable T>
-void print_to(const T &x, std::ostream &s) {
-    s << x;
-}
+template <Streamable T> void print_to(const T &x, std::ostream &s) { s << x; }
 
-template<typename T>
-concept FunctionPointer = std::is_function_v<T>
-                          or std::is_member_function_pointer_v<T>
-                          or std::is_function_v<std::remove_pointer_t<T>>;
+template <typename T>
+concept FunctionPointer =
+    std::is_function_v<T> or std::is_member_function_pointer_v<T> or
+    std::is_function_v<std::remove_pointer_t<T>>;
 
-template<Streamable T>
-requires (FunctionPointer<T>)
+template <Streamable T>
+  requires(FunctionPointer<T>)
 void print_to(const T &x, std::ostream &s) {
-    s << "<function at 0x" << std::hex << (size_t) x << ">";
+  s << "<function at 0x" << std::hex << (size_t)x << ">";
 }
 
-template<typename T>
+template <typename T>
 concept PyPrint = requires(const T &x, std::ostream &s) {
-{ x.py_print(s) } -> std::same_as<void>;
+  { x.py_print(s) } -> std::same_as<void>;
 };
 
-template<PyPrint T>
-void print_to(const T &x, std::ostream &s) {
+template <PyPrint T> void print_to(const T &x, std::ostream &s) {
   x.py_print(s);
 }
 
-template<typename T>
+template <typename T>
 concept Printable = requires(const T &x, std::ostream &s) {
-{ print_to(x, s) } -> std::same_as<void>;
+  { print_to(x, s) } -> std::same_as<void>;
 };
 
-template<Printable T, Printable ... Args>
-void print(T const &head, Args const &... args) {
+template <Printable T, Printable... Args>
+void print(T const &head, Args const &...args) {
   print_to(head, std::cout);
   (((std::cout << ' '), print_to(args, std::cout)), ...);
   std::cout << '\n';
 }
 
-void print() {
-    std::cout << '\n';
-}
-#endif //TYPON_PRINT_HPP
+void print() { std::cout << '\n'; }
+#endif // TYPON_PRINT_HPP

rt/include/python/builtins/set.hpp

@@ -7,8 +7,7 @@
 
 #include <unordered_set>
 
-template<typename T>
-class PySet : public std::unordered_set<T> {
+template <typename T> class PySet : public std::unordered_set<T> {
 public:
   PySet(std::unordered_set<T> &&s) : std::unordered_set<T>(std::move(s)) {}
 
@@ -18,13 +17,9 @@ public:
     return std::unordered_set<T>(this->begin(), this->end());
   }
 
-    std::size_t py_len() const {
-        return this->size();
-    }
+  std::size_t py_len() const { return this->size(); }
 
-    bool py_contains(const T &t) const {
-        return this->find(t) != this->end();
-    }
+  bool py_contains(const T &t) const { return this->find(t) != this->end(); }
 
   class iterator {
   public:
@@ -47,29 +42,19 @@ public:
       return tmp;
     }
 
-        bool operator==(const iterator &rhs) const {
-            return _it == rhs._it;
-        }
+    bool operator==(const iterator &rhs) const { return _it == rhs._it; }
 
-        bool operator!=(const iterator &rhs) const {
-            return _it != rhs._it;
-        }
+    bool operator!=(const iterator &rhs) const { return _it != rhs._it; }
 
-        const T &operator*() const {
-            return *_it;
-        }
+    const T &operator*() const { return *_it; }
 
-        const T *operator->() const {
-            return &*_it;
-        }
+    const T *operator->() const { return &*_it; }
 
   private:
     typename std::unordered_set<T>::iterator _it;
   };
 
-    iterator py_iter() const {
-        return this->begin();
-    }
+  iterator py_iter() const { return this->begin(); }
 
   void py_print(std::ostream &s) const {
     s << '{';
@@ -84,9 +69,8 @@ public:
   }
 };
 
-template<typename T>
-PySet<T> set(std::initializer_list<T> &&s) {
+template <typename T> PySet<T> set(std::initializer_list<T> &&s) {
   return PySet<T>(std::move(s));
 }
 
-#endif //TYPON_SET_HPP
+#endif // TYPON_SET_HPP

rt/include/python/builtins/str.hpp

@@ -5,16 +5,15 @@
 #ifndef TYPON_STR_HPP
 #define TYPON_STR_HPP
 
-#include <string>
 #include <sstream>
+#include <string>
 
 using namespace std::literals;
 
-template<typename T>
-std::string str(const T &x) {
+template <typename T> std::string str(const T &x) {
   std::stringstream s;
   print_to(x, s);
   return s.str();
 }
 
-#endif //TYPON_STR_HPP
+#endif // TYPON_STR_HPP

rt/include/python/sys.hpp

@@ -8,11 +8,11 @@
 #include <iostream>
 
 namespace py_sys {
-    struct sys_t {
+struct sys_t {
   static constexpr auto &stdin = std::cin;
   static constexpr auto &stdout = std::cout;
   static constexpr auto &stderr = std::cerr;
-    } all;
-}
+} all;
+} // namespace py_sys
 
-#endif //TYPON_SYS_HPP
+#endif // TYPON_SYS_HPP