Merge commit '1b64651a9a0c19201cba9c8e993f9760e490289b'

lispBM/lispBM/doc/lbmref.dox

@@ -88,48 +88,53 @@ Compute 5 % 3, evaluates to 2.
 \section sec_comp Comparisons
 
 
-<a name="="> <h3>=</h3> </a>
+<a name="eq"> <h3>eq</h3> </a>
 
-Compare expressions for equality. The = implements structural equality.
-The for of an = expression is <code>(= expr1 ... exprN)</code>
+Compare expressions for equality. The eq implements structural equality.
+The form of an eq expression is <code>(eq expr1 ... exprN)</code>
 
 \note
 Compare the result of <code>(+ 1 2)</code> with 3. The
 result of this comparison is <code>t</code>.
 \code
-(= (+ 1 2) 3)
+(eq (+ 1 2) 3)
 \endcode
 Multiple expressions can be checked at once. The examples below evaluates to
 <code>t</code>
 \code
-(= 1 1 1 1)
+(eq 1 1 1 1)
 
-(= (+ 3 4) (+ 2 5) (+ 1 6))
+(eq (+ 3 4) (+ 2 5) (+ 1 6))
 \endcode
 The following examples evaluate to <code>nil</code> representing false.
 \code
-(= 1 1 1 1 2)
+(eq 1 1 1 1 2)
 
-(= (+ 1 2) (+ 0 2) (+ -1 2))
+(eq (+ 1 2) (+ 0 2) (+ -1 2))
 \endcode
 The = comparison can be used on tree shaped data. The following expression evaluates to
 <code>t</code>.
 \code
-(= '(1 (1 2)) '(1 (1 2)))
+(eq '(1 (1 2)) '(1 (1 2)))
 \endcode
 
 
 ---
 
-<a name="num-eq"> <h3>num-eq</h3> </a>
+<a name="#="> <h3>=</h3> </a>
 
-The <code>num-eq</code> operation can only be used on numerical arguments.
-For numerical arguments <code>num-eq</code> behaves like <a href="#=">=</a>.
+The <code>=</code> operation can only be used on numerical arguments.
 If you know you are comparing numbers, it will be more efficient to use
-<code>num-eq</code>.
+<code>=</code>.
+
+An important difference between <code>eq</code> and <code>=</code> is
+that equals compare the numerical values of the arguments. A 3 is a 3
+independent of them being different types. <code>eq</code> on the other
+hands compares the representations of the arguments exactly and they must
+match in structure, type and value to be considered equal. 
 
 \note
-Example of <code>num-eq</code> comparison.
+Example of <code>=</code> comparison.
 \code
 (num-eq (+ 2 3) (+ 1 4))
 \endcode

lispBM/lispBM/src/eval_cps.c

@@ -1189,10 +1189,12 @@ static inline void eval_continuation(eval_context_t *ctx) {
 }
 
 static inline void eval_define(eval_context_t *ctx) {
-  lbm_value key = lbm_car(lbm_cdr(ctx->curr_exp));
-  lbm_value val_exp = lbm_car(lbm_cdr(lbm_cdr(ctx->curr_exp)));
+  lbm_value args = lbm_cdr(ctx->curr_exp);
+  lbm_value key = lbm_car(args);
+  lbm_value rest_args = lbm_cdr(args);
+  lbm_value val_exp = lbm_car(rest_args);
 
-  if (lbm_type_of(key) == LBM_VAL_TYPE_SYMBOL) {
+  if (lbm_is_symbol(key) && lbm_is_symbol_nil(lbm_cdr(rest_args))) {
     lbm_uint sym_val = lbm_dec_sym(key);
 
     if ((sym_val >= VARIABLE_SYMBOLS_START) &&

lispBM/lispBM/src/prelude.lisp

@@ -2,7 +2,7 @@
 (define reverse
   (lambda (xs)
     (let ((revacc (lambda (acc xs)
-		    (if (= nil xs)
+		    (if (eq nil xs)
 			acc
 		      (revacc (cons (car xs) acc) (cdr xs))))))
       (revacc nil xs))))
@@ -16,7 +16,7 @@
 
 (define length (lambda (xs)
 		 (let ((len (lambda (l xs)
-			      (if (= xs nil)
+			      (if (eq xs nil)
 				  l
 				(len (+ l 1) (cdr xs))))))
 		   (len 0 xs))))
@@ -24,43 +24,43 @@
 (define take (lambda (n xs)
 	       (let ((take-tail
 		      (lambda (acc n xs)
-			(if (num-eq n 0)
+			(if (= n 0)
 			    acc
 			  (take-tail (cons (car xs) acc) (- n 1) (cdr xs))))))
 		 (reverse (take-tail nil n xs)))))
 
 (define drop (lambda (n xs)
-	       (if (num-eq n 0)
+	       (if (= n 0)
 		   xs
-		 (if (= xs nil)
+		 (if (eq xs nil)
 		     nil
 		   (drop (- n 1) (cdr xs))))))
 
 (define zip (lambda (xs ys)
-	      (if ( = xs nil)
+	      (if (eq xs nil)
 		  nil
-		(if ( = ys nil)
+		(if (eq ys nil)
 		    nil
 		  (cons (cons (car xs) (car ys)) (zip (cdr xs) (cdr ys)))))))
 
 (define map (lambda (f xs)
-	      (if (= xs nil)
+	      (if (eq xs nil)
 		  nil
 		(cons (f (car xs)) (map f (cdr xs))))))
 
 (define lookup (lambda (x xs)
-		 (if (= xs nil)
+		 (if (eq xs nil)
 		     nil
-		   (if (= (car (car xs)) x)
+		   (if (eq (car (car xs)) x)
 		       (car (cdr (car xs)))
 		     (lookup x (cdr xs))))))
 
 (define foldr (lambda (f i xs)
-		(if (= xs nil)
+		(if (eq xs nil)
 		    i
 		  (f (car xs) (foldr f i (cdr xs))))))
 
 (define foldl (lambda (f i xs)
-		(if (= xs nil)
+		(if (eq xs nil)
 		    i
 		  (foldl f (f i (car xs)) (cdr xs)))))

lispBM/lispBM/src/symrepr.c

@@ -117,7 +117,7 @@ special_sym const special_symbols[NUM_SPECIAL_SYMBOLS] =  {
   {"*"              , SYM_MUL},
   {"/"              , SYM_DIV},
   {"mod"            , SYM_MOD},
-  {"="              , SYM_EQ},
+  {"="              , SYM_NUMEQ},
   {"<"              , SYM_LT},
   {">"              , SYM_GT},
   {"<="             , SYM_LEQ},
@@ -130,7 +130,7 @@ special_sym const special_symbols[NUM_SPECIAL_SYMBOLS] =  {
   {"yield"          , SYM_YIELD},
   {"wait"           , SYM_WAIT},
   {"spawn"          , SYM_SPAWN},
-  {"num-eq"         , SYM_NUMEQ},
+  {"eq"             , SYM_EQ},
   {"car"            , SYM_CAR},
   {"cdr"            , SYM_CDR},
   {"cons"           , SYM_CONS},

lispBM/lispBM/tests/test_arith_2.lisp

@@ -1,2 +1,2 @@
-(num-eq (+ 1 0xf) 16u28)
+(= (+ 1 0xf) 16u28)
 

lispBM/lispBM/tests/test_array_extensions_1.lisp

@@ -11,14 +11,13 @@
 (bufset-u8 arr 8 62)
 (bufset-u8 arr 9 61)
 
-(= (bufget-u8 arr 0) 70u28)
-(and (num-eq (bufget-u8 arr 0) 70)
-     (num-eq (bufget-u8 arr 1) 69)
-     (num-eq (bufget-u8 arr 2) 68)
-     (num-eq (bufget-u8 arr 3) 67)
-     (num-eq (bufget-u8 arr 4) 66)
-     (num-eq (bufget-u8 arr 5) 65)
-     (num-eq (bufget-u8 arr 6) 64)
-     (num-eq (bufget-u8 arr 7) 63)
-     (num-eq (bufget-u8 arr 8) 62)
-     (num-eq (bufget-u8 arr 9) 61))
+(and (= (bufget-u8 arr 0) 70)
+     (= (bufget-u8 arr 1) 69)
+     (= (bufget-u8 arr 2) 68)
+     (= (bufget-u8 arr 3) 67)
+     (= (bufget-u8 arr 4) 66)
+     (= (bufget-u8 arr 5) 65)
+     (= (bufget-u8 arr 6) 64)
+     (= (bufget-u8 arr 7) 63)
+     (= (bufget-u8 arr 8) 62)
+     (= (bufget-u8 arr 9) 61))

lispBM/lispBM/tests/test_array_extensions_2.lisp

@@ -6,9 +6,9 @@
 (bufset-u32 arr 8 10)
 (bufset-u32 arr 12 0xDEADBEEF)
 
-(and (num-eq (bufget-u32 arr 0) 16777215)
-     (num-eq (bufget-u32 arr 4) 0xFFFFFFFF)
-     (num-eq (bufget-u32 arr 8) 10)
-     (num-eq (bufget-u32 arr 12) 0xDEADBEEF))
+(and (= (bufget-u32 arr 0) 16777215)
+     (= (bufget-u32 arr 4) 0xFFFFFFFF)
+     (= (bufget-u32 arr 8) 10)
+     (= (bufget-u32 arr 12) 0xDEADBEEF))
      
      

lispBM/lispBM/tests/test_array_extensions_3.lisp

@@ -5,7 +5,7 @@
 (bufset-i32 arr 8 10)
 (bufset-i32 arr 12 0xDEADBEEF)
 
-(and (num-eq (bufget-i32 arr 0) 16777215)
-     (num-eq (bufget-i32 arr 4) 0xFFFFFFFF)
-     (num-eq (bufget-i32 arr 8) 10)
-     (num-eq (bufget-i32 arr 12) 0xDEADBEEF))
+(and (= (bufget-i32 arr 0) 16777215)
+     (= (bufget-i32 arr 4) 0xFFFFFFFF)
+     (= (bufget-i32 arr 8) 10)
+     (= (bufget-i32 arr 12) 0xDEADBEEF))

lispBM/lispBM/tests/test_array_extensions_4.lisp

@@ -5,7 +5,7 @@
 (bufset-f32 arr 8 100)
 (bufset-f32 arr 12 42)
 
-(and (num-eq (bufget-f32 arr 0) 3.14)
-     (num-eq (bufget-f32 arr 4) 666.666)
-     (num-eq (bufget-f32 arr 8) 100)
-     (num-eq (bufget-f32 arr 12) 42))
+(and (= (bufget-f32 arr 0) 3.14)
+     (= (bufget-f32 arr 4) 666.666)
+     (= (bufget-f32 arr 8) 100)
+     (= (bufget-f32 arr 12) 42))

lispBM/lispBM/tests/test_array_extensions_5.lisp

@@ -3,5 +3,5 @@
 
 (free arr)
 
-(and (= (car arr) nil)
-     (= (cdr arr) nil))
+(and (eq (car arr) nil)
+     (eq (cdr arr) nil))

lispBM/lispBM/tests/test_compare_0.lisp

@@ -1,2 +1,2 @@
-(and (= t (> 1 0))
-     (= nil (< 1 0)))
+(and (eq t (> 1 0))
+     (eq nil (< 1 0)))

lispBM/lispBM/tests/test_compare_1.lisp

@@ -1,2 +1,2 @@
-(and (= t (>= 1 1))
-     (= t (<= 1 1)))
+(and (eq t (>= 1 1))
+     (eq t (<= 1 1)))

lispBM/lispBM/tests/test_compare_2.lisp

@@ -1,2 +1,2 @@
-(and (= t (>= 1 0))
-     (= t (<= 0 1)))
+(and (eq t (>= 1 0))
+     (eq t (<= 0 1)))

lispBM/lispBM/tests/test_compare_3.lisp

@@ -1,2 +1,2 @@
-(and (= nil (>= 0 1))
-     (= nil (<= 1 0)))
+(and (eq nil (>= 0 1))
+     (eq nil (<= 1 0)))

lispBM/lispBM/tests/test_decode_0.lisp

@@ -1,2 +1,2 @@
 
-(= '(0u28 0u28 255u28 255u28) (decode (- 65536 1)))
+(eq '(0u28 0u28 255u28 255u28) (decode (- 65536 1)))

lispBM/lispBM/tests/test_define_1.lisp

@@ -1,3 +1,3 @@
 
-(= (define a 3) 'a)
+(eq (define a 3) 'a)
 

lispBM/lispBM/tests/test_define_2.lisp

@@ -1,3 +1,3 @@
 
-(= 'bepa (define bepa 3) )
+(eq 'bepa (define bepa 3) )
 

lispBM/lispBM/tests/test_eq_0.lisp

@@ -1,3 +1,3 @@
-(= "hello" "hello")
+(eq "hello" "hello")
 
 

lispBM/lispBM/tests/test_eq_1.lisp

@@ -1,3 +1,3 @@
-(= (= "hello" "hell0") nil)
+(eq (eq "hello" "hell0") nil)
 
 

lispBM/lispBM/tests/test_eq_2.lisp

@@ -1,3 +1,3 @@
-(= (= 1 2) nil)
+(eq (= 1 2) nil)
 
 

lispBM/lispBM/tests/test_explicit_gc_0.lisp

@@ -1,11 +1,11 @@
 
 (define f (lambda (x)
-            (if (num-eq x 0)
+            (if (= x 0)
                 'done
               (progn
                 (gc)
                 (f (- x 1))))))
 
 
-(= (f 100) 'done)
+(eq (f 100) 'done)
               

lispBM/lispBM/tests/test_extension_0.lisp

@@ -1 +1 @@
-(= (ext-even 2) t)
+(eq (ext-even 2) t)

lispBM/lispBM/tests/test_extension_1.lisp

@@ -1 +1 @@
-(= (ext-odd 1) t)
+(eq (ext-odd 1) t)

lispBM/lispBM/tests/test_extension_2.lisp

@@ -1 +1 @@
-(= (ext-even 7) nil)
+(eq (ext-even 7) nil)

lispBM/lispBM/tests/test_extension_3.lisp

@@ -1 +1 @@
-(= (ext-odd 6) nil)
+(eq (ext-odd 6) nil)

lispBM/lispBM/tests/test_fold_0.lisp

@@ -1,6 +1,6 @@
 
 (define fold (lambda (f i xs)
-               (if (= xs nil)
+               (if (eq xs nil)
                    i
                    (fold f (f i (car xs)) (cdr xs)))))
 

lispBM/lispBM/tests/test_if_0.lisp

@@ -1,2 +1,2 @@
-(= (if (> 0 1) 'apa 'bepa) 'bepa)
+(eq (if (> 0 1) 'apa 'bepa) 'bepa)
 

lispBM/lispBM/tests/test_if_1.lisp

@@ -1,2 +1,2 @@
-(= (if (< 0 1) 'apa 'bepa) 'apa)
+(eq (if (< 0 1) 'apa 'bepa) 'apa)
 

lispBM/lispBM/tests/test_ix_1.lisp

@@ -1 +1 @@
-(= nil (ix '(1 2) 100000))
+(eq nil (ix '(1 2) 100000))

lispBM/lispBM/tests/test_let_3.lisp

@@ -1,5 +1,5 @@
 (let ((x 0)
       (f (lambda (y) (+ y x)))
       (g (lambda (x) (+ x 1))))
-  (= (list (f 10) (g 10)) '(10 11)))
+  (eq (list (f 10) (g 10)) '(10 11)))
 

lispBM/lispBM/tests/test_list_0.lisp

@@ -1,3 +1,3 @@
 
-(= (list 1 2 3) '(1 2 3))
+(eq (list 1 2 3) '(1 2 3))
 

lispBM/lispBM/tests/test_list_1.lisp

@@ -1,3 +1,3 @@
 
-(= (list 1 2 (+ 1 2) 4) '(1 2 3 4))
+(eq (list 1 2 (+ 1 2) 4) '(1 2 3 4))
 

lispBM/lispBM/tests/test_logic_1.lisp

@@ -1 +1 @@
-(= (and 't 't) 't)
+(eq (and 't 't) 't)

lispBM/lispBM/tests/test_logic_10.lisp

@@ -1 +1 @@
-(= (not (not (not (not t)))) t)
+(eq (not (not (not (not t)))) t)

lispBM/lispBM/tests/test_logic_11.lisp

@@ -1 +1 @@
-(= (not (not (not (not (not t))))) nil)
+(eq (not (not (not (not (not t))))) nil)

lispBM/lispBM/tests/test_logic_2.lisp

@@ -1 +1 @@
-(= (or 't 'nil) 't)
+(eq (or 't 'nil) 't)

lispBM/lispBM/tests/test_logic_3.lisp

@@ -1 +1 @@
-(= (and 'nil 't) 'nil)
+(eq (and 'nil 't) 'nil)

lispBM/lispBM/tests/test_logic_4.lisp

@@ -1 +1 @@
-(= (or 'nil 'nil) 'nil)
+(eq (or 'nil 'nil) 'nil)

lispBM/lispBM/tests/test_logic_7.lisp

@@ -1 +1 @@
-(= (not (and 1 2 3)) nil)
+(eq (not (and 1 2 3)) nil)

lispBM/lispBM/tests/test_logic_8.lisp

@@ -1 +1 @@
-(= (not nil) t)
+(eq (not nil) t)

lispBM/lispBM/tests/test_logic_9.lisp

@@ -1 +1 @@
-(= (not t) nil)
+(eq (not t) nil)

lispBM/lispBM/tests/test_map_0.lisp

@@ -1,4 +1,4 @@
-(define map (lambda (f xs) (if (= xs nil) nil (cons (f (car xs)) (map f (cdr xs))))))
+(define map (lambda (f xs) (if (eq xs nil) nil (cons (f (car xs)) (map f (cdr xs))))))
 
-(= (map (lambda (x) (+ x 1)) (list 1 2 3 4 5)) (list 2 3 4 5 6))
+(eq (map (lambda (x) (+ x 1)) (list 1 2 3 4 5)) (list 2 3 4 5 6))
 

lispBM/lispBM/tests/test_map_1.lisp

@@ -1,10 +1,10 @@
 (define map (lambda (f xs)
 	      (let ((accmap (lambda (acc xs)
-			      (if (= xs nil)
+			      (if (eq xs nil)
 				  acc
 				(accmap (cons (f (car xs)) acc) (cdr xs))))))
 		(reverse (accmap nil xs)))))
 
-(= (map (lambda (x) (+ x 1)) (list 1 2 3 4 5 6)) (list 2 3 4 5 6 7))
+(eq (map (lambda (x) (+ x 1)) (list 1 2 3 4 5 6)) (list 2 3 4 5 6 7))
 
 		

lispBM/lispBM/tests/test_map_3.lisp

@@ -1,8 +1,7 @@
 (let ((accmap (lambda (f acc xs)
-		(if (= xs nil)
+		(if (eq xs nil)
 		    acc
 		  (accmap f (cons (f (car xs)) acc) (cdr xs))))))
   (define map (lambda (f xs) (reverse (accmap f nil xs)))))
   
-(= (map (lambda (x) (+ x 1)) (list 1 2 3 4 5 6)) (list 2 3 4 5 6 7))
-
+(eq (map (lambda (x) (+ x 1)) (list 1 2 3 4 5 6)) (list 2 3 4 5 6 7))

lispBM/lispBM/tests/test_match_3.lisp

@@ -5,4 +5,4 @@
 		   ( (?cons c) (+ (car c) (f (cdr c))))
 		   ( _ 'error-not-a-list))))
 
-(= (f 'kurt) 'error-not-a-list)
+(eq (f 'kurt) 'error-not-a-list)

lispBM/lispBM/tests/test_qq_0.lisp

@@ -1,2 +1,2 @@
 
-(= '(+ 1 2) `(+ 1 2))
+(eq '(+ 1 2) `(+ 1 2))

lispBM/lispBM/tests/test_qq_1.lisp

@@ -1,2 +1,2 @@
 
-(= `(+ 1 ,(+ 2 3)) '(+ 1 5))
+(eq `(+ 1 ,(+ 2 3)) '(+ 1 5))

lispBM/lispBM/tests/test_qq_2.lisp

@@ -1,2 +1,2 @@
 
-(= `(+ 1 (+ 2 ,(+ 3 4))) '(+ 1 (+ 2 7)))
+(eq `(+ 1 (+ 2 ,(+ 3 4))) '(+ 1 (+ 2 7)))

lispBM/lispBM/tests/test_qq_6.lisp

@@ -1,2 +1,2 @@
 
-(= `(1 2 ,@'(3 4 5)) '(1 2 3 4 5))
+(eq `(1 2 ,@'(3 4 5)) '(1 2 3 4 5))

lispBM/lispBM/tests/test_quote_0.lisp

@@ -1 +1 @@
-(= 'x 'x)
+(eq 'x 'x)

lispBM/lispBM/tests/test_quote_1.lisp

@@ -1 +1 @@
-(= '(1 2 3) (list 1 2 3))
+(eq '(1 2 3) (list 1 2 3))

lispBM/lispBM/tests/test_refmut_5.lisp

@@ -2,4 +2,4 @@
 
 (setcar a (cons 7 8))
 
-(= a (cons (cons 7 8) 2))
+(eq a (cons (cons 7 8) 2))

lispBM/lispBM/tests/test_refmut_6.lisp

@@ -2,4 +2,4 @@
 
 (setcdr a (cons 7 8))
 
-(= a (cons 1 (cons 7 8)))
+(eq a (cons 1 (cons 7 8)))

lispBM/lispBM/tests/test_refmut_8.lisp

@@ -1,3 +1,3 @@
 (let  ((a (cons 1 2)))
      (progn (setcdr a 10)
-	    (= (and (car a 1) (cdr a 10))))) 
+	    (and (= (car a) 1) (= (cdr a) 10))))

lispBM/lispBM/tests/test_sumtree_0.lisp

@@ -1,8 +1,8 @@
 (define sumtree
   (lambda (x)
-    (if (= (type-of x) type-i28)
+    (if (eq (type-of x) type-i28)
 	x
-      (if (= x 'nil)
+      (if (eq x 'nil)
 	  0
 	(let ((a (sumtree (car x)))
 	      (b (sumtree (cdr x))))

lispBM/lispBM/tests/test_sumtree_1.lisp

@@ -1,14 +1,14 @@
 (define is-number
   (lambda (x)
-    (if (= (type-of x) type-i28)
+    (if (eq (type-of x) type-i28)
 	't
-      (if (= (type-of x) type-u28)
+      (if (eq (type-of x) type-u28)
 	  't
-	(if (= (type-of x) type-float)
+	(if (eq (type-of x) type-float)
 	    't
-	  (if (= (type-of x) type-i32)
+	  (if (eq (type-of x) type-i32)
 	      't
-	    (if (= (type-of x) type-u32)
+	    (if (eq (type-of x) type-u32)
 		't
 	      'nil)))))))
 	    
@@ -17,7 +17,7 @@
   (lambda (x)
     (if (is-number x)
 	x
-      (if (= x 'nil)
+      (if (eq x 'nil)
 	  0
 	(let ((a (sumtree (car x)))
 	      (b (sumtree (cdr x))))

lispBM/lispBM/tests/test_sumtree_2.lisp

@@ -1,10 +1,10 @@
 (define is-number
   (lambda (x)
-    (or (= (type-of x) type-i28)
-	(= (type-of x) type-u28)
-	(= (type-of x) type-float)
-	(= (type-of x) type-i32)
-	(= (type-of x) type-u32))
+    (or (eq (type-of x) type-i28)
+	(eq (type-of x) type-u28)
+	(eq (type-of x) type-float)
+	(eq (type-of x) type-i32)
+	(eq (type-of x) type-u32))
     ))
 	    
       
@@ -12,7 +12,7 @@
   (lambda (x)
     (if (is-number x)
 	x
-      (if (= x 'nil)
+      (if (eq x 'nil)
 	  0
 	(let ((a (sumtree (car x)))
 	      (b (sumtree (cdr x))))

lispBM/lispBM/tests/test_tailrec_1.lisp

@@ -1,3 +1,3 @@
-(define f (lambda (acc n) (if (num-eq n 0) acc (f (+ acc n) (- n 1)))))
+(define f (lambda (acc n) (if (= n 0) acc (f (+ acc n) (- n 1)))))
 
 ( = (f 0 10000u32) 50005000u32)

lispBM/lispBM/tests/test_tailrec_2.lisp

@@ -1,3 +1,3 @@
-(define sum (lambda (s rest) (if (= rest nil) s (sum (+ s (car rest)) (cdr rest)))))
+(define sum (lambda (s rest) (if (eq rest nil) s (sum (+ s (car rest)) (cdr rest)))))
 
 ( = (sum 0 (list 2.0 2.0 1.0 1.0 3.0 3.0)) 12.0)

lispBM/lispBM/tests/test_take_iota_0.lisp

@@ -1,2 +1,2 @@
 
-(= (take 100 (iota 1000)) (iota 99))
+(eq (take 100 (iota 1000)) (iota 99))