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, 0 insertions, 983 deletions
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level2.cpp b/intellect-framework-from-internet/starts/meaning-vm/level2.cpp
deleted file mode 100644
index 7c80ea1..0000000
--- a/intellect-framework-from-internet/starts/meaning-vm/level2.cpp
+++ /dev/null
@@ -1,983 +0,0 @@
-#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 11:28:22 +0000