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
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
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
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
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
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
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
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
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
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
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
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
"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
13 matches
Mail list logo
