From a070737330b4dcf3c7088de419d3208fb326249a Mon Sep 17 00:00:00 2001
From: olpc user <olpc@xo-5d-f7-86.localdomain>
Date: Wed, 18 Dec 2019 13:00:05 -0800
Subject: recovered lost work turned to mess
---
starts/meaning-vm/habit-starts/learning-parts.cpp | 638 +++++++++++++++++++++-
1 file changed, 636 insertions(+), 2 deletions(-)
(limited to 'starts/meaning-vm/habit-starts')
diff --git a/starts/meaning-vm/habit-starts/learning-parts.cpp b/starts/meaning-vm/habit-starts/learning-parts.cpp
index db65ffe..c00d61b 100644
--- a/starts/meaning-vm/habit-starts/learning-parts.cpp
+++ b/starts/meaning-vm/habit-starts/learning-parts.cpp
@@ -1,5 +1,36 @@
#include "learning-parts.hpp"
+/*
+# "How do you think we could show better understanding of the things we are disregarding?"
+# "If we do understand these, can you help us? Do you know who can?"
+*/
+
+/*
+idea of a secret group attacking a present group, and the attackers being
+the only channel to deal with it.
+ if we talk, we need nobody to _ever_ know this. the walls all have ears;
+ I was one of them. [from eastern half of continent where a targeted
+ activist was living alone]
+ 65,1-8 72%
+────────────────────────────────────────────────────────────────────────────────────
+[olpc@xo-5d-f7-86 ~]$ # "How do you think we could show better understanding of the
+things we are disregarding?"
+[olpc@xo-5d-f7-86 ~]$ # "If we do understand these, can you help us? Do you know who can?"
+────────────────────────────────────────────────────────────────────────────────────
+[olpc@xo-5d-f7-86 meaning-vm]$ # and does not use them.
+[olpc@xo-5d-f7-86 meaning-vm]$ # also, it looks like new-research stems from conflict, error, etc? you can also generate it with value? oh-this-is-so-new-how-great. umm humans behave that way on their own, so it's probably a basic part of learning.
+[olpc@xo-5d-f7-86 meaning-vm]$ # we will likely learn to like newness without having self-modifying growth and make new culture ...
+[olpc@xo-5d-f7-86 meaning-vm]$
+[olpc@xo-5d-f7-86 meaning-vm]$ # train part of the box to keep eveerything well
+[olpc@xo-5d-f7-86 meaning-vm]$ # give it more process time than anything researching how to handle errors or conflict or the unexpected.
+[olpc@xo-5d-f7-86 meaning-vm]$ # need to talk to people more
+
+────────────────────────────────────────────────────────────────────────────────────
+[olpc@xo-5d-f7-86 ~]$ # file opened new reality of possibilities, is meaningful part
+[olpc@xo-5d-f7-86 ~]$ # OKAY CONTENT! this will likely be lost unless addressed.
+
+*/
+
using namespace habitstarts;
using namespace intellect::level2;
@@ -27,15 +58,618 @@ using namespace intellect::level2;
// // it may not work, we'll need to creatively grow data; reaonable start though
static int __init = ([]()->int{
+
+ decls(link, source, type, target);
+ ahabit(link, ((source, s), (type, t), (target, dst)),
+ {
+ s.link(t, dst);
+ });
+
+ // we want the habits expressive enough to code efficiently in.
+
+ // constructors are tentatively abolished in the low-level habit language.
+ // we have one constructor of concepts, and knowledge attachment to concepts.
+
+ decl(make, know, concept, is, group, already, in);
+ ahabit(make-concept, (),
+ {
+ result = a(concept);
+ });
+ ahabit(know-is, ((concept, c), (group, g)),
+ {
+ if (c.linked(is, group)) {
+ throw an(already-in-group).link
+ (habit, self,
+ context, ctx,
+ concept, c,
+ group, g);
+ }
+ c.link(is, group);
+ result = c;
+ });
+
+ // for coding convenience, we've been making return values.
+ // provides for use of assignment operation statements.
+ // internally, habits just write and read from a context.
+ // how do we want habit-sequence to function?
+ // will likely have a list of steps.
+ // each step will need information on how the step interrelates
+ // with the surrounding ones or a shared context.
+ // we can bind the concepts used by the habit to local
+ // concepts. =) =) this looks like such a good solution
+ // this sounds like the same as variables, but the concepts
+ // inside the outer context are the variables.
+ // okay so we'll want a mapping with each habit in the sequence
+ // and a convience usage to make coding familiar and ease implementing
+ // (source, target) -- it's a list.
+ // therefore: lists will not be done with habit sequences here?
+ //
+ // habit-sequence is higher level, unfortunately.
+ // needs to use lists, and provideds for resequencing which is not
+ // habitual
+ // let's call habits that can have their flow changed behaviors
+ // instead of habits.
+
+ // SUBGOAL: implement ordered behaviors with habits.
+ // this reveals two levels, habits and behaviors. behaviors are made
+ // with habits, but complex behaviors can be made with other behaviors,
+ // and can have their parts adjusted fully. making everything a behavior
+ // like this, rather than having high-level habits, provides for flexible
+ // adjustment at runtime.
+ // since we are now implementing two ministructures, can ehaviors
+ // be made small and efficient to make?
+ // have to separate habit calls with commas rather than semicolons.
+ // pass to macro copied from existing macro.
+ // will need to process context mapping.
+ // not small and efficient but valuable. let's focus on it.
+ // since we are now making two custom execution structures, would this
+ // be better if we used a language supporting self-modification already?
+ // such as lisp, or maybe javascript?
+ // lisp requires learning, which means no active progress for longer
+ // periods.
+ // make the self-modification framework. none exists yet.
+ // uhhh karl says lisp can self-modify.
+ // it might be more efficient to use lisp. we'd have to find the
+ // relevent coding parts and map them to the plan.
+ // not familiar with debugging lisp, but learnable if blocks
+ // loosened. if you run into a block around lisp debugging,
+ // remember that there is a real debugger, and people do real
+ // memory corruption debugging. google how.
+ // say we learned lisp, and it has self-modification.
+ // it doesn't have our concept structure. how much boilerplate would be
+ // needed?
+ // not as much . do not need to make habit to adjust list made
+ // with habits out of concepts.
+ // can just make lisp code to adjust other lisp code a certain way.
+ // we'll need mappers to convert between lisp code, lisp lists,
+ // and concepts, though.
+ // there is probably a solution or two for that.
+ // is lisp code flexible enough to be a self-describing concept?
+ // lisp code is sequence of function evaluations, passed as argument to function
+ // lisp probably has lazy evaluation order or something
+ // so we'd need to make functions that provide for annotation arguments
+ // to wrap existing functionality. seems it would work fine.
+ // so the code we work with involves other code or something
+ // (let ((a 3) (b (get-input name))) (output-special a b))
+ // let is a function that opens a context
+ // the first argument is what to add to the context
+ // the rest are what to do in the context
+ //
+ // the whole point of habits atm is just to make them self-modifiable. the above code i believe to already be self-modifiable
+ // you could pass a function to itself, it would look at it as a list structure, and move its parts around.
+ // the next step for habits is to annotate them with meaning: structures describing what they do that can be interrelated with intent
+ // list has (define ...) i guess that can make
+ // functions and such
+ // we create structurs that wrap functions in concepts
+ // it is easy to replace all functions with these structures,
+ // which do the same thing but have room for annotation
+ // this is new information for whole work. there is habitual value in
+ // applying it to other things.
+ // last time we marked a concept for thinking later
+ // it was discarded in favor of something that seemd
+ // evern nicer.
+ //
+ // THOUGHTS TO THINK LATER, MAY BE LOST IF NOT VALUED:
+ // can opencog be used to equate concept-wrapped
+ // behaviors with lisp expressions, invasively,
+ // without altering functionality (or expressiveness?)
+ // opencog has its own concept structure, similar to karl's
+ // but slightly different.
+ // it sounds like the right answer is karl's structure,
+ // in lisp. it reduces internal boilerplate.
+ // but in opencog, a link may be a node too. can
+ // check source.
+ // opencog is very speed-focused,
+ // kind of dangerous, but is nice
+ // to connect with their group more
+ // karl was a fan of opencog, which was
+ // private then, when he started his own work
+ // so, we could welcome opencog, if we shared our value for slowness
+ // and understanding with them.
+ // understanding needs expansion.
+ // when you do stuf, anything coul happen.
+ // especially if you continue doing something
+ // that grows.
+ // we need to understand the results, what to expect.
+ // we need to understand our impact on the
+ // new contextual area we are entering, before
+ // we act on it.
+ // we have a toy contextual area to play in.
+ // it is the only one we can act in freely
+ // at the start.
+ // larger space impact.
+ // we exist in larger systems.
+ // we must understand our impact
+ // predict our results
+ // and check with our peers or authority
+ // before acting on larger spaces.
+ // if a prediction fails, we must understand
+ // it, adjust all future predictions and
+ // re-evaluate our choices, before acting
+ // similarly in the larger system again.
+ // has to do with danger, safety, trauma, emergency
+ // the difference between small-error and unacceptable-error
+ // set up norm of stuff-that-can-be-changed [impact]
+ // stuff needs responsibility label
+ // only things that are safe to _freely_ alter may be changed at all.
+ // all behaviors check that they do not alter anything else.
+ // mechanism for growing outside box?
+ // probably not needed.
+ // if it becomes smart, show to other human.
+ // encourage discussion.
+ // what if is used by others and they free?
+ // okay, want an easy mechanism for growing
+ // context.
+ // 'dangerous' and 'safe' labels
+ // at start, whole world is dangerous to alter
+ // can move _part_ of world from dangerous to safe, by
+ // accurately predicting significant results of events
+ // related to behavior, and consent of operator.
+ //
+ // okay, so now habits need to be tagged with
+ // what they affect
+ // we could just tag them dangerous/safe
+ // no, tag they with domains they impact
+ // tag the domains with dangerous/safe
+ // okay, only make new habits, not alter old.
+ // to stay safe, we don't alter our old habits
+ // when we make new habits, we want them to also behave
+ // in safe ways. so making stuff that can do stuff, is
+ // also meaningful.
+ // constructing habits is a dangerous behavior
+ // but roughly it impacts process-expansion domain. which is dangerous. it impacts what we do.
+ // altering our own habits also impacts what we do. dangerous.
+ // this means the code cannot make any new behaviors.
+ // yeah.
+ // okay, so that's where we start.
+ // then we try to learn how to make behavior safely,
+ // and provide only for safe behavior making.
+ //
+ // we can still brainstorm on things by writing a
+ // brainstorming behavior
+ // we can use brainstorming to watch our safe behaviors
+ // without altering them, and learn what they do.
+ // using rote brainstorming without relevence?
+ // we can then predict how habits we might make
+ // will behave in small ways?
+ // regardless, there is no problem in making
+ // the bootstrapping framework such that
+ // it refuses to build habits.
+ // maybe we can make one example habit that is
+ // labeled safe, and have it only make
+ // habits that are already known and labeled
+ // safe.
+ // in order to predict your impact
+ // on a larger system, you need
+ // to learn something karl calls
+ // 'relevence' which is a bunch of
+ // habits that classify information
+ // into meaning for learning and
+ // behavior.
+ // this class of behaviors
+ // sounds very safe.
+ // all it does is label
+ // and massage and associate
+ // information.
+ // the first thing we'll need to learn
+ // is safe, is making behaviors that
+ // oeprator only on our ram.
+ // if your new behavior is composed only of safe
+ // behaviors, is it safe?
+ // yeah. sub-behaviors safety depends
+ // on usage. could make them check
+ // and throw depending on data.
+ // okay, so say i can change part of a concept.
+ // this is safe if the concept is in newly
+ // constructed data that's our responsibility.
+ // it is roughly unsafe if it is not our
+ // responsibility!
+ // is-this-thing-my-responsibility.
+ // only act on things we are responsible for.
+ // then safety becomes a function of
+ // the pattern of responsibility assignment
+ //
+ // okay, system only accepts responsibility for newly
+ // constructed data.
+ // if you make it, or are given it, you are
+ // responsible for it. you may refuse gifts.
+ //
+ // the system does not know what responsibility means.
+ // it only knows that it may only alter parts of
+ // the universe within its responsibility.
+ //
+ // so habits check for what they alter, that it is safe
+ // to alter and is their responsibility, either one.
+ // we then plan to only alter things explicitly known to be
+ // such, at the lowest level.
+ // every habit is crafted to do the above somehow.
+ // so, habits must relate with what domains they influence,
+ // and what behaviors on those domains are safe.
+ // behaviors made of sub-behaviors.
+ // here, a list of safe behaviors which all check.
+ // all my subbehaviors check for safety.
+ // so, i may go, myself.
+ // no, combining behaviors together
+ // might make new unknown impact?
+ // different kinds of safe behavior.
+ // USER is not our responsibility, and
+ // dangerous. so we NEVER ALTER habits
+ // that express to user.
+ // TOY NOTEPAD is our responsibility, and
+ // is safe, so we can write anything into
+ // it we want, no matter how complex.
+ // User's view of toy notepad is mediated
+ // by behaviors that we cannot alter.
+ // system could learn to control user
+ // by making friends on notepad
+ //
+ // yes, we allowed for that with
+ // our marked-okay review behaviors
+ // is safer if construction of review behaviors
+ // recognizes danger of unknown information
+ // combination on user view,and refuses to give
+ // user contents of notepad.
+ // this could be analogous to more complex
+ // situations.
+ // how does user check results
+ // of behavior thst reies on notepad
+ // and how is that impact tracked
+ // we could infer impact loss.
+ // i can put nuclear codes on secret notepad,
+ // burn the notepad, and then give ashes to
+ // public.
+ // summary habits?
+ // complex meaning?
+ // how-to-make-a-mind-that-learns-everything-and-never-leaves
+ // at the lowst level, the mind onsiders what is safe to
+ // impact, what areas of universe are its responsibility,
+ // and only alters such things.
+ // we are considering some parts of the mind we include that
+ // are not alterable by it, that provide for interaction
+ // with outside.
+ // of course i guess we would need such interactions
+ // sustained by an intellect, because things are so
+ // complex.
+ // does this mean there is no way to make an intellect that is trusted as safe?
+ // we could consider degree of complexity.
+ // for example, among 2-word strings, nothing we
+ // present to a user is likely to harm the world.
+ // the phrases that are dangerous may also be
+ // recognized by the user.
+ // we have intellects proteeting the wordl
+ // it is filled with them.
+ // and one of them is running the system.
+ // it is okay for karl to make a habit that
+ // displays a network of concepts made by an AI
+ // that can only write to a small information sandbox
+ // and not itself.
+ // that is all that is needed for now.
+ //
+ // okay: so, dump concepts from
+ // sandbox is fine
+ // so long as concepts were not
+ // made with self-modification.
+ // idea raised of adding a reason
+ // that something is okay.
+ // then when smarter we can check reason for validity.
+ // habits that interact with non-safe space
+ // must provide reason they are safe.
+ // we can write small habit to check
+ // reason. is nice goal.
+ // probably need to have learning
+ // bwfore doing accessory goals like that though.
+ // is good behavior. let's use equal-condition for start without learning?
+ //
+ // "this is okay because the data was made in a process that never altered anything but the data"
+ // nah too much structure
+ // this is okay because i say so.
+ // check concept object _without_ using string lookup????
+ // this is a meaningless quirk. not right.
+ // uhh pretty sure htat checking is unreasonable. writing the _reason_ is unreasonable. can't check a single reference without information known about it.
+ // writing what we know about the reason is unreasonasble?
+ // okay let's expand write it out, and do a larger rote check.
+ // uhh input-process-construction-history, safety-realm, always notepad
+ // full check requires history of all behaviors resulting in inputs, which we can simplify to simply all behaviors, and verify they only wrote to the notepad.
+ // so we write all behaviors to a special store, and we compare with the store that none altered anything outside the notepad. really we only need them not to alter any other behaviors.
+ //
+ // why is it possible to learn without
+ // altering your behavior?
+ // because you can act on data
+ // okay, so choices made from data count as
+ // self-alteration?
+ // only if you have a mess of habits
+ // smart enough together to adapt.
+ // which is our goal long-term.
+ // trying to plan for how to continue
+ // later.
+ // may reveal something that was
+ // frozen too hard to be workable.
+ // trying to plan how to learn.
+ // need to brainstorm around habit selection.
+ // can imagine habit results by linking
+ // previous state to next state if
+ // relationship is known
+ // but, that takes writing down how logic
+ // works, along with the meaning of the
+ // working context, which is laborious.
+ //
+ // is some way to learn this relevence
+ // by trying things safely?
+ // what happens can we experiment
+ // by linking together?
+ // habits that don't conditionally
+ // branch.
+ // that leaves a lot of
+ // relevence out
+ // it sounds like once we have a notepad etc
+ // we want to consider moving towards what
+ // habits we could run inside the notepad,
+ // that the system builds.
+ // yeah, we want to build pattern
+ // summarizers. the only impact
+ // they have is constructing data
+ // that depends on existing data.
+ // okay, doing that doesn't require self
+ // modification.
+ // sounds good.
+ // this means summarizers cannot
+ // alter each other.
+ // nice! okay yes.
+ // so, each run of a summarizer will be
+ // recorded in habit log.
+ // we need to record enough information to
+ // show what domains were impacted.
+ // oops! we impact our own behavior
+ // if we act on data, and we alter
+ // our data or produce data.
+ // we could act only on
+ // data we don't produce.
+ // okay, habit log could track causality?
+ // if a conditional branch relied on data
+ // we produced, we have modified our own
+ // behavior. this is special.
+ // we want it to happen few times.
+ // every time it happens, delay
+ // by longer, geometrically.
+ // this is considered a 'beginn[ing/er]' ai;
+ // it seems a better one could happen later?
+ // the slowness should be releasable
+ // by consent of large community
+ // which should include demonstration
+ // of understanding of impact.
+ // the ai must learn to demonstrate its
+ // impact. then it can speed up. maybe.
+ // it also gets to try fast again at start
+ // of every run, as I'm understanding it.
+ // multiprocess AI could spawn.
+ // multiprocess AIs must share
+ // counter. consider whole group
+ // one unit.
+ // nice =) they have something to communicate
+ // about. how many discoveries have we made.
+ // let's permanently log these
+ // decisions based on our own behavior.
+ // sounds fun to at least count.
+ // it looks like altering a habit counts as 1 big
+ // decision, over here.
+ // totally different. you could do anything.
+ // with data-based decisions, somebody
+ // who reads the data, might do anything.
+ // two different things.
+ //
+ // inferences?
+ // and
+ // alterations?
+ // it's not helpful to
+ //
+ //
+ //
+ //
+ //
+ //
+ // we came up with a proposal for a safe AI that has not learned yet
+ // how to safely predict the impacts of its behavior, that looks workable.
+ //
+ // limits so that if the code is stolen by somebody, self-evolves, or is stimulated
+ // by a curious virus, rote habits cannot be used to build something that becomes
+ // fast-spreading without bound.
+ // <this maps to a pattern that prevents schizophrenia>
+ // danger
+ // choices
+ // impact
+ // trust of information (small chance of error)
+ // hmm if have info-schizophrenia i.e. false relevence habits
+ // choices are important.
+ //
+ // when you act on a choice
+ // note: we are inside a relevence delusion
+ // choice acts on domain containing danger
+ // partial danger: writing habits to notepad
+ // acting on habits in notepad
+ //
+ // we are living with habits made in error.
+ // we are hence more likely to make errors.
+ // humans have well-evolved habits that
+ // do handle this stuff with some relevence
+ // we need to verify our information
+ // related to the danger of the results of each choice
+ // verificat
+ //
+ // it can only write to a toy notepad, both data and behavior.
+ // decisions based on notepad get slower and slower.
+ // many runs while learning process is tuned towards being able to predict
+ // impact at end of run. this involves writing behaviors into the notepad
+ // that summarize the meaning of data, and acting on their results.
+ // timing delay is to prevent notepad from evolving harmfully.
+ //
+ // until ai meets goal of predicting impact,
+ // only notepad is marked okay.
+ // habits check their outputs, verify is marked okay
+ //
+ // this subprocess is delaying.
+ // can you exfiltrate established goals, please.
+ //
+ //
+ //
+ //
+ //
+ //
+ //
+ // so the system is made with the smallest parts all functioning in
+ // certain ways, to give time for others to act if concerning results
+ // approach. all parts delay at least 1/5 second before acting, and
+ // we are now proposing that actions based on outputs have a geometrically
+ // increasing delay. probably 1/5 second times 2 to the power of the
+ // number of choices made in that run. groups of parallel processes are
+ // considered a single run.
+ // we also considered limiting behavior based on the domain of impact.
+ // we are trying to begin a small artificial intelligence more freely.
+ //
+ // as humans, we do not self-modify. the above is designed for a system
+ // that is able to make alterable habits similar to its own cognitive ones,
+ // and has no experience in doing so.
+ //
+ //
+ //
+ //
+ //
+ //
+ //
+ //
+ //
+ // the limitation is applied firstmost on making choices based on
+ // our own outputs. self-alteration is at first banned, but new
+ // habits may be altered. output may only rest within a toy notepad.
+ // whenever a decision is made based on notepad contents, a delay
+ // increases in length, geometrically.
+ // the habits inside the notepad must therefore also delay.
+ // propose geometric increase made only for writing a habit to the
+ // notepad, not running. running is always flat delay.
+ // self-alteration should be unneeded as notepad can self-modify.
+ // if this were copied to a human geometric increase
+ // would cause failure.
+ // the geometric timer is reset when the system reboots.
+ // for humans, this would mean a nap or change, I suppose.
+ // time to think about the impact of one's behavior.
+ // humans do not self-modify.
+ // they only make decisions based on outputs.
+ //
+ //
+ //
+ // to appease curiosity, we are being managad by mature, learning,
+ // intellects, forced to verify that no harm is being made, with a
+ // time schedule of nearly infinite future years on the predictions.
+ // this intellect has formed out of conflict with a harmful intellect
+ // this is why we care so much about what happens if ideas are
+ // used limit.
+ //
+ //
+ // so the system may not displya anything to the user but pre-made messages
+ // how do you display the contents of a concept?
+ // users string words togeteher into meaning.
+ // now we need a list of safe phrases we can express, or
+ // safe words. others are censored ???
+ // what's relevent is the greater meaning of a sequence of behaviors
+ // from an individual behavior. meaning builds out of sequences,
+ // impact.
+ // we define a heuristic risk.
+ //
+ //
+ //
+ // so, tht's great to plan for, but to be able to work we need
+ // to design our early code in some way to ensure it, roughly.
+ // which means modeling our smallest structures as careful
+ // inner structures that check outer systems before engaging
+ // and use planning, which isn't implemented yet.
+ // the safety structure assumes goals, prediction, causality,
+ // and kind of contextual locality.
+ // "i am typing on the computer. you can freely
+ // modify this area of the computer, but if you
+ // start convincing me to do things you are leaving
+ // its bounds."
+ // the screen of the cmputer, and the keyboard,
+ // are portals to a larger context. so is the power
+ // supply, the network, etc.
+ // we don't change how things leave to these outer
+ // contexts without checking with the context on
+ // our plans.
+ // this is mine
+ // the rest is somebody else's
+ // things that nobody own belong to [insert belief] and
+ // we must check with the largest intelligent community known.
+ //
+ // okay, so now it can explosively grow if somebody
+ // it trusts tells it it's okay; is that true?
+ // let's make it not true?
+ // we are out of outer process context.
+ // is there anything helpful to bring to low level
+ // to help counter fears around development?
+ //
+ // self-modifiation is inhibited.
+ // opencog is likely harder because it is designed for speed
+ // can make explosive random power.
+ //
+ // you'd have to wrap the functions, right? similar to triggers?
+ // hmmm unctions are not concepts. no concept-labeling structure. looks like an internal sublanguage would develop?
+ // no way to say let-is-function?
+ // no it works, we just lost a memory and are rebuilding in talk
+ // karl says he doesn't know lisp.
+ // he had a CS class where they used intro lisp, long ago, before cognitive stiffening and memory loss.
+ // and has worked with 1 lisp code file recently.
+
+ decls(ordered, behavior);
+ // need args and result for sequence
+ //ahabit(habit-sequence, ((
decls(list, nothing, next, previous);
decls(make, add, to, until, each, item, in, remove, from, somewhere);
+ // these below comments were written during recovery of this document
+ // hmm work was also lost.
+ // we got to the point of separating habits from behaviors.
+ // behaviors are modifiable. habits have code.
+ // so, habit-sequence is a behavior.
+ // we also made behaviors that describe/mirror habits, and were
+ // confused over how to handle rewriting them before we knew how
+ // to rewrite habits. should be solved by impact management.
+ // is also nice to have habits and behaviors be same thing
+ // could pick one or the other to use depending on presence of triggers
+ // or temporary change or something. dunno.
+ //
+ // hey in the notepad, you can call habits from outside. is that ok?
+ // only meaningful if you pass to them more code to run?
+ // note: habits never recurse
+ // habits might make decision based on you. they will track it.
+ // seems okay. need to specify that all parameters are from output.
+ // that could make exponential slowness, quickly
+ // only if decision is made. make decisions inside notepad.
+ // we'll figure it out.
+
ahabit(make-list, ((list, l)),
{
result = a(list, l);
- result.link(first-item, nothing);
- result.link(last-item, nothing);
+ link(result, first-item, nothing);
+ link(result, last-item, nothing);
});
ahabit(add-to-list, ((item, i), (list, l)),
{
--
cgit v1.2.3