switch data to use std::any and merge value struct with concept

7 files changed, 15 insertions, 39 deletions

diff --git a/starts/meaning-vm/level-0/baseref.hpp b/starts/meaning-vm/level-0/baseref.hpp
index 849e205..205b422 100644
--- a/starts/meaning-vm/level-0/baseref.hpp
+++ b/starts/meaning-vm/level-0/baseref.hpp
@@ -49,12 +49,12 @@ public:
 	}
 
 	template <typename T>
-	T& vget(ref const & type) const { return p->vget<T>(type.p)->data; }
+	T& vget(ref const & type) const { return p->vget<T>(type.p); }
 	template <typename T>
-	void vset(ref const & type, T const & v) { p->set(type.p, valloc<T>(v)); }
+	void vset(ref const & type, T const & v) { p->set(type.p, alloc(v)); }
 
 	template <typename T>
-	T& val() { return p->val<T>()->data; }
+	T& val() { return p->val<T>(); }
 
 	operator concept*() const { return p; }
 	concept*& ptr() { return p; }
diff --git a/starts/meaning-vm/level-0/common.hpp b/starts/meaning-vm/level-0/common.hpp
index 74031cc..6e86907 100644
--- a/starts/meaning-vm/level-0/common.hpp
+++ b/starts/meaning-vm/level-0/common.hpp
@@ -7,8 +7,6 @@ namespace level0 {
 
 struct concept;
 struct ref;
-template <typename T> struct value;
-template <typename T> struct vref;
 
 }
 namespace level1 { struct ref; template <typename> struct vref; }
diff --git a/starts/meaning-vm/level-0/concept.hpp b/starts/meaning-vm/level-0/concept.hpp
index 3bd1609..d57ccfc 100644
--- a/starts/meaning-vm/level-0/concept.hpp
+++ b/starts/meaning-vm/level-0/concept.hpp
@@ -2,6 +2,7 @@
 
 #include "common.hpp"
 
+#include <any>
 #include <map>
 #include <vector>
 
@@ -12,6 +13,9 @@ struct concept
 {
 	// a concept is made of concept-typed links to other concepts
 	std::multimap<concept*,concept*> links;
+	// and optional associated arbitrary data
+	std::any data;
+
 	using array = std::vector<concept*>;
 
 	concept* id();
@@ -30,10 +34,10 @@ struct concept
 	void set(concept* type, concept* target);
 
 	template <typename T>
-	value<T>* vget(concept* type) const { return static_cast<value<T>*>(get(type)); }
+	T & vget(concept* type) const { return get(type)->val<T>(); }
 
 	template <typename T>
-	value<T>* val() { return this; }
+	T & val() { return std::any_cast<T&>(data); }
 };
 
 }
diff --git a/starts/meaning-vm/level-0/level-0.hpp b/starts/meaning-vm/level-0/level-0.hpp
index 7062be0..56cd7dd 100644
--- a/starts/meaning-vm/level-0/level-0.hpp
+++ b/starts/meaning-vm/level-0/level-0.hpp
@@ -5,4 +5,3 @@
 #include "errors.hpp"
 #include "memorystore.hpp"
 #include "ref.hpp"
-#include "value.hpp"
diff --git a/starts/meaning-vm/level-0/memorystore.cpp b/starts/meaning-vm/level-0/memorystore.cpp
index b092ca0..adae8b2 100644
--- a/starts/meaning-vm/level-0/memorystore.cpp
+++ b/starts/meaning-vm/level-0/memorystore.cpp
@@ -14,8 +14,9 @@ static auto & concepts()
 	return concepts;
 }
 
-ref alloc(concept * moved) {
-	ref r = moved ? moved : new concept();
+ref alloc(std::any data) {
+	concept * r = new concept();
+	r->data = data;
 	concepts().insert(r);
 	return r;
 }
diff --git a/starts/meaning-vm/level-0/memorystore.hpp b/starts/meaning-vm/level-0/memorystore.hpp
index fd752a0..7843513 100644
--- a/starts/meaning-vm/level-0/memorystore.hpp
+++ b/starts/meaning-vm/level-0/memorystore.hpp
@@ -1,14 +1,13 @@
 #pragma once
 
 #include "common.hpp"
-#include "value.hpp"
+
+#include <any>
 
 namespace intellect {
 namespace level0 {
 
-ref alloc(concept * moved = 0);
-template <typename T>
-value<T> * valloc(T const & v) { return static_cast<value<T>*>(alloc(new value<T>(v)).ptr()); }
+ref alloc(std::any data = {});
 void dealloc(ref);
 std::size_t allocated();
 
diff --git a/starts/meaning-vm/level-0/value.hpp b/starts/meaning-vm/level-0/value.hpp
deleted file mode 100644
index ff704bf..0000000
--- a/starts/meaning-vm/level-0/value.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "common.hpp"
-
-#include "concept.hpp"
-
-namespace intellect {
-namespace level0 {
-
-template <typename T>
-struct value : public concept
-{
-	value(T const & val) : data(val) { }
-
-	value(value<T> const & val) = default;
-
-	operator T&() { return data; }
-	operator T const &() const { return data; }
-
-	T data;
-};
-
-
-}
-}