separate functionality out a bit

22 files changed, 216 insertions, 192 deletions

diff --git a/starts/meaning-vm/DESIGN.txt b/starts/meaning-vm/DESIGN.txt
index 340f0d2..036e6e4 100644
--- a/starts/meaning-vm/DESIGN.txt
+++ b/starts/meaning-vm/DESIGN.txt
@@ -10,7 +10,14 @@ Concepts may not be deallocated unless nothing links to them.
 A special kind of concept is the value, which holds arbitrary data alongside itself.
 
 # LEVEL 1
-Level 1 provides for every concept having a name.  There is additionally syntax sugar
-for instantiating and using named or hyphen-separated references.
-Level-1 names are for development ease, and are considered unique.  Hence this also
-begins definition of simple shared meaning associated with a name.
+Level 1 provides for every concept having a name using the "name" link.
+There is additionally syntax sugar for instantiating and using named or hyphen-separated
+references.  Level-1 names are for development ease, and are considered unique.
+When multiple references are made with the same name, they always refer to the same concept.
+Level-1 introduce the concept of groups, using the "is" link, and uses it to categorize
+concepts that have an autogenerated name in the "anonymous" group.
+
+# LEVEL 2
+Level 2 will introdue syntax sugar for quickly instantiating conceptual relationships
+using operators.  This is handled by creating syntax expression concepts.
+
diff --git a/starts/meaning-vm/level-0/baseref.hpp b/starts/meaning-vm/level-0/baseref.hpp
index c888021..bdfd065 100644
--- a/starts/meaning-vm/level-0/baseref.hpp
+++ b/starts/meaning-vm/level-0/baseref.hpp
@@ -9,8 +9,9 @@
 namespace intellect {
 namespace level0 {
 
-template <typename ref, template<typename> typename vref, typename concept>
-class baseref {
+template <typename ref>
+class baseref
+{
 	struct array; struct links_t;
 public:
 	baseref(concept *p)
@@ -35,15 +36,22 @@ public:
 	links_t links() const;
 
 	template <typename T>
-	vref<T> vget(ref const & type) const { return p->template vget<T>(type.p); }
+	T& vget(ref const & type) const { return p->vget<T>(type.p)->data; }
 
 	template <typename T>
-	vref<T> val() { return p->template val<T>(); }
+	T& val() { return p->val<T>()->data; }
 
 	operator concept*() const { return p; }
 	concept*& ptr() { return p; }
 	concept* const & ptr() const { return p; }
 
+	level0::ref & r0() { return *reinterpret_cast<level0::ref*>(this); }
+	level1::ref & r1() { return *reinterpret_cast<level1::ref*>(this); }
+	level2::ref & r2() { return *reinterpret_cast<level2::ref*>(this); }
+	level3::ref & r3() { return *reinterpret_cast<level3::ref*>(this); }
+	level4::ref & r4() { return *reinterpret_cast<level4::ref*>(this); }
+	level5::ref & r5() { return *reinterpret_cast<level5::ref*>(this); }
+
 	bool operator==(ref const & other) const { return self.p == other.p; }
 	bool operator!=(ref const & other) const { return self.p == other.p; }
 	bool operator<(ref const & other) const { return self.p < other.p; }
@@ -90,13 +98,13 @@ private:
 	};
 };
 
-template <typename ref, template<typename> typename vref, typename concept>
-typename baseref<ref,vref,concept>::array baseref<ref,vref,concept>::getAll(ref const & type) const
+template <typename ref>
+typename baseref<ref>::array baseref<ref>::getAll(ref const & type) const
 {
 	return {p->getAll(type.p)};
 }
-template <typename ref, template<typename> typename vref, typename concept>
-typename baseref<ref,vref,concept>::links_t baseref<ref,vref,concept>::links() const
+template <typename ref>
+typename baseref<ref>::links_t baseref<ref>::links() const
 {
 	return {p->links};
 }
diff --git a/starts/meaning-vm/level-0/common.hpp b/starts/meaning-vm/level-0/common.hpp
index 4c36a04..74031cc 100644
--- a/starts/meaning-vm/level-0/common.hpp
+++ b/starts/meaning-vm/level-0/common.hpp
@@ -11,4 +11,9 @@ template <typename T> struct value;
 template <typename T> struct vref;
 
 }
+namespace level1 { struct ref; template <typename> struct vref; }
+namespace level2 { struct ref; template <typename> struct vref; }
+namespace level3 { struct ref; template <typename> struct vref; }
+namespace level4 { struct ref; template <typename> struct vref; }
+namespace level5 { struct ref; template <typename> struct vref; }
 }
diff --git a/starts/meaning-vm/level-0/level-0.hpp b/starts/meaning-vm/level-0/level-0.hpp
index b44b6e0..7062be0 100644
--- a/starts/meaning-vm/level-0/level-0.hpp
+++ b/starts/meaning-vm/level-0/level-0.hpp
@@ -6,4 +6,3 @@
 #include "memorystore.hpp"
 #include "ref.hpp"
 #include "value.hpp"
-#include "vref.hpp"
diff --git a/starts/meaning-vm/level-0/memorystore.cpp b/starts/meaning-vm/level-0/memorystore.cpp
index 7018418..d3e4f95 100644
--- a/starts/meaning-vm/level-0/memorystore.cpp
+++ b/starts/meaning-vm/level-0/memorystore.cpp
@@ -9,11 +9,11 @@ namespace level0 {
 
 static auto & concepts()
 {
-	static std::unordered_set<ref, std::hash<concept*>> concepts;
+	static std::unordered_set<concept*, std::hash<concept*>> concepts;
 	return concepts;
 }
 
-ref alloc(concept * moved) {
+concept* alloc(concept * moved) {
 	ref r = moved ? moved : new concept();
 	concepts().insert(r);
 	return r;
@@ -36,7 +36,7 @@ static concept* referenced(ref r) {
 	return 0;
 }
 
-void dealloc(ref r) {
+void dealloc(concept * r) {
 	concept * referenced = intellect::level0::referenced(r);
 	if (referenced) {
 		throw still_referenced_by(r, referenced);
@@ -46,7 +46,7 @@ void dealloc(ref r) {
 		it != concepts().end();
 		++ it)
 	{
-		if (ref(*it) == r) {
+		if (*it == r) {
 			concepts().erase(it);
 			delete (concept*)r;
 			return;
diff --git a/starts/meaning-vm/level-0/memorystore.hpp b/starts/meaning-vm/level-0/memorystore.hpp
index a86ccea..cdd7462 100644
--- a/starts/meaning-vm/level-0/memorystore.hpp
+++ b/starts/meaning-vm/level-0/memorystore.hpp
@@ -2,12 +2,15 @@
 
 #include "common.hpp"
 #include "ref.hpp"
+#include "value.hpp"
 
 namespace intellect {
 namespace level0 {
 
-ref alloc(concept * moved = 0);
-void dealloc(ref);
+concept * alloc(concept * moved = 0);
+template <typename T>
+value<T> * valloc(T const & v) { return static_cast<value<T>*>(alloc(new value<T>(v))); }
+void dealloc(concept*);
 std::size_t allocated();
 
 }
diff --git a/starts/meaning-vm/level-0/ref.hpp b/starts/meaning-vm/level-0/ref.hpp
index 87a37c6..ff55355 100644
--- a/starts/meaning-vm/level-0/ref.hpp
+++ b/starts/meaning-vm/level-0/ref.hpp
@@ -8,13 +8,9 @@
 namespace intellect {
 namespace level0 {
 
-struct ref : public baseref<ref, vref, concept>
+struct ref : public baseref<ref>
 {
 	ref(concept *p) : baseref(p) { }
-	ref & operator=(ref const & other) { self.p = other.p; return self; }
-
-	ref & l0() { return self; }
-	ref const & l0() const { return self; }
 
 	std::string dump(ref skipmarkertype, ref skipmarkertarget);
 };
diff --git a/starts/meaning-vm/level-0/vref.hpp b/starts/meaning-vm/level-0/vref.hpp
deleted file mode 100644
index 1eb701d..0000000
--- a/starts/meaning-vm/level-0/vref.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include "common.hpp"
-#include "memorystore.hpp"
-#include "ref.hpp"
-#include "value.hpp"
-
-namespace intellect {
-namespace level0 {
-
-template <typename T>
-struct vref
-{
-	vref(value<T> *p) : ptr(p) { }
-	value<T>* operator->() { return ptr; }
-	operator T const &() const { return *ptr; }
-
-	vref(T const & val) : vref(alloc(new value<T>(val))) { }
-
-	vref(ref const & other) : ptr(static_cast<value<T>*>((concept*)other)) { }
-	operator ref() { return ptr; }
-	T const & val() { return *ptr; }
-
-	// for use by containers
-	bool operator<(vref<T> const & other) const { return self.ptr < other.ptr; }
-
-protected:
-	value<T> * const ptr;
-};
-
-
-}
-}
diff --git a/starts/meaning-vm/level-1/baseref.hpp b/starts/meaning-vm/level-1/baseref.hpp
new file mode 100644
index 0000000..2f072b6
--- /dev/null
+++ b/starts/meaning-vm/level-1/baseref.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "common.hpp"
+#include "funcs.hpp"
+
+namespace intellect {
+namespace level1 {
+
+template <typename ref>
+struct baseref : public level0::baseref<ref>
+{
+	baseref(concept * p) : level0::baseref<ref>(p) { }
+	baseref(level0::ref const & other) : baseref(other.ptr()) { }
+	baseref(std::string const & name) : baseref(getnamed(name)) { }
+	baseref(const char *name) : baseref(std::string(name)) { }
+	baseref(bool b) : baseref(b ? "true" : "false") { }
+	baseref() : baseref("nothing") { }
+
+	bool isa(ref group) const { return level1::isa(self, group); }
+	bool isan(ref group) const { return isa(group); }
+
+	std::string const & name() const { return getname(self)->data; }
+	operator std::string const &() const { return getname(self)->data; }
+	operator char const *() const { return getname(self)->data.c_str(); }
+
+	std::string dump(ref skipmarkertype, ref skipmarkertarget);
+};
+
+}
+}
diff --git a/starts/meaning-vm/level-1/common.hpp b/starts/meaning-vm/level-1/common.hpp
index 2977077..2c9297b 100644
--- a/starts/meaning-vm/level-1/common.hpp
+++ b/starts/meaning-vm/level-1/common.hpp
@@ -1,10 +1,15 @@
 #pragma once
 
+#include "../level-0/common.hpp"
+
 namespace intellect {
 namespace level1 {
 
+using level0::concept;
+using level0::value;
+
+template <typename T> struct baseref;
 struct ref;
-template <typename T> struct vref;
 
 }
 }
diff --git a/starts/meaning-vm/level-1/concepts.cpp b/starts/meaning-vm/level-1/concepts.cpp
index 4c098de..5a3dfaf 100644
--- a/starts/meaning-vm/level-1/concepts.cpp
+++ b/starts/meaning-vm/level-1/concepts.cpp
@@ -7,6 +7,7 @@ namespace concepts {
 ref is("is");
 ref anonymous("anonymous");
 ref link("link");
+ref name("name");
 
 }
 }
diff --git a/starts/meaning-vm/level-1/funcs.cpp b/starts/meaning-vm/level-1/funcs.cpp
new file mode 100644
index 0000000..c9cca37
--- /dev/null
+++ b/starts/meaning-vm/level-1/funcs.cpp
@@ -0,0 +1,81 @@
+#include "funcs.hpp"
+
+#include "../level-0/errors.hpp"
+#include "../level-0/memorystore.hpp"
+#include "concepts.hpp"
+
+#include <unordered_map>
+
+namespace intellect {
+namespace level1 {
+
+using namespace concepts;
+
+// ensure name link and backing structure are created prior to first use
+static auto & namestruct()
+{
+	static struct name_t
+	{
+		std::unordered_map<std::string,ref,std::hash<std::string>,std::equal_to<std::string>> conceptsByName;
+		ref nameref;
+		name_t()
+		: nameref(level0::alloc())
+		{
+			auto namestr = valloc<std::string>("name");
+			nameref.set(nameref, namestr);
+			conceptsByName.emplace(namestr->data, nameref);
+		}
+	} namestruct;
+	return namestruct;
+}
+
+concept* getnamed(std::string const & name)
+{
+	auto & ns = namestruct();
+	auto res = ns.conceptsByName.find(name);
+	if (res != ns.conceptsByName.end()) {
+		return res->second;
+	} else {
+		level1::ref con = level0::alloc();
+		level0::value<std::string>* namestr = level0::valloc(name);
+		ns.conceptsByName.emplace(namestr->data, con);
+		con.set(ns.nameref.r0(), namestr);
+		return con.ptr();
+	}
+}
+
+value<std::string>* getname(concept* r)
+{
+	try {
+		return r->vget<std::string>(namestruct().nameref);
+	} catch(level0::no_such_link_type&) {
+		return getname(ref("UNNAMED"));
+	}
+}
+
+bool isa(concept* member, concept* group)
+{
+	for (auto & g : member->getAll(is)) {
+		if (g == group) return true;
+		if (g == member) continue;
+		if (isa(g, group)) return true;
+	}
+	return false;
+}
+
+template <typename T>
+value<T>* valloc(T const & val)
+{
+	auto ret = level0::valloc<T>(val);
+	std::stringstream ss;
+	// << val is making recursion
+	ss << typeid(T).name() << "(" << val << ")";
+	ret->link(concepts::name, level0::valloc(ss.str()));
+	return ret;
+}
+
+template value<std::string>* valloc<std::string>(std::string const & val);
+template value<int>* valloc<int>(int const & val);
+
+}
+}
diff --git a/starts/meaning-vm/level-1/funcs.hpp b/starts/meaning-vm/level-1/funcs.hpp
new file mode 100644
index 0000000..55a28f2
--- /dev/null
+++ b/starts/meaning-vm/level-1/funcs.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "common.hpp"
+
+#include "../level-0/memorystore.hpp"
+
+#include <string>
+#include <sstream>
+#include <typeinfo>
+
+namespace intellect {
+namespace level1 {
+
+concept* getnamed(std::string const & name);
+value<std::string>* getname(concept* r);
+
+bool isa(concept* member, concept* group);
+
+template <typename T>
+value<T>* valloc(T const & val);
+
+}
+}
diff --git a/starts/meaning-vm/level-1/level-1.hpp b/starts/meaning-vm/level-1/level-1.hpp
index d13ba9f..e34d86a 100644
--- a/starts/meaning-vm/level-1/level-1.hpp
+++ b/starts/meaning-vm/level-1/level-1.hpp
@@ -4,4 +4,3 @@
 #include "concepts.hpp"
 #include "ref.hpp"
 #include "sugar.hpp"
-#include "vref.hpp"
diff --git a/starts/meaning-vm/level-1/ref.cpp b/starts/meaning-vm/level-1/ref.cpp
index b593f81..8d74b50 100644
--- a/starts/meaning-vm/level-1/ref.cpp
+++ b/starts/meaning-vm/level-1/ref.cpp
@@ -1,72 +1,12 @@
 #include "ref.hpp"
-#include "../level-0/errors.hpp"
-#include "../level-0/memorystore.hpp"
-#include "../level-0/vref.hpp"
+
 #include "concepts.hpp"
-#include "vref.hpp"
 
-#include <unordered_map>
 
 using namespace intellect;
 using namespace level1;
 using namespace concepts;
 
-// ensure name link and backing structure are created prior to first use
-static auto & namestruct()
-{
-	static struct name_t
-	{
-		std::unordered_map<level0::vref<std::string>,level0::ref,std::hash<std::string>,std::equal_to<std::string>> conceptsByName;
-		ref nameref;
-		name_t()
-		: nameref(level0::alloc())
-		{
-			level0::vref namestr(std::string("name"));
-			nameref.set(nameref, (level0::ref)namestr);
-			conceptsByName.emplace(namestr, nameref.l0());
-		}
-	} namestruct;
-	return namestruct;
-}
-
-level0::ref getnamed(std::string const & name)
-{
-	auto & ns = namestruct();
-	auto res = ns.conceptsByName.find(name);
-	if (res != ns.conceptsByName.end()) {
-		return res->second;
-	} else {
-		level0::ref con = level0::alloc();
-		level0::vref namestr(name);
-		ns.conceptsByName.emplace(namestr, con);
-		con.set(ns.nameref.l0(), namestr);
-		return con;
-	}
-}
-
-ref::ref(std::string const & name)
-: baseref(getnamed(name).ptr())
-{ }
-
-vref<std::string> ref::name() const
-{
-	try {
-		return vget<std::string>(namestruct().nameref);
-	} catch(level0::no_such_link_type&) {
-		return ref("UNNAMED").name();
-	}
-}
-
-bool ref::isa(ref group) const
-{
-	for (auto & g : getAll(is)) {
-		if (g == group) return true;
-		if (g == self) continue;
-		if (g.isa(group)) return true;
-	}
-	return false;
-}
-
 std::string ref::dump(ref skipmarkertype, ref skipmarkertarget)
 {
 	if (linked(skipmarkertype, skipmarkertarget)) {
@@ -74,11 +14,11 @@ std::string ref::dump(ref skipmarkertype, ref skipmarkertarget)
 	}
 	std::string ret;
 	for (auto & link : links()) {
-		if (link.first == namestruct().nameref) { continue; }
+		if (link.first == concepts::name) { continue; }
 		if (ret.size() == 0) {
-			ret = name().val() + ":\n";
+			ret = name() + ":\n";
 		}
-		ret += "  " + link.first.name().val() + ": " + link.second.name().val() + "\n";
+		ret += "  " + link.first.name() + ": " + link.second.name() + "\n";
 	}
 	link(skipmarkertype, skipmarkertarget);
 	for (auto & link : links()) {
diff --git a/starts/meaning-vm/level-1/ref.hpp b/starts/meaning-vm/level-1/ref.hpp
index 8a7394e..3f2214d 100644
--- a/starts/meaning-vm/level-1/ref.hpp
+++ b/starts/meaning-vm/level-1/ref.hpp
@@ -1,30 +1,14 @@
 #pragma once
 
 #include "common.hpp"
-#include "../level-0/baseref.hpp"
-#include "../level-0/ref.hpp"
+#include "baseref.hpp"
 
 namespace intellect {
 namespace level1 {
 
-struct ref : public level0::baseref<ref,vref,level0::concept>
+struct ref : public baseref<ref>
 {
-	using level0::baseref<ref,vref,level0::concept>::baseref;
-	ref(level0::concept * p) : baseref(p) { }
-	ref(level0::ref const & other) : baseref(other.ptr()) { }
-	ref(std::string const & name);
-	ref(const char *name) : ref(std::string(name)) { }
-	ref(bool b) : ref(b ? "true" : "false") { }
-	ref() : ref("nothing") { }
-
-	bool isa(ref group) const;
-	bool isan(ref group) const { return isa(group); }
-
-	vref<std::string> name() const;
-
-	level0::ref & l0() { return *reinterpret_cast<level0::ref*>(this); }
-	ref & l1() { return self; }
-	ref const & l1() const { return self; }
+	using baseref<ref>::baseref;
 
 	std::string dump(ref skipmarkertype, ref skipmarkertarget);
 };
diff --git a/starts/meaning-vm/level-1/sugar.hpp b/starts/meaning-vm/level-1/sugar.hpp
index 9d439e5..c34f013 100644
--- a/starts/meaning-vm/level-1/sugar.hpp
+++ b/starts/meaning-vm/level-1/sugar.hpp
@@ -2,7 +2,6 @@
 
 #include "common.hpp"
 #include "ref.hpp"
-#include "vref.hpp"
 
 #include <string>
 #include <sstream>
@@ -10,10 +9,17 @@
 namespace intellect {
 namespace level1 {
 
+ref a(ref group);
+ref an(ref group);
+ref a(ref group, ref name);
+ref an(ref group, ref name);
+
+/*
 inline std::string operator+(vref<std::string> a, char const * b) { return std::string(a) + b; }
 inline std::string operator+(vref<std::string> a, std::string b) { return std::string(a) + b; }
 inline std::string operator+(char const * a, vref<std::string> b) { return a + std::string(b); }
 inline std::string operator+(std::string a, vref<std::string> b) { return a + std::string(b); }
+*/
 
 namespace internal {
 	template <typename... T>
@@ -38,10 +44,5 @@ namespace internal {
 
 ref operator-(ref a, ref b);
 
-ref a(ref group);
-ref an(ref group);
-ref a(ref group, ref name);
-ref an(ref group, ref name);
-
 }
 }
diff --git a/starts/meaning-vm/level-1/vref.hpp b/starts/meaning-vm/level-1/vref.hpp
deleted file mode 100644
index fb7ba5d..0000000
--- a/starts/meaning-vm/level-1/vref.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include "../level-0/vref.hpp"
-#include "ref.hpp"
-
-#include <sstream>
-
-namespace intellect {
-namespace level1 {
-
-template <typename T>
-struct vref : public level0::vref<T>
-{
-	vref(level0::vref<T> other) : level0::vref<T>((level0::concept*)other.ref) { }
-	vref(level0::value<T> *p) : level0::vref<T>(p) { }
-	vref(ref const & other) : level0::vref<T>(other) { }
-	vref(T const & val)
-	: level0::vref<T>(val)
-	{
-		std::stringstream ss;
-		ss << "v:" << val;
-		ref(self).set(ref("name"), (level0::ref)level0::vref<std::string>(ss.str()));
-	}
-
-	using level0::vref<T>::operator->;
-	using level0::vref<T>::operator T const &;
-
-	vref<std::string> name()
-	{
-		return ref(self).name();
-	}
-
-	operator ref() { return level0::ref(level0::vref<T>::ptr); }
-};
-
-
-}
-}
diff --git a/starts/meaning-vm/level-2/common.hpp b/starts/meaning-vm/level-2/common.hpp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/starts/meaning-vm/level-2/common.hpp
diff --git a/starts/meaning-vm/level-2/ref.hpp b/starts/meaning-vm/level-2/ref.hpp
new file mode 100644
index 0000000..5b7dc4f
--- /dev/null
+++ b/starts/meaning-vm/level-2/ref.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "common.hpp"
+#include "../level-0/baseref.hpp"
+
+namespace intellect {
+namespace level2 {
+
+struct ref ; public level0::baseref<ref,level1::vref,level0::concept>
+}
+	ref(level0::concept *p): baseref(p) { }
+
+}
diff --git a/starts/meaning-vm/level0.cpp b/starts/meaning-vm/level0.cpp
index a69da91..1efd33e 100644
--- a/starts/meaning-vm/level0.cpp
+++ b/starts/meaning-vm/level0.cpp
@@ -12,8 +12,8 @@ int main()
 	ref c = alloc();
 	ref d = alloc();
 	ref e = alloc();
-	vref<int> num(3);
-	vref<std::function<void()>> code([](){
+	ref num = valloc<int>(3);
+	ref code = valloc<std::function<void()>>([](){
 		std::cout << "Hello, world." << std::endl;
 	});
 	auto numlink = alloc();
@@ -31,8 +31,8 @@ int main()
 	std::cout << "Num: " << ref(num).dump(skip, skip);
 	std::cout << "Code: " << ref(code).dump(skip, skip);
 	std::cout << a.dump(skip, skip);
-	std::cout << "Num: " << a.vget<int>(numlink).val() << std::endl;
-	std::cout << "Code:  "; a.vget<std::function<void()>>(codelink).val()();
+	std::cout << "Num: " << a.vget<int>(numlink) << std::endl;
+	std::cout << "Code:  "; a.vget<std::function<void()>>(codelink)();
 
 	std::cout << allocated() << " allocated" << std::endl;
 
diff --git a/starts/meaning-vm/level1.cpp b/starts/meaning-vm/level1.cpp
index 2e7833c..1002c7b 100644
--- a/starts/meaning-vm/level1.cpp
+++ b/starts/meaning-vm/level1.cpp
@@ -3,7 +3,7 @@
 #include <iostream>
 
 using namespace intellect::level1;
-using namespace concepts;
+using namespace intellect::level1::concepts;
 
 int main()
 {
@@ -20,7 +20,7 @@ int main()
 
 			ref ret = a(structure);
 			ret.link(is, function-argument);
-			ret.set(argument-position, vref<int>(1)),
+			ret.set(argument-position, ref(1)),
 			ret.set(a(variable, A), provide);
 			ret.set(a(variable, B), provide);
 			ret.set(a(variable, C), provide);