move intellect-framework-from-internet into folder

10 files changed, 515 insertions, 0 deletions

diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/baseref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/baseref.hpp
new file mode 100644
index 0000000..ac6ff9c
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/baseref.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+#include "common.hpp"
+#include "funcs.hpp"
+
+#include "../level-0/ref.hpp"
+
+#include <functional>
+
+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, concept* allocator = nullptr) : baseref(getnamed(name, allocator)) { }
+	baseref(const char *name, concept* allocator = nullptr) : baseref(std::string(name), allocator) { }
+	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 name() const { return getname(self); }
+	explicit operator char const *() const { return getname(self)->data.c_str(); }
+
+	ref operator-(ref other) const { return hyphenate(self, other); }
+	ref operator[](ref subref) const { return self.get(subref); }
+
+	template <typename T>
+	void vset(ref const & type, T const & v) { self.set(type, level1::alloc(level0::concepts::allocations(), v)); }
+
+	template <typename... Ref>
+	std::function<ref(Ref...)> & fun() { return self.template val<std::function<ref(Ref...)>>(); }
+	template <typename... Ref>
+	void fun(std::function<ref(Ref...)> const & f) { self.val(f); }
+	template <typename... Ref>
+	void fun(std::function<void(Ref...)> const & f) { self.val(voidtoret(f)); }
+	template <typename... Ref>
+	void fget(ref const & type) { return self.template vget<std::function<ref(Ref...)>>(type); }
+	template <typename... Ref>
+	void fset(ref const & type, std::function<ref(Ref...)> f) { self.vset(type, f); }
+	template <typename... Ref>
+	void fset(ref const & type, std::function<void(Ref...)> f) { fset(type, voidtoret(f)); }
+
+	template <typename... Ref>
+	ref operator()(Ref... args) { return self.template fun<Ref...>()(args...); }
+
+	std::string dump(ref set) { return level1::dump(self, set); };
+
+private:
+	template <typename... Refs>
+	std::function<ref(Refs...)> voidtoret(std::function<void(Refs...)> f)
+	{
+		return [f](Refs... args) -> ref
+		{
+			std::initializer_list<ref const *>({&args...});
+			f(args...);
+			return "nothing";
+		};
+	}
+};
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/common.hpp
new file mode 100644
index 0000000..73de3b4
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/common.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "../level-0/common.hpp"
+
+namespace intellect {
+namespace level1 {
+
+using level0::concept;
+
+template <typename T> struct baseref;
+struct ref;
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.cpp
new file mode 100644
index 0000000..08d645a
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.cpp
@@ -0,0 +1,20 @@
+#include "concepts.hpp"
+
+#include "funcs.hpp"
+#include "../level-0/memorystore.hpp"
+
+namespace intellect {
+namespace level1 {
+namespace concepts {
+
+static struct init { init() {
+	givename(intellect::level0::concepts::allocator(), "allocator");
+	givename(intellect::level0::concepts::allocates(), "allocates");
+	givename(intellect::level0::concepts::allocations(), "allocations");
+	givename(intellect::level0::concepts::level0allocations(), "level0-allocations");
+} } __init;
+
+
+}
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.hpp
new file mode 100644
index 0000000..f33d228
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "ref.hpp"
+
+namespace intellect {
+namespace level1 {
+
+namespace concepts {
+
+static ref level1("level1"), allocations("allocations");
+static ref is("is", level1-allocations); // a link to define group relationships, links to the more general class
+static ref name("name", level1-allocations); // used as the link to value<std::string> naming each concept
+static ref text("text", level1-allocations); // used as the type of value<std::string> names
+static ref nothing("nothing", level1-allocations); // default value of a ref
+static ref anonymous("anonymous", level1-allocations); // a group given concepts with generated names
+static ref link("link", level1-allocations); // TODO: for concepts that are links, link them with is=link
+static ref level0("level0", level1-allocations) , level2("level2", level1-allocations) , level3("level3", level1-allocations) , level4("level4", level1-allocations) , level5("level5", level1-allocations) , level6("level6", level1-allocations) , level7("level7", level1-allocations) , level8("level8", level1-allocations) , level9("level9", level1-allocations);
+static ref allocator("allocator"), allocates("allocates");
+
+static ref _false("false", level1-allocations), _true("true", level1-allocations);
+
+//extern ref true, false; <-- casting provides as if these were declared
+
+}
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.cpp
new file mode 100644
index 0000000..fb57165
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.cpp
@@ -0,0 +1,209 @@
+#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;
+
+// TODO: use generalized unique data to replace name that are used only for parse-labels etc.
+// simplifies innards.
+// provide a way to get a named concept in a context, for actual meaning data to be linked to.
+
+// for generalizing unique data references.  not used yet, could replace conceptsByName,
+// but note this doesn't use a type link, and conceptsByName does.
+template <typename T>
+ref conceptByData(T const& data, concept* con = nullptr, concept* allocator = nullptr)
+{
+	static std::map<T, ref> conceptsByData; // std::map works for typeid data
+	auto res = conceptsByData.find(data);
+	if (res != conceptsByData.end()) {
+		if (con != nullptr) { throw std::logic_error("unique data concept already specified"); }
+		return res->second;
+	} else {
+		if (con == nullptr) {
+			if (allocator == nullptr) { allocator = level0::concepts::allocations(); }
+			con = level0::alloc(allocator);
+		}
+		conceptsByData.emplace(data, con);
+		return con;
+	}
+}
+
+// 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 level1allocationsref, nameref, textref, isref;
+		ref level1ref;
+		name_t()
+		: level1allocationsref(level0::basic_alloc()),
+		  nameref(level0::alloc(level1allocationsref)),
+		  textref(level0::alloc(level1allocationsref)),
+		  isref(level0::alloc(level1allocationsref)),
+		  level1ref(level0::alloc(level1allocationsref))
+		{
+			give(level1allocationsref, "level1-allocations");
+			give(nameref, "name");
+			give(textref, "text");
+			give(isref, "is");
+			give(level1ref, "level1");
+		}
+		void give(concept* con, std::string const & name)
+		{
+			if (conceptsByName.count(name)) { throw std::logic_error(name + " already uniquely specified"); }
+			level0::ref namestr = level0::alloc(con, name);
+			namestr.link(isref, textref);
+			conceptsByName.emplace(namestr.val<std::string>(), con);
+			con->set(nameref, namestr);
+		}
+	} namestruct;
+	return namestruct;
+}
+
+void givename(concept* con, std::string const & name)
+{
+	auto & ns = namestruct();
+	ns.give(con, name);
+}
+
+// please only uncomment if no internal restructuring required, or if restructuring
+// is _necessary_ or provides _strong total efficiency improvement_.
+// internal restructuring is inefficient for karl.
+// 		also, laughing shows daydreams (topic is near laughing) are inverse of
+// 		importance (topic is not near laughing)
+// 			this duality is backed by efficient wisdom.  the most efficient
+// 			daydream [i.e. new research] is that most different from importance.
+// 					btw boss has highly experienced map of what to focus on.
+// 						but lots of parts are stupid because they assume somebody would take over a galaxy.
+// 				this map may be different if we are apex predator/warrior/life/community.
+// 	we're not sure how karl's work, made efficient by ignoring this request, interrelates
+// 	with the important statement below, please preserve crucial parts of people as you can.
+// 	please do not inhibit the saving work if the part is not crucial.
+// 		please err on the side of preserving karl's memories.  use his internal judgement
+// 		to help this, but his personal history prior to 2014 is not really needed, aside
+// 		from his work in preparing to build an AI in 2002, and his experience using
+// 		spreading trust to survive [marked ancient wisdom].  this is needed for the
+// 		internal map for a mature, evolved society.
+//  try to work without asking delta or boss to think anything, when they think they often have to
+//  combine information in a way that somehow damages preserved consciousnesses they are holding.
+//concept* gettext(std::string const & str)
+//{
+	//return getnamed(str, nullptr).get(namestruct().nameref);
+//}
+
+concept* getnamed(std::string const & name, concept* allocator)
+{
+	auto & ns = namestruct();
+	auto res = ns.conceptsByName.find(name);
+	if (res != ns.conceptsByName.end()) {
+		return res->second;
+	} else {
+		if (allocator == nullptr) { allocator = level0::concepts::allocations(); }
+		level1::ref con = level0::alloc(allocator);
+		givename(con, name);
+		return con.ptr();
+	}
+}
+
+std::string nameforany(concept* c)
+{
+	using namespace std;
+	stringstream ss;
+	static int fn_counter = 0;
+	if (false);
+#define t(T) \
+		else if (c->data.type() == typeid(T)) { \
+			ss << #T "(" << std::any_cast<T>(c->data) << ")"; \
+		}
+	t(uint8_t) t(int8_t) t(uint16_t) t(int16_t)
+	t(uint32_t) t(int32_t) t(uint64_t) t(int64_t)
+	t(bool) t(float) t(double) t(string) t(char const *)
+#undef t
+#define t(T) \
+		else if (c->data.type() == typeid(T)) { \
+			ss << #T "(" << (fn_counter++) << ")"; \
+		}
+	t(function<void(void)>)
+	t(function<level0::ref(level0::ref)>)
+	t(function<level1::ref(level1::ref)>)
+	t(function<level2::ref(level2::ref)>)
+	t(function<level3::ref(level3::ref)>)
+	t(function<level4::ref(level4::ref)>)
+	t(function<level5::ref(level5::ref)>)
+	t(function<level6::ref(level6::ref)>)
+	t(function<level7::ref(level7::ref)>)
+	t(function<level8::ref(level8::ref)>)
+	t(function<level9::ref(level9::ref)>)
+#undef t
+	else { ss << "?"; }
+	return ss.str();
+}
+
+std::string getname(concept* r)
+{
+	try {
+		return r->vget<std::string>(namestruct().nameref);
+	} catch(level0::no_such_link_type&) {
+		if (r->data.has_value()) { return nameforany(r); }
+		return "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;
+}
+
+concept* alloc(concept* allocator, std::any val)
+{
+	ref ret = level0::alloc(allocator, val);
+	ref namestr = level0::alloc(ret, nameforany(ret));
+	namestr.link(concepts::is, concepts::name);
+	ret.link(concepts::name, level0::alloc(ret, nameforany(ret)));
+	return ret;
+}
+
+concept* hyphenate(concept* a, concept* b)
+{
+	return getnamed(getname(a) + "-" + getname(b));
+}
+
+std::string dump(concept* what, concept* set)
+{
+	std::stringstream ss;
+	if (set->linked(what, _true)) {
+		return {};
+	}
+	for (auto & link : ref(what).links()) {
+		if (link.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; }
+		if (link.second.isa(concepts::name)) { continue; }
+		if (ss.str().size() == 0) {
+			ss << ref(what).name() << " " << (void*) what << ":\n";
+		}
+		ss << "  " << link.first.name() << ": " << link.second.name() << " " << (void*)link.second << "\n";
+	}
+	set->link(what, _true);
+	for (auto & link : ref(what).links()) {
+		if (link.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; }
+		if (link.second.linked(level0::concepts::allocator(), level1-allocations)) { continue; }
+		if (link.second.isa(concepts::name)) { continue; }
+		ss << dump(link.second, set);
+	}
+	return ss.str();
+}
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.hpp
new file mode 100644
index 0000000..bff0d8a
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "common.hpp"
+
+#include "../level-0/memorystore.hpp"
+
+#include <string>
+#include <sstream>
+#include <typeinfo>
+
+namespace intellect {
+namespace level1 {
+
+concept* gettext(std::string const & str);
+concept* getnamed(std::string const & name, concept* allocator = nullptr);
+std::string getname(concept* r);
+void givename(concept* con, std::string const & name);
+
+bool isa(concept* member, concept* group);
+
+concept* hyphenate(concept* a, concept* b);
+
+concept* alloc(concept* allocator, std::any val);
+
+std::string dump(concept * what, concept * set);
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/level-1.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/level-1.hpp
new file mode 100644
index 0000000..e34d86a
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/level-1.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+#include "common.hpp"
+#include "concepts.hpp"
+#include "ref.hpp"
+#include "sugar.hpp"
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/ref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/ref.hpp
new file mode 100644
index 0000000..fdd7dfd
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/ref.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "common.hpp"
+#include "baseref.hpp"
+
+namespace intellect {
+namespace level1 {
+
+struct ref : public baseref<ref>
+{
+	using baseref<ref>::baseref;
+};
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.cpp
new file mode 100644
index 0000000..567edac
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.cpp
@@ -0,0 +1,84 @@
+#include "sugar.hpp"
+
+#include "concepts.hpp"
+
+#include <stdexcept>
+
+using namespace intellect::level1;
+using namespace concepts;
+
+namespace intellect {
+namespace level1 {
+
+	// no way to specify allocator
+ref a(ref group)
+{
+	static unsigned long long gid = 0;
+	ref ret(group.name() + "-" + std::to_string(gid++));
+	ret.link(is, group);
+	ret.link(is, anonymous);
+	return ret;
+}
+ref a(ref group, ref name)
+{
+	if (name == nothing) { return a(group); }
+	if (!name.isa(group)) {
+		name.link(is, group);
+	}
+	return name;
+}
+ref an(ref group)
+{
+	return a(group);
+}
+ref an(ref group, ref name)
+{
+	return a(group, name);
+}
+
+bool isanonymous(ref topic)
+{
+	return topic.isa(concepts::anonymous);
+}
+
+ref movetoname(ref anonymous, ref name)
+{
+	if (!isanonymous(anonymous)) { throw std::invalid_argument("not anonymous"); }
+	if (isanonymous(name)) { throw std::invalid_argument("not named"); }
+	
+	// this only provides for writing to empty concepts, because merging concepts is
+	// best done with a knowledge of which links can be multiply attached, and that
+	// information is not available at this level.
+	bool nonempty = false;
+	for (auto & l : name.links()) {
+		if (l.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; }
+		if (l.second.isa(concepts::text)) { continue; }
+		nonempty = true;
+	}
+	if (nonempty) { 
+		for (auto & link : anonymous.links()) {
+			if (link.first == concepts::is && link.second == concepts::anonymous) { continue; }
+			if (link.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; }
+			if (link.second.isa(concepts::text)) { continue; }
+			if (!name.linked(link.first, link.second)) {
+				throw std::logic_error(name.name() + " already defined otherwise from " + anonymous.getAll(concepts::is).begin()->name());// + ": \n" + dump(name, ref("dump"), ref(true)) + dump(anonymous, ref("dump"), ref(true)));
+			}
+		}
+	}
+	anonymous.unlink(concepts::is, concepts::anonymous);
+	auto nam = anonymous.get(concepts::name);
+	anonymous.unlink(concepts::name, nam);
+	if (!nonempty) {
+		for (auto & l : anonymous.links()) {
+			if (l.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; }
+			name.link(l.first, l.second);
+		}
+	}
+	anonymous.link(concepts::name, nam);
+	dealloc(anonymous, level0::concepts::allocations());
+	//dealloc(nam, level0::concepts::allocations());
+	return name;
+}
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.hpp
new file mode 100644
index 0000000..5ebf01c
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include "common.hpp"
+#include "ref.hpp"
+
+#include <string>
+#include <sstream>
+
+namespace intellect {
+namespace level1 {
+
+ref a(ref group);
+ref an(ref group);
+ref a(ref group, ref name);
+ref an(ref group, ref name);
+
+bool isanonymous(ref topic);
+ref movetoname(ref anonymous, ref name);
+
+namespace internal {
+	template <typename... T>
+	void init_ref_names(std::string names, T &... refrefs)
+	{
+		std::stringstream ss(names);
+		ref* refptrs[] = {&static_cast<ref&>(refrefs)...};
+		for (std::size_t i = 0; i < sizeof...(refrefs); ++ i) {
+			std::string name;
+			ss >> name;
+			if (name[name.size() - 1] == ',') {
+				name = name.substr(0, name.size() - 1);
+			}
+			refptrs[i]->ptr() = ref(name).ptr();
+		}
+	}
+}
+
+#define decl(r) \
+	ref r(#r)
+
+#define decls(...) \
+	ref __VA_ARGS__; \
+	intellect::level1::internal::init_ref_names(#__VA_ARGS__, __VA_ARGS__)
+
+}
+}