1

I inherited some Java code that does the following:

1) it receives from Clojure a LazySeq object (which is made up of a number of PersistentHashMap objects)

2) it then passes this same LazySeq object (unchanged) back to a Clojure script where it is converted into a String and passed back to Java

The issue is that inside the Java code after step (1) and before step (2), I need to modify some of the PersistentHashMap objects inside the LazySeq and then proceed to step (2). Something like:

LazySeq seq = clojureFunctionReturningLazySeq();

//update the elements of the sequence

String result = clojureFunctionReceivingLazySeq(seq);

I cannot modify the Clojure script itself and the updating of the LazySeq has to happen inside the Java code. I checked the LazySeq API and I cannot find a method to modify (or add) an element.

Thank you,

Chris

Chris
  • 11
  • 1
  • You can treat it like a iterable collection. – A. Webb Jan 17 '14 at 18:54
  • LazySeq and PersistentHashMap are both immutable - in essence, what you'll need to do is build a new sequence based on the content of the one you were passed. It will be a non-trivial amount of work to do this in Java. – Alex Jan 17 '14 at 19:15
  • @Alex It's trivial to e.g. turn it into an ArrayList (ArrayList constructor takes a Collection), mutate the ArrayList at will, and provide back the ArrayList, assuming the receiving Clojure code only needs a Collection. – A. Webb Jan 17 '14 at 19:49
  • @A.Webb True, and you could similarly use HashMap's copy constructor to mutate the maps within the sequence. But lots of idiomatic Clojure code will break if it receives raw maps where it expects a persistent map; without knowing more about the Clojure code I wouldn't want to make any such assumptions. – Alex Jan 17 '14 at 19:58
  • @Alex Right. I was thinking more about mutating the collection than the contents of the collection. Alternatively, use `clojure.lang.RT` to do the work. – A. Webb Jan 17 '14 at 20:16
  • I think the clear path is to get the elements of the lazy seq, and call the LazySeq constructor on the modified elements. Similarly, regarding the "modified" elements, do this by replacing them with the new element returned by associating / updating-in the previous element (there should be a method on PersistentHashMap that takes a new key / val and returns a new PersistentHashMap with that key / val added). I would make this an answer but I don't know the specifics of the API from the Java side. – noisesmith Jan 18 '14 at 12:50
  • Or, write the bit between steps 1 and 2 as a function in Clojure also, compile it, and import it to Java. – A. Webb Jan 23 '14 at 13:16

1 Answers1

0

Short answer: You can't. LazySeq and PersistentHashMap in Clojure are immutable.

Longer answer: Generally, Clojure code makes very few assumptions about the exact kind of list object it's receiving - Most things work against ISeq which, if you don't want to bother with the other Clojure types, is rather trivial to implement.

So, you'd need to create a class that implements ISeq and returns transformed PersistentHashMap's as it runs through its parent LazySeq. Instantiate that class and pass it to clojureFunctionReceivingLazySeq(seq) instead.

CmdrDats
  • 89
  • 3