doc/spec/news.mdk

@@ -1,6 +1,10 @@
 ~ begin news
 News:
 
+* 2024-02-14: Koka v3.1.0 released with a concurrent build system
+  and improved language service over the stdio protocol. Redesign of named effect
+  typing to match the formal system more closely. See `samples/handlers/named` for examples.
+
 * 2024-01-25: Koka v3.0.4 released with improved VS Code hover and inlay information.
   Splits `std/core` in multiple modules, fixes bug in infinite expansion for implicits
   and various other small improvements.

kklib/src/init.c

@@ -174,26 +174,26 @@ static void kklib_init(void) {
   if (process_initialized) return;
   process_initialized = true;
   // for Koka, we need to be fully deterministic and careful when using C functionality that depends on global variables
-  setlocale(LC_ALL, "C.utf8"); 
+  setlocale(LC_ALL, "C.utf8");
 #if defined(WIN32) && (defined(_CONSOLE) || defined(__MINGW32__))
   SetConsoleOutputCP(65001);   // set the console to utf-8 instead of OEM page
 #endif
   kk_cpu_init();
-  atexit(&kklib_done);  
+  atexit(&kklib_done);
 
   #if KK_USE_MEM_ARENA
     #if (KK_INTB_SIZE==4)
     const kk_ssize_t heap_size = kk_shlp(KK_IZ(1), KK_INTB_BITS + KK_BOX_PTR_SHIFT);  // 16GiB
     #elif KK_CHERI && (KK_INTB_SIZE==8)
     const kk_ssize_t heap_size = 128 * KK_GiB;  // todo: parameterize?
-    #else 
+    #else
     #error "define heap initialization for compressed pointers on this platform"
     #endif
     int err = mi_reserve_os_memory_ex(heap_size, false /* commit */, true /* allow large */, true /*exclusive*/, &arena);
     if (err != 0) {
       kk_fatal_error(err, "unable to reserve the initial heap of %zi bytes", heap_size);
     }
-    arena_start = mi_arena_area(arena, &arena_size);    
+    arena_start = mi_arena_area(arena, &arena_size);
   #endif
 }
 
@@ -209,7 +209,7 @@ bool kk_has_bmi1 = false;
 bool kk_has_bmi2 = false;
 bool kk_has_clmul = false;
 
-#if defined(__GNUC__) 
+#if defined(__GNUC__)
 #include <cpuid.h>
 
 static inline bool kk_cpuid(uint32_t* regs4, uint32_t level) {
@@ -234,7 +234,7 @@ static inline int kk_cpuid(uint32_t* regs4, uint32_t level) {
 
 #endif
 
-static void kk_cpu_init(void) 
+static void kk_cpu_init(void)
 {
   //todo: do we need to set the IEEE floating point flags?
   //fexcept_t fexn;
@@ -266,24 +266,24 @@ static void kk_cpu_init(void)
 // The thread local context; usually passed explicitly for efficiency.
 static kk_decl_thread kk_context_t* context;
 
-static struct { kk_block_t _block; kk_integer_t cfc; } kk_evv_empty_static = {
-  { KK_HEADER_STATIC(1,KK_TAG_EVV_VECTOR) }, { ((~KK_UB(0))^0x02) /*==-1 smallint*/}
+static struct { kk_block_t _block; /* kk_integer_t cfc; */ } kk_evv_empty_static = {
+  { KK_HEADER_STATIC(0,KK_TAG_EVV_VECTOR) }  // , { ((~KK_UB(0))^0x02) /*==-1 smallint*/}
 };
 
 struct kk_evv_s {
   kk_block_t _block;
-  kk_integer_t cfc;
+  // kk_integer_t cfc;
 };
 
 kk_datatype_ptr_t kk_evv_empty_singleton(kk_context_t* ctx) {
   static struct kk_evv_s* evv = NULL;
   if (evv == NULL) {
-    evv = kk_block_alloc_as(struct kk_evv_s, 1, KK_TAG_EVV_VECTOR, ctx);
-    evv->cfc = kk_integer_from_small(-1);
+    evv = kk_block_alloc_as(struct kk_evv_s, 0, KK_TAG_EVV_VECTOR, ctx);
+    // evv->cfc = kk_integer_from_small(-1);
   }
   kk_base_type_dup_as(struct kk_evv_s*, evv);
   return kk_datatype_from_base(evv, ctx);
-} 
+}
 
 
 // Get the thread local context (also initializes on demand)
@@ -314,7 +314,7 @@ kk_context_t* kk_get_context(void) {
   ctx->thread_id = (size_t)(&context);
   ctx->unique = kk_integer_one;
   context = ctx;
-  struct kk_box_any_s* boxany = kk_block_alloc_as(struct kk_box_any_s, 0, KK_TAG_BOX_ANY, ctx);  
+  struct kk_box_any_s* boxany = kk_block_alloc_as(struct kk_box_any_s, 0, KK_TAG_BOX_ANY, ctx);
   boxany->_unused = kk_integer_zero;
   ctx->kk_box_any = kk_datatype_from_base(boxany, ctx);
   ctx->evv = kk_evv_empty_singleton(ctx);
@@ -379,9 +379,9 @@ kk_decl_export void  kk_main_end(kk_context_t* ctx) {
     size_t page_reclaim;
     size_t peak_commit;
     kk_process_info(&user_time, &sys_time, &peak_rss, &page_faults, &page_reclaim, &peak_commit);
-    kk_info_message("elapsed: %" PRId64 ".%03lds, user: %ld.%03lds, sys : %ld.%03lds, rss : %lu%s\n", 
-                    wall_time.seconds, (long)(wall_time.attoseconds / (KK_I64(1000000) * KK_I64(1000000000))), 
-                    user_time/1000, user_time%1000, sys_time/1000, sys_time%1000, 
+    kk_info_message("elapsed: %" PRId64 ".%03lds, user: %ld.%03lds, sys : %ld.%03lds, rss : %lu%s\n",
+                    wall_time.seconds, (long)(wall_time.attoseconds / (KK_I64(1000000) * KK_I64(1000000000))),
+                    user_time/1000, user_time%1000, sys_time/1000, sys_time%1000,
                     (peak_rss > 10*1024*1024 ? peak_rss/(1024*1024) : peak_rss/1024),
                     (peak_rss > 10*1024*1024 ? "mb" : "kb") );
   }

koka.cabal

@@ -5,7 +5,7 @@ cabal-version: 1.12
 -- see: https://github.com/sol/hpack
 
 name:           koka
-version:        3.0.5
+version:        3.1.1
 description:    Please see the README on GitHub at <https://github.com/koka-lang/koka#readme>
 homepage:       https://github.com/koka-lang/koka#readme
 bug-reports:    https://github.com/koka-lang/koka/issues
@@ -138,7 +138,7 @@ library
       CPP
       OverloadedStrings
   ghc-options: -j8 -O2
-  cpp-options: -DKOKA_MAIN="koka" -DKOKA_VARIANT="release" -DKOKA_VERSION="3.0.5" -DREADLINE=0
+  cpp-options: -DKOKA_MAIN="koka" -DKOKA_VARIANT="release" -DKOKA_VERSION="3.1.1" -DREADLINE=0
   include-dirs:
       src/Platform/cpp/Platform
   c-sources:

lib/std/core.kk

@@ -127,10 +127,6 @@ pub fun repeat( ^n : int, action : () -> e () ) : e ()
   for(n) fn(i)
     action()
 
-// Executes `action` `n` times for each integer from `0` to `n-1`.
-// If `n <= 0`  the function returns without any call to `action` .
-pub fun for( ^n : int, action : (int) -> e () ) : e ()
-  for(0, n - 1, action)
 
 // Executes `action`  for each integer from `start` to `end` (including `end` ).
 // If `start > end`  the function returns without any call to `action` .
@@ -141,12 +137,11 @@ pub fun range/for( ^start: int, end : int, action : (int) -> e () ) : e ()
       rep(pretend-decreasing(i.inc))
   rep(start)
 
+// Executes `action` `n` times for each integer from `0` to `n-1`.
+// If `n <= 0`  the function returns without any call to `action` .
+pub fun for( ^n : int, action : (int) -> e () ) : e ()
+  range/for(0, n - 1, action)
 
-// Executes `action`  for each integer between `start`  to `end`  (including `end` ).
-// If `start > end`  the function returns without any call to `action` .
-// If `action` returns `Just`, the iteration is stopped and the result returned
-pub fun for-while( n : int, action : (int) -> e maybe<a> ) : e maybe<a>
-  for-while(0, n - 1, action)
 
 // Executes `action`  for each integer between `start`  to `end`  (including `end` ).
 // If `start > end`  the function returns without any call to `action` .
@@ -160,23 +155,35 @@ pub fun range/for-while( start: int, end : int, action : (int) -> e maybe<a> ) :
     else Nothing
   rep(start)
 
+// Executes `action`  for each integer between [0,`n`)  (excluding `n` ).
+// If `n <= 0`  the function returns without any call to `action` .
+// If `action` returns `Just`, the iteration is stopped and the result returned
+pub fun for-while( n : int, action : (int) -> e maybe<a> ) : e maybe<a>
+  range/for-while(0, n - 1, action)
+
+
 // Fold over the integers between [`start`,`end`] (including `end`).
 pub fun range/fold( start : int, end : int, init : a, f : (int,a) -> e a ) : e a
-  if start >= end then init else
+  if start > end then init else
     val x = f(start,init)
     fold(pretend-decreasing(start.inc), end, x, f)
 
 // Fold over the integers between [0,`upto`)  (excluding `upto`).
 pub fun fold( upto : int, init : a, f : (int,a) -> e a ) : e a
-  fold( 0, upto.dec, init, f )
+  range/fold( 0, upto.dec, init, f )
 
-// Fold over the integers between [`start``,`end`] (including `end`) or until `f` returns `Nothing`
+
+// Fold over the integers between [`start`,`end`] (including `end`) or until `f` returns `Nothing`
 pub fun range/fold-while( start : int, end : int, init : a, f : (int,a) -> e maybe<a> ) : e a
-  if start >= end then init else
+  if start > end then init else
     match f(start,init)
-      Just(x) -> fold-while(pretend-decreasing(start.inc), end, x, f)
+      Just(x) -> range/fold-while(pretend-decreasing(start.inc), end, x, f)
       Nothing -> init
 
+// Fold over the integers between [0,`n`) (excluding `n`) or until `f` returns `Nothing`
+pub fun fold-while( n : int, init : a, f : (int,a) -> e maybe<a> ) : e a
+  range/fold-while( 0, n.dec, init, f )
+
 
 // ----------------------------------------------------------------------------
 // Generic equality and comparison

lib/std/core/debug.kk

@@ -13,6 +13,7 @@ import std/core/types
 import std/core/unsafe
 import std/core/hnd
 import std/core/string
+import std/core/console
 
 extern import
   c file "inline/debug.c"
@@ -40,12 +41,12 @@ pub fun file/kk-file-line( ?kk-file, ?kk-line )
 extern xtrace : ( message : string ) -> ()
   c  "kk_trace"
   cs "Primitive.Trace"
-  js "_trace"
+  js "$std_core_console._trace"
 
 extern xtrace-any : forall<a> ( message: string, x : a ) -> ()
   c  "kk_trace_any"
   cs "Primitive.TraceAny"
-  js "_trace_any"
+  js "$std_core_console._trace_any"
 
 val trace-enabled : ref<global,bool> = unsafe-total{ ref(True) }