Skip to content

T
typon
Commit b59c91f4 authored by Tom Niget's avatar Tom Niget
Browse files
Options

Extract builtins into separate subfiles

parent 13196704
Hide whitespace changes
Inline Side-by-side
Showing with 333 additions and 251 deletions
rt/include/python/builtins.hpp
View file @ b59c91f4
......@@ -5,50 +5,18 @@
#ifndef TYPON_BUILTINS_HPP
#define TYPON_BUILTINS_HPP
#include <string>
#include <vector>
#include <iostream>
#include <ostream>
#include <unordered_set>
#include <iostream>
#include <optional>
#include <sstream>
#include <unordered_map>
#include <string>
using namespace std::literals;
template<typename T>
concept PyIterator = requires(T t) {
{ t.py_next() } -> std::same_as<std::optional<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<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<typename T>
void print_to(const T &x, std::ostream &s) {
s << x;
}
template<typename T>
concept Boolean = std::same_as<T, bool>;
template<typename T>
concept Printable = requires(const T &x, std::ostream &s) {
{ x.py_print(s) } -> std::same_as<void>;
......@@ -59,232 +27,30 @@ void print_to(const T &x, std::ostream &s) {
x.py_print(s);
}
template<Boolean T>
void print_to(const T &x, std::ostream &s) {
s << (x ? "True" : "False");
}
template<typename T>
std::string str(const T &x) {
std::stringstream s;
print_to(x, s);
return s.str();
}
template<typename T>
class PyList : public std::vector<T> {
public:
PyList(std::vector<T> &&v) : std::vector<T>(std::move(v)) {}
PyList(std::initializer_list<T> &&v) : std::vector<T>(std::move(v)) {}
operator std::vector<T>() const {
return std::vector<T>(this->begin(), this->end());
}
operator std::vector<T> &() {
return *reinterpret_cast<std::vector<T> *>(this);
}
size_t py_len() const {
return this->size();
}
void py_print(std::ostream &s) const {
s << '[';
if (this->size() > 0) {
print_to(this->operator[](0), s);
for (size_t i = 1; i < this->size(); i++) {
s << ", ";
print_to(this->operator[](i), s);
}
}
s << ']';
}
PyList<T> operator+(const PyList<T> &other) const {
std::vector<T> v;
v.reserve(this->size() + other.size());
v.insert(v.end(), this->begin(), this->end());
v.insert(v.end(), other.begin(), other.end());
return PyList<T>(std::move(v));
}
PyList<T> operator*(size_t n) const {
std::vector<T> v;
v.reserve(this->size() * n);
for (size_t i = 0; i < n; i++) {
v.insert(v.end(), this->begin(), this->end());
}
return PyList<T>(std::move(v));
}
concept PyIterator = requires(T t) {
{ t.py_next() } -> std::same_as<std::optional<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)) {}
PySet(std::initializer_list<T> &&s) : std::unordered_set<T>(std::move(s)) {}
operator std::unordered_set<T>() const {
return std::unordered_set<T>(this->begin(), this->end());
}
size_t py_len() const {
return this->size();
}
bool py_contains(const T &t) const {
return this->find(t) != this->end();
}
class iterator {
public:
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T *;
using reference = T &;
using iterator_category = std::forward_iterator_tag;
iterator(typename std::unordered_set<T>::iterator it) : _it(it) {}
iterator &operator++() {
_it++;
return *this;
}
iterator operator++(int) {
iterator tmp = *this;
_it++;
return tmp;
}
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;
}
private:
typename std::unordered_set<T>::iterator _it;
};
iterator py_iter() const {
return this->begin();
}
void py_print(std::ostream &s) const {
s << '{';
if (this->size() > 0) {
print_to(*this->begin(), s);
for (auto it = ++this->begin(); it != this->end(); it++) {
s << ", ";
print_to(*it, s);
}
}
s << '}';
}
concept PyIterable = requires(T t) {
{ t.py_iter() } -> PyIterator;
};
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::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());
}
operator std::unordered_map<K, V> &() {
return *reinterpret_cast<std::unordered_map<K, V> *>(this);
}
size_t py_len() const {
return this->size();
}
bool py_contains(const K &k) const {
return this->find(k) != this->end();
}
class iterator {
public:
using value_type = std::pair<K, V>;
using difference_type = std::ptrdiff_t;
using pointer = std::pair<K, V> *;
using reference = std::pair<K, V> &;
using iterator_category = std::forward_iterator_tag;
iterator(typename std::unordered_map<K, V>::iterator it) : _it(it) {}
iterator &operator++() {
_it++;
return *this;
}
iterator operator++(int) {
iterator tmp = *this;
_it++;
return tmp;
}
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;
}
private:
typename std::unordered_map<K, V>::iterator _it;
};
iterator py_iter() const {
return this->begin();
}
template<PyIterable T, PyIterator U>
U iter(const T &t) {
return t.py_iter();
}
void py_print(std::ostream &s) const {
s << '{';
if (this->size() > 0) {
print_to(this->begin()->first, s);
s << ": ";
print_to(this->begin()->second, s);
for (auto it = ++this->begin(); it != this->end(); it++) {
s << ", ";
print_to(it->first, s);
s << ": ";
print_to(it->second, s);
}
}
s << '}';
}
template<typename T>
concept PyLen = requires(const T &t) {
{ t.py_len() } -> std::same_as<size_t>;
};
template<typename K, typename V>
PyDict(std::initializer_list<std::pair<K, V>>) -> PyDict<K, V>;
template<PyLen T>
size_t len(const T &t) {
return t.py_len();
}
void print() {
std::cout << '\n';
......@@ -301,4 +67,11 @@ bool is_cpp() {
return true;
}
#include "builtins/bool.hpp"
#include "builtins/complex.hpp"
#include "builtins/dict.hpp"
#include "builtins/list.hpp"
#include "builtins/set.hpp"
#include "builtins/str.hpp"
#endif //TYPON_BUILTINS_HPP
rt/include/python/builtins/bool.hpp 0 → 100644
View file @ b59c91f4
//
// Created by Tom on 08/03/2023.
//
#ifndef TYPON_BOOL_HPP
#define TYPON_BOOL_HPP
#include <ostream>
template<>
void print_to(const bool &x, std::ostream &s) {
s << (x ? "True" : "False");
}
#endif //TYPON_BOOL_HPP
rt/include/python/builtins/complex.hpp 0 → 100644
View file @ b59c91f4
//
// Created by Tom on 08/03/2023.
//
#ifndef TYPON_COMPLEX_HPP
#define TYPON_COMPLEX_HPP
#include <complex>
#include <ostream>
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;
}
void print_to(const PyComplex &x, std::ostream &s) {
if (x.real() == 0) {
s << x.imag() << "j";
} else {
s << '(' << x.real() << "+" << x.imag() << "j)";
}
}
#endif //TYPON_COMPLEX_HPP
rt/include/python/builtins/dict.hpp 0 → 100644
View file @ b59c91f4
//
// Created by Tom on 08/03/2023.
//
#ifndef TYPON_DICT_HPP
#define TYPON_DICT_HPP
#include <unordered_map>
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::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());
}
operator std::unordered_map<K, V> &() {
return *reinterpret_cast<std::unordered_map<K, V> *>(this);
}
std::size_t py_len() const {
return this->size();
}
bool py_contains(const K &k) const {
return this->find(k) != this->end();
}
class iterator {
public:
using value_type = std::pair<K, V>;
using difference_type = std::ptrdiff_t;
using pointer = std::pair<K, V> *;
using reference = std::pair<K, V> &;
using iterator_category = std::forward_iterator_tag;
iterator(typename std::unordered_map<K, V>::iterator it) : _it(it) {}
iterator &operator++() {
_it++;
return *this;
}
iterator operator++(int) {
iterator tmp = *this;
_it++;
return tmp;
}
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;
}
private:
typename std::unordered_map<K, V>::iterator _it;
};
iterator py_iter() const {
return this->begin();
}
void py_print(std::ostream &s) const {
s << '{';
if (this->size() > 0) {
print_to(this->begin()->first, s);
s << ": ";
print_to(this->begin()->second, s);
for (auto it = ++this->begin(); it != this->end(); it++) {
s << ", ";
print_to(it->first, s);
s << ": ";
print_to(it->second, s);
}
}
s << '}';
}
};
template<typename K, typename V>
PyDict(std::initializer_list<std::pair<K, V>>) -> PyDict<K, V>;
#endif //TYPON_DICT_HPP
rt/include/python/builtins/list.hpp 0 → 100644
View file @ b59c91f4
//
// Created by Tom on 08/03/2023.
//
#ifndef TYPON_LIST_HPP
#define TYPON_LIST_HPP
#include <vector>
#include <ostream>
template<typename T>
class PyList : public std::vector<T> {
public:
PyList(std::vector<T> &&v) : std::vector<T>(std::move(v)) {}
PyList(std::initializer_list<T> &&v) : std::vector<T>(std::move(v)) {}
operator std::vector<T>() const {
return std::vector<T>(this->begin(), this->end());
}
operator std::vector<T> &() {
return *reinterpret_cast<std::vector<T> *>(this);
}
size_t py_len() const {
return this->size();
}
void py_print(std::ostream &s) const {
s << '[';
if (this->size() > 0) {
print_to(this->operator[](0), s);
for (size_t i = 1; i < this->size(); i++) {
s << ", ";
print_to(this->operator[](i), s);
}
}
s << ']';
}
PyList<T> operator+(const PyList<T> &other) const {
std::vector<T> v;
v.reserve(this->size() + other.size());
v.insert(v.end(), this->begin(), this->end());
v.insert(v.end(), other.begin(), other.end());
return PyList<T>(std::move(v));
}
PyList<T> operator*(size_t n) const {
std::vector<T> v;
v.reserve(this->size() * n);
for (size_t i = 0; i < n; i++) {
v.insert(v.end(), this->begin(), this->end());
}
return PyList<T>(std::move(v));
}
};
#endif //TYPON_LIST_HPP
rt/include/python/builtins/set.hpp 0 → 100644
View file @ b59c91f4
//
// Created by Tom on 08/03/2023.
//
#ifndef TYPON_SET_HPP
#define TYPON_SET_HPP
#include <unordered_set>
template<typename T>
class PySet : public std::unordered_set<T> {
public:
PySet(std::unordered_set<T> &&s) : std::unordered_set<T>(std::move(s)) {}
PySet(std::initializer_list<T> &&s) : std::unordered_set<T>(std::move(s)) {}
operator std::unordered_set<T>() const {
return std::unordered_set<T>(this->begin(), this->end());
}
std::size_t py_len() const {
return this->size();
}
bool py_contains(const T &t) const {
return this->find(t) != this->end();
}
class iterator {
public:
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T *;
using reference = T &;
using iterator_category = std::forward_iterator_tag;
iterator(typename std::unordered_set<T>::iterator it) : _it(it) {}
iterator &operator++() {
_it++;
return *this;
}
iterator operator++(int) {
iterator tmp = *this;
_it++;
return tmp;
}
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;
}
private:
typename std::unordered_set<T>::iterator _it;
};
iterator py_iter() const {
return this->begin();
}
void py_print(std::ostream &s) const {
s << '{';
if (this->size() > 0) {
print_to(*this->begin(), s);
for (auto it = ++this->begin(); it != this->end(); it++) {
s << ", ";
print_to(*it, s);
}
}
s << '}';
}
};
#endif //TYPON_SET_HPP
rt/include/python/builtins/str.hpp 0 → 100644
View file @ b59c91f4
//
// Created by Tom on 08/03/2023.
//
#ifndef TYPON_STR_HPP
#define TYPON_STR_HPP
#include <string>
#include <sstream>
using namespace std::literals;
template<typename T>
std::string str(const T &x) {
std::stringstream s;
print_to(x, s);
return s.str();
}
#endif //TYPON_STR_HPP
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7