purescript.h

///////////////////////////////////////////////////////////////////////////////
//
// Module : purescript.h
// Copyright : (c) Andy Arvanitis 2018
// License : BSD
//
// Maintainer : Andy Arvanitis
// Stability : experimental
// Portability :
//
// Basic types and functions to support purescript-to-C++ rendering
//
///////////////////////////////////////////////////////////////////////////////
//
#ifndef purescript_H
#definepurescript_H

#include<memory>
#include<vector>
#include<string>
#include<utility>
#if !defined(NDEBUG)
#include<limits>
#endif
#if !defined(PURESCRIPT_DISABLE_EXCEPTIONS)
#include<stdexcept>
#endif
#include"functions.h"
#include"dictionary.h"
#include"recursion.h"

namespacepurescript {

using std::string;

classboxed {
public:
 std::shared_ptr<void> shared;
union {
int _int_;
double _double_;
bool _bool_;
 };

public:
usingfn_t = _template_::fn_t<boxed>;
usingeff_fn_t = _template_::eff_fn_t<boxed>;

usingdict_t = _template_::dict_t<boxed>;
usingarray_t = std::vector<boxed>;

using weak = _template_::weak<boxed>;
using recur = _template_::recur<boxed>;

private:
template <typename T>
using fn_T = _template_::fn_T<boxed, T>;

template <typename T>
using eff_fn_T = _template_::eff_fn_T<boxed, T>;

public:
boxed() noexcept : shared() {}
boxed(const std::nullptr_t) noexcept : shared() {}

boxed(const weak& w) : shared(w.shared()) {}
boxed(const recur& r) : shared(r.shared()) {}
boxed(const recur::weak& w) : shared(w.shared()) {}

template <typename T>
boxed(std::shared_ptr<T>&& other) noexcept : shared(std::move(other)) {}

template <typename T>
boxed(const std::shared_ptr<T>& other) : shared(other) {}

boxed(constint n) noexcept : _int_(n) {}
boxed(constlong n);
boxed(constunsignedlong n);
boxed(constdouble n) noexcept : _double_(n) {}
boxed(constbool b) noexcept : _bool_(b) {}
boxed(constchar s[]) : shared(std::make_shared<string>(s)) {}
boxed(string&& s) : shared(std::make_shared<string>(std::move(s))) {}
boxed(const string& s) : shared(std::make_shared<string>(s)) {}
boxed(array_t&& l) : shared(std::make_shared<array_t>(std::move(l))) {}
boxed(constarray_t& l) : shared(std::make_shared<array_t>(l)) {}
boxed(dict_t&& m) : shared(std::make_shared<dict_t>(std::move(m))) {}
boxed(constdict_t& m) : shared(std::make_shared<dict_t>(m)) {}

template <typename T,
typename U = typename std::remove_reference<T>::type,
typename V = typename std::remove_const<U>::type,
typename = typename std::enable_if<!std::is_same<boxed,V>::value && !std::is_same<recur,V>::value>::type>
boxed(T&& f,
typename std::enable_if<std::is_same<decltype(std::declval<U>()(std::declval<boxed>())), boxed>::value>::type* = 0)
 : shared(std::shared_ptr<fn_t>(std::make_shared<fn_T<T>>(std::forward<T>(f)))) {
 }

template <typename T,
typename U = typename std::remove_reference<T>::type,
typename V = typename std::remove_const<U>::type,
typename = typename std::enable_if<!std::is_same<boxed,V>::value && !std::is_same<recur,V>::value>::type>
boxed(T&& f,
typename std::enable_if<std::is_same<decltype(std::declval<U>()()), boxed>::value>::type* = 0)
 : shared(std::shared_ptr<eff_fn_t>(std::make_shared<eff_fn_T<T>>(std::forward<T>(f)))) {
 }

autoget() constnoexcept -> void * {
return shared.get();
 }

autooperator()(const boxed& arg) const -> boxed {
return (*static_cast<fn_t*>(shared.get()))(arg);
 }

autooperator()() const -> boxed {
return (*static_cast<eff_fn_t*>(shared.get()))();
 }

autooperator[](constchar key[]) const -> const boxed& {
return (*static_cast<constdict_t*>(shared.get()))[key];
 }

autooperator[](constchar key[]) -> boxed& {
return (*static_cast<dict_t*>(shared.get()))[key];
 }

autooperator[](constint index) const -> const boxed&;
autooperator[](constint index) -> boxed&;

 }; // class boxed

externtemplate class_template_::fn_t<boxed>;
externtemplate class_template_::eff_fn_t<boxed>;
externtemplate class_template_::dict_t<boxed>;
externtemplate class_template_::weak<boxed>;
externtemplate class_template_::recur<boxed>;

externconst boxed undefined;

usingfn_t = boxed::fn_t;
usingeff_fn_t = boxed::eff_fn_t;
usingdict_t = boxed::dict_t;
usingarray_t = boxed::array_t;

template <typename T, typename... Args,
typename = typename std::enable_if<!std::is_same<T, int>::value &&
 !std::is_same<T, double>::value &&
 !std::is_same<T, bool>::value
 >::type>
inlineautobox(Args&&... args) -> boxed {
return std::make_shared<T>(std::forward<Args>(args)...);
 }

template <typename T,
typename std::enable_if<std::is_same<T, int>::value, T>::type* = nullptr>
inlineautobox(T arg) noexcept -> boxed {
returnboxed(arg);
 }

template <typename T,
typename std::enable_if<std::is_same<T, double>::value, T>::type* = nullptr>
inlineautobox(T arg) noexcept -> boxed {
returnboxed(arg);
 }

template <typename T,
typename std::enable_if<std::is_same<T, bool>::value, T>::type* = nullptr>
inlineautobox(T arg) noexcept -> boxed {
returnboxed(arg);
 }

template <typename T,
typename = typename std::enable_if<!std::is_same<T, int>::value &&
 !std::is_same<T, double>::value &&
 !std::is_same<T, bool>::value
 >::type>
constexprautounbox(const boxed& b) -> const T& {
return *static_cast<const T*>(b.get());
 }

template <typename T,
typename std::enable_if<std::is_same<T, int>::value, T>::type* = nullptr>
constexprautounbox(const boxed& b) noexcept -> T {
return b._int_;
 }

template <typename T,
typename std::enable_if<std::is_same<T, double>::value, T>::type* = nullptr>
constexprautounbox(const boxed& b) noexcept -> T {
return b._double_;
 }

template <typename T,
typename std::enable_if<std::is_same<T, bool>::value, T>::type* = nullptr>
constexprautounbox(const boxed& b) noexcept -> T {
return b._bool_;
 }

template <typename T,
typename = typename std::enable_if<!std::is_same<T, int>::value &&
 !std::is_same<T, double>::value &&
 !std::is_same<T, bool>::value
 >::type>
constexprautounbox(boxed& b) -> T& {
return *static_cast<T*>(b.get());
 }

template <typename T>
constexprautounbox(const T value) noexcept -> T {
return value;
 }

template <typename T,
typename = typename std::enable_if<std::is_same<T, int>::value>::type>
constexprautounbox(const std::size_t value) noexcept -> long long {
return value;
 }

inlineautoarray_length(const boxed& a) -> boxed::array_t::size_type {
return unbox<boxed::array_t>(a).size();
 }

} // namespace purescript

#if !defined(PURESCRIPT_DISABLE_EXCEPTIONS)
#defineTHROW_(s) throwstd::runtime_error(s)
#else
#defineTHROW_(_) return undefined
#endif

#defineDEFINE_FOREIGN_DICTIONARY_AND_ACCESSOR() \
inlineautoforeign() -> dict_t& {\
staticdict_t _;\
return _;\
 }

#defineFOREIGN_BEGIN(NS) namespaceNS {\
usingnamespacepurescript;\
DEFINE_FOREIGN_DICTIONARY_AND_ACCESSOR()\
staticconstauto data = ([]() -> char {\
dict_t& exports = foreign();
#defineFOREIGN_ENDreturn0; }()); }

#endif // purescript_H