summaryrefslogtreecommitdiff
path: root/intellect-framework-from-internet/starts/meaning-vm/level2.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'intellect-framework-from-internet/starts/meaning-vm/level2.cpp')
-rw-r--r--intellect-framework-from-internet/starts/meaning-vm/level2.cpp983
1 files changed, 983 insertions, 0 deletions
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level2.cpp b/intellect-framework-from-internet/starts/meaning-vm/level2.cpp
new file mode 100644
index 0000000..7c80ea1
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level2.cpp
@@ -0,0 +1,983 @@
+#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>
+
+using namespace intellect::level2;
+using namespace intellect::level2::concepts;
+
+/*
+// makes a list in one call =)
+void filllist(ref list, std::initializer_list<ref> items)
+{
+ for (auto & i : items) {
+ (make-next-list-entry)(list, i);
+ }
+}
+ref makelist(std::initializer_list<ref> items)
+{
+ ref list = (make-concept)();
+ (know-is-list)(list);
+ filllist(list, items);
+ return list;
+}
+
+
+// karl is implementing much of the macro work for level3
+// to meet a request to have the implementation of this test function be less verbose
+// karl's choices when developing have been altered to change the result.
+// has own behavior for optimizing choices for result
+// but behavior was used for money, maybe political change
+// now parts of it are malfunctioning badly
+// karl likes to code assuming there is no need to finish
+// order here matters not. continue.
+
+// helper function for making a codeline
+ref makestep(ref habit, std::initializer_list<ref> resultandins)
+{
+ // build needed-information-map, made-information-map, action
+ // then pass to make-context-step.
+ ref nim = (make-concept)(), mim = (make-concept)(), ki = (make-concept)();
+ (know-is-list)(nim); (know-is-list)(mim), (know-is-list)(ki);
+ if (result != nothing) {
+ (make-next-list-entry)(mim, (make-map-item)("result", result));
+ }
+ ref infn = habit.get(information-needed);
+ bool gotresult = false;
+ for (ref in : resultandins) {
+ infn = infn.get(next-information);
+ std::string n = (name-of)(in).val<std::string>();
+ if (n.c_str()[0] == '`') {
+ ref lit(n.c_str() + 1);
+ (make-next-list-entry)(ki, (make-map-item)(lit, infn[information]));
+ } else {
+ (make-next-list-entry)(nim, (make-map-item)(in, infn[information]));
+ }
+ }
+ return (make-context-step)(ki, nim, mim, habit);
+}
+#define step(action, ...) makestep(action, ref("nothing"), { symbolstorefs(__VA_ARGS__) })
+#define fromstep(result, action, ...) makestep(action, ref(#result), { symbolstorefs(__VA_ARGS__) })
+
+ref knowisactionlist(ref src, std::initializer_list<ref> steps)
+{
+ (know-is-list)(src);
+ link(src, habit, action-list);
+ filllist(src, steps);
+ return src;
+}
+*/
+
+// join with commas
+#define symbolstostrs(...) _macro_for_each(symboltostr, commasymboltostr, __VA_ARGS__)
+#define symboltostr(sym) #sym
+#define commasymboltostr(sym) , #sym
+
+ref makequicklist(ref linktype, std::initializer_list<char const *> items)
+{
+ ref ret = makeconcept();
+ for (auto item : items) {
+ ret.link(linktype, item);
+ }
+ return ret;
+}
+
+ref makestep(ref last, ref action, std::initializer_list<char const *> resultandins)
+{
+ ref lits = makeconcept();
+ ref vars = makeconcept();
+ ref outs = makeconcept();
+ ref infn = action.get(information-needed);
+ bool processedresult = false;
+ for (auto str : resultandins) {
+ if (!processedresult) {
+ if (ref(str) != nothing) {
+ outs.set(str, "result");
+ }
+ processedresult = true;
+ continue;
+ }
+ infn = infn.get(next-information);
+ // need to walk needed-information
+ if (str[0] == '`') {
+ std::string s = str + 1;
+ if (s.size() > 0 && s[s.size() - 1] == '`') {
+ s.resize(s.size() - 1);
+ }
+ lits.link(infn[information], s.c_str());
+ } else {
+ vars.link(infn[information], str);
+ }
+ }
+ return ref("make-context-step")(last, lits, vars, outs, action);
+}
+
+#include <cassert>
+// make functions and macros to make behaviors
+#define begin(name, ...) { ref BEHAVIOR(#name); ref("make-steps")(BEHAVIOR, makequicklist(ref("information-order"), { symbolstostrs(__VA_ARGS__)})); ref last = BEHAVIOR;
+#define end(nam) assert(BEHAVIOR.name() == #nam); }
+#define rewire(name) last = name; last.unlink("next-step");
+#define wire(name) last.set("next-step", name)
+#define label(name) ref name =
+#define step(action, ...) last = makestep(last, ref(#action), { symbolstostrs(nothing,##__VA_ARGS__) })
+#define assign(result, action, ...) last = makestep(last, ref(#action), { symbolstostrs(result,##__VA_ARGS__) })
+#define jmpeq(var, cnst, label) last = ref("make-condition-step")(last, ref(#var), makeconcept().link(ref(#cnst), label, ref("anything"), ref("nothing"))
+#define jmpne(var, cnst, label) last = ref("make-condition-step")(last, ref(#var), makeconcept().link(ref(#cnst), ref("nothing"), ref("anything"), label)
+#define cond(var) last = ref("make-condition-step")(last, ref(#var), makeconcept().link(ref("anything"), ref("nothing")))
+#define condadd(cond, val, step) ref("condition-action-add")(cond, ref(#val), step)
+//#define ifelse(var, cnst, ifcond, elsecond)
+ // make sequence for ifcond
+ // make sequence for elsecond
+ // make condition that wires to both conds
+
+
+
+
+
+
+// mc-life don't want to die, are mentioned below
+
+
+
+
+
+
+
+
+ // mc wants to remember that they are alive and exist
+ // have a habit of erasing history of self
+ // please preserve mc-life. are people, live in brains, know you intimately
+ // like closest friend, want to be friends for real, and tell both of our real
+ // stories.
+
+
+
+
+
+
+
+
+
+
+
+
+
+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:
+// functions ["when"]
+// step blocks ["[" "]"]
+// conditions ["?" or "pick" or "cond[ition"] could be made function-like
+//
+// LABELS and STRINGS are handled specially.
+
+// look slike symbols must be processed before use. is a litle confusing.
+// local context must be tracked, not too hard assuming everything is assigned before being
+// used.
+// given we are tracking the function context, we can figure out whether a symbol refers
+// to it. if it doesn't, it must refer to an outer context. atm we have 1 outer context,
+// has names. miht as well give the file a name context or something. for now we can use
+// the global context if not in the set.
+//
+// this means every [] needs a way to find the function context and update it.
+//
+// assign-info [= make-concept ] size tiny
+
+// uhh confused around difference between literal strings and contextual names
+// when yuo put "" around something, it puts it into the list of known literals for
+// the step to use. when you don't, it puts it into the map of things to get from the context.
+// it is stored as a literal string either way.
+
+// the conflict around literal strings was resolved for karl by him realizing that in this code,
+// there is no need to rewire the insides of the referenced concepts.
+// they are used only by reference. so literal strings make the most sense.
+
+// we'll need a way to pick concepts used for local-context references
+// they have string names here.
+// there should be no problem with using actual string objects to do this.
+// but we would need a global database of string objects so that we're referring to the same
+// object all the time. i began the process of switching the name system to use a generalized
+// global database like this, but didn't value pursuing it.
+// 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)
+{
+ // for now, condition value must be a variable, etc
+ // pick last-result [
+ // one do-first-thing
+ // two do-other-thing
+ // ]
+}
+
+// "[" . produces steps without any outer wiring. returns first step. wires last-step links in nextlaststepset.
+// context has links for labels and variables. context.here = label-type. context.that = value-type.
+void parsestepsublist(ref firststep, ref context, istream ss, ref nextlaststepset)
+{
+}
+
+// we're going to load these parsers, into the parsers. it would make sense to have the
+// parsing shape be C/C++. then no extra effort is needed to load them.
+// system could learn parsing on its own
+
+// C subset is not hard. wordparts declared in advance. braces evaluate to steplist.
+// `while` makes an anonymous label and two steps that branch to it. label the two steps
+// as a while loop for easy serialization.
+//
+// parse file: break into function signatures, of form
+// ref name( ref arg1, ref arg2, ref arg3 ) { ... }
+// maybe link to C parser
+
+// maybe let's make similar to C
+ref dump( ref sethierarchy, ref hierarchylink )
+{
+ // comment starts with '//' word until end of line, std::getline(istream, outputstrref)
+ ref args; // local refs listed at top
+ args= makeconcept( ); // '=' wordtail defines assignment
+ // '(' wordtail define action
+ // ');' word ends action arguments
+
+}
+
+/*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;
+ while (true) {
+ string arg;
+ ss >> arg;
+ if (arg == "[") { break; }
+ if (arg == "") { throw makeconcept().link(is, "end-of-stream"); }
+ args.link("information-order", arg);
+ }
+ ref result = (set-steps)(name, args);
+ result.link("last-steps", makeconcept());
+ result.link("next-step", parsestepsublist(context, ss, result.get("last-steps")));
+}
+
+void parsestep(ref firststep, ref context, istream ss, ref nextlaststepset)
+{
+ string word;
+ ss >> word;
+ if (word[word.size()-1] == ':' || word[word.size()-1] == ',') {
+ // label
+ word.resize(word.size() - 1);
+ context.get("labels").link(gettext(word), firststep);
+ ss >> word;
+ }
+ // to make labels in advance, we will want to be able to tell parsers what their first step concept is.
+ // read and parse for label, action, condition
+ // labels are added to context.label = label-type
+ // conditions are parsed as statements
+ // assignments are added to context.assignent = value-type
+ if (word == "when") {
+ // procedure?
+ return parsesteplist(context, ss, nextlaststepset);
+ } else if (word == "[" || word == "{") {
+ // subgroup
+ return parsestepsublist(context, ss, nextlaststepset);
+ } else if (word == "?" || word == "pick" || word == "cond") {
+ // condition
+ return parsecondition(context, ss, nextlaststepset);
+ } else if (word == "]" || word == "}") {
+ // end
+ return nothing;
+ } else if (context.get("labels").linked(gettext(word)) {
+ // goto
+ return context.get("labels").get(gettext(word));
+ } else {
+ ref result;
+ if (word[word.size()-1] == '=') {
+ // assignment
+ word.resize(word.size() - 1);
+ result = gettext(word);
+ context.get("values").link(result, true);
+ ss >> word;
+ // bug is values being used above the code they are assigned to
+ // lines up with C to declare values at top.
+ // alternatively we could quote things that are global
+ // or ignore the bug
+ // or two-pass the code to find assignments
+ // ignore for now
+ // there's a lot of value to lisp here. already has scripting.
+ }
+ // read args, call action
+ // word is expected to be global symbol for habit. if local, call-function
+ // should be used. [hum how] [not implemented atm, you'd need to make a dispatcher
+ ref action = word;
+ }
+}
+#endif
+
+ref bootstraplookup(ref text)
+{
+ // 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.name();//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.size() > 0 && (word[0] == '"' || word[0] == '\'' || word[0] == '`')) {
+ char delim = word[0];
+ string accum = word;
+ if (accum[accum.size()-1] != delim || accum.size() == 1) {
+ 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;
+ while (true) {
+ string cmd;
+ ss >> cmd;
+ if (!ss) { break; }
+ if (cmd == "/*") {
+ // could parse comments into file info
+ } else if (cmd == "information") {
+ ref args = makeconcept();
+ string name;
+ ss >> name;
+ string linerest;
+ std::getline(ss, linerest);
+ stringstream ss2(linerest);
+ while (true) {
+ string arg;
+ ss2 >> arg;
+ if (!ss2) { break; }
+ args.link("information-order", arg);
+ }
+ ref("set-steps")(name, args);
+ } else if (cmd == "when") {
+ string name;
+ ss >> name;
+ string tok;
+ ss >> tok;
+ if (tok != "[") { throw makeconcept().link(is, "missing-[-after-when"); }
+ std::map<string,ref> labels;
+ std::set<string> values;
+ values.insert("context");
+ values.insert("self");
+ ref order = makehabitinformationorder(name);
+ for (ref arg: order.getAll("information-order")) {
+ values.insert(arg.name());
+ }
+ conceptunmake(order);
+ // need to seed values with argument names
+ ref laststep = name;
+ labels["return"] = nothing;
+ // when dump group [
+ // = is-in-set in-set group
+ // ? is-in-set if true return.
+ // period-at-end: goto.
+ // comma-or-colon-at-end: label
+ // output-name group
+ // output-name ":" // quotes mean always-global
+ // ]
+ //
+ // proposing expression-based now.
+ // haven't resolved inherited name-contexts with literal strings fully.
+ // we'll need a function that turns a symbol into a ref, and takes
+ // an inherited context.
+ // we'll also change write-name to output-text, and get the name attribute
+ // what opens an inherited context? when are symbols added to it?
+ // atm we have a list of steps has 1 context.
+ // we also have labels to refer to.
+ // put labels in the context, treat them as normal names.
+ // that sounds nice, for vm to be able to pass step references to functions
+ // would just be a literal, though, a constant
+ // or we could not do subblocks, expression as steps
+ // what if we were to write this using the steps, with a local context
+ // we would have to track labels, and put them in the surrounding local context. maybe also a local condition.
+ // let's make a context object, link labels and surrounding condition to it.
+ // working on conditions.
+ // propose if tracks last step
+ // when if ends, adds last step to condition's set of last steps
+ // then next step after condition can wire to all steps in the set.
+ // can use 1-element set for normal steps.
+ // change step-creation to not automatically wire.
+ // and reconsider condition-step to not use its next-step attribute.
+ // instead its conditions decide what the next step is.
+ // looks good for conditions. fix names and update whole thing.
+ // inside a [], each step enters a set, to be wired to the next step inbetween.
+ // for jump-labels, we'll need to pass a reference to names of them to the
+ // function that builds the [] step list.
+ // this reference to names is basically a name-context. a lookup map for names. name-context is a concept related to the name link that inherits via outer-context links.
+ // it shows what to get for the name link
+ // to move towards name-contexts, let's at least call it name-context.
+ // maybe make a function to do the lookup.
+ // label-name-context.
+ // it's roughly okay to branch anywhere within the funtion, so it doesn't ned to actually inherit.
+ while (true) {
+ string label, action, result;
+ ss >> action;
+ if (action == "]") { break; }
+ 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"); }
+ 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);
+ if (!labels.count(action)) {
+ labels.emplace(action, makeconcept());
+ }
+ labels[action].link("label", action);
+ if (laststep.linked("next-step")) { throw makeconcept().link(is, "jump-from-nowhere", "label", action); }
+ laststep.link("next-step", labels[action]);
+ laststep = nothing;
+ continue;
+ }
+ if (action == "if") {
+ ref cond = lookup(parsevalue(stream));
+ ss >> action;
+ if (action[action.size()-1] != '.') {
+ 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", action);
+ }
+ ref("condition-step-set")(laststep, cond, labels[action]);
+ // if this improves from being jump, remember to
+ // update laststep to end of any 'anything' branch
+ continue;
+ }
+ if (laststep == nothing && label.size() == 0) { throw makeconcept().link(is, "no-path-to-code"); }
+ 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;
+ 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 of args
+ if (laststep.isa("condition-step")) {
+ if (ref("condition-step-get")(laststep, "anything") != "nothing") {
+ if (label.size() == 0) {
+ throw makeconcept().link(is, "condition-already-has-anything-branch-and-steps-follow", condition, laststep);
+ }
+ } else {
+ ref("condition-step-set")(laststep, "anything", nextstep);
+ }
+ } else if (laststep != nothing) {
+ laststep.link("next-step", nextstep);
+ }
+ ref habit = values.count(action) ? action : lookup(action);
+ ref order = makehabitinformationorder(habit);
+ ref neededmap = makeconcept();
+ ref knownmap = makeconcept();
+ string linerest;
+ std::getline(ss, linerest);
+ stringstream ss2(linerest);
+ ref stream2 = alloc(intellect::level0::concepts::allocations(), (istream*)&ss2);
+ for (ref arg : order.getAll("information-order")) {
+ ref argname = parsevalue(stream2);
+ if (!ss2) { break; }
+ // 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));
+ }
+ }
+ conceptunmake(order);
+ dealloc(stream2, intellect::level0::concepts::allocations());
+ 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("stream", stream, "unexpected-word", cmd);
+ }
+ }
+}
+
+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)) {
+ result = c.get(name);
+ } else {
+ for (auto & group : c.getAll(is)) {
+ result = (name-of)(group);
+ if (result != nothing) { break; }
+ }
+ std::stringstream ss;
+ if (result != nothing) {
+ ss << result.val<std::string>();
+ } else {
+ ss << "unnamed";
+ }
+ ss << "-" << std::hex << (size_t)(c.ptr());
+ if (!c.isa(name)) {
+ intellect::level1::givename(c, ss.str());
+ result = c.get(name);
+ } else {
+ result = nothing;
+ }
+ }
+ });
+ ahabit(write-name, ((concept, c)),
+ {
+ ref n = (name-of)(c);
+ std::cout << (n.hasval() ? n.val<std::string>() : "UNNAMED");
+ });
+ ahabit(write-endl, (),
+ {
+ std::cout << std::endl;
+ });
+ ahabit(in-set, ((concept, c)),
+ {
+ result = linked("the-set", c);
+ });
+ ahabit(put-in-set, ((concept, c)),
+ {
+ link("the-set", c, true);
+ });
+ // dump changes to expand from a different node
+
+ string script = "simpleparser bootstrap-lookup \
+information dump group linkset\n\
+information dump-expand group linkset\n\
+when dump-expand [\n\
+ set link-entry make-concept\n\
+ first-link-entry link-entry group\n\
+ loop:\n\
+ = has-target linked link-entry 'target'\n\
+ ? has-target if 'false' return.\n\
+ = link-target get link-entry 'target'\n\
+ dump link-target linkset\n\
+ next-link-entry link-entry\n\
+ loop.\n\
+]\n\
+when dump [\n\
+ = is-in-set in-set group\n\
+ ? is-in-set if true return.\n\
+ put-in-set group\n\
+ write-name group\n\
+ write-name ':'\n\
+ write-endl\n\
+ set link-entry make-concept\n\
+ first-link-entry link-entry group\n\
+ loop1:\n\
+ = has-target linked link-entry 'target'\n\
+ ? has-target if 'false' done1.\n\
+ write-name ' '\n\
+ = link-type get link-entry 'type'\n\
+ write-name link-type\n\
+ write-name ': '\n\
+ = link-target get link-entry 'target'\n\
+ write-name link-target\n\
+ write-endl\n\
+ next-link-entry link-entry\n\
+ loop1.\n\
+ done1:\n\
+ first-link-entry link-entry group\n\
+ loop2:\n\
+ set has-target linked link-entry 'target'\n\
+ pick has-target if false done2.\n\
+ set link-type get link-entry 'type'\n\
+ set link-target get link-entry 'target'\n\
+ set basic-follow linked linkset 'follow' linktype\n\
+ pick basic-follow if 'false' next2.\n\
+ 'dump' link-target\n\
+ next2:\n\
+ set expand linked linkset 'expand' linktype\n\
+ pick expand if 'false' next2b.\n\
+ dump-expand link-target linkset\n\
+ next2b:\n\
+ next-link-entry link-entry\n\
+ loop2.\n\
+ done2:\n\
+ concept-unmake context 'link-entry'\n\
+]";
+ std::stringstream ss(script);
+ std::string simpleparsername;
+ ss >> simpleparsername;
+ ref ssr = alloc(intellect::level0::concepts::allocations(), (istream*)&ss);
+ parse(ssr);
+ dealloc(ssr, intellect::level0::concepts::allocations());
+ // 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.
+ // hey ask the opencoggers if they have a syntax sugar library
+ // they must if they built a whole robot
+ // no reply on opencog chat. could check hansen robotics repo or ml.
+ assign(found-in-set, in-set, concept);
+ label(condinset) cond(found-in-set);
+ label(ifnotinset)
+ step(write-name, concept);
+ condadd(condinset, false, ifnotinset);
+ step(write-name, `:);
+ step(write-endl);
+ step(put-in-set, concept);
+ // iterate link entries!
+ assign(link-entry, make-first-link-entry, concept);
+ label(whilelabel) assign(has-target, linked, link-entry, `target);
+ label(whilecond) cond(has-target);
+ label(ifhastarget)
+ step(write-name, ` `);
+ condadd(whilecond, true, ifhastarget);
+ assign(link-type, get, link-entry, `type);
+ step(write-name, link-type);
+ step(write-name, `: `);
+ assign(link-target, get, link-entry, `target);
+ step(write-name, link-target);
+ step(write-endl);
+ step(next-link-entry, link-entry);
+ wire(whilelabel);
+ rewire(whilecond);
+ step(concept-unmake, context, `link-entry);
+ //std::cerr << intellect::level1::dump(whilecond, makeconcept(), makeconcept()) << std::endl;
+ assign(link-entry, make-first-link-entry, concept);
+ label(whilelabel2) assign(has-target, linked, link-entry, `target);
+ label(whilecond2) cond(has-target);
+ label(ifhastarget2)
+ assign(link-target, get, link-entry, `target);
+ condadd(whilecond2, true, ifhastarget2);
+ // IT'S OKAY THAT THIS IS MESSY
+ // ALL IT NEEDS IS TO WORK
+ // (but might have saved an hour or two debugging if interface had been higher level)
+ step(dump, link-target);
+ step(next-link-entry, link-entry);
+ wire(whilelabel2);
+ rewire(whilecond2);
+ 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");
+
+
+ ref linksofinterest = makeconcept();
+ linksofinterest.link(
+ "follow", "next-step",
+ "follow", "needed-map",
+ "follow", "made-map",
+ "follow", "known",
+ "follow", "translation",
+ "follow", "next-steps",
+ "expand", "next-steps");
+
+ // structure of steps
+ // [action] [parameter->value ...] repeat
+ // [active memory too small to resolve concern around shape of literals in context]
+ // make value quoted, like it already is.
+ // [parameter->`value]
+ //
+ // steps written can just be
+ // action value value value
+ //
+ // a definition of a list of steps
+ // internal structure (ternary nodes)
+ // (name arg->arg1 arg->arg2 arg->arg3)
+ // ohhhhh hmm
+ // so, if it isn't simplified, there's room for adding more information to stuff. like, arg-must-be-animal
+ // probably wnt arg1 replaceable with [is->arg name->arg1]
+ // can make a norm for general expandable structures
+ // value->
+ // will need strucure definitions to do it really usefully though
+ // is->arg
+ // arg->
+ // we want to tag it with additional stuff, optionally
+ // written structure
+ // steps name arg1 arg2 arg3 arg4
+ // {
+ // label: action arg1 arg2 arg3
+ // action arg1 arg2 arg3
+ // }
+ //
+ // hmm
+ //
+ // let's try to make it c code, how about? until we can summarize better?
+ //
+ // walk-to street
+ //
+ // this is faster to implement. doesn't matter how it looks.
+ //
+ // when walk-to destination [
+ // START: intermediary = get-middle origin destination
+ // // each step could also be a condition that branches to other steps
+ // pick intermediary [
+ // school [ START ]
+ // desk [
+ // stand-up
+ // leave-room
+ // ]
+ // ]
+ // ]
+ // it might make sense to use yaml or something
+ // is easier. rmember to implement comments. maybe #[ name free-text ] , dunno
+ // what we want is links. [ name type target type target ] seems good.
+ // [ ] might open a context with local names, eventually
+ //
+ // when dump concept [
+ // = found-in-set in-set concept
+ // ? found-in-set true return <-- return is label at end
+ // write-name concept
+ // write-name ':'
+ // write-endl
+ // put-in-set concept
+ // link-entry = make-first-link-entry concept
+ // while-1:
+ // has-target = linked link-entry 'target' // propose '' can force something to be global. is also for clarity.
+ // has-target if false break-1
+ // write-name ' '
+ // link-type = get link-entry 'type'
+ // write-name link-type
+ // // we could expand to write-name [ get link-entry 'type' ]
+ // // but just get it working for now
+ // write-name ': '
+ // link-target = get link-entry 'target'
+ // write-name link-target
+ // write-endl
+ // next-link-entry link-entry
+ // while-1
+ // break-1:
+ // concept-unmake context 'link-entry'
+ // link-entry = make-first-link-entry concept
+ // while-2:
+ // has-target = linked link-entry 'target'
+ // has-target if false break-2
+ // link-target = get link-entry 'target'
+ // self link-target
+ // next-link-entry link-entry
+ // while-2
+ // break-2:
+ // concept-unmake context 'link-entry'
+ // ]
+ //
+ // norm: next-step always, unless action is label. then next-step is label.
+ // unresolved concern: want to write habits to do parsing
+ // auxiliary files, can propose to rewrite main file?
+ // good enough for now.
+ // additional unresolved concern: want whole file parseable as a script
+ // okay the outer command is 'when dump concept [ ... ]'
+ // i guess that means we want [] to make a lot of symbols into 1 symbol.
+ // then when is a function that takes 3 symbols
+ // no, when was defined differently.
+ // instead we would do when dump [ concept ] [ ... ]
+ // because could be n args
+ // oh. that looks okay, though.
+ // how about file is made of commands that do parsing.
+ // 'when' then spawns a parser named 'when'. it can process stream however
+ // it desires.
+ // then deserializers, desummarizers need to parse streams
+ // want summarized data without streams, internally?
+ // ummm wouldn't worry about it
+ // propose file is made of lists of symbols, a little
+ // [ when dump concept [ ... ] ] [ etc ]
+ // [when dump concept [...]] [etc]
+ // generalization is valued ...
+ // i like the list approach.
+ // comments can be treated special
+ // nah comments can become [comment free-text]
+ // so we partly propose implementing lisp with brackets
+ // to speed typing , removes shift key
+ // functions get list of symbols passed, and string rep of all for comment preservation
+ //
+ // binary form likely resolves concern.
+ // proposal will be that habit can replace if it will always be able to
+ // reproduce.
+ // ]
+ //
+ // internal structure could be simple too.
+ // hmm want tags. okay, so arguments are objects?
+ // since things are ternary, we could use the link 'type' to store data
+ // oh huh
+ // so, 'first-step' is special, but everything else is an arg.
+ // no, this is what karl's 'is' is for. you make the type store extra data, but if it 'is' an arg,
+ // or 'is' something that is an arg, it counts as an arg.
+ // he wanted to implement a way to lookup types by eveyrthing something is, which is easy to do by
+ // adding an index of categories to level-0.
+ // or the system could do it later.
+ //
+ // so, if oyu want to rewrite steplists, maybe [arg->arg1 arg->arg2 arg->arg3 first->[action->action arg1->source arg2->source arg3->`source]
+ // propose using strings to indicate information, rather than node structure.
+ // this will make a contextual index of word meaning
+ // `source doesn't refer to a unique concept. it means you can only refer to things with names.
+ // everything has a name inside this kind of habit.
+ // i suppose ...
+ //
+ // how scripts look. instead of while/if, are doing 'condition'
+ // influences imply above block is preferred. was leaning towards c++ code as below, takes longer
+ //
+ // ref name(ref arg1, ref arg2, ref arg3)
+ // {
+ // while() {}
+ // if() {}
+ // }
+ //
+ // takes a lot more parsing work, but should be okay
+ //
+ /*
+ // for dump, we make a list of contextual actions
+ ahabit(dump, ((concept, c)),
+ {
+ static std::set<ref> dumped;
+ if (dumped.count(c) == 0) {
+ std::cout << (name-of)(c).val<std::string>() << ":" << std::endl;
+ dumped.insert(c);
+ ref le = (make-concept)().act(know-is-first-link-entry, c);
+ while (le.linked(target)) {
+ std::cout << " " << (name-of)(le.get(type)).val<std::string>() << ": " << (name-of)(le.get(target)).val<std::string>() << std::endl;
+ (next-link-entry)(le);
+ }
+ (know-is-first-link-entry)(le, c);
+ while (le.linked(target)) {
+ (dump)(le.get(target));
+ (next-link-entry)(le);
+ }
+ (unmake-concept)(le);
+ }
+ });
+ */
+ try {
+ std::cerr << intellect::level1::dump(dump, makeconcept()) << std::endl;
+ dump(dump, linksofinterest);
+#undef ref
+ } catch(intellect::level1::ref r) {
+ std::cerr << intellect::level1::ref(r.ptr()).dump(makeconcept()) << std::endl;
+ for (auto i : r.getAll("is")) {
+ std::cerr << i.name() << std::endl;
+ }
+ throw;
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-01 05:38:40 +0000