Threading macro (->>) parentheses required for functions without arguments

[Madd0g]

I'm new to scheme, but have a bit of experience with clojure. Should providing a bare-function reference to the threading macro work? I get: Error: Generic: macro expansion depth reached!

Reproduction

;; This works:
(->> '(1 2 3 4 5)
 (filter even?)
 (map (lambda (x) (* x x))))

;; This fails with "macro expansion depth reached":
(->> '(1 2 3 4 5)
 (filter even?)
 (map (lambda (x) (* x x)))
 first)

;; This works:
(->> '(1 2 3 4 5)
 (filter even?)
 (map (lambda (x) (* x x)))
 (first))

Thanks

[mattwparas]

Agh, I thought I fixed this bug. Give me a bit and I'll push the fix

[mattwparas]

FYI this is fixed now

[Madd0g]

oh actually another thing I noticed - when I pass a lambda it returns:

#<bytecode-closure>

Repro:

(->> '(1 2 3 4 5)
     (filter even?)
     (map (lambda (x) (* x x)))
     (lambda (lst) (car lst)))

;; => #<bytecode-closure>

[mattwparas]

taking a look

[mattwparas]

So this is behaving as expected, I understand its weird looking, but my implementation is based off of https://docs.racket-lang.org/threading/index.html

If you do:

(->> '(1 2 3 4 5)
     (filter even?)
     (map (lambda (x) (* x x)))
     ((lambda (lst) (car lst)))) ;; add another layer of nesting here

It gets the job done.

That being said in this case you could just put car there as well and it would do the same thing

[Madd0g]

ahh ok!

like we didn't have enough parens 🤣

in my actual use-case I wanted to reposition a parameter (wasn't sure how it's done in scheme, so I was experimenting)

[mattwparas]

yeah so feel free to tinker with the macro, this is the implementation:

(define-syntax l>
  (syntax-rules ()
    [(l> fun) fun]
    [(l> fun args* ...) (lambda (x) (fun args* ... x))]))

(define-syntax ->>
  (syntax-rules ()
    [(->> a) a]
    [(->> a (b c ...)) ((l> b c ...) a)]
    [(->> a (b)) ((l> b) a)]
    [(~>> a b) ((l> b) a)]
    [(->> a b c ...) (->> (->> a b) c ...)]))

I've noticed a small bug in the macro expander w.r.t. using lambda in a pattern, so I'm pushing a fix for that.

In this case you could do:

(define (test a b c) (+ a b c))

(~> 10
       ((lambda (x) (test 10 x 20)))

I think would do the trick.

I don't have the macros as fleshed out as the racket library - that would be nice to be able to arbitrarily move the params around without the ceremony of the wrapped lambda