Part of the problem is that you confuse compile time and runtime.
Macro are evaluated at compile-time.
So when you write:
(my-macro SomeClass. a b) , my-macro can't access the runtime value of a and b.
So if you want your second example to work, you need flatten to be
called at runtime and not
On Fri, Apr 20, 2012 at 11:14 AM, Marc Limotte wrote:
> Thomas,
>
> Try this:
>
> (defmacro my-macro2 [func & args] `(~func ~@(flatten (eval (vec args)
>
>
This won't work for:
(let [a [2 3]] (my-macro2 SomeClass. a))
--
You received this message because you are subscribed to the Google
Gr
This is not the idiomatic way but you can stay quite close from your code by:
(defn game [ board ]
(fn [n i]
(cond
(= n :x) (game (assoc board i 'x))
( = n :o) (game (assoc board i 'o))
(= n :print) (println board
(defn (new-game (game (in
It looks very good.
Just a few side-notes:
- this representation is quite well known, as it is the Church
encoding of list, often used in System F, for example.
It corresponds to stating the definition of sequences as the
initial algebra of F A = 1 + Any x A.
- you can play a dual trick for S
On Wed, May 9, 2012 at 1:00 PM, Rich Hickey wrote:
> This analogy is not quite right.
>
>> (fn [n] (vector n (+ n 1))
>
> is not a reducing fn. Tt is a cons cell builder, and the Church encoding
> builds lists.
>
It is because I did not write it in the right way. Sorry about that.
It can be made
On Wed, May 9, 2012 at 5:01 PM, Rostislav Svoboda
wrote:
> On 9 May 2012 17:31, Tassilo Horn wrote:
>> you should bind *read-eval* to false when reading data from unknown sources.
>
> This is the point! On one hand I need to evaluate data from a client
> on the other hand I'd like to filter out t
I can describe the background to understand my last email.
>From the programming point of view, I have been told since yesterday
that what I explained has already been explained better in "Stream
Fusion From Lists to Streams to Nothing at All" from Coutts
Leschinskiy and Stewart:
metagraph.org/pa
On Fri, May 11, 2012 at 12:47 AM, Rich Hickey wrote:
> IMO, Nicolas' material is a distraction in understanding reducers, except as
> historical background.
I perfectly agree.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, s
Dear all,
Is there a way to apply a function to all members of a transient map?
Best regards,
Nicolas.
--
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 a
So, if I have a transient and want to reduce it and then continue to
use it transiently,
I need to call persistent!, reduce and transient again.
Is there a reason for that?
(The documentation says that read operation are allowed. And it is
actually possible
to write a reduce for a transient vecto
Any android port in the pipeline?
--
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 fr
LoL is a good book. Very entertaining, even if part of the content is debatable.
(It is a very opiniated book)
Reading it after On Lisp could be a good idea, as there are a few
references from LoL to On Lisp.
http://www.paulgraham.com/onlisp.html
The book is definitely a good read, makes you think
I think part of the problem is that commute should not return any result.
You are not sure this is actually the value that will be returned,
this is costly
and misleading.
There should be at least a variant of commute that return nil.
--
You received this message because you are subscribed to th
> (extend Employee
> AProtocol
> (merge default-implementation {:new-function (fn ...)}))
>
But you lose a bit of performance with that...
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@go
I had wished such a feature all week.
You don't need it often, but when you need it, it is really annoying
to circumvent.
traits would really be useful.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googl
> So I suggest you take it to heart. Put deftype, defrecord and defprotocol
> away and don't pull them back out for quite some time. At the beginning,
> they are just a distraction from Clojure's core philosophy. Focus on maps,
> vectors, sets, functions, multimethods and macros.
But there are
>
> Have you actually looked at the data structure implementations in
> ClojureScript? The work is done. It's all protocols.
>
Hi David,
I just have. This is a nice work. There is a lot of repetitions though.
For example:
- IEquiv
(-equiv [coll other] (equiv-sequential coll other))
- IHash
>
> And now any of those implementations can easily change at anytime without
> any external considerations. So what's the problem?
Well if you want to amend all of them at the same time, you have to
modify all of them.
On your advice of using extend-type: maybe I am wrong but I think it
has a pe
> Same here--I can count on one hand the number of times I've wanted to
> implement polymorphism in three and a half years. Every time
> multimethods have worked great for the task. If you had polymorphism
> in a tight loop they might not suffice, but the decision to abandon
> multimethods should o
>> On the other hand, defrecord/deftype encourage you to write your protocol
>> implementation in a way that cannot be reused unless you very specifically
>> plan for it (factoring the protocol implementation into a separate map) and
>> use a coding style that (might?) be less efficient (i.e., addi
> Everyone just reiterates the mantra “It's slower! It's slower! It's
> slower!”, but no one talks about the trade-offs. And I bet only a very
> small fraction ever checked what “slower” means in their specific use
> case.
I think the whole thread is about the trade-off: some people complains
that
> The only exception is mutable fields in the type where you don't want
uncontrolled access. There you indeed need a protocol to handle the
synchronisation of the field access.
>
>
And then you need to include everything accessing the internal state of
your data structures in a big deftype with lit
>
> Access internal state?
>>
Like __hash in your code.
>> For example, the earlier hash example cannot be put as an extension.
>
> Why should most extensions manipulate mutable fields?
>
Most certainly won't. Now none of them can.
--
You received this message because you are subscribed to the
Dear all,
Is there a way to write something like:
(let [x (foo1 (fn [] (bar y)))
y (foo2 x)] )
where the y on line 1 refers to y in line 2?
I currently use an atom and an affectation to "tie the loop"...
Best,
Nicolas.
--
You received this message because you are subscribed to
> I agree with the other commenters that letfn is good when you can use
> it, but here you can't use it. Your general approach is really the
> best you can do, though it's nicer to use promise/deliver than atom/
> swap!, since these values are never going to change again.
I was looking for somethi
It is not totally clear in your post how you want to keep the data?
Is it in memory (with a transactional log somewhere)?
If it is the case, you can do better than reducing the whole data set
when executing a query:
you can keep a cache of query results, or indexed data and maintain
it, while still
Stack-overflows in quicksort can mean that you are hitting the worst
case of this algorithm complexity.
(Meaning that you are sorting an array already sorted in one direction
or the other.
In this situation, the size of the recursive call are n - 1 and 0,
instead of being roughly n/2 for both calls
that mutation inside piece is
> the only non-functional detail...everything else I am indeed returning new
> boards, new pieces (promotion, death etc)...
>
If I were you, I would look into a way to make Pieces pure too.
Because their mutability cascades into the whole state and makes the descript
On Wed, Jun 13, 2012 at 10:46 AM, nicolas.o...@gmail.com
wrote:
> that mutation inside piece is
>> the only non-functional detail...everything else I am indeed returning new
>> boards, new pieces (promotion, death etc)...
>>
>
And from what I understand of your design,
> different positions now or some are nil (dead))... if i make the pieces pure
> what comes to mind is resetting or swapping possibly 32 atoms instead..
No, you will have an atom containing a new board with new pieces in
their new position.
(By the way, you can go a long way writing what you want
> you mean making 32 new pieces after each move regardless of whether they
> moved or not? how can I identify the ones that are different from the ones
> that remain unchanged so i can conj them in a new list? move will eventually
> call 'build-board' which has to look somewhere for the current pie
> (defn move
> "The function responsible for moving Pieces. Each piece knows how to move
> itself. If trying? is true, there will be no histiry of the new state of the
> board. Returns the new board."
> ^clojure.lang.PersistentVector
> [game mappings p coords]
> {:pre [(satisfies? Piece p)]} ;saf
>> (defmacro in?
>> "Returns true if colle contains elm, false otherwise."
>> [colle elm]
>> `(if (some #{~elm} ~colle) true false))
Yes. Should not be a macro. (There is no reason for it to be a macro).
On top of that, it is not very often useful to convert nil to false as
clojure understands n
On Thu, Jun 14, 2012 at 6:19 PM, Jim - FooBar(); wrote:
> I don't see why not if you really really need to return true/false...
>
Because it can be written as a function. Macro are only for things that
cannot be easily written as functions.
(And then it should be backed by functions that are usa
>
>
>> why add the extra overhead of potentially boxing/unboxing x in such a
> simple case? Its not like the macro is getting out of control...Its a one
> liner...
>
> Because functions are first class and not macros.
Ex:
(map to-bool l)
--
You received this message because you are subscribed to
Yes.
For example, you can have a look at CPS transformation.
If you want tail recursion and not tail calls, you can add
trampolining to the mix.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroup
On Mon, Jul 23, 2012 at 3:14 PM, Mimmo Cosenza wrote:
> hi Merek and thanks for the link. But it does not answer my question.
> I was looking for a demonstration of the reducibility of (not tail)
> recursion to tail recursion. Or there is a demonstration of that, or nobody
> could say that a (not
Hi,
Great notes. I like a lot.
A few (mostly technical) comments:
> Concept of Computation
>
> What does it mean to compute? Turns out this is a complicated question. From
> what I can tell, to compute is an actualization (or concrete version) of a
> mathematical function. We are swimming in a
> There is indeed an infinite number of functions, or relationships between
> natural numbers. I don't think that means that that any one of those
> relationships is not computable because it is within the range of infinite
> functions. The countable parts of a program can still accept an infinite
Another one. (The exception is for early termination)
(def found! (Exception.))
(defn has22 [l]
(try
(reduce #(and (= 2 %2) (or (not %1) (throw found!))) false l)
false
(catch Exception e true)))
--
You received this message because you are subscribed to
> The technique, using throw an Exception when succeeded in searching, strikes
> me!
You can make it less ugly with a bit of library:
user> (deftype EarlyExit [result])
user.EarlyExit
user> (defn early-exit [x] (EarlyExit. x))
user> (defn reduce-with-early-exit [f acc coll]
(if (insta
Constructors are not a good idea, because they tie the functionality
to the implementation.
You want to be able to change your record to something else without
changing your client code.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to thi
(defn recurse [f] (fn [& args] (apply f (recurse f) args)))
(def fac
(recurse (fn [self n]
(if (zero? n)
1
(* n (self (dec n)))
There is a performance cost. recursive can be specialised on different
number of arguments, to reduce
this cost.
> My answer to this is: everything is an implementation at some level. So do
> you think we need factory functions of factory functions, and factory
> functions of factory functions of factory functions? I am sure that will be
> more flexible than just one level of factory functions.
We already ha
> (defrecord MyRecord [x y z]
> (make-record [arg1 arg2 arg3 ...] ...))
>
> (make-record MyRecord arg1 arg2 arg3 ...)
This construct is not very good. make-record is not first-class (It
cannot be used as an argument to a function).
Its first argument is not first-class (it has to be statically t
There is no such thing in Clojure.
Separation of IO and non IO is done by:
- encouraging pure functions
- providing very good pure data structures, and libraries
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo
trampolines is a slightly different example.
--
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 uns
Visualvm is quite nice and simple to use.
On 10 Aug 2012 23:21, "Hussein B." wrote:
> Hi,
> I want to measure how much space an algorithm is taking and then trying to
> change some aspects to see how things are going to differ.
> I also want to measure how much time it takes to complete an operat
First solution:
(defn groupSum [l x]
(or (zero? x) ; we have won!
(and (not (< x 0)) ; we can't win
(not (empty? l)) ; lost!
(or (groupSum (rest l) (- x (first l)))
(recur (rest l) x)
The "we
>
> How do I construct a combining fn out of 'max-key' and is there an idiom or
> a pattern for doing so?
You might use the fact that -Infinity is a neutral element for max.
(Or the smallest long if you work with longs).
Alternatively you can represent your value as either a number or nil,
nil bei
Hi Jim,
I tried a bit.
The performance of this is not perfect but seems not horrible.
It can do a level 5 exploration in 11 sec on my computer, with a
branching factor of 30.
(Of course, there is very little computation for the next move.)
The generation is now lazy, but the depth is used in the e
By the way, I just found an obvious bug in that code, but
that should be easy to correct.
(if (= res Double/NEGATIVE_INFINITY) (evaluate (:board tree))
res
This is obviously wrong.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To
>
> thanks a lot Nicolas...I'll definitely play around with your code tomorrow
> morning...if you say you can go up to level 5 in 11 sec this is really good
> performance -I can't wait to explore the code...I'll let you know of any
> comments of mine soon!
>
>
Of course, don't trust this code. I ha
A correction for the wrong part:
(defn my-max ([x y] (if (nil? x) y
(if (nil? y) x
(max x y
([] nil))
(defn tree-value ^double [tree evaluate ^long depth]
(let [children (:children tree)]
(if (or (zero? depth))
(evaluate (:board t
(defn generate [board next-boards]
;; next-boards return a seq of MoveAndBoard
(BoardAndChildren. board
(r/map (fn [m]
(MoveAndTree.
(:move m)
(generate (:board m) next
Dear all,
What is the meaning of :while in a for?
I understand :when, and also that :while jumps more element when the
condition is not met,
but where does it jump to exactly?
Best regards,
Nicolas.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
T
I understand now.
The documentation could be clearer on that.
Your triangular example is very clear.
--
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 mod
Hi,
3 questions:
1. Are you sure your moves list at the op level is in a vector?
Looking at the code for reducers, it seems that it is the only
implementation actually doing concurrency.
2. The default block size for spawning a new thread is 512. Meaning
that if you have
less than 512 first m
Sorry, I forgot to convert to a vector:
(defn best-move "Start folding here." [dir b d]
(r/fold 1 best best
(r/map #(Move-Value. (:move %) (search score-by-count (:tree %) d))
(into [] (:children (game-tree
dir b next-level))
--
You received this
> In particular, if I attempt to replace the `r/reduce` call on line #23,
> with a call to `r/fold`, I get the following crash:
>
This calss sems strange.
remaining? should represent a monoid for it to work.
Meaning two functions:
1 -> A and (A -> A -> A)
In your code, the case with no arg return
On Wed, Aug 22, 2012 at 1:53 PM, Jim - FooBar(); wrote:
> Ok, so I followed your suggestions and the block size did the trick with
> regards to using all 4 cores of mine...However, even so, I get no
> performance improvements!!! It still needs close to 4 min to go to level 4
> and it still needs 5
> I'm really sorry but I don't follow...I'm only doing (:value best) or
> (:value next). best or next return a Move-Value (it has :move and :value
> keys) where the :value key could be Integer/MIN_VALUE - I'm not doing
> (:value Integer/MIN_VALUE) anywhere...
Then you want to write:
(defn best
([]
You should replace your functions that computes the board by function
that does return 30 times the same board.
And evaluation function by something that returns a constant value.
And check : speed and speed-up for folding.
Then you will know for sure whether the slowness comes from the
explore an
=
On Tue, Aug 21, 2012 at 11:50 AM, Arie van Wingerden wrote:
> Extra restrictions on (range of values of) variables used in the for.
> See here:
> http://clojure.github.com/clojure/clojure.core-api.html#clojure.core/for
>
The link says nothing about the meaning of the modifiers.
(I agree it shoul
If it is so slow, that's maybe because the branching factor is very high.
Could you have an atom incremented in your evaluation function, or in
next level, to check how many boards are generated for level 2 or 3?
(At least this could give an approximate time for computing each board.
(83 - 8) / num
gt; Note: Anyone with a free account can add/edit examples on that site.
>
> Andy
>
> On Aug 21, 2012, at 8:34 AM, nicolas.o...@gmail.com wrote:
>
>> I understand now.
>> The documentation could be clearer on that.
>> Your triangular example is very clear.
>
> --
&
More optimsation ideas:
> (defn next-level [b dir]
>
> (r/map #(Move->Board. % (core/try-move %))
> (core/team-moves @curr-game b dir))) ;;curr-game is a promise
> (definline team-moves
> [game b dir]
> `(let [team# (gather-team ~b ~dir)
>tmvs# (r/mapcat (fn [p#] (r/ma
Dear all,
After reading this:
http://infoscience.epfl.ch/record/169879/files/RMTrees.pdf
I was wondering what was the current performance characteristics of
the different ways to
concatenate arrays in clojure?
Best regards,
Nicolas.
--
You received this message because you are subscribed to
> (and creates vectors via (into [] (r/map )))
Depending of your method of scoring, you could try to do it just with a reducer.
(Without creating a vector with it).
If your code does not spend its time in GC (can be seen in the first
pane), CPU sampling might be a better place to look.
--
> (defn score-by-count ^long [b dir]
> (let [ hm (into [] (core/gather-team b dir))
>aw (into [] (core/gather-team b (unchecked-negate dir)))]
> (unchecked-subtract (count hm)
> (count aw
>
(defn counting-accumulator [acc _]
(inc acc))
(defn score-by-count ^lo
Here's my take:
We want to define a function my-comp. It takes n functions and return
their composition.
We want to return a function of any number of arguments, so let's
start by working with a given
set of argument args, and returning the value of the composition
applied to those arguments.
- I
On Sun, Aug 26, 2012 at 3:07 PM, David Nolen wrote:
> I haven't found this to be the case. Java fares pretty well on Alioth.
http://shootout.alioth.debian.org/help.php#java
Shows that it does not change much on programs that run for mor than a
few seconds.
--
You received this message because
>
> 1. Gary Bernhardt has been playing with a "new" approach he calls
> "Functional Core, Imperative Shell". Essentially, it's another take on
> the question of how to limit the scope of mutation in order to get the
> most out of the correctness of mutation-free algorithms and the
> performance of
It is quite easy to write a macro define in clojure that does that:
(defmacro define [head & body]
(if (sequential? head)
`(define ~(first head) (fn [ ~@(rest head)] ~@body))
`(def ~head ~@body)))
(define ((A [p1 p2]) [p3 p4]) [p2 p4]))
((A [1 2]) [3 4]) => [2 4]
--
You recei
I tend to like 1 better. I do not like working with vars without a good reason.
--
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 pa
Clojure is a good language to start.
The only thing is that there are more ressource for beginners in other
languages.
For Racket (another Lisp), you have the very good:
How to design programs.
http://www.ccs.neu.edu/home/matthias/HtDP2e/
(this is the second edition, you might have to peak in th
No continuations or coroutines support on the JVM, as far as I know.
However, there are a few monad libraries for clojure with which you
would probably
be able to do what you want. (Using the continuation monad...)
http://www.intensivesystems.net/tutorials/monads_101.html , for example.
Delimited
Depending of the code they have to write, you can walk their code at
compile time and transform it to
monadic normal form or CPS style, which would allow to do what you want.
I would tend to think that with a lot of threads you will win with
closures and not native threads.
And would only a few th
You have 2 distinct problems:
- allocating many short-lived objects. It can affect performance but
does not matter for long-term memory occupation
- keeping too many things in memory. Then you have to resolve an
algorithmic question, quite independent of
the technology you use.
On Wed, Oct 3,
The usual approach to this kind of things is to have a Functional
representation of the world, that contains the game logic. To have
pure functions that modifies the world with the time and inputs of
players.
And everytime you want to render a frame to call a render function
that does all the work.
In a few lines:
Monads are a common framework to represent any sequential computation.
What is a sequential computation?
- either no computation at all.
return :: a -> m a
does that.
- or I have already a computation and want to go on with my computation.
But then, I need to be able to look
I would think so.
But to maximise your chances of getting useful help, it is often
better to post small pieces of codes and explain what
you are trying to achieve with them.
Best,
Nicolas.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to
I happened to stumble on something like that in 1.2, with
= slower than >=, which is in turn slower than zero?.
(Even when everything is a primitive)
I never really understood why and would be happy to understand it better.
Dimitry, have you tryed to replace (= x y) by (zero? (- x u)), or with
an
You can try == for numbers
--
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
Maybe optimizing now is a bit early, as a lot of the performance
caracteristics of clojure programs will
change with 1.3.
Might be better to start writing programs that will be fast with 1.3.
On Tue, Oct 26, 2010 at 9:46 AM, Marko Kocić wrote:
> Clojure has recently been added to http://shootout
You need to use both eval and a macro to get then environment.
I think &env contains the lexical environment in any macro call now.
(I don't know in each form though).
So you need to walk the term, looking for free variables, close under
free variables by creating a function and then call eval.
Th
Functor's fmap in Haskell is passed where to apply the function as an
(hidden in the type class dictionary) argument.
You would need somehow to be more specific about where you want to
apply your function in the data-structure.
(On predefined position, a la Functor, or on every leaf, with a
defini
As I understand it, m-seq is transforms a list of monadic computation
into a computation returning the list of result.
The resulting computation just sequentially does every computationin
the sequence and keep the result.
It is useful when the arity is not known at runtime foir example.
On Tue,
Some things are certainly possible. It depends whether you consider
all computers to be friendly of
some of them to be evil.
If all of them are friendly, you can annotate your data by permissions.
Else, you need either to check what you send to other computers, or
crypt with different keys.
--
On Wed, Nov 3, 2010 at 10:32 AM, ka wrote:
> 1. How to combine protocols?
>
AFAIK, it is not possible. You must implement all the different protocols.
It might look desapointing, but on the other hand it is not necessary.
(As there is no static typing in Clojure)
What is your use-case?
> 2. Do
Very fast 3 minutes talk could be fun too.
Name, nicknames, and what you are using Clojure for.
No slides of course.
Best,
Nicolas.
--
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 t
I see your point.
Somehow, it is annoying to have to manipulate a set of protocols that
always go together.
And it would be nice to have a shorthand.
I have a very small prototype here:
git://nicolasoury.repositoryhosting.com/nicolasoury/type-classes.git
of some code to allow "type-classes" like
Dear all,
Currently swank-clojure SNAPSHOT does not show the stack, nor the
exception, on some uncaught exception.
Is it something I can do to inspect the errors?
Best,
Nicolas.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group
On Sun, Nov 7, 2010 at 3:28 PM, iko...@gmail.com wrote:
> 2010/11/7 David Sletten
>>
>> Or for those of you who prefer that other people won't be able to read
>> your code:
>> (defn foldr [f coll]
>> (reduce #(f %2 %1) (reverse coll)))
>>
>
fold-right can not be made tail-recursive and in one-p
If you want that, you don't need macro.
(defn bench [f]
(let [start ...
result (f)] ; note the call to f
))
But you would have to call it with:
(bench #(expr)) or (bench (fn [] expr))
You cannot do it directly because it would evaluate expr before the
call to bench.
This one
Last point: on very fast bench, the time of a function call is not negligeable.
--
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 pa
Sorry. Last line should read:
(defmacro bench [expr] `(bench-fn (fn [] ~expr)))
On Tue, Nov 9, 2010 at 1:06 PM, nicolas.o...@gmail.com
wrote:
> If you want that, you don't need macro.
>
> (defn bench [f]
> (let [start ...
> result (f)] ; note the call to f
>
A solution based on unfold with the last element read (or initially
nil) and the rest of the list as a seed.
On Thu, Nov 11, 2010 at 12:12 AM, David Jacobs
wrote:
> Thanks for all of the options, and Ken, thanks for the detailed comparison.
> This will be extremely useful. (I'm trying to port so
JVMs has a strange limitation for the size of methods.
I don't know if there is a plan to solve that on the JVM side.
It is quite hard to solve that on the compiler side.
When I bumped inot this (once for an ICFP contest), I rewrote a macro
so that it emitted
smaller methods called from a big meth
> I believe the underlying problem is a limit of the JVM. Maybe it
> would be possible for the Clojure compiler to work around the
> limitation, though.
It has a non trivial interaction with the lack of TCO.
The trivial transformation of going from a big method to a sequence of
small methods coul
1 - 100 of 139 matches
Mail list logo
