lists: Rename some list words

diff --git a/basis/lists/lazy/lazy.factor b/basis/lists/lazy/lazy.factor
index be7b0cf54f96f56489a4e2b9421023160324fb6b..69984803df22466dd525ab0f0cbd2366bf0aa48d 100644 (file)
--- a/basis/lists/lazy/lazy.factor
+++ b/basis/lists/lazy/lazy.factor
@@ -14,20 +14,20 @@ M: promise nil? ( cons -- ? )
     force nil? ;
  
 ! Both 'car' and 'cdr' are promises
-TUPLE: lazy-cons car cdr ;
+TUPLE: lazy-cons-state car cdr ;
 
 : lazy-cons ( car cdr -- promise )
     [ T{ promise f f t f } clone ] 2dip
-        [ promise ] bi@ \ lazy-cons boa
+        [ promise ] bi@ \ lazy-cons-state boa
         >>value ;
 
-M: lazy-cons car ( lazy-cons -- car )
+M: lazy-cons-state car ( lazy-cons -- car )
     car>> force ;
 
-M: lazy-cons cdr ( lazy-cons -- cdr )
+M: lazy-cons-state cdr ( lazy-cons -- cdr )
     cdr>> force ;
 
-M: lazy-cons nil? ( lazy-cons -- ? )
+M: lazy-cons-state nil? ( lazy-cons -- ? )
     nil eq? ;
 
 : 1lazy-list ( a -- lazy-cons )
@@ -70,20 +70,20 @@ M: memoized-cons nil? ( memoized-cons -- ? )
         nil?>>
     ] if ;
 
-TUPLE: lazy-map cons quot ;
+TUPLE: lazy-map-state cons quot ;
 
-C: <lazy-map> lazy-map
+C: <lazy-map-state> lazy-map-state
 
 : lazy-map ( list quot -- result )
-    over nil? [ 2drop nil ] [ <lazy-map> <memoized-cons> ] if ;
+    over nil? [ 2drop nil ] [ <lazy-map-state> <memoized-cons> ] if ;
 
-M: lazy-map car ( lazy-map -- car )
+M: lazy-map-state car ( lazy-map -- car )
     [ cons>> car ] [ quot>> call( old -- new ) ] bi ;
 
-M: lazy-map cdr ( lazy-map -- cdr )
+M: lazy-map-state cdr ( lazy-map -- cdr )
     [ cons>> cdr ] [ quot>> lazy-map ] bi ;
 
-M: lazy-map nil? ( lazy-map -- ? )
+M: lazy-map-state nil? ( lazy-map -- ? )
     cons>> nil? ;
 
 TUPLE: lazy-take n cons ;
@@ -352,8 +352,8 @@ INSTANCE: memoized-cons list
 INSTANCE: promise list
 INSTANCE: lazy-io list
 INSTANCE: lazy-concat list
-INSTANCE: lazy-cons list
-INSTANCE: lazy-map list
+INSTANCE: lazy-cons-state list
+INSTANCE: lazy-map-state list
 INSTANCE: lazy-take list
 INSTANCE: lazy-append list
 INSTANCE: lazy-from-by list

diff --git a/basis/lists/lists-tests.factor b/basis/lists/lists-tests.factor
index a39cc174904bdee10a4a6d6041f388775e3fbebb..ef7c62262dbf88f701ac9aa35ac118a4db584d30 100644 (file)
--- a/basis/lists/lists-tests.factor
+++ b/basis/lists/lists-tests.factor
@@ -12,37 +12,37 @@ IN: lists.tests
 ] unit-test
 
 { { 3 4 5 6 } } [
-    T{ cons f 1       
-        T{ cons f 2 
-            T{ cons f 3
-                T{ cons f 4
+    T{ cons-state f 1
+        T{ cons-state f 2
+            T{ cons-state f 3
+                T{ cons-state f 4
                 +nil+ } } } } [ 2 + ] lmap>array
 ] unit-test
 
 { 10 } [
-    T{ cons f 1       
-        T{ cons f 2 
-            T{ cons f 3
-                T{ cons f 4
+    T{ cons-state f 1
+        T{ cons-state f 2
+            T{ cons-state f 3
+                T{ cons-state f 4
                 +nil+ } } } } 0 [ + ] foldl
 ] unit-test
-    
-{ T{ cons f 2 T{ cons f 3 T{ cons f 4 T{ cons f 5 +nil+ } } } } } [
+
+{ T{ cons-state f 2 T{ cons-state f 3 T{ cons-state f 4 T{ cons-state f 5 +nil+ } } } } } [
     { 1 2 3 4 } sequence>list [ 1 + ] lmap
 ] unit-test
-    
+
 { 15 } [
  { 1 2 3 4 5 } sequence>list 0 [ + ] foldr
 ] unit-test
-    
+
 { { 5 4 3 2 1 } } [
     { 1 2 3 4 5 } sequence>list lreverse list>array
 ] unit-test
-    
+
 { 5 } [
     { 1 2 3 4 5 } sequence>list llength
 ] unit-test
-    
+
 { { 1 2 3 4 5 6 } } [
     { 1 2 3 } sequence>list { 4 5 6 } sequence>list lappend list>array
 ] unit-test

diff --git a/basis/lists/lists.factor b/basis/lists/lists.factor
index 91b671bd61680149f17fcbaff1a66fc34d326c3f..adb2bf49921a5fa4c814be056a66a365509511f3 100644 (file)
--- a/basis/lists/lists.factor
+++ b/basis/lists/lists.factor
@@ -10,13 +10,13 @@ GENERIC: car ( cons -- car )
 GENERIC: cdr ( cons -- cdr )
 GENERIC: nil? ( object -- ?   )
     
-TUPLE: cons { car read-only } { cdr read-only } ;
+TUPLE: cons-state { car read-only } { cdr read-only } ;
 
-C: cons cons
+C: cons cons-state
 
-M: cons car ( cons -- car ) car>> ;
+M: cons-state car ( cons -- car ) car>> ;
 
-M: cons cdr ( cons -- cdr ) cdr>> ;
+M: cons-state cdr ( cons -- cdr ) cdr>> ;
 
 SINGLETON: +nil+
 M: +nil+ nil? drop t ;