improve test_snip

Author: jcupitt

TODO

@@ -1,3 +1,43 @@
+- not as lazy as they could be:
+
+	print
+	++
+
+  both seemt to be strict, so eg. "join_sep ", " (map print primes)" never
+  returns, "print primes" never returns
+
+- finish new test_snip.def
+
+- add multiple definitions, finish function argument destructuring
+
+	sym has a field for "next definition", initially NULL
+
+`	add_defining looks for an existing sym with this name, if it finds
+	one, add a new sym called "{name}-$$4" or whatever
+
+	chase to the end of "next definition" on the existing sym, append our
+	new sym
+
+	during compile, generate code like
+
+		fred a b c
+			= destructured_fred, args_match
+			= fred-$$1 a b c
+		{
+			destructured_fred = rhs of fred
+			args_match = a_matches && b_matches && c_matches
+		}
+
+	if a func has many RHS and the last RHS uses destrucuring, generate a
+	final def with
+
+		fred a b c
+			= error "no def of fred matches args a b c";
+
+	- error if more than one def of fred has no destructuring
+	- error if defs don't all have the same number of args
+	- error if a def with no destructuring isn't the last def
+
 - try < > in the image titlebar
 
     seems to get stuck on eg. mp3 files

share/nip4/start/_list.def

@@ -44,7 +44,7 @@ difference = foldl @ converse @ delete;
  * drop 3 "abcd" == "d"
  * drop :: num -> [*] -> [*]
  */
-drop n l 
+drop n l
 	= l, n <= 0 || l == []
 	= drop (n - 1) (tl l);
 
@@ -93,11 +93,11 @@ flatten x
 
 /* foldl fn st l: fold list l from the left with function fn and start st
  *
- * Start from the left hand end of the list (unlike foldr, see below). 
+ * Start from the left hand end of the list (unlike foldr, see below).
  * foldl is less useful (and much slower).
  *
  * foldl fn start [a,b .. z] = ((((st fn a) fn b) ..) fn z)
- * foldl :: (* -> ** -> *) -> * -> [**] -> * 
+ * foldl :: (* -> ** -> *) -> * -> [**] -> *
  */
 foldl fn st l
 	= st, l == []
@@ -221,15 +221,15 @@ len l
  * limit :: [*] -> *
  */
 limit l
-	= error "incorrect use of limit", 
+	= error "incorrect use of limit",
 		l == [] || tl l == [] || tl (tl l) == []
 	= a, a == b
 	= limit (b : x)
 {
 	a:b:x = l;
 }
 
-/* Turn a function of n args into a function which takes a single arg of an 
+/* Turn a function of n args into a function which takes a single arg of an
  * n-element list.
  */
 list_1ary fn x = fn x?0;
@@ -248,13 +248,13 @@ map f l
 	= [], l == [];
 	= f (hd l) : map f (tl l);
 
-/* map2 fn l1 l2: map two lists together with fn 
+/* map2 fn l1 l2: map two lists together with fn
  *
  * map2 :: (* -> ** -> ***) -> [*] -> [**] -> [***]
  */
 map2 fn l1 l2 = map (list_2ary fn) (zip2 l1 l2);
 
-/* map3 fn l1 l2 l3: map three lists together with fn 
+/* map3 fn l1 l2 l3: map three lists together with fn
  *
  * map3 :: (* -> ** -> *** -> ****) -> [*] -> [**] -> [***] -> [****]
  */
@@ -348,7 +348,7 @@ sortc comp l
 	n = len l;
 	n2 = (int) (n / 2);
 
-	/* merge l1 l2: merge sorted lists l1 and l2 to make a single 
+	/* merge l1 l2: merge sorted lists l1 and l2 to make a single
 	 * sorted list
 	 */
 	merge l1 l2
@@ -397,38 +397,38 @@ sortr l = sortc more l;
 split fn l
         = [], l == [] || l' == []
         = head : split fn tail
-{ 
+{
         nfn = not @ fn;
 
         l' = dropwhile fn l;
         head = takewhile nfn l';
         tail = dropwhile nfn l';
-}   
+}
 
 /* splits fn l: break a list into sections separated by a single fn
  *
  * split (equal ',') ",,1" == ["", "", "1"]
  * split :: (* -> bool) -> [*] -> [[*]]
  */
 splits fn l
-        = [], l == [] 
+        = [], l == []
         = head : splits fn tail
-{ 
+{
         fn' = not @ fn;
-	dropif x 
+	dropif x
 		= [], x == []
 		= tl x;
 
         head = takewhile fn' l;
         tail = dropif (dropwhile fn' l);
-}   
+}
 
 /* splitpl fnl l: split a list up with a list of predicates
  *
  * splitpl [is_digit, is_letter, is_digit] "123cat" == ["123", "cat", []]
  * splitpl :: [* -> bool] -> [*] -> [[*]]
  */
-splitpl fnl l 
+splitpl fnl l
         = l, fnl == []
         = head : splitpl (tl fnl) tail
 {
@@ -448,7 +448,7 @@ split_lines n l
 /* take n l: take the first n elements from list l
  * take :: num -> [*] -> [*]
  */
-take n l 
+take n l
 	= [], n <= 0
 	= [], l == []
 	= hd l : take (n-1) (tl l);
@@ -463,7 +463,7 @@ takewhile fn l
 	= hd l : takewhile fn (tl l), fn (hd l)
 	= [];
 
-/* zip2 l1 l2: zip two lists together 
+/* zip2 l1 l2: zip two lists together
  *
  * zip2 [1,2] ['a', 'b', 'c'] == [[1,'a'],[2,'b']]
  * zip2 :: [*] -> [**] -> [[*,**]]

src/heap.c

@@ -2698,6 +2698,9 @@ shell_pelement(Reduce *rc, PElement *base)
 		g_assert(FALSE);
 	}
 
+	// print output as we go
+	fflush(stdout);
+
 	return TRUE;
 }
 

test/workspaces/test_snip.def

@@ -35,7 +35,8 @@ test_unary op_name fn
         ]);
         image = (to_real @ fn @ ifmt @ to_image) x;
         number = (to_real @ fn @ nfmt) x;
-        matrix = (to_real @ fn @ ifmt @ to_matrix) x;
+        //matrix = (to_real @ fn @ ifmt @ to_matrix) x;
+        matrix = image;
     }
 }
 
@@ -53,11 +54,12 @@ test_binary op_name fn
         ]);
         image = to_real (fn ((ifmt @ to_image) x) ((ifmt @ to_image) y));
         number = to_real (fn (nfmt x) (nfmt y));
-        matrix = to_real (fn ((ifmt @ to_matrix) x) ((ifmt @ to_matrix) y));
+        //matrix = to_real (fn ((ifmt @ to_matrix) x) ((ifmt @ to_matrix) y));
+        matrix = image;
     }
 }
 
-tests = [
+tests = concat [
     test_binary "add" add,
     test_binary "subtract" subtract,
     test_binary "multiply" multiply,
@@ -70,8 +72,10 @@ tests = [
     test_unary "constant multiplied by" (converse multiply 7),
     test_unary "constant subtracted from" (subtract 4),
     test_unary "subtract constant" (converse subtract 4),
-    ["" ++ "a" == "a", "concat"],
-    [hd [1, error "nope"] == 1, "lazy hd"]
+    [
+        ["" ++ "a" == "a", "concat"],
+        [hd [1, error "nope"] == 1, "lazy hd"]
+    ]
 ]
 {
     // libvips divide returns 0 for divide by zero
@@ -82,9 +86,28 @@ tests = [
 }
 
 main
-    = concat (map print_result tests) ++ "\n"
+    = [
+        map (const '.') pass,
+        map print_fail fail,
+        "\n"
+    ]
 {
-    print_result result
-        = ".", result?0
-        = error result?1;
+    split fn l
+        = foldr split_item [[], []] l
+    {
+        split_item x sofar
+            = [pass', fail']
+        {
+            [pass, fail] = sofar;
+            pass'
+                = x : pass, fn x
+                = pass;
+            fail'
+                = x : fail, !fn x
+                = fail;
+        }
+    }
+
+    [pass, fail] = split (extract 0) tests;
+    print_fail x = "FAIL: " ++ x?1;
 }