Re: ClojureScript in IE 9 (does it work?)

[David Powell]

On Mon, Jan 16, 2012 at 7:59 AM, gchristnsn  wrote:
> I can't even call `(js/alert "test")' in IE 9, it compiles into:
>
> alert.call(null,"test");
>
> and says: "Invalid calling object" (IE 9 standards mode, in IE 8
> standards mode it doesn't recognize the `call' method)
>
> I need `alert' to debug some other glitch which arises in IE 9 (but
> all works fine in other browsers), is it by design?

The problem is that things like window.alert on IE, are weird built-in
things that aren't actually 'functions' in the javascript sense, in
that they don't have Function as their prototype, so clojurescript's
attempt to .call them fails.  I think that this might actually be
permitted behaviour?

So, I'm not sure what the best solution is.  As a quick workaround you
could probably write your own myalert function in javascript that just
calls window.alert, and include it at the top of your page -
clojurescript will be able to call js/myalert.

Perhaps clojurescript should have some sort of workaround for making
these built-ins work on IE...  Any ideas?

-- 
Dave

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: A STM profile tool

[Jonathan Cardoso]

Interesting!

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Proxies and overriding protected methods

[Chris Perkins]

Norman,

Finalize is a protected method, so you can't call it. You get the same 
error trying to call finalize on anything - it has nothing to do with proxy.

user> (.finalize (Object.))
No matching field found: finalize for class java.lang.Object

- Chris


-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Proxies and overriding protected methods

[Chris Perkins]

On Monday, January 16, 2012 6:12:34 AM UTC-5, Chris Perkins wrote:
>
> Norman,
>
> Finalize is a protected method, so you can't call it. You get the same 
> error trying to call finalize on anything - it has nothing to do with proxy.
>
> user> (.finalize (Object.))
> No matching field found: finalize for class java.lang.Object
>
> - Chris
>

Oops, ignore that - haven't had my morning coffee yet :)  I see that you 
are trying to make finalize accessible by overriding it. Agreed that it 
seems like it should work.  Assuming that proxy can successfully override 
other protected methods, you should probably log a bug.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Proxies and overriding protected methods

[Norman Gray]

Chris, hello.

On 2012 Jan 16, at 11:23, Chris Perkins wrote:

> Oops, ignore that - haven't had my morning coffee yet :)  I see that you 
> are trying to make finalize accessible by overriding it.

Indeed!

> Agreed that it 
> seems like it should work.  Assuming that proxy can successfully override 
> other protected methods, you should probably log a bug.

Righto.  I presume the Clojure.core bugparade is at 
, yes?

All the best,

Norman


-- 
Norman Gray  :  http://nxg.me.uk

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: A STM profile tool

[dennis zhuang]

hi,all
I've upgraded the version to 1.0.1-SNAPSHOT.
And added a new function ref-stats to get the statistics information of a
reference.For example:

=>(use'stm)
=>(def a (ref 1))
=>(def b (ref 2))
=>(dotimes [_ 100] (future (dosync (alter a + 1) (alter b - 1

=>@a
101
=>@b
-98

=>(stm-stats)
{"(alter a + 1)(alter b - 1)" {:not-running 9, :average-retry 15,
:total-cost 3048, :get-fault 52, :barge-fail 372, :change-committed 1064,
:total-times 100, :average-cost 30}}

=>(ref-stats a)
{"(alter a + 1)(alter b - 1)" {:alter 1601, :get-fault 52, :barge-fail 372,
:change-committed 1064}}

We can get a detail information of a reference involed in a tranaction.The
:alter means it was invoked with alter 1601 times including retry times.
:get-fault means we can't get a committed value before the transaction read
point,so we have to retry it. :change-commited means that other transaction
has commited a new value of this reference before our transaction,so we
have to retry it again. :barge-fail means we wanted to barge other
transaction,but we failed,we still have to retry the transaction.

2012/1/16 Jonathan Cardoso 

> Interesting!
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en




-- 
庄晓丹
Email:killme2...@gmail.com
伯岩(花名)  bo...@taobao.com
Site:   http://fnil.net

淘宝（中国）软件有限公司 / 产品技术部 / Java中间件

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Proxies and overriding protected methods

[Cedric Greevey]

On Sun, Jan 15, 2012 at 5:26 PM, Norman Gray  wrote:
> Section 6.6.2 of the JLS mentions that "A protected member or constructor of 
> an object may be accessed from outside the package in which it is declared 
> only by code that is responsible for the implementation of that object"  
> (this is echoed in Sect 2.7.4 of the JVM spec). Now, the text which follows 
> that seems to boil down to saying that subclass implementations can see 
> protected instance fields or methods, which we all know, of course.
>
> Also, you established that methods overridden in a proxy are public.

Also, that it overrides all of them whether you provide an
implementation or not. A few tests seem to confirm that the default
implementations are just call-super implementations (when the
overridden method is concrete, anyway). More on that anon.

> There seem to be a couple of possibilities.
>
>  * There's an edge-case of the legalese in JLS 6.6.2 or JVMS 2.7.4 or 5.4.4 
> that is triggered by Clojure's implementation of the proxy class, and which 
> is beyond my current forensic powers to spot.

Further down in the weeds than I've yet gotten while investigating this.

>  * Or there's a special case.  The 'generate-proxy' function in 
> 
>  does mention "finalize" in a test which apparently excludes specifically 
> that method from a "set of supers' non-private instance methods", but I can't 
> work out quite what it's doing with those.  It _may_ be that the goal there 
> is to automatically call super.methods for each method in the proxy, and I 
> can see why one would want finalize() to be exempt from that, but if so, it 
> may be this code which is, inadvertantly or not, preventing extending-classes 
> adding finalizers.

Seems likely then that it's either an intentional limitation, or a bug
resulting from preventing the finalizer from automatically starting
with super.finalize(). A proper nontrivial finalizer should be try {
do something; } finally { super.finalize(); } so your cleanup goes
first, then your superclass's -- reverse order of initialization; so
it shouldn't *start* with finalize. A proper clojure finalizer would
have to be (finalize [] (try (do something) (finally (proxy-super
finalize. Though finalizers are icky, they probably *should* be
allowed, for completeness' sake. I'm inclined to regard this as a bug,
unless someone posts with a convincing explanation why clojure proxies
having nontrivial finalizers would be a very bad idea.

> The fact that (as you note) the proxy code is documented not to have access 
> to protected members does suggest that the proxying class is at least not 
> straightforwardly a subclass of the base class.

As I understand it, there are two pieces to the proxy.

One is a subclass of the specified base class and/or interface(s). The
proxy object is of this class; as you saw, your HashMap derived proxy
had an (ancestors (.getClass x)) that contained HashMap among other
things.

The other component is a map of clojure function objects. The proxy
object's methods just look things up in this map and invoke them. The
map can be updated later, with update-proxy, and the existing proxy
object's methods will change behavior correspondingly, something not
otherwise possible. That's why there's a default call-super
implementation of every method, even if you don't override it when you
first call proxy, because if there wasn't, you couldn't later override
it with update-proxy.

It also lets you always call protected methods that you didn't override:

user=> (.toString (proxy [Object] [] (toString [] (do (.clone this) "boo!"
#

If the proxy didn't make clone public, the clojure function could not
call it in the do up above, because it's not a method of the proxy
class itself, but of its own class, as outlined above. And to prove
it:

user=> (.toString (proxy [Object] [] (toString [] (.getClassName
(first (.getStackTrace (Exception.)))
"user$eval940$fn__941"

The class user$eval940 is a class with a method that executes the
compiled (.toString ...) code. When that is entered at the REPL, it's
compiled, that class (or one with a similar name) is created, and that
method is then invoked to actually execute what you entered at the
REPL.

The class user$eval940$fn__941 is a nested class of that class, and
will be the body of the toString method specified for the proxy.

The proxy itself, as noted above, has a toString override that looks
up toString in some clojure map, pulls out an instance of
user$eval940$fn__941, and calls the no-argument invoke method, which
contains the compiled toString body.

So, the clone method of the proxy's class, user$java.lang.Object$0, is
being called from the class user$eval940$fn__941. In this case, it
would have worked anyway since both are in the default package, but if
they weren't in the same Clojure namespace (or both in single-segment
namespaces) it wouldn't work if the pro

Re: 4Clojure exersice question

[Meikel Brandmeyer]

Hi,

Am 14.01.2012 um 14:19 schrieb Erlis Vidal:

> Sometimes while solving a problem, we can not see simpler solutions. 
> 
> What do you think? 

Clojure is homoiconic. Walk the output of the reader and for each symbol do a 
(resolve sym) and check the Var against the list of forbidden Vars. Inform the 
user that she must not use locals with names of forbidden Vars. That should 
give a reasonable approximation for not using the forbidden Vars, while still 
being simple to implement with a little support of the user.

I'm not sure were jails and such are needed here (besides server security of 
the 4clojure process).

Sincerely
Meikel

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: ClojureScript in IE 9 (does it work?)

[ckirkendall]

I ran into the same thing with .setTimeout in enfocus.  I moved to
using the wrapper function inside the goog library.  In the case
of .setTimeout I used goog.async.Delay and for alert maybe you could
use goog.ui.dialog.

http://closure-library.googlecode.com/svn/docs/class_goog_ui_Dialog.html

Creighton Kirkendall

On Jan 16, 5:32 am, David Powell  wrote:
> On Mon, Jan 16, 2012 at 7:59 AM, gchristnsn  wrote:
> > I can't even call `(js/alert "test")' in IE 9, it compiles into:
>
> > alert.call(null,"test");
>
> > and says: "Invalid calling object" (IE 9 standayrds mode, in IE 8
> > standards mode it doesn't recognize the `call' method)
>
> > I need `alert' to debug some other glitch which arises in IE 9 (but
> > all works fine in other browsers), is it by design?
>
> The problem is that things like window.alert on IE, are weird built-in
> things that aren't actually 'functions' in the javascript sense, in
> that they don't have Function as their prototype, so clojurescript's
> attempt to .call them fails.  I think that this might actually be
> permitted behaviour?
>
> So, I'm not sure what the best solution is.  As a quick workaround you
> could probably write your own myalert function in javascript that just
> calls window.alert, and include it at the top of your page -
> clojurescript will be able to call js/myalert.
>
> Perhaps clojurescript should have some sort of workaround for making
> these built-ins work on IE...  Any ideas?
>
> --
> Dave

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Could be my favourite improvement in 1.4

[Tavis Rudd]

This issue could be avoided by only treating a colon as whitespace when 
followed by a comma. As easy cut-paste of json seems to be the key 
motivation here, the commas are going to be there anyway: valid {"v":, 
1234} vs syntax error {a-key: should-be-a-keyword}.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Lazy sequence transformation with item merge

[Ulrich Küttler]

Hi all,

I am looking for a function that gives me a lazy sequence from a
simple key, value file. Keys are words at the beginning of a line.
Value start after a key and can span multiple lines. Thus, a file
looks something like:

key1 = value1 is there
and continues
key2 = new value
key3 = value3
takes some more lines
as well

I have a simple python generator that does the dirty work for me:

def readpairs(name):
key = None
value = None
for line in file(name):
line = line.strip()
data = line.split("=")
if len(data) == 2:
if key is not None:
yield key, value
key, value = data[0], [data[1]]
else:
if key is None:
raise Exception("no key here")
value.append(line)
if key is not None:
yield key, value

The nice thing about this code is that it hides the messy details of
reading multiple lines and gives me a clean sequence of key, value
pairs to work with. I would like to have the same thing in clojure. I
just do not find a good solution. Do you have any idea?

Thanks a lot.

Ulrich

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Libraries for ClojureScript.

[Kevin Lynagh]

Manoj,

I wrote a ClojureScript wrapper around the D3 JavaScript library,

https://github.com/lynaghk/cljs-d3

and took some liberties with the D3 API to make it more concise and
otherwise Clojure-like.
For instance, you set attributes in D3 like

d3_selection
  .attr("x", 5)
  .attr("y", 10)
  .attr("fill", "blue")

and I added a macro that would expand a map literal into multiple attr
calls so in cljs-d3 people could write

(-> d3-selection
  (attr {:x 5, :y 10, :fill, "blue"}))

One difficulty I had in building a ClojureScript facade for D3 is that
it wasn't clear when to coerce between JavaScript and Clojure
datatypes.
For instance, D3 has some higher level functions that return things
like scales or calculate histograms.
Some D3 layouts take these functions as arguments, but they can also
be used stand alone.
Should the wrapped call to D3's histogram function return the
original, native JavaScript array (for compatibility with D3 layouts),
or a ClojureScript seq (for the ClojureScript programmer who wants the
histogram itself)?

One other concern to keep in mind is that many JavaScript libraries
aren't compatible with the Closure compiler's advanced optimizations.
Advanced optimizations are awesome---I'm working on a Clojure data
visualization library similar in spirit to D3, and for many static
visualizations the compiled JavaScript (including the ClojureScript
runtime itself) is less than half the size of minified D3.

best,

Kevin


On Jan 15, 5:23 pm, ckirkendall  wrote:
> Manjo,
> I think there is considerable benefit in keeping certain APIs similar
> between ClojureScript and Clojure.  In places where the intent is the
> same I would suggest going with a familiar API.  I took this approach
> with enfocus by basing it on enlive.  It sped up my development
> because I didn't have to ponder if the semantics were usable. In the
> places where my feature set didn't line up, I found myself working and
> reworking the apis because they weren't clean enough or they seemed
> confusing.  All of that being said, ClojuresSript is very young and I
> don't think we have a right way to do things yet. Right now I would be
> willing to try any testing library regardless if it matched
> Clojure.
>
> Creighton Kirkendall
>
> On Jan 15, 12:37 am, mmwaikar  wrote:
>
>
>
>
>
>
>
> > Hi,
>
> > My question is about design of libraries for ClojureScript.
>
> > So for ex, there is clojure.test which has some public API. Now assume one
> > has used it and is comfortable with its API.
> > Now he has to write some ClojureScript code and wants to write some unit
> > tests as well.
>
> > Obviously, he'll use some pre-existing JS library / framework, but it will
> > have its own API.
> > Now -
>
> > 1) Does it make sense to write a ClojureScript wrapper over existing JS
> > libraries (as there are wrappers over many Java libraries / frameworks)?
> > 2) Does it make sense, or is it better if this ClojureScript wrapper,
> > exposes the same (as far as possible) or similar API to that of one of the
> > Clojure libraries? The obvious advantage being the programmer has to get
> > accustomed to just one API, which works for Clojure as well as
> > ClojureScript.
>
> > Please let me know your views.
>
> > Thanks,
> > Manoj.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Controlling the test environment

[Matt Stump]

 

Is there a way to set different values for global vars when running tests 
as opposed to the development or production environment?  I need to control 
which database my tests for a noir project connect to. Ideally I would like 
to do something like the following: for production and development, if 
an environment variable is set connect to the database server at the 
specified URL, if not then fall back to localhost.  For test start up an 
embedded server, and connect. After the test is done, rollback the global 
var to the previous value and resume connecting to the server on localhost 
or at the location specified by the environment variable.

I could create some fixture with-test-database that modifies a global var, 
but that seems a little hackish.

How are other people solving this problem?  Is there something similar 
pre-baked into noir, clojure.test or midje?

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Clojurescript One: (def fiv 5) compiles to ".fiv = 5;\n" ?

[Indy]

Having the same issue and the only way I've resolved it is by having both 
the server and the cljs-repl running in the same repl.

   - run script/repl from the *shell* or launch it as an inferior-lisp
   - (use '[one.sample.dev-server :only (run-server cljs-repl)])
   - (run-server)
   - (cljs-repl)

 

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

(= difference in java-clojure and clojure.net)

[Roope]

In java-clojure 1.3:

user=> (= 10.0 10)
false

In clojure.net 1.3:

user=> (= 10.0 10)
true

Sorry if this has been reported already

Robert

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: converting a string to a list

[Samuel Lê]

Thanks for the answsers!
Jay's last answer is just what I was looking for.

thanks,
Sam

2012/1/14 Jay Fields 

> this seems easier...
>
> user=> (map str "abc")
> ("a" "b" "c")
>
> Though the original question says a list to a string and the example shows
> a string to a list (of symbols)
>
> user=> (apply str ["a" "b" "c"])
> "abc'
>
> But, the example is looks like it wants
>
> user=> (map (comp symbol str) "abc")
> (a b c)
>
> Hopefully one of those is what you're looking for.
>
> Cheers, Jay
>
> On Jan 14, 2012, at 1:01 PM, dennis zhuang wrote:
>
> You can do this
> > ((comp #(map str %) seq) "abcdef")
> ("a" "b" "c" "d" "e" "f")
>
> 2012/1/15 Bruce Durling 
>
>> Sam,
>>
>> Strings can be turned into sequences with seq.
>>
>> > (seq "foo")
>> (\f \o \o)
>>
>> The backslashes are because f o and o are character literals.
>>
>> cheers,
>> Bruce
>>
>> On Sat, Jan 14, 2012 at 10:13, Samuel Lê  wrote:
>> > Hi,
>> >
>> > I was wondering if there was a function to convert a list into a string,
>> > something like:
>> > (string-to-list "abcde")   ;; (a b c d e)
>> >
>> > thanks!
>> >
>> > Sam
>> >
>> > --
>> > You received this message because you are subscribed to the Google
>> > Groups "Clojure" group.
>> > To post to this group, send email to clojure@googlegroups.com
>> > Note that posts from new members are moderated - please be patient with
>> your
>> > first post.
>> > To unsubscribe from this group, send email to
>> > clojure+unsubscr...@googlegroups.com
>> > For more options, visit this group at
>> > http://groups.google.com/group/clojure?hl=en
>>
>> --
>> You received this message because you are subscribed to the Google
>> Groups "Clojure" group.
>> To post to this group, send email to clojure@googlegroups.com
>> Note that posts from new members are moderated - please be patient with
>> your first post.
>> To unsubscribe from this group, send email to
>> clojure+unsubscr...@googlegroups.com
>> For more options, visit this group at
>> http://groups.google.com/group/clojure?hl=en
>>
>
>
>
> --
> 庄晓丹
> Email:killme2...@gmail.com
> 伯岩(花名)  bo...@taobao.com
> Site:   http://fnil.net
>
> 淘宝（中国）软件有限公司 / 产品技术部 / Java中间件
>
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
>
>
>  --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Lazy sequence transformation with item merge

[Cedric Greevey]

Something like:

(defn skv [str]
  (seq (.split str " = " 2)))

(defn second-bit-not-equal-sign? [str]
  (not (second (skv str

(defn extract* [lseq]
  (when lseq
(lazy-seq
  (let [[f & r] lseq]
(if (second-bit-not-equal-sign? f) (throw (Exception. "no key here")))
(let [[p1 p2] (split-with second-bit-not-equal-sign? r)
  [k v] (skv f)
  v (apply str v p1)]
  (cons [k v] (extract* (seq p2

(defn extract [lseq]
  (extract* (seq (map clojure.string/trim lseq

user=> (extract ["key1 = value1 is there" "and continues" "key2 = new
value" "key3 = value3" "takes some more lines" "as well"])
(["key1" "value1 is thereand continues"]
 ["key2" "new value"]
 ["key3" "value3takes some more linesas well"])

If you want a map, (into {} (extract ...)). The obvious input source
is a line-seq obtained somehow. If you want spaces or newlines at the
concatenation sites (e.g. "value3 takes some more lines as well" or
"value3\ntakes some more lines\nas well") in the output, change (apply
str v p1) to (apply str v (interleave (repeat \space) p1)) or (apply
str v (interleave (repeat \newline) p1)).

I suggest you study the code to understand how the Python you posted
was translated into Clojure so you can more readily do it yourself in
the future with other code you're porting. Be aware, too, of the
effects of Clojure's addition of laziness; particularly, that the lazy
sequence output will be backed by the line-seq, which will be backed
by a reader, and if you let the output pass out of (with-open [rdr
(whatever)] ...) before it's fully realized you'll have problems. (If
you package the output into a map inside of the (with-open ...) you
won't have a problem there.) Also, note that once consumption is
started the underlying line-seq will have one additional element
realized beyond the last one in realized elements of the output, since
it has to be peeked at to know when the current maybe-multi-line
record ends and the next begins. If the individual lines are short,
this shouldn't be an issue even for huge input files (though stuffing
the whole thing into a map would be).

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Proxies and overriding protected methods

[Norman Gray]

Cedric, hello.

Thanks for these further notes.  Following your remarks and Chris's, I've 
logged this as a bug at 

I've added a few further comments below.

On 16 Jan 2012, at 17:56, Cedric Greevey wrote:

> A proper clojure finalizer would
> have to be (finalize [] (try (do something) (finally (proxy-super
> finalize. Though finalizers are icky, they probably *should* be
> allowed, for completeness' sake. I'm inclined to regard this as a bug,
> unless someone posts with a convincing explanation why clojure proxies
> having nontrivial finalizers would be a very bad idea.

I was about to disagree with you about finalizers, but on reflection I won't.

I'm in Clojure, having stumbled over the border from Racket, which is a lot 
more comfortable with finalizers, via notions of custodians and wills.  In the 
application I'm working on, I believe I can eventually make (JVM) finalizers 
robust, and in this case there aren't the resource-exhaustion problems that 
convincingly argue against the strategy in general; but since the JLS goes out 
of its way to make only the most evasive guarantees about finalizer behaviour, 
I think one can say that finalizers just aren't JVM-idiomatic, matteradamn what 
the brackets look like, and conclude that I should find another pattern.  I 
feel a with-* macro coming on

> As I understand it, there are two pieces to the proxy.
> 
> One is a subclass of the specified base class and/or interface(s). The
> proxy object is of this class; as you saw, your HashMap derived proxy
> had an (ancestors (.getClass x)) that contained HashMap among other
> things.
> 
> The other component is a map of clojure function objects. The proxy
> object's methods just look things up in this map and invoke them. The
> map can be updated later, with update-proxy, and the existing proxy
> object's methods will change behavior correspondingly, something not
> otherwise possible. That's why there's a default call-super
> implementation of every method, even if you don't override it when you
> first call proxy, because if there wasn't, you couldn't later override
> it with update-proxy.

This is very valuable background.

> Anything called by a Java library in a tight loop via an interface,
> though, you might prefer reify for. Reify has some other features,
> too, and probably some other limitations. Though there's a sizable
> overlap region where either can be used with acceptable results.

It's not clear from the docs what 'reify' returns, but it seems to accept only 
protocols, interfaces or java.lang.Object.  It does appear therefore that the 
only way of extending (in JVM terms) a class is through 
bells-and-whistles-and-gongs gen-class.

Best wishes, to all,

Norman


-- 
Norman Gray  :  http://nxg.me.uk

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Lazy sequence transformation with item merge

[Cedric Greevey]

On Mon, Jan 16, 2012 at 5:28 PM, Cedric Greevey  wrote:
> If you want a map, (into {} (extract ...)). The obvious input source
> is a line-seq obtained somehow. If you want spaces or newlines at the
> concatenation sites (e.g. "value3 takes some more lines as well" or
> "value3\ntakes some more lines\nas well") in the output, change (apply
> str v p1) to (apply str v (interleave (repeat \space) p1)) or (apply
> str v (interleave (repeat \newline) p1)).

Addendum: it looks like maybe you wanted a sequence of strings instead
of a single string as the value, i.e. a sub-line-seq. If so, just
change (apply str v p1) to (cons v p1)!

Also, note that I didn't use interpose in the above rather than
interleave because it would omit a delimiter between the value start
in v and the first continuation of it in p1. Adding an explicit extra
\space or \newline between v and (interpose ...) would result in
single-line values having a trailing space or newline, which I assumed
was undesirable (particularly as you clearly started your processing
by trimming blanks from the ends of input lines!); interleave, on the
other hand, gives exactly the desired result, prefixing every item in
p1 with the delimiter, including the first, and emitting no delimiters
if p1 is empty.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Proxies and overriding protected methods

[Cedric Greevey]

On Mon, Jan 16, 2012 at 5:29 PM, Norman Gray  wrote:
>> Anything called by a Java library in a tight loop via an interface,
>> though, you might prefer reify for. Reify has some other features,
>> too, and probably some other limitations. Though there's a sizable
>> overlap region where either can be used with acceptable results.
>
> It's not clear from the docs what 'reify' returns, but it seems to accept 
> only protocols, interfaces or java.lang.Object.  It does appear therefore 
> that the only way of extending (in JVM terms) a class is through 
> bells-and-whistles-and-gongs gen-class.

That'd be one of the other limitations of reify. In your particular
HashMap-extending case it wouldn't work, though you could implement
Map and delegate to a closed-over HashMap.

Like proxy, though, reify returns an instance rather than creating a
class for later instance-creation (or for static method calls);
deftype, defrecord, and gen-class do that and defrecord makes Map-like
classes (but immutable ones) (you can still add other behavior,
including overriding methods from Object and such).

Think of proxy and reify as somewhat like Java anonymous inner
classes, and deftype, defrecord, and gen-class as somewhat like
non-anonymous Java classes, with defrecord additionally inheriting
many of the behaviors of Clojure's map type.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Controlling the test environment

[Cedric Greevey]

On Sun, Jan 15, 2012 at 6:18 PM, Matt Stump  wrote:
> Is there a way to set different values for global vars when running tests as
> opposed to the development or production environment?  I need to control
> which database my tests for a noir project connect to. Ideally I would like
> to do something like the following: for production and development, if
> an environment variable is set connect to the database server at the
> specified URL, if not then fall back to localhost.  For test start up an
> embedded server, and connect. After the test is done, rollback the global
> var to the previous value and resume connecting to the server on localhost
> or at the location specified by the environment variable.
>
> I could create some fixture with-test-database that modifies a global var,
> but that seems a little hackish.
>
> How are other people solving this problem?  Is there something similar
> pre-baked into noir, clojure.test or midje?

How about with-redefs?

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Lazy sequence transformation with item merge

[Meikel Brandmeyer]

Hi,

here another, slightly different, although in the core similar solution.

(defn pair-seq
  [lines]
  (lazy-seq
(when-let [lines (seq lines)]
  (let [line   (first lines)
lines  (next lines)
equal-sign (.indexOf line "=")
contd  (take-while #(-> % (.indexOf "=") neg?) lines)]
(cons [(subs line 0 equal-sign)
   (apply str (subs line (inc equal-sign)) contd)]
  (pair-seq (seq (drop (count contd) lines

Whitespace handling is left as an exercise to the astute reader. ;-P

Sincerely
Meikel

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

clojurescript goog libs - dispose - and garbage collection

[Dave Sann]

If you use something like goog.async.Delay, or other goog closure libs that 
produce objects that have a dispose method, 

Is it imperative that .dispose is called when you are done with this object?
What happens if not? memory leak?
How do you manage this if you are passing such objects around in function 
closures or other structures 
where you may not (want to) know exactly when this may be no longer 
required?



I was looking at this thread - and the conversion of js/setTimeout to 
goog.async.Delay, along with the enfocus implementation

https://groups.google.com/d/msg/clojure/epHVbmcNzgs/3pVyS_AKCYUJ

from enfocus:

(defn setTimeout [func ttime]
  (. (new goog.async.Delay func ttime) (start))) 


what about functions such as this?

(defn repeat-with-timeout 
  [f t]
  (let [stop (f)]
(if-not (= true stop)
  (js/setTimeout #(repeat-with-timeout f t) t 

Cheers

Dave




-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: strange problem

[Andy Fingerhut]

I don't have enough knowledge to tell you "Oh, just do this, and your Emacs
issues will be solved." but I can give some hints as to what these
characters are, so perhaps others can say, or you can direct your Google
searches in a more focused manner.

I believe those are Unicode characters, and ones called "supplementary"
characters, and thus due to the way Java and Clojure store strings are
stored (which is in an encoding called UTF-16 [1]), they require 2
consecutive 16-bit Java chars to represent.  These don't get tested as
often as characters in the BMP (Basic Multilingual Plane -- this covers the
most common characters used, and require only a single Java char to store),
in most software.  When it comes to copying and pasting them between
applications, or sending them across debug sockets, every piece of software
along the way gets its own chance to muck things up.  Likely a day will
come when software that doesn't handle these things properly will be rare,
but I don't think we are there yet.

The particular characters you gave as an example appear to be Unicode
characters with these code points:

U+1F60A "SMILING FACE WITH SMILING EYES"
U+1F60F "SMIRKING FACE"

I am not sure if these are considered Emoji [2] characters or not, but I
have heard that these characters are getting popular in Twitter, phone text
messages, and a few other places.  I found that out by saving the web page
as an HTML file, opening that file in Emacs, moving the cursor over those
characters, pressing C-x =.  At the bottom of the window doing so shows
this for the first character:

Char:  (128522, #o373012, #x1f60a, file ...) point=26267
of 54273 (48%) columns=91

The empty rectangle is because the font I was using didn't include a glyph
for this character.  the 3 numbers in parentheses are the decimal, octal,
and hex value of the Unicode code point -- I copies the hex value above and
looked up its name in this file:

http://www.unicode.org/Public/UNIDATA/UnicodeData.txt

There are other web sites that let you search for these things, too, and
see them graphically in the browser window even if you don't have the
proper fonts installed.

I don't know if it is only supplementary characters that will cause you
problems, but if so, you can detect strings containing them with a function
like this:

(defn contains-supp?
  "Returns true if the string or CharSequence s contains supplementary
   characters, outside the Basic Multilingual Plane.  Returns false if
   the string only contains characters in the BMP.

   For Java/Clojure strings, which are encoded in UTF-16, a string
   contains supplementary characters only if the string contains at
   least one surrogate code unit in the range U+D800 through U+DFFF."
  [^CharSequence s]
  (if (first (filter #(<= (int Character/MIN_SURROGATE)
  % (int Character/MAX_SURROGATE))
 (map int s)))
true false))

You can leave out the "(if" and "true false)" if you don't mind getting
back nil for false and non-nil for true, which Clojure if/when/etc. all
interpret as false (nil), or true (any value other than nil or false).

Andy

[1] http://en.wikipedia.org/wiki/UTF-16

[2] http://en.wikipedia.org/wiki/Emoji


On Mon, Jan 16, 2012 at 7:58 AM, joachim  wrote:

> Dear All,
>
> I'm not sure if this is the right place to ask, but I am experiencing
> a strange and rather annoying problem, probably in the interaction
> between clojure and emacs.
>
> Basically, I have to deal with strings. Sometimes the strings contain
> non-standard characters (I do not know the nature of these characters
> myself). Here is an example string, with the non-standard characters
> printed as squares:
>
>   "Michelle Obama is a Capricorn !!! Jan 17th. 😊😏 --->
> http://t.co/1moZ4IUZ";
>
> When I run clojure from a terminal and input the above string there is
> no problem:
>
>   joachim@joachim-HP-EliteBook-8440p:~/opt/clojure-1.3.0$ java -jar
> clojure-1.3.0.jar
>   Clojure 1.3.0
>   user=> "Michelle Obama is a Capricorn !!! Jan 17th. 😊😏 --->
> http://t.co/1moZ4IUZ";
>   "Michelle Obama is a Capricorn !!! Jan 17th. 😊😏 --->
> http://t.co/1moZ4IUZ";
>   user=>
>
> However, when I try the same in an emacs repl, I get  "Lisp connection
> closed unexpectedly: connection broken by remote peer". I have no idea
> what is going on or how to deal with this problem. Sometimes during
> development I like to print the strings to see what is going on, but
> this also causes the connection to close.
>
> I would also be happy if I could recognize "problematic" strings, so
> that I can skip them when printing, thus avoiding the problem
> (although this would not really be a solution),
>
> Any ideas?
>
> Joachim.
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this gr

Re: lein-cljsbuild 0.0.1 released

[Dave Sann]

This looks interesting.

I have a couple of comments and questions:

1. I am wary of the copying of cls -> cljs files in the src tree. Due to 
the (inevitable at some point) confusion over which code is authored as 
cljs and which copied. I really think that these need to be kept separate 
(somehow).

2. Do lein "checkouts" work with cljs compilation? 

3. Any thoughts on packaging cljs jars and clj jars?

Cheers

Dave

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: clojurescript goog libs - dispose - and garbage collection

[ckirkendall]

Dave,
I think you are right that my implementation does cause a memory leak
over time.  It interesting that I can't find a single example of
someone calling dispose on an object like this.  The google code for
disposable hold a global reference to all disposable instances and
only removes when dispose it called.  It might be better to use the
static function goog.Timer.callOnce(listener, opt_delay,
opt_handler).


Creighton Kirkendall

On Jan 16, 6:25 pm, Dave Sann  wrote:
> If you use something like goog.async.Delay, or other goog closure libs that
> produce objects that have a dispose method,
>
> Is it imperative that .dispose is called when you are done with this object?
> What happens if not? memory leak?
> How do you manage this if you are passing such objects around in function
> closures or other structures
> where you may not (want to) know exactly when this may be no longer
> required?
>
> I was looking at this thread - and the conversion of js/setTimeout to
> goog.async.Delay, along with the enfocus implementation
>
> https://groups.google.com/d/msg/clojure/epHVbmcNzgs/3pVyS_AKCYUJ
>
> from enfocus:
>
> (defn setTimeout [func ttime]
>   (. (new goog.async.Delay func ttime) (start)))
>
> what about functions such as this?
>
> (defn repeat-with-timeout
>   [f t]
>   (let [stop (f)]
>     (if-not (= true stop)
>       (js/setTimeout #(repeat-with-timeout f t) t
>
> Cheers
>
> Dave

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: clojurescript goog libs - dispose - and garbage collection

[Cedric Greevey]

On Mon, Jan 16, 2012 at 9:45 PM, ckirkendall  wrote:
> Dave,
> I think you are right that my implementation does cause a memory leak
> over time.  It interesting that I can't find a single example of
> someone calling dispose on an object like this.

Perhaps there should be a with-disposables macro in ClojureScript for
things that should be disposed, in much the way there's with-open in
vanilla Clojure for things that should be closed.

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: Could be my favourite improvement in 1.4

[Alex Baranosky]

This seems like a strange special case.

What percentage of users need to paste JSON into the REPL?
Of those users, what percentage of the time do they need to do this?


On Mon, Jan 16, 2012 at 1:19 PM, Tavis Rudd  wrote:

> This issue could be avoided by only treating a colon as whitespace when
> followed by a comma. As easy cut-paste of json seems to be the key
> motivation here, the commas are going to be there anyway: valid {"v":,
> 1234} vs syntax error {a-key: should-be-a-keyword}.
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: clojurescript goog libs - dispose - and garbage collection

[ckirkendall]

Dave,
I found a good explanation of disposables:
http://groups.google.com/group/closure-library-discuss/browse_thread/thread/b2b38d0045464439

Creighton Kirkendall

On Jan 16, 6:25 pm, Dave Sann  wrote:
> If you use something like goog.async.Delay, or other goog closure libs that
> produce objects that have a dispose method,
>
> Is it imperative that .dispose is called when you are done with this object?
> What happens if not? memory leak?
> How do you manage this if you are passing such objects around in function
> closures or other structures
> where you may not (want to) know exactly when this may be no longer
> required?
>
> I was looking at this thread - and the conversion of js/setTimeout to
> goog.async.Delay, along with the enfocus implementation
>
> https://groups.google.com/d/msg/clojure/epHVbmcNzgs/3pVyS_AKCYUJ
>
> from enfocus:
>
> (defn setTimeout [func ttime]
>   (. (new goog.async.Delay func ttime) (start)))
>
> what about functions such as this?
>
> (defn repeat-with-timeout
>   [f t]
>   (let [stop (f)]
>     (if-not (= true stop)
>       (js/setTimeout #(repeat-with-timeout f t) t
>
> Cheers
>
> Dave

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

nrepl client test suite?

[Martin DeMello]

I'm helping develop a native nrepl client for jark, which mostly works
for jark, but doesn't adhere fully to the spec (e.g. multiple value
fields are not handled properly, status doesn't distinguish between
various types of error). I'd like to get it into full compliance so
that it can be useful for other projects. Is there an existing test
suite I can code against?

martin

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: nrepl client test suite?

[Chas Emerick]

Martin,

nREPL has a decent set of tests (in https://github.com/clojure/tools.nrepl), 
though I'm not sure of how applicable / helpful it will be in testing 
alternative client implementations.  Making what's there more helpful for use 
cases like yours is something I'd like to hear about.

BTW, in case you hadn't heard, there will be some changes coming to nREPL 
shortly, outlined here so far:

https://github.com/clojure/tools.nrepl/wiki/nREPL.Next

Being a client implementor, your feedback in this endeavor is most welcome.  
Such discussions should probably head over to the clojure-dev list.

Thanks,

- Chas

On Jan 16, 2012, at 11:34 PM, Martin DeMello wrote:

> I'm helping develop a native nrepl client for jark, which mostly works
> for jark, but doesn't adhere fully to the spec (e.g. multiple value
> fields are not handled properly, status doesn't distinguish between
> various types of error). I'd like to get it into full compliance so
> that it can be useful for other projects. Is there an existing test
> suite I can code against?
> 
> martin
> 
> -- 
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with your 
> first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: nrepl client test suite?

[Cedric Greevey]

On Tue, Jan 17, 2012 at 12:00 AM, Chas Emerick  wrote:
> BTW, in case you hadn't heard, there will be some changes coming to nREPL 
> shortly, outlined here so far:
>
> https://github.com/clojure/tools.nrepl/wiki/nREPL.Next

Hey, this is Clojure. Shouldn't we be eschewing names like nREPL.Next
in favor of (next nREPL)? :)

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Re: strange problem

[Ulises]

> Any ideas?

Perhaps this is what you're after:
https://github.com/technomancy/swank-clojure/issues/57

U

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en