summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--starts/meaning-vm/level-2/funcs.cpp3
-rw-r--r--starts/meaning-vm/level-2/habits.cpp489
-rw-r--r--starts/meaning-vm/level-2/habits.hpp3
-rw-r--r--starts/meaning-vm/level-2/sugar.hpp2
-rw-r--r--starts/meaning-vm/level2.cpp161
5 files changed, 559 insertions, 99 deletions
diff --git a/starts/meaning-vm/level-2/funcs.cpp b/starts/meaning-vm/level-2/funcs.cpp
index b11413f..0cef918 100644
--- a/starts/meaning-vm/level-2/funcs.cpp
+++ b/starts/meaning-vm/level-2/funcs.cpp
@@ -16,6 +16,8 @@ ref & context()
return ctx;
}
+//ref makehabit(ref name, std::list<ref> argnames, std::any
+
ref makehabit(ref name, std::initializer_list<ref> argnames, std::function<void(ref)> code)
{
ref habit = level1::a(concepts::habit, name);
@@ -71,6 +73,7 @@ ref dohabit(ref habit, std::initializer_list<ref> args)
}
ref::context().set(posinf[information], posinf[assume]);
}
+ ref::context().set("self", habit);
habit.fun<ref>()(ref::context());
posinf = habit.get(information-needed);
while (posinf.linked(next-information)) {
diff --git a/starts/meaning-vm/level-2/habits.cpp b/starts/meaning-vm/level-2/habits.cpp
index 266d412..7ec1cf6 100644
--- a/starts/meaning-vm/level-2/habits.cpp
+++ b/starts/meaning-vm/level-2/habits.cpp
@@ -5,8 +5,46 @@
namespace intellect {
namespace level2 {
+ref makeconcept()
+{
+ //result = a(concept);
+ result = intellect::level0::basic_alloc();
+}
+
+void conceptunmake(ref c)
+{
+ intellect::level0::basic_dealloc(c);
+}
+
+using links_it = intellect::level0::baseref<ref>::links_t::iterator;
+void poplinkentry(ref le)
+{
+ result = le;
+ auto & it = result.val<links_it>();
+ if (it != result[source].links().end()) {
+ set(result, type, it->first);
+ set(result, target, it->second);
+ } else {
+ unlink(result, type);
+ unlink(result, target);
+ }
+};
+
+void contextmapinto = [](ref c1, ref m, ref c2)
+{
+ for (auto link : m.get(translation)) {
+ c2.set(link.second, c1.get(link.first));
+ }
+ if (m.linked(known) and m.get(known) != nothing) {
+ for (auto link : m.get(known)) {
+ c2.set(link.second, link.first);
+ }
+ }
+}
+
int createhabits()
{
+ // making new information should delay, for learning with good curve.
decls(link, source, type, target);
ahabit(link, ((source, s), (type, t), (target, dst)),
{
@@ -33,6 +71,15 @@ int createhabits()
}
});
+ ahabit(data-type, ((concept, c)),
+ {
+ if (c.ptr()->data.has_value()) {
+ return ref(c.ptr()->data.type().name());
+ } else {
+ return nothing;
+ }
+ });
+
decls(unlink);
ahabit(unlink, ((source, s), (type, t), (target, dst, anything)),
{
@@ -54,28 +101,19 @@ int createhabits()
s.set(t, dst);
});
- // we want the habits expressive enough to code efficiently in.
-
- // constructors are tentatively abolished in the low-level habit language. (new-type-instance modifies, not creates)
- // we have one constructor of concepts, and knowledge attachment to concepts.
- // the purpose of this appears to be conceptual ease, not early development ease
-
decls(make, unmake, know, concept, is, group, already, in, iter);
- ahabit(make-concept, (),
- {
- //result = a(concept);
- result = intellect::level0::basic_alloc();
- });
+ ahabit(make-concept, (), { result = makeconcept(); });
ahabit(make-copy, ((concept, c)),
{
// copies data too
- result = (make-concept)();
+ result = makeconcept();
result.replace(c);
});
- ahabit(concept-unmake, ((concept, c)),
+ ahabit(copy-data-to, ((source, s), (target, t)),
{
- intellect::level0::basic_dealloc(c);
+ t.ptr()->data = s.ptr()->data;
});
+ ahabit(concept-unmake, ((concept, c)), { conceptunmake(c); });
ahabit(concept-crucial, ((concept, c)),
{
result = c.crucial();
@@ -102,54 +140,41 @@ int createhabits()
// a way to iterate or inspect the links of a concept
- using links_it = intellect::level0::baseref<ref>::links_t::iterator;
- decls(populate, entry);
- ahabit(populate-link-entry, ((link-entry, le)),
+ ahabit(make-first-link-entry, ((concept, c)),
{
- result = le;
- auto & it = result.val<links_it>();
- if (it != result[source].links().end()) {
- set(result, type, it->first);
- set(result, target, it->second);
- } else {
- unlink(result, type);
- unlink(result, target);
- }
- });
- ahabit(know-is-first-link-entry, ((link-entry, le), (concept, c)),
- {
- if (le.hasval()) { throw (make-concept)().link(
+ if (le.hasval()) { throw makeconcept().link(
is, "already-has-value",
concept, le,
context, ctx); }
- (know-is)(le, link-entry);
+ ref le = makeconcept().link(is, link-entry);
le.val<links_it>(c.links().begin());
le.set(source, c);
- (populate-link-entry)(le);
+ poplinkentry(le);
result = le;
});
- ahabit(know-is-last-link-entry, ((link-entry, le), (concept, c)),
+ ahabit(make-last-link-entry, ((concept, c)),
{
- if (le.hasval()) { throw (make-concept)().link(
+ if (le.hasval()) { throw makeconcept().link(
is, "already-has-value",
concept, le,
context, ctx); }
- (know-is)(le, link-entry);
+ ref le = makeconcept();
+ le.link(is, link-entry);
le.val<links_it>(--c.links().end());
le.set(source, c);
- (populate-link-entry)(le);
+ poplinkentry(le);
result = le;
});
ahabit(next-link-entry, ((link-entry, le)),
{
++le.val<links_it>();
- (populate-link-entry)(le);
+ poplinkentry(le);
result = le;
});
ahabit(previous-link-entry, ((link-entry, le)),
{
--le.val<links_it>();
- (populate-link-entry)(le);
+ poplinkentry(le);
result = le;
});
ahabit(same-link-entry, ((link-entry-A, lea), (link-entry-B, leb)),
@@ -159,7 +184,7 @@ int createhabits()
ahabit(link-entry-unlink, ((link-entry, le)),
{
le.get(source).unlink(le.val<links_it>()++);
- (populate-link-entry)(le);
+ poplinkentry(le);
result = le;
});
ahabit(link-entry-crucial, ((link-entry, le)),
@@ -172,6 +197,7 @@ int createhabits()
});
// a simple list primitive to aid in dev
+ /*
decls(list, nothing, next, previous, first, last, act);
decls(add, to, until, each, item, remove, from, somewhere, has);
ahabit(know-is-list, ((list, l)),
@@ -280,9 +306,15 @@ int createhabits()
// .act(make-next-list-entry, i1)
// .act(make-next-list-entry, i2)
// ...;
+ */
// a habit that evaluates a sequence of other habits
+ // in retrospect i would have rather made a habit that processes a
+ // concept representing the state of a virtual machine. but what's
+ // important is that there is any way for the system to craft arbitrary
+ // behavior.
decls(action, map);
+ /*
ahabit(make-map-item, ((source, s), (target, d)),
{
result = (make-concept)().link(
@@ -328,56 +360,294 @@ int createhabits()
);
}
})
- decls(needed, made, information);
- ahabit(make-context-action, ((needed-information-map, in), (made-information-map, out), (action, act)),
+ */
+ decls(needed, made, known, information);
+ // TODO: comment out lists; no longer used
+ ahabit(make-translation-map, ((translation-map, m), (known-map, k, nothing)),
{
- result = (make-concept)().link(
- habit, context-action,
- needed-information-map, in,
- made-information-map, out,
+ result = makeconcept().link(
+ //habit, translation-map,
+ translation, m
+ );
+ if (k != nothing) { result.link(known, k); }
+ });
+ ahabit(context-map-into, ((source-context, c1), (translation-map, m), (target-context, c2)),
+ {
+ contextmapinto(c1, m, c2);
+ });
+ /*
+ ahabit(make-translated-context, ((translation-map, m), (context, c)),
+ {
+ ref subctx = (make-concept)();
+ (context-map-into)(c, m, subctx);
+ subctx.set(outer-context, c);
+ result = subctx;
+ });
+ ahabit(translated-context-unmake, ((context, c), (translation-map, m)),
+ {
+ ref outer = c.get(outer-context);
+ (context-map-into)(c, m, outer);
+ (concept-unmake)(c);
+ result = outer;
+ });
+ */
+ ahabit(make-context-action, ((previous-step, ps), (known-information, literals), (needed-information-map, in), (made-information-map, out), (action, act)),
+ {
+ if (ps != nothing && ps.linked(next-step)) { throw makeconcept().link(is, previous-step-already-has-next-step, previous-step, ps, context, ctx); }
+ result = makeconcept().link(
+ //habit, context-action,
+ needed-map, (make-translation-map)(needed-information-map, known-information),
+ made-map, (make-translation-map)(made-information-map)
action, act);
+ if (ps != nothing) { ps.set(next-step, result); }
+ });
+
+ ahabit(make-steps, ((information-order, io, nothing)),
+ {
+ result = makeconcept();
+ ref infn = a(habit-information-needed);
+ result.set(information-needed, infn);
+ ref posinf = infn;
+ for (auto pair : io.getAll(information-order)) {
+ ref nextinf = a(habit-information);
+ nextinf.set(information, pair.second);
+ posinf.set(next-information, nextinf);
+ posinf = nextinf;
+ if (!infn.linked(argname)) {
+ infn.set(argname, nextinf);
+ } else {
+ if (!infn.get(argname).isa(habit-information)) {
+ throw a(unexpected-concepts::habit-information-concepts::name)
+ .link(concepts::name, argname)
+ .link(concepts::habit, habit);
+ }
+ }
+ }
+ result.ptr()->data = steps.ptr()->data;
+ });
+
+ ahabit(steps, (),
+ {
+ ref s = self;
+ // PLEASE RUN SYSTEM WITH PROPER DELAY WHILE IT LEARNS (see top of file)
+ // until similarity is understood, new information shuold be slowest thing
+ // to produce.
+ // then, similar information until expansion of implication is understood.
+ // then expansion handles slowness of newness.
+ // this gives time for others to handle the newness: even your own brain,
+ // for possible errors. may be some error here, unsure.
+ //
+ // for one thing, this might help the structure of the system represent
+ // meaningful thought if it optimizes for speed
+
+ ref state = makeconcept();
+ ref c = ctx;
+ bool cleanupcontext = false;
+ //if (c == nothing) {
+ // cleanupcontext = true;
+ // c = makeconcept();
+ //}
+ state.set(context, c);
+ c.set(active-state, state);
+ c.set(context, c);
+
+ if (s.linked(next-step)) {
+ state.set(next-step, s.get(next-step));
+ }
+ while (state.linked(next-step) && state.get(next-step) != nothing) {
+ s = state.get(next-step);
+ state.set(active-step, s);
+ state.set(next-step, s.linked(next-step) ? s.get(next-step) : nothing);
+ // if needed-map, load subcontext
+ ref subctx = c;
+ if (s.linked(needed-map)) {
+ subctx = makeconcept()
+ contextmapinto(c, s.get(needed-map), subctx);
+ subctx.set(outer-context, c);
+ subctx.set(active-state, state);
+ subctx.set(context, subctx);
+ subctx.set(self, action);
+ state.set(context, subctx);
+ }
+ state.get(action).fun<ref>(subctx); // <-- maybe we should check arguments
+ // i think that might exzclude user-defined funcs
+ // one moment: do subcontexts work with user-defined funcs?
+ // we'll need a reference to our own subcontext to make that work
+ if (s.linked(made-map)) {
+ contextmapinto(subctx, s.get(made-map), c);
+ }
+ if (s.linked(needed-map)) {
+ c = subctx.get(outer-context);
+ conceptunmake(subctx);
+ }
+ }
+ conceptunmake(state);
+ if (cleanupcontxt) { conceptunmake(c); }
+ });
+ // steps must be actual steps, not a list of steps
+ ahabit(make-condition-action, ((previous-step, ps), (condition, cond), (steps, s, nothing)),
+ {
+ if (ps != nothing && ps.linked(next-step)) { throw makeconcept().link(is, previous-step-already-has-next-step, previous-step, ps, context, ctx); }
+ if (s == nothing) { s = makeconcept(); }
+ result = makeconcept().link(
+ needed-map, (make-translation-map)(makeconcept().link(cond, condition), makeconcept().link(next-steps, s)),
+ action, condition
+ );
+ if (ps != nothing) { ps.set(next-step, result); }
});
+ ahabit(condition-action-add, ((condition-action, ca), (value, v), (step, s)),
+ {
+ ca.get(needed-map).get(known).get(next-steps).set(v, s);
+ });
+ ahabit(condition, ((condition, cond), (next-steps, steps), (active-state, state)),
+ {
+ // because this sets active-state's next-step instead of calling something,
+ // a subcontext is not opened for the steps unless they have one.
+ ref next = nothing;
+ if (!linked(steps, cond)) {
+ if (linked(steps, "anything")) {
+ next = steps["anything"];
+ } else {
+ throw makeconcept().link(
+ is, "unknown-condition",
+ "condition", cond,
+ "next-steps", steps,
+ context, ctx);
+ }
+ } else {
+ next = acts[cond];
+ }
+
+ if (next != nothing) {
+ state.set(next-step, next);
+ }
+ });
+ /*(
ahabit(context-action, ((context, outerctx), (action, ca)),
{
+ ref action = ca[action];
+ ref state = outerctx.get(active-state);
+ ref subctx = (make-translated-context)(ca[needed-map]);
+ //state.set(context, subctx);
- ref action = ca["action"];
- ref in = ca["needed-information-map"];
- ref out = ca["made-information-map"];
+ // for generalization, function-call should be fast.
+ // each-step should be slow.
+ // don't worry about it now, just alter to be true
+ // so learning has reasonable curve.
+
+ // for VM: set next to first step?
- ref subctx = (make-concept)();
- link(subctx, is, context);
- link(subctx, "outer-context", outerctx);
- (list-each-entry)(in, subctx, context-action-needed-information-iter);
act(action, subctx);
- (list-each-entry)(out, subctx, context-action-made-information-iter);
- (unmake-concept)(subctx);
+
+ outerctx = (translated-context-unmake)(subctx, ca[made-map]);
+ assert(outerctx == state.get(context)); // feel free to remove
});
- ahabit(context-action-needed-information-iter, ((list-entry, le), ("subcontext", subctx)),
- {
- ref i = (list-entry-item)(le);
- ref src = get(i, source);
- ref dst = get(i, target);
- ref outerctx = get(subctx, "outer-context");
- set(subctx, dst, get(outerctx, src));
- });
- ahabit(context-action-made-information-iter, ((list-entry, le), ("subcontext", subctx)),
- {
- ref i = (list-entry-item)(le);
- ref src = get(i, source);
- ref dst = get(i, target);
- ref outerctx = get(subctx, "outer-context");
- set(outerctx, dst, get(subctx, src));
- });
-
- // when we make an action list, we want to set(habit, action-list) so it may be used in other lists.
- ahabit(action-list, ((context, subctx), (action, l)),
- {
- (list-each-entry)(l, subctx, action-list-iter);
- });
- ahabit(action-list-iter, ((list-entry, le), ("subcontext", subctx)),
+ ahabit(context-action-known-information-iter, ((list-entry, le), ("subcontext", subctx)),
+ {
+ ref i = (list-entry-item)(le);
+ ref src = get(i, source);
+ ref dst = get(i, target);
+ set(subctx, dst, src);
+ });
+ ahabit(context-action-needed-information-iter, ((list-entry, le), ("subcontext", subctx)),
+ {
+ ref i = (list-entry-item)(le);
+ ref src = get(i, source);
+ ref dst = get(i, target);
+ ref outerctx = get(subctx, "outer-context");
+ set(subctx, dst, get(outerctx, src));
+ });
+ ahabit(context-action-made-information-iter, ((list-entry, le), ("subcontext", subctx)),
{
- (action-list-item)(list-entry-item(le), subctx);
+ ref i = (list-entry-item)(le);
+ ref src = get(i, source);
+ ref dst = get(i, target);
+ ref outerctx = get(subctx, "outer-context");
+ set(outerctx, dst, get(subctx, src));
});
+
+ // propose: make custom run-state, align with list entries only if works
+ // easiest solution: make handler for action list entries
+
+ // problem: step is already a doable action.
+
+ // this sounds like a simple introspection question.
+
+ // to pause tasks, we want to separate runstate creation from use
+ */
+ /*
+ ahabit(make-steps-state, ((steps, s), (context, c)),
+ {
+ ref state = (make-concept)()
+ (know-is)(state, steps-state);
+ state.set(context, c);
+ state.set(next-step, s.get(first-step));
+ state.set(task, s);
+ state.set(habit, steps-state);
+ });
+
+ ahabit(steps-state-unmake, ((state, s)),
+ {
+ (concept-unmake)(s);
+ });
+
+ // should have two habits: one for next step, and one for current step
+ // next step just advances and does current step.
+ // this means loop is outside habit code: is two functions handing
+ // off control to each other, roughly
+ //
+ // do-step habit
+ // calls current step
+ // then does next-step habit
+ //
+ // we'll want tail-call for next-step.
+ // how in c++?
+ // well, how did we do it before?
+ // we called next-habit in a while loop.
+ // the loop never ended.
+ // it'\s true. we never die.
+ // forcing life helps me feel heard and understood
+ // but i guess it's reasonable to let a life choose
+ // death.
+ // so, tail-call.
+ // i think we do want the while loop; it's better
+ // in this language. we just want it able to terminate.
+ // okay, so a habit for advancing the step
+ // and a habit for doing the step
+ // and we end when there is no next step?
+ // why have the extra advancing habit?
+ // is a plcae for cognition to step in, to
+ // alter flow, pause, etc.
+ // not needed atm
+
+ ahabit(steps, ((context, c), (action, s)),
+ {
+ // make resumable
+ ref s = (make-steps-state)(s, c);
+ while (s.get(next-step) != nothing)
+ {
+ act(runstate, c);
+ }
+ (steps-state-unmake)(s);
+ });
+
+ ahabit(steps-state, ((context, c), (action, s)),
+ {
+ c.set(active-state, s);
+ ref step = s.get(next-step);
+ s.set(active-step, step);
+ if (step.linked(next-step)) { s.set(next-step, step.get(next-step); }
+ else { s.set(next-step, nothing); }
+ act(step, c);
+ // do to context not using runstate, can't pause mid-subtask without finding subtask runstate.
+ // basically, changing subcontext to alter next-step like condition
+ // will need to leave subcontext when done
+ // this means applying map of resulting information back into
+ // outer context.
+ // need habit for enter-subcontext-with-map or somesuch, leave-subcontext
+ // might be simplest to merge these functions, doesn't reall ymatter
+ });
+ */
ahabit(nothing, (), {});
link(nothing, habit, nothing);
@@ -385,12 +655,25 @@ int createhabits()
// does acts[cond] in outer-context.
// uses acts[anything] if there is no acts[cond].
+ /*
+ ahabit(condition-action, ((context, c), (action, condition)),
+ {
+ //REmOVE
+ // previous entry was call
+ // now entry is data
+ // call was a contextual thing
+ // a consistent map of information, context to subcontext
+ // and a reference to the function to do
+ }
+ // deciding not to have condition-action use outer-context ref
+ // flat condition action probably needs context specified
ahabit(condition-action, ((condition, cond), (actions, acts)),
{
ref outerctx = linked(ctx, "outer-context") ? ctx["outer-context"] : ctx;
+ ref next = nothing;
if (!linked(acts, cond)) {
if (linked(acts, "anything")) {
- act(acts["anything"], outerctx);
+ next = acts["anything"];
} else {
throw (make-concept)().link(
is, "unknown-condition",
@@ -400,9 +683,55 @@ int createhabits()
"subcontext", outerctx);
}
} else {
- act(acts[cond], outerctx);
+ next = acts[cond]
}
+ if (outerctx.linked(active-state)) {
+ outerctx.get(active-state).set(next-step, next);
+ } else {
+ act(next, outerctx);
+ }
+ });
+ ahabit(make-condition-action, ((condition, c), (actions, acts)),
+ {
+ result = (make-concept)();
+ result.link(
+ condition, c,
+ actions, acts
+ );
+ });
+ ahabit(condition-action, ((context, c), (action, condition)),
+ {
+ // ...
+ ref outerctx = linked(c, "outer-context") ? c["outer-context"] : c;
+ ref next = nothing;
+ if (!linked(acts, cond)) {
+ if (linked(acts, "anything")) {
+ next = acts["anything"];
+ } else {
+ throw (make-concept)().link(
+ is, "unknown-condition",
+ "condition", cond,
+ "actions", acts,
+ context, ctx,
+ "subcontext", outerctx);
+ }
+ } else {
+ next = acts[cond]
+ }
+ if (outerctx.linked(active-state)) {
+ outerctx.get(active-state).set(next-step, next);
+ } else {
+ act(next, outerctx);
+ }
+ // TODO AFTER SUBCONTEXTS, so we can consider role of action
+ // handlers in context. likely will be unchanged.
+ // old: outerctx.get(active-state).set(next-step, next);
+ });
+ ahabit(condition, ((condition, cond), (actions, acts), (context, actctx)),
+ {
+ // STUB acts on acts with actctx straight
});
+ */
return 0;
}
diff --git a/starts/meaning-vm/level-2/habits.hpp b/starts/meaning-vm/level-2/habits.hpp
index b416ee0..dfc83b2 100644
--- a/starts/meaning-vm/level-2/habits.hpp
+++ b/starts/meaning-vm/level-2/habits.hpp
@@ -145,7 +145,8 @@ namespace concepts {
// make a contextual subcontext for an action
// the maps are lists of translation map items
- // result = (make-context-action)(needed-information-map, made-information-map, action)
+ // known-information is a map where the source items are taken literally instead of mapped
+ // result = (make-context-action)(known-information, needed-information-map, made-information-map, action)
static ref action("action");
// condition do one of multiple possible actions
diff --git a/starts/meaning-vm/level-2/sugar.hpp b/starts/meaning-vm/level-2/sugar.hpp
index 7f8b6b8..f8cb61f 100644
--- a/starts/meaning-vm/level-2/sugar.hpp
+++ b/starts/meaning-vm/level-2/sugar.hpp
@@ -42,7 +42,7 @@ namespace sugar {
sugar::usleep(delay); \
} \
} \
- ref self = ref(#name); (void)self; \
+ ref self = ctx.get(ref("self")); (void)self; \
ref result("nothing"); (void)result; \
_macro_call(_macro_for_each_parens, _macro_habit_set_posarg, _macro_habit_set_posarg _macro_comma_remove_parens(argnametoklist)); \
__VA_ARGS__ \
diff --git a/starts/meaning-vm/level2.cpp b/starts/meaning-vm/level2.cpp
index bfda42f..468eb8e 100644
--- a/starts/meaning-vm/level2.cpp
+++ b/starts/meaning-vm/level2.cpp
@@ -7,6 +7,7 @@
using namespace intellect::level2;
using namespace intellect::level2::concepts;
+/*
// makes a list in one call =)
void filllist(ref list, std::initializer_list<ref> items)
{
@@ -22,10 +23,6 @@ ref makelist(std::initializer_list<ref> items)
return list;
}
-// join refs with commas
-#define symbolstorefs(...) _macro_for_each(symboltoref, commasymboltoref, __VA_ARGS__)
-#define symboltoref(sym) ref(#sym)
-#define commasymboltoref(sym) , ref(#sym)
// 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
@@ -41,21 +38,102 @@ ref makestep(ref habit, ref result, std::initializer_list<ref> ins)
{
// build needed-information-map, made-information-map, action
// then pass to make-context-action.
- ref nim = (make-concept)(), mim = (make-concept)();
- (know-is-list)(nim); (know-is-list)(mim);
+ 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);
for (ref in : ins) {
infn = infn.get(next-information);
- (make-next-list-entry)(nim, (make-map-item)(in, infn[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-action)(nim, mim, habit);
+ return (make-context-action)(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 makestep(ref last, ref action, ref result, std::initializer_list<char const *> ins)
+{
+ ref lits = (make-concept)();
+ ref vars = (make-concept)();
+ ref outs = (make-concept)();
+ if (result != nothing) {
+ outs.set("result", result);
+ }
+ ref infn = action.get(information-needed);
+ for (auto str : ins) {
+ infn = infn.get(next-information);
+ // need to walk needed-information
+ if (str[0] == '`') {
+ std::string s = str + 1;
+ if (s.size() > 0 && str[s.size() - 1] == '`') {
+ s.resize(s.size() - 1);
+ }
+ lits.link(infn[information], str + 1);
+ } else {
+ vars.link(infn[information], str);
+ }
+ }
+ return (make-context-action)(last, lits, vars, outs, action);
+}
+
+// make functions and macros to make behaviors
+#define begin(name) { ref BEHAVIOR(#name); ref last = BEHAVIOR;
+#define end(name) assert(BEHAVIOR.name() == #name); }
+#define rewire(name) last = name
+#define wire(name) last.set(next-step, name)
+#define label(name) ref name =
+#define step(action, ...) last = makestep(last, action, ref("nothing"), { symbolstorefs(__VA_ARGS__) })
+#define assign(result, action, ...) last = makestep(last, action, ref(#result), { symbolstorefs(__VA_ARGS__) })
+#define jmpeq(var, cnst, label) last = ref("make-condition-action")(last, ref(#var), ref("make-concept")().link(ref(#cnst), label, ref("anything"), ref("nothing"))
+#define jmpne(var, cnst, label) last = ref("make-condition-action")(last, ref(#var), ref("make-concept")().link(ref(#cnst), ref("nothing"), ref("anything"), label)
+#define cond(var) last = nothing; ref("make-condition-action")(last, ref(#var), ref("make-concept")().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.
int main()
{
@@ -80,17 +158,65 @@ int main()
result = get(c, name);
}
});
- // I guess I'd better code dump as a behavior.
- decls(dump, type, target);
- ref dump = ref("dump");
- (know-is-list)(dump);
- filllist(dump,
+ ahabit(write-name, ((concept, c)),
{
- // make steps for all parts of dump
- step(),
- fromstep(),
+ std::cout << (name-of)(c);
});
- link(dump, habit, action-list);
+ 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);
+ });
+ // I guess I'd better code dump as a behavior.
+ begin(dump);
+ // 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);
+ 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, link-entry);
+ 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(whilecond, true, ifhastarget2);
+ // IT'S OKAY THAT THIS IS MESSY
+ // ALL IT NEEDS IS TO WORK
+ step(dump, link-target);
+ step(next-link-entry, link-entry);
+ rewire(whilecond2);
+ step(concept-unmke, link-entry);
+ end(dump);
+ /*
// for dump, we make a list of contextual actions
ahabit(dump, ((concept, c)),
{
@@ -111,4 +237,5 @@ int main()
(unmake-concept)(le);
}
});
+ dump(dump);
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-01 21:23:58 +0000