From e6f2b95fb543b535b1914bd4954e240dbd724275 Mon Sep 17 00:00:00 2001 From: olpc user Date: Mon, 9 Dec 2019 06:51:41 -0800 Subject: positional argument sugar for habits --- starts/meaning-vm/level-2/baseref.hpp | 2 + starts/meaning-vm/level-2/common.hpp | 3 ++ starts/meaning-vm/level-2/concepts.hpp | 4 ++ starts/meaning-vm/level-2/funcs.cpp | 43 +++++++++++++++++++- starts/meaning-vm/level-2/funcs.hpp | 5 +++ starts/meaning-vm/level-2/sugar.hpp | 73 +++++++++++++++++----------------- 6 files changed, 93 insertions(+), 37 deletions(-) (limited to 'starts/meaning-vm/level-2') 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 // thread-local context static ref context() { return level2::context(); } + template + 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 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 argnames, std::function 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 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 +#include + namespace intellect { namespace level2 { ref context(); +ref makehabit(ref name, std::initializer_list argnames, std::function code); +ref dohabit(ref habit, std::initializer_list 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 // int time(0); int clock_gettime(CLOCK_REALTIME, struct timespec *tp{tv_sec,tv_nsec}) #include // 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) \ - [=]() -> 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: +// UNSET SYMBOL: +// between the two 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) \ + [=]() \ { \ - 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 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); + } -- cgit v1.2.3