12:51 <Putonlalla> It looks like `free-vars` cannot handle `define` or `define-values`. Is there a procedure that can?

12:54 <bremner> hmm. not an expert, but what happens if you fully expand (I guess to a module form?) first

12:56 <Putonlalla> Forbidden forms may still be present in top-level bindings.

13:07 <Putonlalla> Well, I just got `free-vars: unknown core form: lambda` error message out of it, so now I just think it's broken.

13:13 <Putonlalla> Evaluating `(expand #'(define (twice prc) (lambda (x) (prc (prc x)))))` gives `#'(define-values (twice) (lambda (prc) (lambda (x) (#%app prc (#%app prc x)))))` and then `free-vars` chokes on `lambda` that was supposed to expand into `#%plain-lambda` or `case-lambda`.

13:14 <Putonlalla> So, `expand` doesn't expand according to this. https://docs.racket-lang.org/reference/syntax-model.html#%28part._fully-expanded%29

13:27 <Putonlalla> I can't find any tests verifying this either. There's no `fully-expanded?` defined anywhere.

13:37 <Putonlalla> This is related. https://groups.google.com/g/racket-users/c/RB3inP62SVA/m/54r6pJL0wMYJ

13:45 <bremner> maybe post to discourse? matthew flatt reads that

14:24 <Putonlalla> I think it's faster to implement my own expander.

14:42 <bremner> o.O

14:42 <bremner> ok then.

14:53 <samth> Putonlalla: free-vars expects fully-expanded code and only works on expressions (although changing it to work with define-values would be pretty easy). Here's an example of using it successfully:

14:53 <samth> https://www.irccloud.com/pastebin/0trAUJbz/

14:54 <samth> Putonlalla: also I'm not sure where you got the idea that expand doesn't fully expand programs

14:54 <Putonlalla> Only `#%plain-lambda` and `case-lambda` are in the grammar, while `lambda` is still left after expansion.

14:54 <samth> I think you took the expansion and then typed it in again which doesn

14:55 <samth> 't give the same answer

14:55 <samth> the `lambda` in the output there is the same binding as `#%plain-lambda` in the fully-expanded grammar

14:55 <samth> (which is why `free-vars` works in my snippet

14:55 <samth> )

14:56 <Putonlalla> Oh. That's not very intuitive.

14:56 <samth> the symbol in an identifier representation doesn't tell you what binding it is (and can't)

15:04 <Putonlalla> Now that I spent a little time thinking about this, it also seems like `free-vars` doesn't actually give you the free variables in an expression. It gives you the bound variables.

15:08 <Putonlalla> That is, `(free-vars (expand #'(+ 1 x)))` yields `'()` instead of `'(+ x)`.

15:56 <samth> Putonlalla: mostly this is because you're working at the top level which doesn't really have "free" and "bound" variables. The idea is to look at the "free lambda/let-bound variables of an expression" which is not what `x` is

15:57 <samth> If you want `+` in the output you need the `#:module-bound?` keyword argument