Equivalent of C programming syntax "#define" in Julia language

Question

In the C Programming Language, the #define directive allows the definition of macros within the source code. These macro definitions allow constant values to be declared for use throughout the code.

Macro definitions are not variables and cannot be changed by the program code like variables. We generally use this syntax when creating constants that represent numbers, strings or expressions. like this

#include <stdio.h>

#define NAME "Jack"
#define AGE 10

int main()
{
   printf("%s is over %d years old.\n", NAME, AGE);
   return 0;
}

The beauty is that if I have multiple functions in my code I don't need to input the constant variable into every function, and the compiler simply replaces the defined expression with proceeding value.

Now my question is: Is there any equivalent command in Julia programming for this?

for example

density = 1 # somehow a defined variabe.
function bar(g)
    t =  density +g
end
function foo()
     r = dencity + 2
end 

main()
   g = 10;
   foo()
   bar(g)
end

There is no exact equivalent but you can use `const` instead, — n. m. could be an AI, Aug 13 '17 at 18:45
[Named constants](https://docs.julialang.org/en/stable/manual/variables-and-scoping/#Constants-1)? [Macros](https://docs.julialang.org/en/stable/manual/metaprogramming/#man-macros-1)? — Some programmer dude, Aug 13 '17 at 18:49
do I need to use the variable in the function input arguments every time? — Alireza Ghavaminia, Aug 13 '17 at 18:51
No, the functions have access to (const) variables in global scope — Michael K. Borregaard, Aug 13 '17 at 18:55
And all I needed was a very quick search through the documentation. I've *never* programmed in Julia. I don't want to sound condescending but please try to do it first yourself next time. — Some programmer dude, Aug 14 '17 at 04:01
Why do you expect most of C features to be available mutans mutandis in Julia? — Basile Starynkevitch, Apr 22 '18 at 13:41
@BasileStarynkevitch Im not an English native so I didnt understand `mutans mutandis`. By the way, If Ive understood your question, my answer is "Because I believe that Julia is a strong language".I am currently working in a research center. I have codes from the previous researchers that is written in C\C++, Fortran or Matlab and I need to translate them into Julia If I can find the equivalent of each instruction I don't need to reinvent a new algorithm So it is much more easier for me and my colleagues to understand what is happening. — Alireza Ghavaminia, Apr 22 '18 at 14:36
@BasileStarynkevitch I fined the meaning of mutans mutandis. :)) — Alireza Ghavaminia, Apr 22 '18 at 14:40
Sorry, meant [mutatis mutandis](https://en.wikipedia.org/wiki/Mutatis_mutandis) (latin phrase usable in English & French) — Basile Starynkevitch, Apr 22 '18 at 17:41

Takeshi · Accepted Answer · 2018-05-23T22:23:48.100

You can emulate the C #define behavior with a macro in Julia.

macro NAME()
    return :("Jack")
end

macro AGE()
    return :(10)
end

In the Julia REPL, typing @NAME will return "Jack".

julia> @NAME
"Jack"

julia> @AGE
10

Remember to enclose the macro call in parentheses for safety, e.g.,

julia> println("Hello ", (@NAME))
Hello Jack

julia> println(@NAME * " is " * repr(@AGE) * " years old")
ERROR: syntax: "*" is not a unary operator

julia> println((@NAME) * " is " * repr(@AGE) * " years old")
Jack is 10 years old

But is this really necessary? The idiomatic way in Julia is to define global const variables. Although the documentation discourages the use of global variable for performance reasons, a macro like this does not help you on performance, and you can tell it from the LLVM code.

macro NAME()
    return :("Jack")
end

const name = "Jack"

function f_hello_global()
    println("Hello ", name)
end

function f_hello_macro()
    println("Hello ", (@NAME))
end

For trivial functions like these, you'll find that the LLVM codes look exactly the same (too long; not shown here).

julia> @code_llvm f_hello_global()
. . . 

julia> @code_llvm f_hello_macro()
. . .

Edit: By the way, I would argue that if you have a need to use the global variable, then use it. The argument made in the Julia documentation (current stable version: 0.6.2) is that it may slow down the performance sometimes. However, imagine if a constant is used in 100 functions spread in 20 modules, would you prefer to write the same line of code 100 times and painstakingly check if the numbers are consistent across modules, or would you define it once and use it in all places? I'd think that the proper use of global constants makes the code clean and easy to maintain, and this concern often prevails over a small gain in performance.

score 1 · Answer 2 · answered Apr 22 '18 at 13:19

thanks to all who answered me. I found that global and const keywords will help me do such things but there are some performance restriction on using them i.e. type definition and type recognition of global variables by Julia. Although you can use const and global to make a variable visible in the global scope, it is not recommended in Julia documentations.

Equivalent of C programming syntax "#define" in Julia language

2 Answers2