lfe/lfe@d9a4e4d
b935818
lfe-rebar3/compile@6d7a824

rebar 3.0.0+build.3378.refc619921 on Erlang/OTP 18 Erts 7.3

===> Uncaught error: {case_clause,
                             {error,
                              [{error,
                                [{"/path/to/my_project/_build/default/lib/clj/src/clj-seq.lfe",
                                  [{3,lfe_lint,
                                    {redef_fun,
                                     {'LFE-EXPAND-EXPORTED-MACRO',3}}}]}],
                                []}],
                              [],[]}}

Alias to defun.

@dysinger created some nice implementations of various functions and macros in his lfesl project (so far only his thrushing macros have been copied over). In particular, I think I've seen a couple improvements there over what I've done for one or two predicates. That should be reviewed more carefully and then updated with his code.

See https://github.com/dysinger/lfesl/tree/master/include

See the older version of this issue for more context:

• lfex/lutil#14

Treat tuples as vectors.

As with get-in/2.

@rvirding below is the issue I was referring to in the lfe/lfe#201 ticket. I haven't dug into it yet, but I wanted to get this issue created in case you had time before I got to it later today,

Here's the output of compiling (with rebar3):

 ~~>    Compiling ./src/clj-seq.lfe ...
===>        Compiling
            "/home/oubiwann/lab/lfe/clj/src/clj-seq.lfe"
            to "/home/oubiwann/lab/lfe/clj/_build/default/lib/clj/ebin/clj-seq.beam" ...
===>        Config: [{outdir,
                                     "/home/oubiwann/lab/lfe/clj/_build/default/lib/clj/ebin"},
                                 debug_info,debug_info,
                                 {i,"include"},
                                 return,verbose]
===>    Compile results: {error,
                                  [{error,
                                    [{"/home/oubiwann/lab/lfe/clj/src/clj-seq.lfe",
                                      [{3,lfe_lint,
                                        {redef_fun,
                                         {'LFE-EXPAND-EXPORTED-MACRO',3}}}]}],
                                    []}],
                                  [],[]}
===> Uncaught error in rebar_core. Run with DEBUG=1 to see stacktrace
===> Uncaught error: {case_clause,
                             {error,
                              [{error,
                                [{"/home/oubiwann/lab/lfe/clj/src/clj-seq.lfe",
                                  [{3,lfe_lint,
                                    {redef_fun,
                                     {'LFE-EXPAND-EXPORTED-MACRO',3}}}]}],
                                []}],
                              [],[]}}

https://github.com/clojure/clojure/blob/clojure-1.6.0/src/clj/clojure/core.clj#L2683

Hi there,

Nice work bringing some of the great parts of Clojure to LFE.

I'm not sure whether it is even feasible but it would be great to see some of Clojure's threading macros introduced to this library. In particular the -> thread-first and ->> thread-last macros.

Another comparison would be Elixir's |> pipe operator.

Per @yurrriq's suggestion in issue #21, we should add ltest to the rebar.config.

A question is how we are going to map clojure data structures to LFE/erlang? With the CL module we sort of did it but not with everything, for example booleans. Another is how far we want to go with the clojure concurrency types which except for agents don't really map well to LFE.

Need to spend some more time reading about them, but so far it seems that it could provide a nice means of using a single set of functions for map, foldl, filter, take, etc., without having to write a different one for each type (lists, maps, dicts, tulpes, sets, etc.).

We'll see.

Reading:

• http://blog.cognitect.com/blog/2014/8/6/transducers-are-coming
• http://clojure.org/transducers
• http://thecomputersarewinning.com/post/Transducers-Are-Fundamental/
• http://isaaccambron.com/blog/2014/12/13/transducer-composition.html

For full context, see the discussion here:

• lfex/lutil#15

Possibly as an alias for case?

(condp = x
  10 :ten
  20 :twenty
  30 :forty
  :dunno)

I've got an implementation of doto lying around. Should we include it?

Per @arpunk's ticket in the ltest project (see lfex/ltest#34), I'm going to be removing the dep for ltest in clj. But we'll also need a long-term solution (as long as the clj project exists outside of LFE-proper). As such, this ticket has two parts:

1. Break the cyclic dependency experienced by ltest (and projects that wish to use ltest and clj as a dep)
2. Provide along-term solution for bringing ltest into the clj project (mostly for developers and contributors of the clj project)

There are several other approaches we can use. As we bump into a need for pulling down the dep, we can work around it. I'll leave ticket open until that second half is addressed.