pcc/include/purescript.hh · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

on 120a22e help sign in

rowtype-yoga/purescript-native/pcc/include/purescript.hh

344 lines 12 kB history raw

1///////////////////////////////////////////////////////////////////////////////

2//

3// Module : purescript.hh

4// Copyright : (c) Andy Arvanitis 2015

5// License : MIT

6//

7// Maintainer : Andy Arvanitis <andy.arvanitis@gmail.com>

8// Stability : experimental

9// Portability :

10//

11// Basic types and functions to support purescript-to-C++1x rendering

12//

13///////////////////////////////////////////////////////////////////////////////

14//

15#ifndef PureScript_HH

16#define PureScript_HH

18// Standard includes

20#if defined(DEBUG)

21 #include <cassert>

22#else

23 #define NDEBUG

24 #undef assert

25 #define assert(x)

26#endif

28#include <memory>

29#include <functional>

30#include <string>

31#include <vector>

32#include <unordered_map>

33#include <stdexcept>

34#include "map_key.hh"

36namespace PureScript {

38using string = std::string;

39using runtime_error = std::runtime_error;

40using nullptr_t = std::nullptr_t;

42const bool undefined = false;

44// A variant data class designed to provide some features of dynamic typing.

45//

46class any {

48 public:

49 enum class Type {

50 Unknown,

51 Integer,

52 Double,

53 Character,

54 Boolean,

55 String,

56 Map,

57 Vector,

58 Function,

59 EffFunction,

60 Thunk,

61 Pointer

62 };

64 mutable Type type = Type::Unknown;

66 struct as_thunk {

67 };

68 static constexpr as_thunk unthunk = as_thunk{};

70 using map = std::unordered_map<const map_key_t, const any, map_key_t::hasher, map_key_t::equal>;

71 using vector = std::vector<any>;

72 using fn = std::function<any(const any&)>;

73 using eff_fn = std::function<any()>;

74 using thunk = std::function<const any& (const as_thunk)>;

76 template <typename T>

77 using shared = std::shared_ptr<T>;

79 template <typename T>

80 static constexpr auto make_shared(const T& arg) -> shared<T> {

81 return std::make_shared<T>(arg);

82 }

84 template <typename T>

85 static constexpr auto make_shared(T&& arg) -> shared<T> {

86 return std::make_shared<T>(std::move(arg));

87 }

89 private:

90 union {

91 mutable long i;

92 mutable double d;

93 mutable char c;

94 mutable bool b;

95 mutable shared<string> s;

96 mutable shared<map> m;

97 mutable shared<vector> v;

98 mutable shared<fn> f;

99 mutable shared<eff_fn> e;

100 mutable shared<thunk> t;

101 mutable shared<void> p;

102 };

103

104 public:

105

106 any(const long val) : type(Type::Integer), i(val) {}

107 any(const int val) : type(Type::Integer), i(val) {}

108 any(const unsigned int val) : type(Type::Integer), i(val) {}

109 any(const double val) : type(Type::Double), d(val) {}

110 any(const char val) : type(Type::Character), c(val) {}

111

112 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>

113 any(const T val) : type(Type::Boolean), b(val) {}

114

115 any(const string& val) : type(Type::String), s(make_shared<string>(val)) {}

116 any(string&& val) : type(Type::String), s(make_shared<string>(std::move(val))) {}

117 any(const char val[]) : type(Type::String), s(make_shared<string>(val)) {}

118

119 any(const map& val) : type(Type::Map), m(make_shared<map>(val)) {}

120 any(map&& val) : type(Type::Map), m(make_shared<map>(std::move(val))) {}

121

122 any(const vector& val) : type(Type::Vector), v(make_shared<vector>(val)) {}

123 any(vector&& val) : type(Type::Vector), v(make_shared<vector>(std::move(val))) {}

124

125 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value>::type>

126 any(const T& val, typename std::enable_if<std::is_assignable<fn,T>::value>::type* = 0)

127 : type(Type::Function), f(make_shared<fn>(val)) {}

128

129 template <typename T>

130 any(const T& val, typename std::enable_if<std::is_assignable<eff_fn,T>::value>::type* = 0)

131 : type(Type::EffFunction), e(make_shared<eff_fn>(val)) {}

132

133 template <typename T>

134 any(const T& val, typename std::enable_if<std::is_assignable<thunk,T>::value>::type* = 0)

135 : type(Type::Thunk), t(make_shared<thunk>(val)) {}

136

137 template <typename T>

138 any(const T& val, typename std::enable_if<std::is_assignable<shared<void>,T>::value>::type* = 0)

139 : type(Type::Pointer), p(val) {}

140

141 template <typename T>

142 any(T&& val, typename std::enable_if<std::is_assignable<shared<void>,T>::value>::type* = 0)

143 : type(Type::Pointer), p(std::move(val)) {}

144

145 any(std::nullptr_t) : type(Type::Pointer), p(nullptr) {}

146

147 any(const any&);

148 any(any&&);

149

150 auto operator=(const any&) -> any&;

151 auto operator=(any&) -> any&;

152 auto operator=(any&&) -> any&;

153

154 any() = delete;

155 ~any();

156

157 template <typename T>

158 auto cast() const -> typename std::enable_if<std::is_same<T, long>::value, T>::type;

159

160 template <typename T>

161 auto cast() const -> typename std::enable_if<std::is_same<T, double>::value, T>::type;

162

163 template <typename T>

164 auto cast() const -> typename std::enable_if<std::is_same<T, char>::value, T>::type;

165

166 template <typename T>

167 auto cast() const -> typename std::enable_if<std::is_same<T, bool>::value, T>::type;

168

169 template <typename T>

170 auto cast() const -> typename std::enable_if<std::is_same<T, string>::value, const T&>::type;

171

172 template <typename T>

173 auto cast() const -> typename std::enable_if<std::is_same<T, const char*>::value, const T>::type;

174

175 template <typename T>

176 auto cast() const -> typename std::enable_if<std::is_same<T, map>::value, const T&>::type;

177

178 template <typename T>

179 auto cast() const -> typename std::enable_if<std::is_same<T, vector>::value, const T&>::type;

180

181 template <typename T>

182 auto cast() const -> typename std::enable_if<std::is_assignable<shared<void>,T>::value, typename T::element_type*>::type {

183 return static_cast<typename T::element_type*>(extractPointer());

184 }

185

186 auto operator()(const any&) const -> any;

187

188 auto operator()(const as_thunk) const -> const any&;

189

190 auto operator()() const -> any;

191

192 operator long() const;

193 operator double() const;

194 operator bool() const;

195

196 operator const string&() const;

197 operator const map&() const;

198 operator const vector&() const;

199

200 auto operator[](const map_key_t&) const -> const any&;

201 auto operator[](const vector::size_type) const -> const any&;

202 auto operator[](const any&) const -> const any&;

203

204 auto extractPointer() const -> void*;

205

206 static auto extract_value(const any&) -> const any&;

207

208 auto operator==(const any&) const -> bool;

209 auto operator==(const long) const -> bool;

210 auto operator==(const double) const -> bool;

211 auto operator==(const char) const -> bool;

212 auto operator==(const bool) const -> bool;

213 auto operator==(const string&) const -> bool;

214 auto operator==(const char * const) const -> bool;

215

216 auto operator!=(const any&) const -> bool;

217 auto operator!=(const long) const -> bool;

218 auto operator!=(const double) const -> bool;

219 auto operator!=(const char) const -> bool;

220 auto operator!=(const bool) const -> bool;

221 auto operator!=(const string&) const -> bool;

222 auto operator!=(const char * const) const -> bool;

223

224 auto operator<(const any&) const -> bool;

225 auto operator<(const long) const -> bool;

226 auto operator<(const double) const -> bool;

227 auto operator<(const char) const -> bool;

228 auto operator<(const bool) const -> bool;

229 auto operator<(const string&) const -> bool;

230 auto operator<(const char * const) const -> bool;

231

232 auto operator<=(const any&) const -> bool;

233 auto operator<=(const long) const -> bool;

234 auto operator<=(const double) const -> bool;

235 auto operator<=(const char) const -> bool;

236 auto operator<=(const bool) const -> bool;

237 auto operator<=(const string&) const -> bool;

238 auto operator<=(const char * const) const -> bool;

239

240 auto operator>(const any&) const -> bool;

241 auto operator>(const long) const -> bool;

242 auto operator>(const double) const -> bool;

243 auto operator>(const char) const -> bool;

244 auto operator>(const bool) const -> bool;

245 auto operator>(const string&) const -> bool;

246 auto operator>(const char * const) const -> bool;

247

248 auto operator>=(const any&) const -> bool;

249 auto operator>=(const long) const -> bool;

250 auto operator>=(const double) const -> bool;

251 auto operator>=(const char) const -> bool;

252 auto operator>=(const bool) const -> bool;

253 auto operator>=(const string&) const -> bool;

254 auto operator>=(const char * const) const -> bool;

255

256 auto operator+(const any&) const -> any;

257 auto operator+(const long) const -> long;

258 auto operator+(const double) const -> double;

259 auto operator+(const char) const -> char;

260 auto operator+(const string&) const -> string;

261 auto operator+(const char * const) const -> string;

262

263 auto operator-(const any&) const -> any;

264 auto operator-(const long) const -> long;

265 auto operator-(const double) const -> double;

266 auto operator-(const char) const -> char;

267

268 auto operator*(const any&) const -> any;

269 auto operator*(const long) const -> long;

270 auto operator*(const double) const -> double;

271

272 auto operator/(const any&) const -> any;

273 auto operator/(const long) const -> long;

274 auto operator/(const double) const -> double;

275

276 auto operator%(const any&) const -> any;

277 auto operator%(const long) const -> long;

278

279 auto operator-() const -> any; // unary negate

280

281 friend auto operator==(const long, const any&) -> bool;

282 friend auto operator!=(const long, const any&) -> bool;

283 friend auto operator< (const long, const any&) -> bool;

284 friend auto operator<=(const long, const any&) -> bool;

285 friend auto operator> (const long, const any&) -> bool;

286 friend auto operator>=(const long, const any&) -> bool;

287

288 friend auto operator==(const double, const any&) -> bool;

289 friend auto operator!=(const double, const any&) -> bool;

290 friend auto operator< (const double, const any&) -> bool;

291 friend auto operator<=(const double, const any&) -> bool;

292 friend auto operator> (const double, const any&) -> bool;

293 friend auto operator>=(const double, const any&) -> bool;

294

295 friend auto operator==(const char, const any&) -> bool;

296 friend auto operator!=(const char, const any&) -> bool;

297 friend auto operator< (const char, const any&) -> bool;

298 friend auto operator<=(const char, const any&) -> bool;

299 friend auto operator> (const char, const any&) -> bool;

300 friend auto operator>=(const char, const any&) -> bool;

301

302 friend auto operator==(const bool, const any&) -> bool;

303 friend auto operator!=(const bool, const any&) -> bool;

304 friend auto operator< (const bool, const any&) -> bool;

305 friend auto operator<=(const bool, const any&) -> bool;

306 friend auto operator> (const bool, const any&) -> bool;

307 friend auto operator>=(const bool, const any&) -> bool;

308

309 friend auto operator==(const string&, const any&) -> bool;

310 friend auto operator!=(const string&, const any&) -> bool;

311 friend auto operator< (const string&, const any&) -> bool;

312 friend auto operator<=(const string&, const any&) -> bool;

313 friend auto operator> (const string&, const any&) -> bool;

314 friend auto operator>=(const string&, const any&) -> bool;

315

316 friend auto operator==(const char* const, const any&) -> bool;

317 friend auto operator!=(const char* const, const any&) -> bool;

318 friend auto operator< (const char* const, const any&) -> bool;

319 friend auto operator<=(const char* const, const any&) -> bool;

320 friend auto operator> (const char* const, const any&) -> bool;

321 friend auto operator>=(const char* const, const any&) -> bool;

322

323 friend auto operator+(const long, const any&) -> long;

324 friend auto operator-(const long, const any&) -> long;

325 friend auto operator*(const long, const any&) -> long;

326 friend auto operator/(const long, const any&) -> long;

327 friend auto operator%(const long, const any&) -> long;

328

329 friend auto operator+(const double, const any&) -> double;

330 friend auto operator-(const double, const any&) -> double;

331 friend auto operator*(const double, const any&) -> double;

332 friend auto operator/(const double, const any&) -> double;

333

334 friend auto operator+(const char, const any&) -> char;

335 friend auto operator-(const char, const any&) -> char;

336

337 friend auto operator+(const string&, const any&) -> string;

338 friend auto operator+(const char* const, const any&) -> string;

339

340};

341

342} // namespace PureScript

343

344#endif // PureScript_HH