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
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
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.
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,
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
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
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
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
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
>
> 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
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
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
> (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
> (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.
--
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
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
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.
>
> --
&
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
=
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
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
> 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
([]
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
> 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
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
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
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
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
(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
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
>
> 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
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
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
>
> 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
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
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
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
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
> (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
> 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
(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.
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
> 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
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
> 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
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
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
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
>
>
>> 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
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
>> (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
> (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
> 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
> 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
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,
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
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
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
> 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
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
>
> 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
> 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
> 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
>> 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
> 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
>
> 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
>
> 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
> 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
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
> (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 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
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
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
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
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
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
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 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
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
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
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
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
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
Did you have a look at:
http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf
After p. 50 there is a description of dequeues. I don't know how they
compare to yours.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojur
>
> Is this also useful for implementing something like Datalog? If yes,
> in what ways?
>
> Regards,
> Shantanu
I don't know for Datalog but for Prolog.
Imagine you have
parent(a,b).
parent(b,c).
ancestor(X,Y) :- parent(X,Z) , ancestor(Z,Y). (1)
ancestor(X,Y) :- parent(X,Y). (2)
Now you have t
On Mon, Jan 17, 2011 at 3:10 AM, chris wrote:
> Is it insane to suggest that perhaps clojure should work with scala
> such that we can write both languages in the same file?
>
A lot of reasons for which it is not possible:
- it would mean coordinating two implementations/implementers.
- it would
I never was fully convinced an atom around a functional hash was
perfect for concurrency.
There is no write/write or read/write concurrency possible, even on
independent data.
Someone was working a while ago ob TransactionalHashMap, if I recall well.
Is there something already to benchmark agains
After a few thoughts, I think this is a mistake not to allow this,
even if it his highly discouraged.
I think indeed, if you consider the data-structure usage of types and
Objects it is a very bad idea to have a mutable private field.
But some type you create are not for holding data on the long-
On Thu, Dec 23, 2010 at 10:29 PM, Meikel Brandmeyer wrote:
> Hi,
>
> Am 23.12.2010 um 23:15 schrieb nicolas.o...@gmail.com:
>
>> If I were to write such a patch, would it be accepted?
>
> I lean now quite a bit out the window, but I dare say: „No.“ The reason I
&g
On Thu, Dec 23, 2010 at 9:28 PM, Meikel Brandmeyer wrote:
> Hi,
>
> Am 23.12.2010 um 15:26 schrieb nicolas.o...@gmail.com:
>
>> Is there a way to make some mutable fields public in a deftype?
>
> I think it is opinionated, that this is not possible as the documentation
Dear all,
Is there a way to make some mutable fields public in a deftype?
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 are moder
Which version of Clojure are you using?
(How to speed that up depends a lot of the version you use)
I would like to see a with a longer run.
Optimised clojure is *asymptotically* nearly as fast as Java.
With under 1000 calls I am not sure the JIT is called.
Best,
Nicolas.
On Wed, Dec 22, 2010
It's a funy and original trick but on this example at least,
it seems slower (and it can use a lot of memory, because it retains a
stack in the heap) than trampoline:
(time (get-value (even 1500)))
"Elapsed time: 1899.881769 msecs"
And a version with trampoline
(defn odd [^long x]
(i
I have an example to clarify what I understood of your idea:
(declare odd)
(defn even [x]
(if (zero? x)
[true]
(lazy-seq nil (odd (dec x)
(defn odd [ x]
(if (zero? x)
[false]
(lazy-seq nil (even (dec x)
(defn get-value [l]
> Yes I know, I thought the way I wrote the code was clear about that :)
I am sorry, I did not understand.
So let me try to explicit your transformation (please correct me if I am wrong):
- start with some mutually recursive functions: a and b, for example
- create a "lazy stack" for the recursiv
> With TCO mutually recursive functions do not consume the stack. The same is
> true for well constructed lazy sequences.
> David
With TCO, mutually *tail* recursive functions do not consume the stack.
non-tail call always consume the stack in non CPS compiled languages.
(In which, it consumes th
> Those are mutual recursive functions. Trying to define them as regular
> functions will quickly result in a stack overflow.
> You could use trampoline but in my experience you will take a significant
> performance hit.
> Lazy sequences are a way to efficiently represent mutually recursive
> compu
> In my experience lazy-seqs are a reasonable replacement for the lack of TCO,
> and from what I've heard that is one of the reasons they exist.
> (defn a [x]
> (lazy-seq
> (cons x (b (inc x)
> (defn b [x]
> (lazy-seq
> (cons x (a (inc x)
> David
>
I am not sure I get you. C
>
> I am not a Clojure expert. But if I understood Clojure correctly,
> Clojure would not be Clojure if it where natively compiled. Eg. The
> whole lazy seq's are required because of lack of tail call
> optimization in the JVM. Or am I wrong?
>
>
I don't think the lazy seq are necessary because of
If you want native with enough reflection to compile clojure,
Objective-C might be a better choice than C++.
--
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
If you wait for clojure in clojure and then use VMkit (LLVM based
thing to do Virtual Machine), it can be an interesting project.
I am not sure if it would be considered as really native, though.
Nicolas.
--
You received this message because you are subscribed to the Google
Groups "Clojure" grou
1 - 100 of 139 matches
Mail list logo
