Add support for non-default compare template argument in std::map wrappers

1 files changed, 96 insertions, 96 deletions

diff --git a/Lib/mzscheme/std_map.i b/Lib/mzscheme/std_map.i
index 849f8baf5..6a0cb2d36 100644
--- a/Lib/mzscheme/std_map.i
+++ b/Lib/mzscheme/std_map.i
@@ -40,12 +40,12 @@
 
 namespace std {
 
-    template<class K, class T> class map {
-        %typemap(in) map<K,T> (std::map<K,T>* m) {
+    template<class K, class T, class C = std::less<K> > class map {
+        %typemap(in) map< K, T, C > (std::map< K, T, C >* m) {
             if (SCHEME_NULLP($input)) {
-                $1 = std::map<K,T >();
+                $1 = std::map< K, T, C >();
             } else if (SCHEME_PAIRP($input)) {
-                $1 = std::map<K,T >();
+                $1 = std::map< K, T, C >();
                 Scheme_Object* alist = $input;
                 while (!SCHEME_NULLP(alist)) {
                     K* k;
@@ -72,15 +72,15 @@ namespace std {
                        SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
             }
         }
-        %typemap(in) const map<K,T>& (std::map<K,T> temp,
-                                      std::map<K,T>* m),
-                     const map<K,T>* (std::map<K,T> temp,
-                                      std::map<K,T>* m) {
+        %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp,
+                                      std::map< K, T, C >* m),
+                     const map< K, T, C >* (std::map< K, T, C > temp,
+                                      std::map< K, T, C >* m) {
             if (SCHEME_NULLP($input)) {
-                temp = std::map<K,T >();
+                temp = std::map< K, T, C >();
                 $1 = &temp;
             } else if (SCHEME_PAIRP($input)) {
-                temp = std::map<K,T >();
+                temp = std::map< K, T, C >();
                 $1 = &temp;
                 Scheme_Object* alist = $input;
                 while (!SCHEME_NULLP(alist)) {
@@ -107,9 +107,9 @@ namespace std {
                 $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
             }
         }
-        %typemap(out) map<K,T> {
+        %typemap(out) map< K, T, C > {
             Scheme_Object* alist = scheme_null;
-            for (std::map<K,T >::reverse_iterator i=$1.rbegin(); 
+            for (std::map< K, T, C >::reverse_iterator i=$1.rbegin(); 
                                                   i!=$1.rend(); ++i) {
                 K* key = new K(i->first);
                 T* val = new T(i->second);
@@ -120,7 +120,7 @@ namespace std {
             }
             $result = alist;
         }
-        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
+        %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
             /* native sequence? */
             if (SCHEME_NULLP($input)) {
                 /* an empty sequence can be of any type */
@@ -156,7 +156,7 @@ namespace std {
                 }
             } else {
                 /* wrapped map? */
-                std::map<K,T >* m;
+                std::map< K, T, C >* m;
                 if (SWIG_ConvertPtr($input,(void **) &m,
                                 $&1_descriptor, 0) != -1)
                     $1 = 1;
@@ -164,8 +164,8 @@ namespace std {
                     $1 = 0;
             }
         }
-        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
-                                       const map<K,T>* {
+        %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
+                                       const map< K, T, C >* {
             /* native sequence? */
             if (SCHEME_NULLP($input)) {
                 /* an empty sequence can be of any type */
@@ -201,7 +201,7 @@ namespace std {
                 }
             } else {
                 /* wrapped map? */
-                std::map<K,T >* m;
+                std::map< K, T, C >* m;
                 if (SWIG_ConvertPtr($input,(void **) &m,
                                 $1_descriptor, 0) != -1)
                     $1 = 1;
@@ -222,14 +222,14 @@ namespace std {
         typedef K key_type;
         typedef T mapped_type;
         map();
-        map(const map<K,T> &);
+        map(const map< K, T, C > &);
         
         unsigned int size() const;
         bool empty() const;
         void clear();
         %extend {
             T& __getitem__(const K& key) throw (std::out_of_range) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 if (i != self->end())
                     return i->second;
                 else
@@ -239,19 +239,19 @@ namespace std {
                 (*self)[key] = x;
             }
             void __delitem__(const K& key) throw (std::out_of_range) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 if (i != self->end())
                     self->erase(i);
                 else
                     throw std::out_of_range("key not found");
             }
             bool has_key(const K& key) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 return i != self->end();
             }
             Scheme_Object* keys() {
                 Scheme_Object* result = scheme_null;
-                for (std::map<K,T >::reverse_iterator i=self->rbegin(); 
+                for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); 
                                                       i!=self->rend(); ++i) {
                     K* key = new K(i->first);
                     Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
@@ -267,12 +267,12 @@ namespace std {
 
     %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
 
-    template<class T> class map<K,T> {
-        %typemap(in) map<K,T> (std::map<K,T>* m) {
+    template<class T> class map< K, T, C > {
+        %typemap(in) map< K, T, C > (std::map< K, T, C >* m) {
             if (SCHEME_NULLP($input)) {
-                $1 = std::map<K,T >();
+                $1 = std::map< K, T, C >();
             } else if (SCHEME_PAIRP($input)) {
-                $1 = std::map<K,T >();
+                $1 = std::map< K, T, C >();
                 Scheme_Object* alist = $input;
                 while (!SCHEME_NULLP(alist)) {
                     T* x;
@@ -284,7 +284,7 @@ namespace std {
                     val = scheme_cdr(entry);
                     if (!CHECK(key))
                         SWIG_exception(SWIG_TypeError,
-                                       "map<" #K "," #T "> expected");
+                                       "map<" #K "," #T "," #C "> expected");
                     if (SWIG_ConvertPtr(val,(void**) &x,
                                     $descriptor(T *), 0) == -1) {
                         if (!SCHEME_PAIRP(val))
@@ -300,15 +300,15 @@ namespace std {
                        SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
             }
         }
-        %typemap(in) const map<K,T>& (std::map<K,T> temp,
-                                      std::map<K,T>* m),
-                     const map<K,T>* (std::map<K,T> temp,
-                                      std::map<K,T>* m) {
+        %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp,
+                                      std::map< K, T, C >* m),
+                     const map< K, T, C >* (std::map< K, T, C > temp,
+                                      std::map< K, T, C >* m) {
             if (SCHEME_NULLP($input)) {
-                temp = std::map<K,T >();
+                temp = std::map< K, T, C >();
                 $1 = &temp;
             } else if (SCHEME_PAIRP($input)) {
-                temp = std::map<K,T >();
+                temp = std::map< K, T, C >();
                 $1 = &temp;
                 Scheme_Object* alist = $input;
                 while (!SCHEME_NULLP(alist)) {
@@ -321,7 +321,7 @@ namespace std {
                     val = scheme_cdr(entry);
                     if (!CHECK(key))
                         SWIG_exception(SWIG_TypeError,
-                                       "map<" #K "," #T "> expected");
+                                       "map<" #K "," #T "," #C "> expected");
                     if (SWIG_ConvertPtr(val,(void**) &x,
                                     $descriptor(T *), 0) == -1) {
                         if (!SCHEME_PAIRP(val))
@@ -336,9 +336,9 @@ namespace std {
                 $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
             }
         }
-        %typemap(out) map<K,T> {
+        %typemap(out) map< K, T, C > {
             Scheme_Object* alist = scheme_null;
-            for (std::map<K,T >::reverse_iterator i=$1.rbegin(); 
+            for (std::map< K, T, C >::reverse_iterator i=$1.rbegin(); 
                                                   i!=$1.rend(); ++i) {
                 T* val = new T(i->second);
                 Scheme_Object* k = CONVERT_TO(i->first);
@@ -348,7 +348,7 @@ namespace std {
             }
             $result = alist;
         }
-        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
+        %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
             // native sequence?
             if (SCHEME_NULLP($input)) {
                 /* an empty sequence can be of any type */
@@ -382,7 +382,7 @@ namespace std {
                 }
             } else {
                 // wrapped map?
-                std::map<K,T >* m;
+                std::map< K, T, C >* m;
                 if (SWIG_ConvertPtr($input,(void **) &m,
                                 $&1_descriptor, 0) != -1)
                     $1 = 1;
@@ -390,8 +390,8 @@ namespace std {
                     $1 = 0;
             }
         }
-        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
-                                       const map<K,T>* {
+        %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
+                                       const map< K, T, C >* {
             // native sequence?
             if (SCHEME_NULLP($input)) {
                 /* an empty sequence can be of any type */
@@ -425,7 +425,7 @@ namespace std {
                 }
             } else {
                 // wrapped map?
-                std::map<K,T >* m;
+                std::map< K, T, C >* m;
                 if (SWIG_ConvertPtr($input,(void **) &m,
                                 $1_descriptor, 0) != -1)
                     $1 = 1;
@@ -442,14 +442,14 @@ namespace std {
         %rename("has-key?") has_key;
       public:
         map();
-        map(const map<K,T> &);
+        map(const map< K, T, C > &);
         
         unsigned int size() const;
         bool empty() const;
         void clear();
         %extend {
             T& __getitem__(K key) throw (std::out_of_range) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 if (i != self->end())
                     return i->second;
                 else
@@ -459,19 +459,19 @@ namespace std {
                 (*self)[key] = x;
             }
             void __delitem__(K key) throw (std::out_of_range) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 if (i != self->end())
                     self->erase(i);
                 else
                     throw std::out_of_range("key not found");
             }
             bool has_key(K key) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 return i != self->end();
             }
             Scheme_Object* keys() {
                 Scheme_Object* result = scheme_null;
-                for (std::map<K,T >::reverse_iterator i=self->rbegin(); 
+                for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); 
                                                       i!=self->rend(); ++i) {
                     Scheme_Object* k = CONVERT_TO(i->first);
                     result = scheme_make_pair(k,result);
@@ -483,12 +483,12 @@ namespace std {
     %enddef
 
     %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
-    template<class K> class map<K,T> {
-        %typemap(in) map<K,T> (std::map<K,T>* m) {
+    template<class K> class map< K, T, C > {
+        %typemap(in) map< K, T, C > (std::map< K, T, C >* m) {
             if (SCHEME_NULLP($input)) {
-                $1 = std::map<K,T >();
+                $1 = std::map< K, T, C >();
             } else if (SCHEME_PAIRP($input)) {
-                $1 = std::map<K,T >();
+                $1 = std::map< K, T, C >();
                 Scheme_Object* alist = $input;
                 while (!SCHEME_NULLP(alist)) {
                     K* k;
@@ -505,7 +505,7 @@ namespace std {
                         val = scheme_car(val);
                         if (!CHECK(val))
                             SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
+                                           "map<" #K "," #T "," #C "> expected");
                     }
                     (($1_type &)$1)[*k] = CONVERT_FROM(val);
                     alist = scheme_cdr(alist);
@@ -515,15 +515,15 @@ namespace std {
                        SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
             }
         }
-        %typemap(in) const map<K,T>& (std::map<K,T> temp,
-                                      std::map<K,T>* m),
-                     const map<K,T>* (std::map<K,T> temp,
-                                      std::map<K,T>* m) {
+        %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp,
+                                      std::map< K, T, C >* m),
+                     const map< K, T, C >* (std::map< K, T, C > temp,
+                                      std::map< K, T, C >* m) {
             if (SCHEME_NULLP($input)) {
-                temp = std::map<K,T >();
+                temp = std::map< K, T, C >();
                 $1 = &temp;
             } else if (SCHEME_PAIRP($input)) {
-                temp = std::map<K,T >();
+                temp = std::map< K, T, C >();
                 $1 = &temp;
                 Scheme_Object* alist = $input;
                 while (!SCHEME_NULLP(alist)) {
@@ -541,7 +541,7 @@ namespace std {
                         val = scheme_car(val);
                         if (!CHECK(val))
                             SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
+                                           "map<" #K "," #T "," #C "> expected");
                     }
                     temp[*k] = CONVERT_FROM(val);
                     alist = scheme_cdr(alist);
@@ -550,9 +550,9 @@ namespace std {
                 $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
             }
         }
-        %typemap(out) map<K,T> {
+        %typemap(out) map< K, T, C > {
             Scheme_Object* alist = scheme_null;
-            for (std::map<K,T >::reverse_iterator i=$1.rbegin(); 
+            for (std::map< K, T, C >::reverse_iterator i=$1.rbegin(); 
                                                   i!=$1.rend(); ++i) {
                 K* key = new K(i->first);
                 Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
@@ -562,7 +562,7 @@ namespace std {
             }
             $result = alist;
         }
-        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
+        %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
             // native sequence?
             if (SCHEME_NULLP($input)) {
                 /* an empty sequence can be of any type */
@@ -595,7 +595,7 @@ namespace std {
                 }
             } else {
                 // wrapped map?
-                std::map<K,T >* m;
+                std::map< K, T, C >* m;
                 if (SWIG_ConvertPtr($input,(void **) &m,
                                 $&1_descriptor, 0) != -1)
                     $1 = 1;
@@ -603,8 +603,8 @@ namespace std {
                     $1 = 0;
             }
         }
-        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
-                                       const map<K,T>* {
+        %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
+                                       const map< K, T, C >* {
             // native sequence?
             if (SCHEME_NULLP($input)) {
                 /* an empty sequence can be of any type */
@@ -637,7 +637,7 @@ namespace std {
                 }
             } else {
                 // wrapped map?
-                std::map<K,T >* m;
+                std::map< K, T, C >* m;
                 if (SWIG_ConvertPtr($input,(void **) &m,
                                 $1_descriptor, 0) != -1)
                     $1 = 1;
@@ -654,14 +654,14 @@ namespace std {
         %rename("has-key?") has_key;
       public:
         map();
-        map(const map<K,T> &);
+        map(const map< K, T, C > &);
         
         unsigned int size() const;
         bool empty() const;
         void clear();
         %extend {
             T __getitem__(const K& key) throw (std::out_of_range) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 if (i != self->end())
                     return i->second;
                 else
@@ -671,19 +671,19 @@ namespace std {
                 (*self)[key] = x;
             }
             void __delitem__(const K& key) throw (std::out_of_range) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 if (i != self->end())
                     self->erase(i);
                 else
                     throw std::out_of_range("key not found");
             }
             bool has_key(const K& key) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 return i != self->end();
             }
             Scheme_Object* keys() {
                 Scheme_Object* result = scheme_null;
-                for (std::map<K,T >::reverse_iterator i=self->rbegin(); 
+                for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); 
                                                       i!=self->rend(); ++i) {
                     K* key = new K(i->first);
                     Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
@@ -697,12 +697,12 @@ namespace std {
 
     %define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
                                        T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
-    template<> class map<K,T> {
-        %typemap(in) map<K,T> (std::map<K,T>* m) {
+    template<> class map< K, T, C > {
+        %typemap(in) map< K, T, C > (std::map< K, T, C >* m) {
             if (SCHEME_NULLP($input)) {
-                $1 = std::map<K,T >();
+                $1 = std::map< K, T, C >();
             } else if (SCHEME_PAIRP($input)) {
-                $1 = std::map<K,T >();
+                $1 = std::map< K, T, C >();
                 Scheme_Object* alist = $input;
                 while (!SCHEME_NULLP(alist)) {
                     Scheme_Object *entry, *key, *val;
@@ -713,14 +713,14 @@ namespace std {
                     val = scheme_cdr(entry);
                     if (!CHECK_K(key))
                         SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
+                                           "map<" #K "," #T "," #C "> expected");
                     if (!CHECK_T(val)) {
                         if (!SCHEME_PAIRP(val))
                             SWIG_exception(SWIG_TypeError,"alist expected");
                         val = scheme_car(val);
                         if (!CHECK_T(val))
                             SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
+                                           "map<" #K "," #T "," #C "> expected");
                     }
                     (($1_type &)$1)[CONVERT_K_FROM(key)] = 
                                                CONVERT_T_FROM(val);
@@ -731,15 +731,15 @@ namespace std {
                        SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
             }
         }
-        %typemap(in) const map<K,T>& (std::map<K,T> temp,
-                                      std::map<K,T>* m),
-                     const map<K,T>* (std::map<K,T> temp,
-                                      std::map<K,T>* m) {
+        %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp,
+                                      std::map< K, T, C >* m),
+                     const map< K, T, C >* (std::map< K, T, C > temp,
+                                      std::map< K, T, C >* m) {
             if (SCHEME_NULLP($input)) {
-                temp = std::map<K,T >();
+                temp = std::map< K, T, C >();
                 $1 = &temp;
             } else if (SCHEME_PAIRP($input)) {
-                temp = std::map<K,T >();
+                temp = std::map< K, T, C >();
                 $1 = &temp;
                 Scheme_Object* alist = $input;
                 while (!SCHEME_NULLP(alist)) {
@@ -751,14 +751,14 @@ namespace std {
                     val = scheme_cdr(entry);
                     if (!CHECK_K(key))
                         SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
+                                           "map<" #K "," #T "," #C "> expected");
                     if (!CHECK_T(val)) {
                         if (!SCHEME_PAIRP(val))
                             SWIG_exception(SWIG_TypeError,"alist expected");
                         val = scheme_car(val);
                         if (!CHECK_T(val))
                             SWIG_exception(SWIG_TypeError,
-                                           "map<" #K "," #T "> expected");
+                                           "map<" #K "," #T "," #C "> expected");
                     }
                     temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val);
                     alist = scheme_cdr(alist);
@@ -767,9 +767,9 @@ namespace std {
                 $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
             }
         }
-        %typemap(out) map<K,T> {
+        %typemap(out) map< K, T, C > {
             Scheme_Object* alist = scheme_null;
-            for (std::map<K,T >::reverse_iterator i=$1.rbegin(); 
+            for (std::map< K, T, C >::reverse_iterator i=$1.rbegin(); 
                                                   i!=$1.rend(); ++i) {
                 Scheme_Object* k = CONVERT_K_TO(i->first);
                 Scheme_Object* x = CONVERT_T_TO(i->second);
@@ -778,7 +778,7 @@ namespace std {
             }
             $result = alist;
         }
-        %typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
+        %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
             // native sequence?
             if (SCHEME_NULLP($input)) {
                 /* an empty sequence can be of any type */
@@ -809,7 +809,7 @@ namespace std {
                 }
             } else {
                 // wrapped map?
-                std::map<K,T >* m;
+                std::map< K, T, C >* m;
                 if (SWIG_ConvertPtr($input,(void **) &m,
                                 $&1_descriptor, 0) != -1)
                     $1 = 1;
@@ -817,8 +817,8 @@ namespace std {
                     $1 = 0;
             }
         }
-        %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
-                                       const map<K,T>* {
+        %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
+                                       const map< K, T, C >* {
             // native sequence?
             if (SCHEME_NULLP($input)) {
                 /* an empty sequence can be of any type */
@@ -849,7 +849,7 @@ namespace std {
                 }
             } else {
                 // wrapped map?
-                std::map<K,T >* m;
+                std::map< K, T, C >* m;
                 if (SWIG_ConvertPtr($input,(void **) &m,
                                 $1_descriptor, 0) != -1)
                     $1 = 1;
@@ -866,14 +866,14 @@ namespace std {
         %rename("has-key?") has_key;
       public:
         map();
-        map(const map<K,T> &);
+        map(const map< K, T, C > &);
         
         unsigned int size() const;
         bool empty() const;
         void clear();
         %extend {
             T __getitem__(K key) throw (std::out_of_range) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 if (i != self->end())
                     return i->second;
                 else
@@ -883,19 +883,19 @@ namespace std {
                 (*self)[key] = x;
             }
             void __delitem__(K key) throw (std::out_of_range) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 if (i != self->end())
                     self->erase(i);
                 else
                     throw std::out_of_range("key not found");
             }
             bool has_key(K key) {
-                std::map<K,T >::iterator i = self->find(key);
+                std::map< K, T, C >::iterator i = self->find(key);
                 return i != self->end();
             }
             Scheme_Object* keys() {
                 Scheme_Object* result = scheme_null;
-                for (std::map<K,T >::reverse_iterator i=self->rbegin(); 
+                for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); 
                                                       i!=self->rend(); ++i) {
                     Scheme_Object* k = CONVERT_K_TO(i->first);
                     result = scheme_make_pair(k,result);