"Xledger is a finance, project, and business information system that gives
customers tighter control of their businesses.
We are expanding our team in Colorado Springs, which focuses on
Clojurescript (with Om), F#, and SQL Server. We're looking for engineers
who can make a strong contribution t
A shell script written in a procedural style (e.g. with Bash or equivalent
shell language) will frequently start out by declaring some global
variables, then perform some conditional checks (if then else), throw in a
few loops (for, while), and ultimately end up with some new values in those
in
So I've been hammocking it up recently on this subject. Just to add more
philosophical perspective - you could look at the universe in two different
ways: from the _inside_, where a thing subjectively experiences the flow of
time, as the world mutates around it; and from the _outside_, where
object
user> (macroexpand-1 '(defn foo [x] (inc x)))
(def foo (clojure.core/fn ([x] (inc x
If defn is just a macro, then it seems I can do this:
user> (defn bar [] (fn ([x] (inc x
#'user/bar
user> (def foo (bar))
#'user/foo
user> foo
#function[user/bar/fn--10778]
But the result is a little di
Using defining macros as non top-level forms may not be forbidden by the
language but its use is generally discouraged.
See http://clhs.lisp.se/Issues/iss104_w.htm for a discussion about this
issue in Common Lisp for some background context. In short, compile time
effects may not be captured wh
Oh... 'bar' and 'make-step' count as macros? My intent was that they're
ordinary functions that return functions. Am I mistaken? Or does the issue
you referred to apply to using defining *functions and macros *as
non-top-level forms?
(defn bar [] (fn ([x] (inc x
(defn make-step [some-arg
defn, def, etc are what I mean by "defining macros".
On Monday, August 8, 2016 at 5:19:04 PM UTC-4, fah...@gmail.com wrote:
>
> Oh... 'bar' and 'make-step' count as macros? My intent was that they're
> ordinary functions that return functions. Am I mistaken? Or does the issue
> you referred t
def isn't a good example actually because it's a special form. But the same
principle applies when using it as a non-top level form.
On Monday, August 8, 2016 at 5:30:12 PM UTC-4, adrian...@mail.yu.edu wrote:
>
> defn, def, etc are what I mean by "defining macros".
>
> On Monday, August 8, 2016
On Aug 8, 2016 1:52 PM, wrote:
>
> user> (macroexpand-1 '(defn foo [x] (inc x)))
> (def foo (clojure.core/fn ([x] (inc x
>
> If defn is just a macro, then it seems I can do this:
>
> user> (defn bar [] (fn ([x] (inc x
> #'user/bar
>
> user> (def foo (bar))
> #'user/foo
>
> user> foo
> #fun
I don't understand -- How am I using 'def' in a non-top-level-form?
I thought I was calling 'bar', getting the result which is a function, and
binding that function to a name 'foo', where the binding is 'def' at the
top level. Is that not what I'm doing?
I'm trying to avoid the use of unnecess
Ah, are you saying the binding isn't taking place at the top level because
I had to call 'bar' to get the right hand side (so to speak) of the binding?
And if 'bar' were a macro instead, then it would be expanded first and then
nothing would have to be evaluated before binding to 'foo', and so i
On Sun, Aug 07, 2016 at 10:21:44PM -0600, Timothy Baldridge wrote:
> So I'm tempted to ask at this point, what does your program do? If you're
> doing nothing but CPU work, then yeah you may need to do something in the
> main thread. However, all IO work should be done outside of go block. Go
> blo
That good suggestion @ Xiangtao Zhou
I think we also can define customized reader/writer in `(create-table-ddl
table spec)`
```clojure
(create-table-ddl :user [[:name "VARCHAR(32)" {:read identity :wirte
identity}]])
```
On Monday, August 8, 2016 at 6:15:24 AM UTC+8, Sean Corfield wrote:
>
> Tha
13 matches
Mail list logo
