Modified the not-yet-documented stc/views.h

Renamed listview => clview

clview_literal(), and crange_literal() creates
compound literal objects.

4 files changed, 40 insertions, 29 deletions

diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index e9a66df8..3a97361e 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -263,16 +263,16 @@ Note that `c_flt_take()` is given as an optional argument, which makes the loop
 ### crange
 **crange** is a number sequence generator type. The **crange_value** type is `long long`. Below, *start*, *stop*, *step* are type *crange_value*:
 ```c
-crange      crange_init(stop);              // will generate 0, 1, ..., stop-1
-crange      crange_init(start, stop);       // will generate start, start+1, ... stop-1
-crange      crange_init(start, stop, step); // will generate start, start+step, ... upto-not-including stop
+crange      crange_make(stop);              // will generate 0, 1, ..., stop-1
+crange      crange_make(start, stop);       // will generate start, start+1, ... stop-1
+crange      crange_make(start, stop, step); // will generate start, start+step, ... upto-not-including stop
                                             // note that step may be negative.
 crange_iter crange_begin(crange* self);
 crange_iter crange_end(crange* self);
 void        crange_next(crange_iter* it);
 
 // 1. All primes less than 32:
-crange r1 = crange_init(3, 32, 2);
+crange r1 = crange_make(3, 32, 2);
 printf("2"); // first prime
 c_forfilter (i, crange, r1 
               , isPrime(*i.ref))
@@ -280,9 +280,8 @@ c_forfilter (i, crange, r1
 // 2 3 5 7 11 13 17 19 23 29 31
 
 // 2. The 11 first primes:
-crange r2 = crange_init(3, crange_MAX, 2);
 printf("2");
-c_forfilter (i, crange, r2 
+c_forfilter (i, crange, crange_literal(3, crange_MAX, 2) 
               , isPrime(*i.ref)
               , c_flt_take(10))
     printf(" %lld", *i.ref);
diff --git a/examples/forfilter.c b/examples/forfilter.c
index cc7c3478..9079d88e 100644
--- a/examples/forfilter.c
+++ b/examples/forfilter.c
@@ -60,7 +60,7 @@ fn main() {
 void demo2(void)
 {
     c_auto (IVec, vector) {
-        crange rv = crange_init(crange_MAX);
+        crange rv = crange_make(crange_MAX);
         c_forfilter (x, crange, rv
                       , flt_isOdd(x)
                      && c_flt_skipwhile(x, *x.ref != 11)
@@ -123,7 +123,7 @@ void demo5(void)
     #define flt_even(i) ((*i.ref & 1) == 0)
     #define flt_mid_decade(i) ((*i.ref % 10) != 0)
     puts("demo5:");
-    crange r1 = crange_init(1963, crange_MAX);
+    crange r1 = crange_make(1963, crange_MAX);
     c_forfilter (i, crange, r1
                   , c_flt_skip(i,15)
                  && c_flt_skipwhile(i, flt_mid_decade(i))
diff --git a/examples/prime.c b/examples/prime.c
index 8f883f14..287fb69b 100644
--- a/examples/prime.c
+++ b/examples/prime.c
@@ -41,7 +41,7 @@ int main(void)
         puts("");
 
         puts("Show the last 50 primes using a temporary crange generator:");
-        c_forfilter (i, crange, c_range(n - 1, 0, -2)
+        c_forfilter (i, crange, crange_literal(n - 1, 0, -2)
                       , cbits_test(&primes, *i.ref>>1)
                       , c_flt_take(i, 50)) {
             printf("%lld ", *i.ref);
diff --git a/include/stc/views.h b/include/stc/views.h
index 31aaba0d..7ac50957 100644
--- a/include/stc/views.h
+++ b/include/stc/views.h
@@ -23,27 +23,38 @@
 /* 
 #include <stdio.h>
 #include <stc/views.h>
-using_listview(IView, int);
+using_clview(IView, int);
 
 int main()
 {
     int array[] = {1, 2, 3, 4, 5};
-    IView iv = IView_init(array, c_arraylen(array));
+    IView iv = {array, c_arraylen(array)};
     
-    c_foreach (i, IView, iv) printf(" %d", *i.ref);
+    c_foreach (i, IView, iv)
+        printf(" %d", *i.ref);
     puts("");
-
-    c_forfilter (i, IView, c_listview(IView, {10, 20, 30, 22, 23})
+    
+    // use a temporary IView object.
+    c_forfilter (i, IView, clview_literal(IView, {10, 20, 30, 23, 22, 21})
                   , c_flt_skipwhile(i, *i.ref < 25)
-                  , c_flt_take(i, 2))
+                 && (*i.ref & 1) == 0 // even only
+                  , c_flt_take(i, 2)) // break after 2
         printf(" %d", *i.ref);
     puts("");
 
-    crange r1 = crange_init(80, 90);
-    c_foreach (i, crange, r1) printf(" %lld", *i.ref);
+    // crange:
+
+    crange r1 = crange_make(80, 90);
+    c_foreach (i, crange, r1)
+        printf(" %lld", *i.ref);
     puts("");
 
-    c_foreach (i, crange, c_range(0, 100, 8)) printf(" %lld", *i.ref);
+    // use a temporary crange object.
+    int a = 100, b = INT32_MAX;
+    c_forfilter (i, crange, crange_literal(a, b, 8)
+                  , i.index > 10
+                  , c_flt_take(i, 3))
+        printf(" %lld", *i.ref);
     puts("");
 }
 */
@@ -52,18 +63,17 @@ int main()
 
 #include <stc/ccommon.h>
 
-#define c_listview(C, ...) \
+// clview type
+
+#define clview_literal(C, ...) \
     ((C){.data = (C##_value[])__VA_ARGS__, \
          .size = sizeof((C##_value[])__VA_ARGS__)/sizeof(C##_value)})
 
-#define using_listview(Self, T) \
+#define using_clview(Self, T) \
 typedef T Self##_raw; typedef const Self##_raw Self##_value; \
 typedef struct { Self##_value *data; size_t size; } Self; \
 typedef struct { Self##_value *ref, *end; } Self##_iter; \
  \
-STC_INLINE Self Self##_init(Self##_value* data, size_t size) \
-    { Self me = {.data=data, .size=size}; return me; } \
- \
 STC_INLINE Self##_value* Self##_at(const Self* self, size_t idx) \
     { assert(idx < self->size); return self->data + idx; } \
  \
@@ -82,19 +92,21 @@ STC_INLINE void Self##_next(Self##_iter* it) \
 struct stc_nostruct
 
 
-#define c_range(...) \
-    (*(crange[]){crange_init(__VA_ARGS__)})
+// crange type
+
+#define crange_literal(...) \
+    (*(crange[]){crange_make(__VA_ARGS__)})
 #define crange_MAX INT64_MAX
 
 typedef long long crange_value;
 typedef struct { crange_value start, end, step, value; } crange;
 typedef struct { crange_value *ref, end, step; } crange_iter;
 
-#define crange_init(...) c_MACRO_OVERLOAD(crange_init, __VA_ARGS__)
-#define crange_init1(stop) crange_init3(0, stop, 1)
-#define crange_init2(start, stop) crange_init3(start, stop, 1)
+#define crange_make(...) c_MACRO_OVERLOAD(crange_make, __VA_ARGS__)
+#define crange_make1(stop) crange_make3(0, stop, 1)
+#define crange_make2(start, stop) crange_make3(start, stop, 1)
 
-STC_INLINE crange crange_init3(crange_value start, crange_value stop, crange_value step)
+STC_INLINE crange crange_make3(crange_value start, crange_value stop, crange_value step)
     { crange r = {start, stop - (step > 0), step}; return r; }
 
 STC_INLINE crange_iter crange_begin(crange* self)