1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
#include "learning-parts.hpp"
using namespace habitstarts;
using namespace intellect::level2;
// Propose:
// everything that happens is passed to a set of common habits.
// these habits categorize, summarize, and pass to relevent habits.
// high level triggers are thus efficient, because they respond only
// to the group that applies to them.
// these habits must be learned.
// when providing a trigger at a high level, provide a way to get examples
// of what it should and should not trigger for. this provides for learning
// how to do this.
// the above looks like relevence to me. propose learning it.
// to learn most effectively, apply to process of learning.
// how do we adjust from success or from failure? need some attribute
// of scenario to store for next time, to respond to differently.
// so when we do something, we'll want to be able to store all information
// needed to learn to improve.
// we can include in this the meaning of a concept, and add language translation.
// is this 'apple'? is this? yes, no. then pattern recognition could engage
// triggers. later we'll want to propagate wrongness from failures.
// likely we'll grow better if we use this on things before they have words.
// // propose using random or exhaustive trial to find successes until habits develop
// // and then using the same on possible structure matches of the data
// // it may not work, we'll need to creatively grow data; reaonable start though
static int __init = ([]()->int{
decls(list, nothing, next, previous);
decls(make, add, to, until, each, item, in, remove, from, somewhere);
ahabit(make-list, ((list, l)),
{
result = a(list, l);
result.link(first-item, nothing);
result.link(last-item, nothing);
});
ahabit(add-to-list, ((item, i), (list, l)),
{
ref prev = l.get(last-item);
ref li = a(list-item);
li.link(item, i);
li.link(next, nothing);
li.link(previous, prev);
if (l.linked(first-item, nothing)) {
l.set(first-item, li);
l.set(last-item, li);
} else {
ref prev = l.get(last-item);
l.set(last-item, li);
prev.set(next, li);
}
});
// TODO: this is a useful function with way too much verbosity
// please make it simple, later.
ahabit(until-each-list-item-context-in-list, ((action, a), (context, c), (list, l)),
{
ref cur = l.get(first-item);
while (cur != nothing && result == nothing) {
result = a(cur, context);
cur = cur.get(next);
}
});
ahabit(remove-from-somewhere-in-list, ((item, i), (list, l)),
{
result = (until-each-list-item-context-in-list)(
ahabit(self-iter, ((list-item, i2), (remove-item, i)),
{
if (i2.get(item) == i) {
result = true
ref prev = i2.get(previous);
ref n = i2.get(next);
if (prev != nothing) {
prev.set(next, n);
}
if (n != nothing) {
n.set(previous, prev);
}
i2.unlink(previous);
i2.unlink(next);
i2.unlink(item);
dealloc(i2); // hmm. we do have an active goal of making memory allocation be habit based. this might work here, though.
}
}),
i, l);
});
ahabit(happened-habit, ((happened, ev)),
{
// TODO: perform each event associated with happened
if (!happened.linked(whenever-list)) { return; }
(until-each-list-item-context-in-list)(action-whenever-happened, ctx, happened.get(whenever-list));
});
ahabit(action-whenever-happened, ((list-item, li), (happened-context, hapctx)),
{
// here: when we trigger a behavior, we want information associated with producing the trigger,
// as well as the event that triggered. that's two contexts.
// list-item has item
// item has action and context
ref i = li.get(item);
// i think below we are proposing that handlers
// take one context, which is the one prepared
// in the list, then we inject our context
// into that, inside a "happened" property.
i.get(action)(hapctx, i.get(action-context));
});
ahabit(whenever-habit, ((happens, ev), (action, act), (action-context, actctx)),
{
if ((action-context).linked(happened)) {
throw std::logic_error("happened on action-context");
}
if (!ev.linked(whenever-list)) {
ev.set(whenever-list, (make-list)(nothing));
}
ref list = ev.get(whenever-list);
// happens gets the list
ref item = a(whenever-action);
item.set(action, act);
item.set(action-context, actctx);
(add-to-list)(item, list);
// store ctx[action] on ctx[happens] as behavior to do
// store ctx[action-context] as context for behavior
// PROPOSE: automatically place [happened] inside [action-context] as a stub
// for call event objects, and then place [context] inside [happened].
// PROPOSE: report error if [action-context] contains [happened]
// as a stub for error patterns, it would be pretty nice to throw
// a unique concept ref for each error type. plan to add to level-0.
});
ahabit(stop-when-habit, ((action, act), (happens, ev)),
{
// remove doing ctx[action] for ctx[happens]
});
ahabit(once-habit, ((happens, ev), (action, act), (action-context, actctx)),
{
// takes ctx[action] and ctx[happens] and ctx[action-context]
// uses above habits to do the action only once, probably by using
// a trigger on the habit-happening habit to check if a label is set,
// and remove the habit if it is.
});
return 0;
})();
|
