News for hackers. Stuff that matters.
Re:Hy – A Lisp-flavored Python by mthomas on Wednesday August 02, 2017 @04:44PM (#14914448)
I find that both are equally (un)readable. However, for expressions that are that long, I'm inclined to write:

    (setv result (-> (+ 1 3 88) 
                     (/ 2) 
                     (- 8)))
Re:Hy – A Lisp-flavored Python by jamescostian on Wednesday August 02, 2017 @05:26PM (#14914815)
I am not a lisper, but that looks pretty cool. The non-lisp ways of writing that would either require adding parens like GP or writing things like "result /= 2", but that means repeating "result" or whatever variable many times.
Re:Hy – A Lisp-flavored Python by cle on Wednesday August 02, 2017 @05:56PM (#14915060)
This is even better than in-fix notation.
Re:Hy – A Lisp-flavored Python by btschaegg on Wednesday August 02, 2017 @11:54PM (#14916847)
Still being an absolute beginner at lispy syntax, I'll have to ask you the same question though.

While I see the awesomeness in threading macros, I'm usually left pondering a while on where the result actually goes in the next s-expression. How long did it take you to get used to that? Would you prefer someting like `as->` for readability?

Re:Hy – A Lisp-flavored Python by klibertp on Thursday August 03, 2017 @04:05AM (#14917810)
I thought it's a simple mnemonic: -> means inserting the form just after the beginning of the next one, while ->> inserts at the end of it.

You most certainly can have explicit variable to thread through expressions, like this:

   (it-> (form1 it) (form2 3 it 4) ...)
where it means "previous expression". I think there's a Clojure library which already implements this. You can use that if you want.
Re:Hy – A Lisp-flavored Python by serpix on Thursday August 03, 2017 @06:45AM (#14918446)
in Clojure this is achieved with `as->`
Re:Hy – A Lisp-flavored Python by baldfat on Thursday August 03, 2017 @07:20AM (#14918580)
In Racket we actually have a threading macro with ~>

This:

(- (bytes-ref (string->bytes/utf-8 (symbol->string 'abc)) 1) 2)

Becomes this:

(~> 'abc

    symbol->string

    string->bytes/utf-8

    (bytes-ref 1)

    (- 2))

https://docs.racket-lang.org/threading/index.html
Re:Hy – A Lisp-flavored Python by peatmoss on Thursday August 03, 2017 @09:33AM (#14919371)
I believe the use of "~>" rather than "->" in Racket was set in #lang rackjure which adds in some of the Clojure syntax to Racket. Also amusing is their explanation:

> For example the threading macros are ~> and ~>> (using ~ instead of -) because Racket already uses -> for contracts. Plus as Danny Yoo pointed out to me, ~ is more "thready".

http://docs.racket-lang.org/rackjure/index.html#%28part._.Ba...

More thready indeed :-p

Re:Hy – A Lisp-flavored Python by alphapapa on Saturday August 05, 2017 @01:04AM (#14934315)
Emacs 25 has thread-first and thread-last macros in subr-x.el.
Re:Hy – A Lisp-flavored Python by lliamander on Wednesday August 02, 2017 @08:34PM (#14915988)
Also, I've seen lisps that obviate the need for the outermost parentheses (I think by using significant whitespace). In that case, the above example would have as many parens as the python example (for those who are keeping count).
Re:Hy – A Lisp-flavored Python by lliamander on Wednesday August 02, 2017 @08:32PM (#14915977)
Indeed, I like that better than either typical prefix or infix nested expressions.

What do you advise in the case the expression tree is a little bit more complex?

For example: (setv result (- (/ (+ 1 3 88) 2) (* 8 (+ 3 2)))

Re:Hy – A Lisp-flavored Python by jlarocco on Wednesday August 02, 2017 @10:03PM (#14916385)
Because the operators all take a list of values it's sometimes convenient to format them like any other long list, with each nested sub-expression on its own line to form a tree:

    (setv result (- (/ (+ 1 3 88)
                       2)
                    (* 8 
                       (+ 3 2)))
Another possibility is to use a (let ...) to give nested values temporary names, like:

    (setv result (let ((first (/ (+ 1 3 88) 2))
                       (second (* 8 (+ 3 2))))
                   (- first second)))
It helps if "first" and "second" have meaningful names like "velocity" or "force" that can describe what they are.
Re:Hy – A Lisp-flavored Python by mthomas on Wednesday August 02, 2017 @09:17PM (#14916199)
I don't see any clever way to make that more readable. I would have to break it into two subexpressions and then take the difference. i.e.

    (setv e0 (-> (+ 1 3 88) (/ 2)))
    (setv e1 (-> (+ 3 2) (* 8)))
    (setv result (- e0 e1))
Re:Hy – A Lisp-flavored Python by kazinator on Wednesday August 02, 2017 @11:35PM (#14916775)
BTW doesn't setv support multiple pairs?

    (setv e0 (-> (+ 1 3 88) (/ 2)))
          e1 (-> (+ 3 2) (* 8))
          result (- e0 e1))
like setq and setf in CL.