(module lshift/jcollection-ec
    ((:jiterator has-next next)
     (:jenumeration has-more-elements next-element)
     (:jarray java-array-length java-array-ref)
     (:jcollection iterator)
     (:jmap-keys iterator key-set)
     (:jmap-values iterator jvalues)
     (:jmap iterator has-next next entry-set get-key get-value)

     (jarray-ec ->jarray list-ec)

     (jarray-list-ec j-unary-ec add <java.util.array-list>)
     (jhash-set-ec j-unary-ec add <java.util.hash-set>)
     (jlinked-hash-set-ec j-unary-ec add <java.util.linked-hash-set>)
     (jlinked-list-ec j-unary-ec add <java.util.linked-list>)
     (jtree-set-ec j-unary-ec add <java.util.tree-set>)

     (jhash-map-ec j-binary-ec put <java.util.hash-map>)
     (jhashtable-ec j-binary-ec put <java.util.hashtable>)
     (jidentity-hash-map-ec j-binary-ec put <java.util.identity-hash-map>)
     (jlinked-hash-map-ec j-binary-ec put <java.util.linked-hash-map>)
     (jtree-map-ec j-binary-ec put <java.util.tree-map>)
     (jweak-hash-map-ec j-binary-ec put <java.util.weak-hash-map>))

  (import srfi-42)
  (import s2j)

  (define-java-classes
    <java.util.array-list>
    <java.util.hash-map>
    <java.util.hash-set>
    <java.util.hashtable>
    <java.util.identity-hash-map>
    <java.util.linked-hash-map>
    <java.util.linked-hash-set>
    <java.util.linked-list>
    <java.util.tree-map>
    <java.util.tree-set>
    <java.util.weak-hash-map>)

  (define-generic-java-methods
    iterator
    has-next
    next
    has-more-elements
    next-element
    key-set
    (jvalues |values|)
    entry-set
    get-key
    get-value
    add
    put)

  (define-syntax :jiterator
    (syntax-rules (index)
      ((:jiterator cc var (index i) arg ...)
       (:parallel cc (:jiterator var arg ...) (:integers i)))
      ((:jiterator cc var transformer iter0)
       (:do cc
	    (let ((iter iter0)))
	    ()
	    (->boolean (has-next iter))
	    (let ((var (transformer (next iter)))))
	    #t
	    ()))
      ((:jiterator cc var iter0)
       (:do cc
	    (let ((iter iter0)))
	    ()
	    (->boolean (has-next iter))
	    (let ((var (next iter))))
	    #t
	    ()))))

  (define-syntax :jenumeration
    (syntax-rules (index)
      ((:jenumeration cc var (index i) arg ...)
       (:parallel cc (:jenumeration var arg ...) (:integers i)))
      ((:jenumeration cc var transformer enum0)
       (:do cc
	    (let ((enum enum0)))
	    ()
	    (->boolean (has-more-elements enum))
	    (let ((var (transformer (next-element enum)))))
	    #t
	    ()))
      ((:jenumeration cc var enum0)
       (:do cc
	    (let ((enum enum0)))
	    ()
	    (->boolean (has-more-elements enum))
	    (let ((var (next-element enum))))
	    #t
	    ()))))

  (define-syntax :jarray
    (syntax-rules (index)
      ((:jarray cc var (index i) transformer arr0)
       (:do cc
	    (let ((arr arr0) (len 0))
	      (set! len (java-array-length arr)))
	    ((i 0))
	    (< i len)
	    (let ((var (transformer (java-array-ref arr i)))))
	    #t
	    ((+ i 1))))
      ((:jarray cc var (index i) arr0)
       (:do cc
	    (let ((arr arr0) (len 0))
	      (set! len (java-array-length arr)))
	    ((i 0))
	    (< i len)
	    (let ((var (java-array-ref arr i))))
	    #t
	    ((+ i 1))))
      ((:jarray cc var transformer arr0)
       (:jarray cc var (index i) transformer arr0))
      ((:jarray cc var arr0)
       (:jarray cc var (index i) arr0))))

  (define-syntax :jcollection
    (syntax-rules ()
      ((:jcollection cc var a1 a2 coll)
       (:jiterator cc var a1 a2 (iterator coll)))
      ((:jcollection cc var a1 coll)
       (:jiterator cc var a1 (iterator coll)))
      ((:jcollection cc var coll)
       (:jiterator cc var (iterator coll)))))

  (define-syntax :jmap-keys
    (syntax-rules ()
      ((:jmap-keys cc var a1 a2 coll)
       (:jiterator cc var a1 a2 (iterator (key-set coll))))
      ((:jmap-keys cc var a1 coll)
       (:jiterator cc var a1 (iterator (key-set coll))))
      ((:jmap-keys cc var coll)
       (:jiterator cc var (iterator (key-set coll))))))

  (define-syntax :jmap-values
    (syntax-rules ()
      ((:jmap-values cc var a1 a2 coll)
       (:jiterator cc var a1 a2 (iterator (jvalues coll))))
      ((:jmap-values cc var a1 coll)
       (:jiterator cc var a1 (iterator (jvalues coll))))
      ((:jmap-values cc var coll)
       (:jiterator cc var (iterator (jvalues coll))))))

  (define-syntax :jmap
    (syntax-rules (index)
      ((:jmap cc var1 var2 (index i) arg ...)
       (:parallel cc (:jmap var1 var2 arg ...) (:integers i)))
      ((:jmap cc (transformer1 var1) (transformer2 var2) coll)
       (:do cc
	    (let ((iter (iterator (entry-set coll)))))
	    ()
	    (->boolean (has-next iter))
	    (let ((entry (next iter)) (var1 #f) (var2 #f))
	      (set! var1 (transformer1 (get-key entry)))
	      (set! var2 (transformer2 (get-value entry))))
	    #t
	    ()))
      ((:jmap cc var1 (transformer2 var2) coll)
       (:jmap cc (values var1) (transformer2 var2) coll))
      ((:jmap cc (transformer1 var1) var2 coll)
       (:jmap cc (transformer1 var1) (values var2) coll))
      ((:jmap cc var1 var2 coll)
       (:jmap cc (values var1) (values var2) coll))))

  (define-syntax jarray-ec
    (syntax-rules ()
      ((jarray-ec class q expr)
       (->jarray (list-ec q expr) class))))

  (define-syntax j-unary-ec
    (syntax-rules ()
      ((j-unary-ec class adder q expr)
       (let ((result (java-new class)))
	 (do-ec q (adder result expr))
	 result))))

  (define-syntax j-binary-ec
    (syntax-rules ()
      ((j-unary-ec class adder q key-expr value-expr)
       (let ((result (java-new class)))
	 (do-ec q (adder result key-expr value-expr))
	 result))))

  (let-syntax ((define-j-unary-ec (syntax-rules ()
				    ((_ (name class) ...)
				     (begin
				       (define-syntax name
					 (syntax-rules ()
					   ((_ q expr)
					    (j-unary-ec class add q expr))))
				       ...)))))
    (define-j-unary-ec
      (jarray-list-ec <java.util.array-list>)
      (jhash-set-ec <java.util.hash-set>)
      (jlinked-hash-set-ec <java.util.linked-hash-set>)
      (jlinked-list-ec <java.util.linked-list>)
      (jtree-set-ec <java.util.tree-set>)))

  (let-syntax ((define-j-binary-ec (syntax-rules ()
				     ((_ (name class) ...)
				      (begin
					(define-syntax name
					  (syntax-rules ()
					    ((_ q key-expr value-expr)
					     (j-binary-ec class put q key-expr value-expr))))
					...)))))
    (define-j-binary-ec
      (jhash-map-ec <java.util.hash-map>)
      (jhashtable-ec <java.util.hashtable>)
      (jidentity-hash-map-ec <java.util.identity-hash-map>)
      (jlinked-hash-map-ec <java.util.linked-hash-map>)
      (jtree-map-ec <java.util.tree-map>)
      (jweak-hash-map-ec <java.util.weak-hash-map>)))

  )