Why distinguish macro names with @?

[DNF]

@barfo

The negative side is code which looks like modem noise… [if anyone remembers modem noise]

I do remember modem noise But noise is the opposite of signal, the @ carries signal here. It’s the opposite of line noise, which is just extra letters without any useful information.

[barfo]

Yup just extra @'s without useful information.

I wouldn’t put a smiley on being able to remember modem noise.
barfo.

[DNF]

@barfo

I wouldn’t put a smiley on being able to remember modem noise.

No, it’s just line noise ( )

[Henrique_Becker]

The @f(...) syntax is unnecessary, and can be argued to be a complication, yet I welcome it with open arms. The alternative for a macro with multiple arguments which each is an expression and do not fit into a line is:

(@f (...) (...)
    (...) (...))

I never programmed in Lisp, but I believe that maybe your nostalgia is being a tad bit strong if you prefer everyone to be forced to write this case this way.

[Henrique_Becker]

@barfo

Yup just extra @'s without useful information.

I can hardly believe you are arguing in good faith if you just disregard everyone’s points on why they find that @ transmit useful information and just state the contrary as a fact. If you have an eidetic memory, read the whole Base API, and always read the whole API for every package of every code that you will work with, and therefore remember which identifiers are macros and which aren’t, well, good for you, but the language will not be tailored for your specific use case.

As you mentioned, other languages gone the same path, and it is probably for the same reason; this is, the cost of one extra character dwarfs in comparison with the usefulness of immediately knowing if it is a macro or a function that is being invoked. I have used JuMP which API is mostly macros and I found no problem in typing some @ for extra clarity.

I do imagine that you are also against putting ! at the end of functions that mutate their arguments based on the same principle.

[barfo]

No nostalgia involved, what’s the difference between …

@Henrique_Becker

(@f (...) (...)
    (...) (...))

and

@f((...), 
   (...),
   (...),
   (...))

?

extra comma’s in the later maybe?
barfo.

[Henrique_Becker]

The second version could be:

@f(..., 
   ...,
   ...,
   ...)

No inner parenthesis needed.

[barfo]

Assuming the parenthesis were necessary is the first they are necessary in the second.
barfo

[barfo]

ignoring the difference between prefix and infix notation.

[barfo]

for the inner expressions

[DNF]

If you inadvertently push ‘Reply’ before your post is finished, you can click edit (the pencil sign) under your post, to finish it.

[barfo]

yeah…lazy… late here sorry.

[barfo]

And I am just playing devil’s advocate here. I think the language is almost ok. And the implementation has clearly been done well. There are a few things I don’t get, @ being the main one and the “@f …” syntax probably messes with how I think that should work. At a minimum it makes it what I think should happen hard and I don’t understand its benefit.

night night,
barfo.

[liuyxpp]

May I say that I REALLY LOVE this @, which alerts me I am using a macro. As typical scientists, we are most of the time the consumers of macros. And I will take extreme care of these things since it is pretty hard to identify a bug (especially numerically related) involving macros. I feel fortunate that Julia has a tremendous visual hint for macros.

[mbauman]

Remember that @jeff.bezanson is a lisper at heart. Here are his reasons for using the @ sigil back in 2010:

@Email thread with Jeff in 2010

As a lisper, I of course understand the ugliness of @. But I think on the balance it is worth it:

• it alerts you that something different is happening
• it prevents macro names from conflicting with other things
• it allows macros to have paren-less syntax
• it makes it easy to syntax color macros like keywords
• it makes it easier to save pre-expanded code. otherwise, it would be possible for an expression in one file to turn into a macro call as a result of a definition changing in another file (e.g. changing something from a function to a macro). with @, files stay self-contained since we know exactly which expressions to delay expanding.

[jeff.bezanson]

@barfo

which bits of lisp are macros and which bits aren’t, answer: don’t know, don’t care.

It does matter though, because macros aren’t first class. Given (f x), if f is a macro you can’t e.g. use it as an argument to map.

@barfo

yeah well there is the @f … versus @f(…) syntax thing.

Yes we could live without that.

[aplavin]

@DNF

Hey. I can actually do

m = var"@btime"

But can’t call it.

You can, the variable name should just start with @:

julia> var"@mytime" = var"@time"
@time (macro with 2 methods)

julia> @mytime 123
  0.000001 seconds
123

[barfo]

No idea who @jeff.bezanson is… remember I’m the devil…

• who cares
• huh?
• don’t know why you want this anyway
• only green on my vt220
• emacs can figure it out anyway
• makes no sense at all… if it’s precompiled it’s precompiled, get over it if it goes wrong.

some who knows how, kill off this thread. It’s pointless noise now.
barfo.

[barfo]

@jeff.bezanson

It does matter though, because macros aren’t first class. Given (f x) , if f is a macro you can’t e.g. use it as an argument to map .

True… but that doesn’t explain the need to announce f as a macro. If it is, then (map f …) will fail in some random implementation defined way and it’ll do that whether it’s called ‘f’ or ‘@f’.

At least for the syntax which looks like a function call all you’ve done is add @ to the front of all the names.

I haven’t thought about the other syntax because it would not occur to me to use it.
barfo.

[oxinabox]

@barfo

No idea who @jeff.bezanson is

Jeff Bezanson (programmer)