diff options
Diffstat (limited to 'intellect-framework-from-internet/starts/meaning-vm/level-1')
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__) + +} +} |