Merge pull request #7 from rusini/alex

Author: rusini

AUTHORS

@@ -0,0 +1,3 @@
+Alexey Protasov (AKA Alex or rusini)  
+info@manool.org  
+https://manool.org

AUTHORS.md

@@ -89,7 +89,7 @@ libdecnumber-objs = $(patsubst %,build/obj/libdecnumber/%.o, \
    decimal128 \
 ) # end
 
-build/mnlexec : $(manool-objs) $(libdecnumber-objs) | build/lib/manool.org.18/std/0.5/all.mnl ; @mkdir -p $(dir $@)
+build/mnlexec : $(manool-objs) $(libdecnumber-objs) | build/lib/manool.org.18/std/0.6/all.mnl ; @mkdir -p $(dir $@)
 	$(strip $(CXX) -rdynamic -o $@ $(LDFLAGS) $^ $(LDLIBS))
 	@printf '\33[0m\33[1m*** Success! To run MANOOL try: ./mnl \33[4mmanool-source-file\33[24m [\33[4margument\33[24m...] ***\33[0m\n'
 
@@ -102,7 +102,7 @@ plugins = $(patsubst %,build/lib/manool.org.18/std/_%.mnl-plugin, \
    threads \
    misc \
 ) # end
-build/lib/manool.org.18/std/0.5/all.mnl : lib-0.5-all.mnl | $(plugins) ; @mkdir -p $(dir $@)
+build/lib/manool.org.18/std/0.6/all.mnl : lib-0.6-all.mnl | $(plugins) ; @mkdir -p $(dir $@)
 	cp $< $@
 $(plugins) : build/lib/manool.org.18/std/_%.mnl-plugin : lib-%-main.cc ; @mkdir -p $(dir $@)
 	$(strip $(CXX) -shared $(LDFLAGS_SO) -o $@ -MMD -MP $(CXXFLAGS) $(CPPFLAGS) $(mnl_config) $(LDFLAGS) $< $(LDLIBS))
@@ -129,9 +129,9 @@ includes = \
 # end
 install : all
 	rm -rf $(PREFIX)/bin/mnlexec $(PREFIX)/lib/manool $(PREFIX)/include/manool
-	mkdir -p $(PREFIX)/bin $(PREFIX)/lib/manool/manool.org.18/std/0.5 $(PREFIX)/include/manool
+	mkdir -p $(PREFIX)/bin $(PREFIX)/lib/manool/manool.org.18/std/0.6 $(PREFIX)/include/manool
 	cp build/mnlexec $(PREFIX)/bin
-	cp build/lib/manool.org.18/std/0.5/all.mnl $(PREFIX)/lib/manool/manool.org.18/std/0.5
+	cp build/lib/manool.org.18/std/0.6/all.mnl $(PREFIX)/lib/manool/manool.org.18/std/0.6
 	cp $(plugins) $(PREFIX)/lib/manool/manool.org.18/std
 	cp $(includes) $(PREFIX)/include/manool
 .PHONY : install

GNUmakefile

@@ -7,7 +7,7 @@ General Instructions
 Try, e.g.:
 
     make
-    ./mnl <(echo $'{{extern "manool.org.18/std/0.5/all"} in Out.WriteLine["Hello, world!"]}')
+    ./mnl <(echo $'{{extern "manool.org.18/std/0.6/all"} in Out.WriteLine["Hello, world!"]}')
 
 Note that there is no need to run `./configure` (though, it's harmless), since the set of supported host/target platforms is more homogeneous than it used to be
 for GNU tools, and thus all platform-specific tuning can be done in a simpler way (that is, during actual building). In theory, the source file `config.tcc` is
@@ -17,7 +17,7 @@ To run MANOOL from within a different directory, point the environment variable
 `mnlexec` as in the following example:
 
     MNL_PATH=<working-tree directory>/build/lib <working-tree directory>/build/mnlexec \
-    <(echo $'{{extern "manool.org.18/std/0.5/all"} in Out.WriteLine["Hello, world!"]}')
+    <(echo $'{{extern "manool.org.18/std/0.6/all"} in Out.WriteLine["Hello, world!"]}')
 
 The section Confirmed Builds provides more specific instructions together with recommended compilation options for 23 combinations of OSes/ISAs/ABIs/compilers.
 
@@ -94,7 +94,7 @@ To install MANOOL after building, try, e.g. (also read about the `PREFIX` makefi
 To run installed MANOOL, point the environment variable `MNL_PATH` to the installed-library directory, e.g.:
 
     MNL_PATH=/usr/local/lib/manool mnlexec \
-    <(echo $'{{extern "manool.org.18/std/0.5/all"} in Out.WriteLine["Hello, world!"]}')
+    <(echo $'{{extern "manool.org.18/std/0.6/all"} in Out.WriteLine["Hello, world!"]}')
 
 To get the `mnlexec` invocation synopsis and a short description of all recognized environment variables, just run it without arguments: `mnlexec`.
 
@@ -104,7 +104,7 @@ environment):
 
     cat >hello && chmod +x hello
     #!/usr/bin/env mnlexec
-    {{extern "manool.org.18/std/0.5/all"} in Out.WriteLine["Hello, world!"]}
+    {{extern "manool.org.18/std/0.6/all"} in Out.WriteLine["Hello, world!"]}
     <Control-D>
     ./hello
 
@@ -181,7 +181,7 @@ Confirmed Builds
 
 ***
 
-+ openSUSE Leap 15.1, x86-64, x86-64/lp64, g++
++ openSUSE Leap 15.2, x86-64, x86-64/lp64, g++
 
       sudo zypper install gcc-c++ make
       make
@@ -198,15 +198,15 @@ Confirmed Builds
 
 + CentOS 6, x86-64, x86-64/lp64, g++
 
-      sudo yum install centos-release-scl && sudo yum install devtoolset-8-gcc-c++
-      make SCL='scl enable devtoolset-8 --'
+      sudo yum install centos-release-scl && sudo yum install devtoolset-9-gcc-c++
+      make SCL='scl enable devtoolset-9 --'
 
 ***
 
 + CentOS 7, x86-64, x86-64/lp64, g++
 
-      sudo yum install centos-release-scl && sudo yum install devtoolset-8-gcc-c++
-      make SCL='scl enable devtoolset-8 --'
+      sudo yum install centos-release-scl && sudo yum install devtoolset-9-gcc-c++
+      make SCL='scl enable devtoolset-9 --'
 
 + CentOS 7, x86-64, x86-64/lp64, clang++
 

INSTALL.md

@@ -1,11 +1,28 @@
-<img alt="MANOOL Logo" src="https://manool.org/MANOOL-Logo.png" width="64" height="64"> MANOOL v0.5.0
+<img alt="MANOOL Logo" src="https://manool.org/MANOOL-Logo.png" width="64" height="64"> MANOOL v0.6.0
 =====================================================================================================
 
-MANOOL is a programming language with the same purpose as Python, Ruby, PHP, Common Lisp, or Scheme, but it is designed with one central idea in mind:
-  * to maximize the *expressive power / implementation complexity* ratio.
+**MANOOL is meant to make exploratory programming safer and faster.**
 
-The author's implementation fits in only 10 KLOC in C++, yet it exhibits competitive run-time performance.
+Some programming tasks are common and predictable from the project management perspective, but often, even enterprise information systems (especially in the
+area of startups) involve some innovation and exploratory programming. Imagine you have such task at hand. Whenever this happens you have two options:
+  1. use an *implementation-level* programming language, such as C, C++, Java, or maybe Rust (if you want to try a more recent approach) or
+  2. use a language more suitable for *throw-away* programming, such as PHP, Python, Ruby, JavaScript, or even Scheme.
 
-**For a complete project overview**, please refer to [Introduction to MANOOL](https://manool.org/specification/introduction-to-manool).
+In the former case, you eventually get stuck with your coding -- trying to conceive some poorly understood algorithms, deciding which data types to use and how
+to get around seemingly arbitrary constraints for composite data types, devising resource management policies, and dealing with confusing program logic.
 
-"**MA**NOOL is *Not* an Object-Oriented Language!"
+Then you resort to the second option, in which case you also have to conceive poorly understood algorithms, deal with confusing program logic, and occasionally
+think about how to circumvent composite data type constraints, but most probably you end up familiarized yourself with the problem domain and come to a working
+prototype.
+
+You show your solution (which mostly looks nice) to the managers, and suddenly they react: "OK, let's clear up the bugs; tomorrow we deploy it in production!".
+Then disaster falls on you; after some time of production use, it turns out that
+  * your code is not scalable to a grown user base and hence larger workload, or the solution is simply slow according to your end users,
+  * your code has mysterious and hard to localize bugs, and of course
+  * the program logic itself still looks confusing and complex.
+
+  This happens because paying attention to those details would imply undue cognitive burden at the early stage of development. And unlike your managers you
+already knew that: a major rewrite is unavoidable, now in a "real" implementation-level language -- does this sound familiar?
+
+While MANOOL is a general-purpose programming language, it is specifically designed to solve the above problem. It may also help you to come to a working
+prototype faster and then gradually refactor your code up to a production-quality state instead of rewriting the code entirely from scratch.

README.md

@@ -16,24 +16,32 @@
 # include "config.tcc"
 # include "mnl-aux-core.tcc"
 
+# include <time.h> // clock_gettime
 # include <cstdio> // sprintf, stderr, fprintf, fputs, fflush
-# include <ctime>  // time
 
 namespace MNL_AUX_UUID { using namespace aux;
    namespace aux {
-      using std::_Exit; // <cstdlib>
+      using std::_Exit; using std::srand; // <cstdlib>
       using std::sprintf; using std::fprintf; using std::fputs; using std::fflush; // <cstdio>
-      using std::time; // <time>
    }
 
 // Translation Infrastructure //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    MNL_IF_WITH_MT(thread_local) decltype(symtab) pub::symtab;
 
+   namespace aux { namespace { struct stub {
+      MNL_INLINE static val  execute(bool)   { MNL_UNREACHABLE(); }
+      MNL_INLINE static void exec_in(val &&) { MNL_UNREACHABLE(); }
+      MNL_INLINE static val  exec_out()      { MNL_UNREACHABLE(); }
+      MNL_INLINE static bool is_rvalue() { return false; }
+      MNL_INLINE static bool is_lvalue() { return false; }
+      MNL_INLINE static code compile(code &&, const form &, const loc &_loc) { err_compile("invalid form", _loc); }
+   }; }}
    code pub::compile(const form &form, const loc &_loc) { return // *** The Compiler Core Dispatcher! ***
       test<sym>(form) && symtab[cast<const sym &>(form)] ?
          symtab[cast<const sym &>(form)] :
-      test<sym>(form) && ((const string &)cast<const sym &>(form))[0] >= 'a' && ((const string &)cast<const sym &>(form))[0] <= 'z' ?
-         (err_compile("unbound keyword (nested in this context)", form._loc(_loc)), code{}) :
+      test<sym>(form) && (((const string &)cast<const sym &>(form))[0] >= 'a' && ((const string &)cast<const sym &>(form))[0] <= 'z' ||
+      ((const string &)cast<const sym &>(form))[0] == '_' || ((const string &)cast<const sym &>(form))[0] == '`') ?
+         MNL_AUX_INIT((code)stub{}) :
       test<long long>(form) || test<string>(form) || test<sym>(form) ?
          [&]()->code{ code make_lit(const val &); return make_lit(form); }() : // actually from MANOOL API
       form.is_list() && !form.empty() ?
@@ -107,8 +115,12 @@ namespace MNL_AUX_UUID { using namespace aux;
       return !MNL_LIKELY(argv[0].rep.tag() == 0x7FF8u) || argv[0].rep.dat<void *>() != rep.dat<void *>();
    case 3: // Order
       if (MNL_UNLIKELY(argc != 1)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-      if (MNL_UNLIKELY(argv[0].rep.tag() != 0x7FF8u) || MNL_UNLIKELY(argv[0].rep.dat<void *>() != rep.dat<void *>())) MNL_ERR(MNL_SYM("TypeMismatch"));
-      return 0;
+      { auto mask = MNL_AUX_RAND(uintptr_t);
+        int res = default_order(argv[0]);
+        return MNL_UNLIKELY(res) ? res :
+           ((reinterpret_cast<uintptr_t>(rep.dat<void *>()) ^ mask) < (reinterpret_cast<uintptr_t>(argv[0].rep.dat<void *>()) ^ mask)) -
+           ((reinterpret_cast<uintptr_t>(argv[0].rep.dat<void *>()) ^ mask) < (reinterpret_cast<uintptr_t>(rep.dat<void *>()) ^ mask));
+      }
    case 4: // Clone
       if (MNL_UNLIKELY(argc != 0)) MNL_ERR(MNL_SYM("InvalidInvocation"));
       return move(*this);
@@ -162,11 +174,19 @@ namespace MNL_AUX_UUID { using namespace aux;
    record_descr::record_descr(initializer_list<const char *> il): record_descr([=]()->set<sym>{
       set<sym> res; for (auto el: il) res.insert(el); return res;
    }()) {}
+   int pub::order(const record_descr &lhs, const record_descr &rhs) noexcept {
+      auto mask = MNL_AUX_RAND(uintptr_t);
+      return
+         ((reinterpret_cast<uintptr_t>(&*lhs.rep) ^ mask) < (reinterpret_cast<uintptr_t>(&*rhs.rep) ^ mask)) -
+         ((reinterpret_cast<uintptr_t>(&*rhs.rep) ^ mask) < (reinterpret_cast<uintptr_t>(&*lhs.rep) ^ mask));
+   }
 
    decltype(record_descr::store) record_descr::store;
    MNL_IF_WITH_MT(decltype(record_descr::mutex) record_descr::mutex;)
 
 // Seed Legacy Random Number Generator /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-namespace aux { namespace { MNL_PRIORITY(1000) struct { int _ = (srand(time({})), 0); } _srand; }}
+namespace aux { namespace { MNL_PRIORITY(1000) class { int _ = []()->int{
+   struct ::timespec ts; ::clock_gettime(CLOCK_REALTIME, &ts); return srand(ts.tv_sec ^ (unsigned)ts.tv_nsec / 1000), 0;
+}(); } _srand; }}
 
 } // namespace MNL_AUX_UUID

core-misc.cc

@@ -436,7 +436,7 @@ namespace aux {
             return !test<>(argv[1]);
          case sym::op_order:
             if (MNL_UNLIKELY(argc != 2)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-            if (MNL_UNLIKELY(!test<>(argv[1]))) MNL_ERR(MNL_SYM("TypeMismatch"));
+            if (MNL_UNLIKELY(!test<>(argv[1]))) return argv[0].default_order(argv[1]);
             return 0;
          case sym::op_clone: case sym::op_deep_clone:
             if (MNL_UNLIKELY(argc != 1)) MNL_ERR(MNL_SYM("InvalidInvocation"));
@@ -512,7 +512,7 @@ namespace aux {
             return cast<long long>(argv[0]) >= cast<long long>(argv[1]);
          case sym::op_order:
             if (MNL_UNLIKELY(argc != 2)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-            if (MNL_UNLIKELY(!test<long long>(argv[1]))) MNL_ERR(MNL_SYM("TypeMismatch"));
+            if (MNL_UNLIKELY(!test<long long>(argv[1]))) return argv[0].default_order(argv[1]);
             return (cast<long long>(argv[0]) > cast<long long>(argv[1])) - (cast<long long>(argv[0]) < cast<long long>(argv[1]));
          case sym::op_abs:
             if (MNL_UNLIKELY(argc != 1)) MNL_ERR(MNL_SYM("InvalidInvocation"));
@@ -580,7 +580,7 @@ namespace aux {
             return cast<DAT>(argv[0]) >= cast<DAT>(argv[1]); \
          case sym::op_order: \
             if (MNL_UNLIKELY(argc != 2)) MNL_ERR(MNL_SYM("InvalidInvocation")); \
-            if (MNL_UNLIKELY(!test<DAT>(argv[1]))) MNL_ERR(MNL_SYM("TypeMismatch")); \
+            if (MNL_UNLIKELY(!test<DAT>(argv[1]))) return argv[0].default_order(argv[1]); \
             return signbit(cast<DAT>(argv[0])) ^ signbit(cast<DAT>(argv[1])) ? signbit(cast<DAT>(argv[1])) - signbit(cast<DAT>(argv[0])) : \
                cast<DAT>(argv[0]) < cast<DAT>(argv[1]) ? -1 : cast<DAT>(argv[0]) != cast<DAT>(argv[1]); \
          case sym::op_abs: \
@@ -724,7 +724,7 @@ namespace aux {
             return !MNL_LIKELY(test<sym>(argv[1])) || cast<const sym &>(argv[0]) != cast<const sym &>(argv[1]);
          case sym::op_order:
             if (MNL_UNLIKELY(argc != 2)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-            if (MNL_UNLIKELY(!test<sym>(argv[1]))) MNL_ERR(MNL_SYM("TypeMismatch"));
+            if (MNL_UNLIKELY(!test<sym>(argv[1]))) return argv[0].default_order(argv[1]);
             return (cast<sym>(argv[0]) > cast<sym>(argv[1])) - (cast<sym>(argv[0]) < cast<sym>(argv[1]));
          case sym::op_apply:
             return cast<const sym &>(argv[0])(argc - 1, argv + 1, argv_out + !!argv_out);
@@ -746,7 +746,7 @@ namespace aux {
             return argv[1].rep.tag() != 0x7FFEu;
          case sym::op_order:
             if (MNL_UNLIKELY(argc != 2)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-            if (MNL_UNLIKELY(!test<bool>(argv[1]))) MNL_ERR(MNL_SYM("TypeMismatch"));
+            if (MNL_UNLIKELY(!test<bool>(argv[1]))) return argv[0].default_order(argv[1]);
             return +-cast<bool>(argv[1]);
          case sym::op_or:
          case sym::op_xor:
@@ -778,7 +778,7 @@ namespace aux {
             return argv[1].rep.tag() != 0x7FFFu;
          case sym::op_order:
             if (MNL_UNLIKELY(argc != 2)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-            if (MNL_UNLIKELY(!test<bool>(argv[1]))) MNL_ERR(MNL_SYM("TypeMismatch"));
+            if (MNL_UNLIKELY(!test<bool>(argv[1]))) return argv[0].default_order(argv[1]);
             return +!cast<bool>(argv[1]);
          case sym::op_and:
             if (MNL_UNLIKELY(argc != 2)) MNL_ERR(MNL_SYM("InvalidInvocation"));
@@ -854,7 +854,7 @@ namespace aux {
             return cast<unsigned>(argv[0]) >= cast<unsigned>(argv[1]);
          case sym::op_order:
             if (MNL_UNLIKELY(argc != 2)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-            if (MNL_UNLIKELY(!test<unsigned>(argv[1]))) MNL_ERR(MNL_SYM("TypeMismatch"));
+            if (MNL_UNLIKELY(!test<unsigned>(argv[1]))) return argv[0].default_order(argv[1]);
             return (cast<unsigned>(argv[0]) > cast<unsigned>(argv[1])) - (cast<unsigned>(argv[0]) < cast<unsigned>(argv[1]));
          case sym::op_abs:
             if (MNL_UNLIKELY(argc != 1)) MNL_ERR(MNL_SYM("InvalidInvocation"));
@@ -1225,7 +1225,7 @@ namespace aux {
          return !MNL_LIKELY(test<string>(argv[0])) || (MNL_IF_WITH_IDENT_OPT(&dat != &cast<const string &>(argv[0]) &&) dat != cast<const string &>(argv[0]));
       case sym::op_order:
          if (MNL_UNLIKELY(argc != 1)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-         if (MNL_UNLIKELY(!test<string>(argv[0]))) MNL_ERR(MNL_SYM("TypeMismatch"));
+         if (MNL_UNLIKELY(!test<string>(argv[0]))) return self.default_order(argv[0]);
          MNL_IF_WITH_IDENT_OPT(if (&dat == &cast<const string &>(argv[0])) return 0;)
          for (auto lhs = dat.cbegin(), rhs = cast<const string &>(argv[0]).begin();; ++lhs, ++rhs) {
             if (MNL_UNLIKELY(lhs == dat.cend())) return -(rhs != cast<const string &>(argv[0]).end());
@@ -1416,7 +1416,7 @@ namespace aux {
          }
       case sym::op_order:
          if (MNL_UNLIKELY(argc != 1)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-         if (MNL_UNLIKELY(!test<vector<val>>(argv[0]))) MNL_ERR(MNL_SYM("TypeMismatch"));
+         if (MNL_UNLIKELY(!test<vector<val>>(argv[0]))) return self.default_order(argv[0]);
          MNL_IF_WITH_IDENT_OPT(if (&dat == &cast<const vector<val> &>(argv[0])) return 0;)
          for (auto lhs = dat.cbegin(), rhs = cast<const vector<val> &>(argv[0]).begin();; ++lhs, ++rhs) {
             if (MNL_UNLIKELY(lhs == dat.cend())) return -(rhs != cast<const vector<val> &>(argv[0]).end());
@@ -1554,8 +1554,9 @@ namespace aux {
          return false;
       case sym::op_order:
          if (MNL_UNLIKELY(argc != 1)) MNL_ERR(MNL_SYM("InvalidInvocation"));
-         if (MNL_UNLIKELY(!test<_record>(argv[0])) || MNL_UNLIKELY(descr != cast<const _record &>(argv[0]).descr)) MNL_ERR(MNL_SYM("TypeMismatch"));
+         if (MNL_UNLIKELY(!test<_record>(argv[0]))) return self.default_order(argv[0]);
          MNL_IF_WITH_IDENT_OPT(if (this == &cast<const _record &>(argv[0])) return 0;)
+         { int res = order(descr, cast<const _record &>(argv[0]).descr); if (MNL_UNLIKELY(res)) return res; }
          for (auto lhs = begin(const_cast<const _record *>(this)->items), rhs = begin(cast<const _record &>(argv[0]).items); lhs != end(items); ++lhs, ++rhs)
             { auto res = safe_cast<long long>(op(args<2>{*lhs, *rhs})); if (MNL_UNLIKELY(res)) return res; }
          return 0;