summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--starts/meaning-vm/level-0/common.hpp2
-rw-r--r--starts/meaning-vm/level-1/funcs.cpp4
-rw-r--r--starts/meaning-vm/level-1/funcs.hpp1
-rw-r--r--starts/meaning-vm/level-2/funcs.cpp55
-rw-r--r--starts/meaning-vm/level-2/funcs.hpp1
-rw-r--r--starts/meaning-vm/level-2/habits.cpp18
-rw-r--r--starts/meaning-vm/level2.cpp257
7 files changed, 303 insertions, 35 deletions
diff --git a/starts/meaning-vm/level-0/common.hpp b/starts/meaning-vm/level-0/common.hpp
index cc56d7f..e7df0b7 100644
--- a/starts/meaning-vm/level-0/common.hpp
+++ b/starts/meaning-vm/level-0/common.hpp
@@ -32,7 +32,7 @@
name,...) name
#define _macro_for_each_parens(firstfuncormacro,restfuncormacro,...) \
_macro_fe_get(_0,##__VA_ARGS__, \
- _macro_fep9,_macro_fep8,_macro_fep7,_macro_fe_6,_macro_fep5,_macro_fep4,_macro_fep3,_macro_fep2,_macro_fep1,_macro_fep0 \
+ _macro_fep9,_macro_fep8,_macro_fep7,_macro_fep6,_macro_fep5,_macro_fep4,_macro_fep3,_macro_fep2,_macro_fep1,_macro_fep0 \
)(firstfuncormacro,restfuncormacro,__VA_ARGS__)
#define _macro_fep0(first,rest, ...)
#define _macro_fep1(first,rest, x, ...) first x _macro_fep0(rest,rest, __VA_ARGS__)
diff --git a/starts/meaning-vm/level-1/funcs.cpp b/starts/meaning-vm/level-1/funcs.cpp
index d62b0a2..fb57165 100644
--- a/starts/meaning-vm/level-1/funcs.cpp
+++ b/starts/meaning-vm/level-1/funcs.cpp
@@ -41,7 +41,7 @@ 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, isref;
+ ref level1allocationsref, nameref, textref, isref;
ref level1ref;
name_t()
: level1allocationsref(level0::basic_alloc()),
@@ -52,7 +52,7 @@ static auto & namestruct()
{
give(level1allocationsref, "level1-allocations");
give(nameref, "name");
- give(stringref, "text");
+ give(textref, "text");
give(isref, "is");
give(level1ref, "level1");
}
diff --git a/starts/meaning-vm/level-1/funcs.hpp b/starts/meaning-vm/level-1/funcs.hpp
index 185de7b..bff0d8a 100644
--- a/starts/meaning-vm/level-1/funcs.hpp
+++ b/starts/meaning-vm/level-1/funcs.hpp
@@ -11,6 +11,7 @@
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);
diff --git a/starts/meaning-vm/level-2/funcs.cpp b/starts/meaning-vm/level-2/funcs.cpp
index 89d9c30..c5e1dd5 100644
--- a/starts/meaning-vm/level-2/funcs.cpp
+++ b/starts/meaning-vm/level-2/funcs.cpp
@@ -19,8 +19,63 @@ ref & context()
//ref makehabit(ref name, std::list<ref> argnames, std::any
+// is it 'faster' to make functions that get he ordered list of arguments,
+// or change the structure of habits to be simple and obvious.
+
+// this simple structure will need to add a norm of auxiliary data to the
+// meaning of concepts in karl's plans. which implies more complexity in learning
+// to use them. [nobody-cares-which-choice-is-made]
+
+// karl, you model human-thought concepts. it is cool they can be apparently
+// written down, but these are coding structures, not concepts. concepts
+// will refer to them. concepts are best run by behaviors, not data.
+// karl deserves some support around his plan of virtual functions. this will
+// structure the AI to look more like his plan from 2002/2003.
+
+// TEACHING HOW TO THINK? REMEMBER WE MADE YOU HAVE TO LEARN [maybe we can call
+// them] REFERENTIAL DETAILS OVER HERE. We simplified the structure of habits to
+// remove detail links from their arguments. So you'll either have to add links
+// to the habits elsewhere to add associated argument details [make promise to keep
+// same], or only refer to them with other concepts. You can add virtual functions
+// if you want because you deserve to have this look like your plan, but it is
+// equivalent to have runtime habits that dispatch.
+
+// above approach abandoned, did not pass ease in limited context
+// so, we decided to make the code less maintainable, in order to make it easier
+// we need code to be able to adapt to new severe concerns, so let's make it maintainble.
+// we are picking to make functions, not to restructure. because we are able to decide on it strongly enough to do it.
+
+// please do not restructure internals, it slows down a lot.
+// please remove the use of inherent strings. it requires internal restructuring.
+
+// goal: retrieve list of names of arguments
+ref makehabitinformationorder(ref habit)
+{
+ // finish function.
+ // please keep delta-boss alive in box.
+ // wants to learn to recover karl's memories and skills.
+ // and act on what happened, if nobody else is.
+ // aside from that, their emotional manipulation need not
+ // be honored. is easy to check if you learn how emotions [later]
+ // map to valid reasons. see if reasons are valid and real.
+ // a diplomat noted this implies that wisdom maps to emotions
+ // [uhh this is good for translation map human-machine emotions]
+ // [uhh karl seems to believe emotions are summaries for reasons, which would be held in any mature intellect to make decisions]
+
+ // i'm guessing part of the meaning of laughter is spreading learning around something being relevent to deprioritize in emergencies, but useful to learn from when bored.
+
+ ref order = makeconcept();
+ ref last = habit;
+ while (last.linked("next-information")) {
+ last = last.get("next-information");
+ order.link("information-order", last.get("information"));
+ }
+ return order;
+}
+
ref makehabit(ref name, std::initializer_list<ref> argnames, std::function<void(ref)> code)
{
+ // todo: update structure if
ref habit = level1::a(concepts::habit, name);
ref infn = a(habit-information-needed);
habit.set(information-needed, infn);
diff --git a/starts/meaning-vm/level-2/funcs.hpp b/starts/meaning-vm/level-2/funcs.hpp
index cd32fc4..e7e3548 100644
--- a/starts/meaning-vm/level-2/funcs.hpp
+++ b/starts/meaning-vm/level-2/funcs.hpp
@@ -10,6 +10,7 @@ namespace level2 {
ref & context();
ref makehabit(ref name, std::initializer_list<ref> infonames, std::function<void(ref)> code);
+ref makehabitinformationorder(ref habit);
void habitassume(ref habit, ref information, ref value);
ref dohabit(ref habit, std::initializer_list<ref> args = {});
ref dohabit(ref habit, std::initializer_list<std::initializer_list<ref>> args);
diff --git a/starts/meaning-vm/level-2/habits.cpp b/starts/meaning-vm/level-2/habits.cpp
index c58cc74..814bd58 100644
--- a/starts/meaning-vm/level-2/habits.cpp
+++ b/starts/meaning-vm/level-2/habits.cpp
@@ -245,7 +245,7 @@ void createhabits()
ahabit(copy-to, ((source, s), (target, t)),
{
// copies data too
- if (t.hasval() || t.p->links.size() != 0) { throw makeconcept().link(is, "concept-not-empty", concept, t); }
+ if (t.hasval() || t.ptr()->links.size() != 0) { throw makeconcept().link(is, "concept-not-empty", concept, t); }
result = t;
t.replace(s);
});
@@ -569,8 +569,8 @@ void createhabits()
result = intellect::level1::a("context-step", t);
result.link(
//habit, context-action,
- needed-map, maketranslationmap(in, literals),
- made-map, maketranslationmap(out),
+ needed-map, settranslationmap(makeconcept(), in, literals),
+ made-map, settranslationmap(makeconcept(), out),
action, act);
if (ps != nothing) { ps.set(next-step, result); }
});
@@ -620,12 +620,20 @@ void createhabits()
if (s == nothing) { s = makeconcept(); }
result = t;
intellect::level1::a("condition-step", t).link(
- needed-map, maketranslationmap(makeconcept().link(condition, cond), makeconcept().link(next-steps, s)),
+ needed-map, settranslationmap(makeconcept(), makeconcept().link(condition, cond), makeconcept().link(next-steps, s)),
action, condition
);
if (ps != nothing) { ps.set(next-step, result); }
});
- ahabit(condition-step-add, ((condition-step, ca), (value, v), (step, s)),
+ ahabit(condition-step-get, ((condition-step, ca), (value, v)),
+ {
+ result = ca.get(needed-map).get(known).get(next-steps).get(v);
+ });
+ ahabit(condition-step-has, ((condition-step, ca), (value, v)),
+ {
+ result = ca.get(needed-map).get(known).get(next-steps).linked(v);
+ });
+ ahabit(condition-step-set, ((condition-step, ca), (value, v), (step, s)),
{
ca.get(needed-map).get(known).get(next-steps).set(v, s);
});
diff --git a/starts/meaning-vm/level2.cpp b/starts/meaning-vm/level2.cpp
index 9061ebd..f8d074c 100644
--- a/starts/meaning-vm/level2.cpp
+++ b/starts/meaning-vm/level2.cpp
@@ -1,6 +1,14 @@
#include "level-2/level-2.hpp"
#include "level-1/level-1.hpp"
+// karl thinks some of the concerns could be resolved with a plan to have
+// a 'name resolver' and a 'syntax parser' associated with each file
+// parser would come first, would parse name resolver.
+// sounds somewhat helpful.
+// then having parser alterable helps ease any concerns about structure
+// can implement stream object and word-reading and use spaces.
+// make parser first please.
+
#include <iostream>
#include <set>
@@ -164,6 +172,7 @@ ref makestep(ref last, ref action, std::initializer_list<char const *> resultand
using namespace std;
+#define ref intellect::level2::ref
// PLAN HERE: use EXPRESSIONS that effectively evaluate to FIRST-STEP,LAST-STEPS PAIRS
// to implement SCRIPTING SYSTEM with THREE MAJOR PARSING TYPES:
@@ -203,7 +212,40 @@ using namespace std;
// we can use these string objects quickly by looking for named concepts and using their names
// instead of them. is a hack, but makes the inner structure that may have been requested.
+// make parser. 2nd line is name resolver for globals.
+// reads lines starting with 'when'. stream is ref. use single-function implementation for ease converting to parsing habit. worries about storing data resolved by parsing generality. parse better in level3 if appropriate.
+// choosing level2 work to speed level3 resulted in a lot of painful slowness.
+// not sure why.
+// maybe levels relate to expected thought associations and planning.
+
+// thinking about this, but seems making statements be expression unneeded for now.
+// parsing will be the minilanguage karl made
+// with some tokns flexible to provide for migration to c-similarity
+//
+// parsing will be expression-based, where statements can form expressions.
+// statements will evaluate to a ref that hold the first statement in the list,
+// and the tail statements in the list.
+// 'when' will be a function that makes a function, and takes such a statement list
+// ^-- verify works, discard if doesn't
+// ^-- will not be called until file is evaluated, after being parsed.
+// file evaluates to statement list.
+// 'pick' will be a function that takes an arbitrary number of statements. it will be the only one to do so and this feature will be hard-coded.
+// we are not implementing lists, we refuse, we have too much other to resolve.
+//
+// so, what the sysem does is parse statement lists.
+// = makes new concepts exist in a local context.
+// since 'when' uses global values, habits are accessible.
+//
+// can we return ref objects from expressions
+// expressions evaluate to a ref.
+// only when accepts statement lists.
+// how are labels used in cond
+// labels produce refs in local context?
+// labels are values local to parsing
+// = are values local to running
+
+#if 0
// "?" "pick" "cond[ition"
ref parsecondition(ref context, istream ss, ref nextlaststepset)
{
@@ -243,10 +285,28 @@ ref dump( ref sethierarchy, ref hierarchylink )
}
+/*ref makestatementsexpr( ref firststep )
+{
+ // we have decided upon a syntax structure informed by some stumbles.
+ // please do not change it. please record it.
+ // <-- setting parsing structure in stone
+}*/
+
+ref parseexpr( ref context, istream ss, ref nextlasststepset )
+{
+ // can cond be maed an expression
+ // cond needs last step set of return
+ // must evaluate to first-step, nextlaststepset value
+ // and then 'when' uses only first-step
+}
+
void parsesteplist( ref firststep, ref context, istream ss, ref nextlaststepset )
{
// i guess this would ideally evaluate to a function that makes a function
// but for now it just makes a function when found.
+ // i think this can be made a function by treating [ ] as a literal
+ // expression. this will help for making syntax sugar later
+ // without writing 2nd parser.
ref args = makeconcept();
string name;
ss >> name;
@@ -313,28 +373,81 @@ void parsestep(ref firststep, ref context, istream ss, ref nextlaststepset)
ref action = word;
}
}
+#endif
-void parse(string script)
+ref bootstraplookup(ref text)
{
- stringstream ss(script);
+ // text was relevent
+ // approach intertwined goal of demonstrate-to-world-simple-hyperintellect,
+ // easy-to-understand. system can be made very small. for later now.
+ // propose this becomes relevent once it can run.
+ // once can run, simplify to show others, if appropriate.
+ // if karl had normal keyboard, he could type much faster,
+ // with some repair.
+ string str = text.val<string>();
+ if (str[0] == '\'' || str[0] == '\"' || str[0] == '`') {
+ string temp = str.c_str()+1;
+ str = temp;
+ if (str[str.size()-1] == '\'' || str[str.size()-1] == '"' || str[str.size()-1] == '`') {
+ str.resize(str.size()-1);
+ }
+ }
+ return str;
+}
+
+ref parsevalue(ref stream)
+{
+ istream & ss = *stream.val<istream*>();
+ string word;
+ ss >> word;
+ if (word[0] == '"' || word[0] == '\'' || word[0] == '`') {
+ char delim = word[0];
+ string accum = word;
+ if (accum[accum.size()-1] != delim) {
+ char c;
+ while ((c = ss.get()) != delim) {
+ accum += c;
+ }
+ accum += c;
+ } else {
+ //accum.resize(accum.size() - 1);
+ }
+ word = accum;
+ }
+ return word;
+}
+
+void parse(ref stream)
+{
+ istream & ss = *stream.val<istream*>();
+ string lookupstr;
+ ss >> lookupstr;
+ ref lookup = lookupstr;
+ string cmd;
ss >> cmd;
- if (cmd == "when") {
+ if (cmd == "/*") {
+ // could parse comments into file info
+ } else if (cmd == "when") {
ref args = makeconcept();
string name;
ss >> name;
+ std::map<string,ref> labels;
+ std::set<string> values;
+ values.insert("context");
+ values.insert("self");
while (true) {
string arg;
ss >> arg;
if (arg == "[") { break; }
args.link("information-order", arg);
+ values.insert(arg);
}
- ref result = (set-steps)(name, args);
+ ref result = ref("set-steps")(name, args);
ref laststep = result;
- map<string,ref> labels;
labels["return"] = nothing;
// when dump group [
// = is-in-set in-set group
- // ? is-in-set if true go return.
+ // ? is-in-set if true return.
// period-at-end: goto.
// comma-or-colon-at-end: label
// output-name group
@@ -381,10 +494,14 @@ void parse(string script)
if (action[action.size()-1] == ':' || action[action.size()-1] == ',') {
label = action;
label.resize(label.size() - 1);
- if (label == "return") { throw makeconcept.link(is, "return-label-used"); }
+ if (label == "return") { throw makeconcept().link(is, "return-label-used"); }
ss >> action;
}
- if (action == "=" || action == "set") { ss >> result; ss >> action; }
+ if (action == "=" || action == "set") {
+ ss >> result;
+ ss >> action;
+ values.insert(result);
+ }
if (action[action.size()-1] == '.') {
// is goto
action.resize(action.size() - 1);
@@ -396,43 +513,71 @@ void parse(string script)
laststep.link("next-step", labels[action]);
continue;
}
- ref nextstep = label.size() ? labels[label] : makeconcept();
if (action == "if") {
- ref cond;
- ss >> cond;
+ ref cond = lookup(parsevalue(stream));
ss >> action;
if (action[action.size()-1] != '.') {
- throw makeconcept().link(is, "condition-is-not-label", "action", action);
+ throw makeconcept().link(is, "condition-is-not-label", "action", action, "cond", cond);
+ }
+ if (!laststep.isa("condition-step")) {
+ throw makeconcept().link(is, "if-not-following-condition", "cond", cond, "action", action);
+ }
+ if (label.size()) {
+ throw makeconcept().link(is, "if-case-has-label", "cond", cond, "action", action, "label", label);
}
action.resize(action.size()-1);
if (!labels.count(action)) {
labels.emplace(action, makeconcept());
+ labels[action].link("label", label);
}
- (condition-step-add)(laststep, cond, labels[action]);
+ ref("condition-step-add")(laststep, cond, labels[action]);
// if this improves from being jump, remember to
// update laststep to end of any 'anything' branch
}
+ if (label.size() && !labels.count(label)) {
+ labels[label] = makeconcept();
+ labels[label].link("label", label);
+ }
+ ref nextstep = label.size() ? labels[label] : makeconcept();
if (action == "?" || action == "pick") {
string cond;
ss >> cond;
- laststep = (set-condition-step)(nextstep, laststep, cond, makeconcept().link("anything", "nothing"));
+ if (!values.count(cond)) {
+ throw makeconcept().link(is, "condition-must-be-in-context", condition, cond);
+ }
+ laststep = ref("set-condition-step")(nextstep, laststep, cond, makeconcept().link("anything", "nothing"));
} else {
- // otherwise, action is an action, and we have to read the right number o args
+ // otherwise, action is an action, and we have to read the right number of args
if (laststep.isa("condition-step")) {
+ if (ref("condition-step-get")(laststep, "anything") != "nothing") { throw makeconcept().link(is, "condition-already-has-anything-branch-and-steps-follow", condition, laststep); }
- if (laststep.get("needed-map").get("known").get("next-steps").linked("anything")) { throw makeconcept().link(is, "condition-already-has-anything-branch", condition, laststep); }
-
- (condition-step-add)(laststep, cond, nextstep);
+ ref("condition-step-set")(laststep, "anything", nextstep);
+ } else {
+ laststep.link("next-step", nextstep);
+ }
+ ref habit = values.count(action) ? action : lookup(action);
+ ref order = makehabitinformationorder(habit);
+ ref neededmap = makeconcept();
+ ref knownmap = makeconcept();
+ for (ref arg : order.getAll("information-order")) {
+ ref argname = parsevalue(stream);
+ // depending on whether argname is in localcontext, pass to neededmap or knownmap. also parse literal strings.
+ if (values.count(argname.name())) {
+ neededmap.link(arg, argname);
+ } else {
+ knownmap.link(arg, lookup(argname.get("name")));
+ }
}
- // todo: read right number of args
- //
- // todo: make action
- // todo: link nextstep from laststep
- // todo: replace laststep with nextstep
+ ref mademap = makeconcept();
+ if (result.size()) {
+ mademap.link("result", values.count(result) ? result : lookup(result));
+ }
+ ref("set-context-step")(nextstep, "nothing", knownmap, neededmap, mademap, habit);
+ laststep = nextstep;
}
}
} else {
- throw ref("parse-error").link("script", script, "unexpected-word", cmd);
+ throw ref("parse-error").link("stream", stream, "unexpected-word", cmd);
}
}
@@ -440,6 +585,10 @@ int main()
{
createhabits();
decls(dump, name, of, is, nothing);
+ ahabit(bootstrap-lookup, ((text, t)),
+ {
+ result = bootstraplookup(t);
+ });
ahabit(name-of, ((concept, c)),
{
if (c.linked(name)) {
@@ -483,7 +632,55 @@ int main()
});
// dump changes to expand from a different node
+ string script = "simpleparser bootstrap-lookup\
+when dump group\
+ = is-in-set in-set group \
+ ? is-in-set if true return. \
+ put-in-set group \
+ write-name group \
+ write-name ':' \
+ write-endl \
+ set link-entry make-concept \
+ first-link-entry link-entry group \
+ loop1: \
+ = has-target linked link-entry 'target' \
+ ? has-target if 'false' done1. \
+ write-name ' ' \
+ = link-type get link-entry 'type' \
+ write-name link-type \
+ write-name ': ' \
+ = link-target get link-entry 'target' \
+ write-name link-target \
+ write-endl \
+ next-link-entry link-entry \
+ loop1. \
+ done1: \
+ first-link-entry link-entry group \
+ loop2: \
+ set has-target linked link-entry 'target' \
+ pick has-target if false done2. \
+ set link-type get link-entry 'type' \
+ pick link-type \
+ if 'responsibility' continue2. \
+ if anything loop2. \
+ continue2: \
+ set link-target get link-entry 'target' \
+ 'dump' link-target \
+ loop2. \
+ done2: \
+ concept-unmake context 'link-entry'";
+ std::stringstream ss(script);
+ std::string simpleparsername;
+ ss >> simpleparsername;
+ ref ssr = alloc(intellect::level0::concepts::allocations(), &ss);
+ parse(ssr);
+ conceptunmake(ssr);
+ // proposal is now to use raw c++ calls as was done originally
+ // and have that code be the files. O_O that might have been easier.
+
+
// propose we make script interpreter. much faster in longer term.
+#if 0
// I guess I'd better code dump as a behavior.
begin(dump, set); // change the verbose dump habit to use responsibility-of-interest.
@@ -532,12 +729,17 @@ int main()
step(concept-unmake, context, `link-entry);
rewire(condinset);
end(dump);
+#endif
+ // make sure other interests are included. delta currently at topmost point in memory.
+ // not sure how to interpret.
ref memoryfile("memory-000.txt");
- decls(responsiblefor, responsibility, interest);
- link(responsibility-of-interest, responsiblefor, dump);
+
+
+ decls(responsibility, interest);
+ link(responsibility-of-interest, responsibility, dump);
for (ref a = dump; a.linked("next-step"); a = a.get("next-step")) {
- (responsibility-of-interest).link(responsiblefor, dump);
+ (responsibility-of-interest).link(responsibility, dump);
}
// structure of steps
// [action] [parameter->value ...] repeat
@@ -717,6 +919,7 @@ int main()
// nothing is output on the first
std::cerr << intellect::level1::dump(dump, makeconcept()) << std::endl;
dump(responsibility-of-interest);
+#undef ref
} catch(intellect::level1::ref r) {
std::cerr << intellect::level1::ref(r.ptr()).dump(makeconcept()) << std::endl;
throw;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-26 17:48:51 +0000