Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Clojure macros continue to surprise me

tonsky.me

Post reply on HN
Print view View original

11–20 of 31 posts

Re: Clojure macros continue to surprise me

#11

Post by chii »

phoe-krk wrote: post #10
chii wrote: post #9

Earlier quoted context omitted.

no you're misunderstanding me. I'm saying that the macro's purpose is to read the source file and produce something at compile time. It's not a "normal" (read: runtime) function, as this feature cannot be implemented using a function that only executes at runtime.

Sure, but the macro function is a normal function - it has inputs, outputs, and (preferably) should be pure. There's nothing special about the macro function itself, really. You can see it explicitly in Common Lisp, where you can easily access and replace a macro-function with a custom one that you DEFUN yourself, like this. CL-USER> (defun my-quote-fn (form env) (declare (ignore env)) (destructuring-bind (operator &…

> call that function at compilation time

that's why it's called a macro and not a function. You're using the word function in the mathematical sense, and not in the lisp sense.

Re: Clojure macros continue to surprise me

#12

Post by lispm »

chii wrote: post #7
kazinator wrote: post #4

> What if our macro read the source file? > Like, actually went to the file system, opened a file, and read its content? We already have the file name conveniently stored in file , and luckily Clojure keeps sources around. > So this is what I ended up with: > (defn slurp-source [file key] Looks like a function to me (which is good).

it can't be a function because the source is only guaranteed to be available at compile time, rather than at runtime.

It could be a helper-function which gets called by a macro expansion at compile-time. One would define the feature as a function which is available at compile-time and the macro calls it during expansion.

Re: Clojure macros continue to surprise me

#14

Post by KingMob »

chii wrote: post #11
phoe-krk wrote: post #10

Earlier quoted context omitted.

Sure, but the macro function is a normal function - it has inputs, outputs, and (preferably) should be pure. There's nothing special about the macro function itself, really. You can see it explicitly in Common Lisp, where you can easily access and replace a macro-function with a custom one that you DEFUN yourself, like this. CL-USER> (defun my-quote-fn (form env) (declare (ignore env)) (destructuring-bind (operator &…

> call that function at compilation time that's why it's called a macro and not a function. You're using the word function in the mathematical sense, and not in the lisp sense.

I mean, sorta, but Lisp macro writers learn early on that macros are also functions, it's just they operate on a list of symbols, and are called in a different phase.

So saying "it can't be a function" doesn't ring true, either.

Re: Clojure macros continue to surprise me

#16

Post by layer8 »

compacct27 wrote: post #13

The real trick here is dodging ASTs, which, after trying to use in so many parse-the-code projects, really aren’t needed all the time but are put pretty highly on the pedestal

An AST can carry the original source representation on each node as metadata — best of both worlds.

Re: Clojure macros continue to surprise me

#18

Post by kazinator »

chii wrote: post #7
kazinator wrote: post #4

> What if our macro read the source file? > Like, actually went to the file system, opened a file, and read its content? We already have the file name conveniently stored in file , and luckily Clojure keeps sources around. > So this is what I ended up with: > (defn slurp-source [file key] Looks like a function to me (which is good).

it can't be a function because the source is only guaranteed to be available at compile time, rather than at runtime.

It's reading code from a file, which you can make arrangements for to be there at any time you want.

Files are not directly relevant to macros.

The code that a macro invocation has access to by design is the datum which comprises that invocation itself. That may have come from an expression in a file, and may be annotated in some way with the location info. Other than that, macros do not necessarily have access to their textual source code. No such thing necessarily exists because macros can be invoked by code that was generated (possibly by other macros or in other ways) and so never existed as characters in a file.

I don't have a clear picture of the architecture of the system that the article refers to, but the author presents, as his end result, a defn form, which defines a function and not a macro.

If a macro is needed to get that function to be called at compile time, that would be a minor hooking detail, and not an instance of a macro being used to perpetrate a complex code transformation. The function just needs a file name and a string.

(It looks as if the author's system may be interactive; the code files are there all the time and can be changed, and he wants the view of the files to refresh?)

Re: Clojure macros continue to surprise me

#19

Post by kazinator »

chii wrote: post #11
phoe-krk wrote: post #10

Earlier quoted context omitted.

Sure, but the macro function is a normal function - it has inputs, outputs, and (preferably) should be pure. There's nothing special about the macro function itself, really. You can see it explicitly in Common Lisp, where you can easily access and replace a macro-function with a custom one that you DEFUN yourself, like this. CL-USER> (defun my-quote-fn (form env) (declare (ignore env)) (destructuring-bind (operator &…

> call that function at compilation time that's why it's called a macro and not a function. You're using the word function in the mathematical sense, and not in the lisp sense.

The irrefutable fact is that the author presents the core logic of the file-reading solution as a defn, not a defmacro. It may be driven by a macro, but evidently that part is not noteworthy enough to be presented.

Re: Clojure macros continue to surprise me

#20

Post by kazinator »

TXR Lisp:

  $ cat slurp-source.tl
  (defun slurp-source (path key)
    (let* ((lines (file-get-lines path))
           (match (member-if (op contains key) lines))
           (tail (rest match))
           (indent (find-min-key tail : (op match-regex @1 #/\s*/)))
           (dedent (mapcar (op drop indent) tail)))
      `@{dedent "\n"}\n`))
  $ txr -i slurp-source.tl
  1> (put-string (slurp-source "slurp-source.tl" "let*"))
       (match (member-if (op contains key) lines))
       (tail (rest match))
       (indent (find-min-key tail : (op match-regex @1 #/\s*/)))
       (dedent (mapcar (op drop indent) tail)))
  `@{dedent "\n"}\n`))
  t
Post reply on HN