positional argument sugar for habits

6 files changed, 93 insertions, 37 deletions

diff --git a/starts/meaning-vm/level-2/baseref.hpp b/starts/meaning-vm/level-2/baseref.hpp
index c2bc0d1..921d1d3 100644
--- a/starts/meaning-vm/level-2/baseref.hpp
+++ b/starts/meaning-vm/level-2/baseref.hpp
@@ -19,6 +19,8 @@ struct baseref : public level1::baseref<ref>
 	// thread-local context
 	static ref context() { return level2::context(); }
 
+	template <typename... Refs>
+	ref operator()(Refs... args) { return level2::dohabit(self, {args.ptr()...}); }
 };
 
 }
diff --git a/starts/meaning-vm/level-2/common.hpp b/starts/meaning-vm/level-2/common.hpp
index aac072e..3d38155 100644
--- a/starts/meaning-vm/level-2/common.hpp
+++ b/starts/meaning-vm/level-2/common.hpp
@@ -6,5 +6,8 @@ namespace level2 {
 template <typename T> struct baseref;
 struct ref;
 
+namespace concepts {
+}
+
 }
 }
diff --git a/starts/meaning-vm/level-2/concepts.hpp b/starts/meaning-vm/level-2/concepts.hpp
index a8cfb0d..3a6ac6b 100644
--- a/starts/meaning-vm/level-2/concepts.hpp
+++ b/starts/meaning-vm/level-2/concepts.hpp
@@ -8,6 +8,10 @@ namespace level2 {
 namespace concepts {
 
 static ref context("context");
+static ref habit("habit");
+static ref next("next");
+static ref positional("positional");
+static ref argument("argument");
 
 }
 
diff --git a/starts/meaning-vm/level-2/funcs.cpp b/starts/meaning-vm/level-2/funcs.cpp
index c25ead2..b17d221 100644
--- a/starts/meaning-vm/level-2/funcs.cpp
+++ b/starts/meaning-vm/level-2/funcs.cpp
@@ -2,17 +2,58 @@
 
 #include "../level-1/sugar.hpp"
 #include "ref.hpp"
+#include "concepts.hpp"
 
 
 namespace intellect {
 using namespace level1;
 namespace level2 {
 
+using namespace concepts;
+
 ref context()
 {
-	static thread_local auto ctx = a("context");
+	static thread_local auto ctx = a(concepts::context);
 	return ctx;
 }
 
+ref makehabit(ref name, std::initializer_list<ref> argnames, std::function<void()> code)
+{
+	ref habit = level1::a(habit, name);
+	ref posarg = habit;
+	for (auto argname : argnames) {
+		ref nextarg = a(positional-argument);
+		nextarg.set(argument, argname);
+		posarg.set(next-positional-argument, nextarg);
+		posarg = nextarg;
+	}
+	habit.fun(code);
+	return habit;
+}
+
+ref dohabit(ref habit, std::initializer_list<ref> args)
+{
+	using namespace concepts;
+	ref posarg = habit;
+	for (ref const & arg : args) {
+		if (!posarg.linked(next-positional-argument)) {
+			throw std::invalid_argument("wrong number of arguments to habit");
+		}
+		posarg = posarg[next-positional-argument];
+		// TODO: subcontexts
+		ref::context().set(posarg[argument], arg);
+	}
+	if (posarg.linked(next-positional-argument)) {
+		throw std::invalid_argument("wrong number of arguments to habit");
+	}
+	ref ret = habit.fun<>()();
+	posarg = habit;
+	while (posarg.linked(next-positional-argument)) {
+		posarg = posarg[next-positional-argument];
+		ref::context().unlink(posarg[argument]);
+	}
+	return ret;
+}
+
 }
 }
diff --git a/starts/meaning-vm/level-2/funcs.hpp b/starts/meaning-vm/level-2/funcs.hpp
index 52c041d..770ff0a 100644
--- a/starts/meaning-vm/level-2/funcs.hpp
+++ b/starts/meaning-vm/level-2/funcs.hpp
@@ -2,10 +2,15 @@
 
 #include "common.hpp"
 
+#include <functional>
+#include <initializer_list>
+
 namespace intellect {
 namespace level2 {
 
 ref context();
+ref makehabit(ref name, std::initializer_list<ref> argnames, std::function<void()> code);
+ref dohabit(ref habit, std::initializer_list<ref> args);
 
 }
 }
diff --git a/starts/meaning-vm/level-2/sugar.hpp b/starts/meaning-vm/level-2/sugar.hpp
index 6734eae..3b0e2c0 100644
--- a/starts/meaning-vm/level-2/sugar.hpp
+++ b/starts/meaning-vm/level-2/sugar.hpp
@@ -4,45 +4,46 @@
 #include <time.h> // int time(0); int clock_gettime(CLOCK_REALTIME, struct timespec *tp{tv_sec,tv_nsec})
 #include <unistd.h> // usleep(unsigned int usecs)
 
-#define habitdelay \
-	static int thisdelay = (double(rand()) / RAND_MAX * 400000 + 200000); \
-	usleep(thisdelay)
-
 #undef self
-#define ahabit(name, ...) \
-	a(habit, name); \
-	(name).fun((std::function<void()>) \
-	[=]() -> ref\
+
+// habits have a structure such that they contain information about their positional
+// arguments.  they are made with a macro that turns the args into local variables.
+// the function to call them takes any number of arguments, and these are placed in the
+// thread context according to the information in the habit.
+
+// idea: preprocessor for level3 runs with habits
+// runs after C preprocessor and responds to output produced by macros e.g.
+// SET SYMBOL: <any string>
+// UNSET SYMBOL: <any string>
+// between the two <any string> is converted to valid c symbol when not double quoted.
+// removes much of the need for individual word declarations,
+// 	and starts to pave way towards user/intellect participation
+// here, could remove the 'tok' for local refnames.
+
+#define ahabit(name, argnametoklist, ...) \
+	intellect::level2::makehabit( \
+		name, \
+		{_macro_call(_macro_for_each_parens, _macro_habit_argnameref _macro_comma_remove_parens(argnametoklist))}, \
+		(std::function<void()>) \
+	[=]() \
 	{ \
-		habitdelay; \
+		{ \
+			static int delay = (double(rand()) / RAND_MAX * 400000 + 200000); \
+			usleep(delay); \
+		} \
 		ref self = name; (void)self; \
 		ref ctx = intellect::level2::ref::context(); (void) ctx;\
+		_macro_call(_macro_for_each_parens, _macro_habit_set_posarg _macro_comma_remove_parens(argnametoklist)); \
 		__VA_ARGS__ \
-		return intellect::level1::concepts::nothing; \
 	});
-
-// thinking on handling arguments with less boilerplate, more positional sugar
-// transfer argslist to a context for calling?
-// possibly transfer argslist to a function signature for the call
-// transfer context to the argslist for handling call
-// for each item of argslist, make a local variable, and set it to its value
-/*
-#define _positionalhabitarg(local, arg) \
-	ref local = ctx.get(arg);
-#define _ph
-
-#define apositionalhabit(name, argslist, ...) \
-	a(habit, name); \
-	(name).fun((std::function<ref(ref)>) \
-	[=](ref ctx) \
-	{ \
-		\
-	});
-*/
-
-// seed random number generator statically, for habitdelay
-namespace __internal {
-static struct timespec __tp;
-static int __timeres = clock_gettime(CLOCK_REALTIME, &__tp);
-static int __seed = (srand(__tp.tv_nsec), __tp.tv_nsec);
-}
+	#define _macro_habit_argnameref(name, tok) \
+		ref(#name)
+	#define _macro_habit_set_posarg(name, tok) \
+		ref tok = ctx[ref(#name)];
+	
+	// seed random number generator statically, for habit delay
+	namespace _macro_habit {
+	static struct timespec tp;
+	static int timeres = clock_gettime(CLOCK_REALTIME, &tp);
+	static int seed = (srand(tp.tv_nsec), tp.tv_nsec);
+	}