I know, but would it be possible to generate code in module X, using g as a
globally defined function so that the function g gets resolved based on the
module where f is being used?
Ps: I don't want to pass g as a parameter to f.
Here is an example:
julia> module X
export f
g(x) = 2x
f(x) = g(x)
end
X
julia> module Y
using X
g(x) = 3x
println(f(4))
end
8 *# this should have been 12 if the function g is used from Y, it hasn't
been used because when we look at the AST, we would see it is making a call
to the function g in module X.*
Y
julia> f.env.defs.func.code
AST(:($(Expr(:lambda, Any[:x], Any[Any[Any[:x,:Any,0]],Any[],0,Any[]],
:(begin # none, line 4:
*return (X.g)(x) # here*
end)))))
So in the light of this, is it possible to generate code using a macro with
some sort of a special AST node, which resolves the function based on the
current scope the code.????
On Wednesday, February 17, 2016 at 1:24:33 PM UTC-8, Stefan Karpinski wrote:
>
> There is no g defined inside of module X.
>
> On Wed, Feb 17, 2016 at 3:19 PM, Julia Tylors <[email protected]
> <javascript:>> wrote:
>
>> julia> module X
>> export f
>> function f(x)
>> g(x)
>> end
>> end
>> X
>>
>> julia> module Y
>> using X
>> g(x) = 2x
>> f(4)
>> end
>> ERROR: UndefVarError: g not defined
>> in f at ./none:4
>>
>> I am trying to use another function g(x) which can be defined in any
>> other module by calling function f.
>> This is the idea at its simplest. But It seems it doesn't work.
>>
>>
>> On Monday, February 15, 2016 at 7:03:54 PM UTC-8, Cedric St-Jean wrote:
>>>
>>> Hi Julia, what are you trying to achieve, concretely?
>>>
>>> On Monday, February 15, 2016 at 2:36:15 PM UTC-5, Julia Tylors wrote:
>>>>
>>>> I started to think, this may be normal working of julia.
>>>>
>>>> import X:_ex_func
>>>> using X
>>>> _ex_func() = println("DDD")
>>>> _1ex_func()
>>>> julia> _1ex_func()
>>>> DDD
>>>> sty
>>>>
>>>> julia> module Y
>>>> using X
>>>> _
>>>> _1ex_func __precompile__ _ex_func
>>>> julia> module Y
>>>> using X
>>>> _1ex_func()
>>>> end
>>>> DDD
>>>> sty
>>>> Y
>>>>
>>>> However, it seems once a function is overridden, it stays overridden in
>>>> every module.
>>>> That is a very weird idea. why is there such a design decision? Can
>>>> someone care to explain it?
>>>>
>>>> Thanks
>>>>
>>>> On Monday, February 15, 2016 at 11:04:07 AM UTC-8, Julia Tylors wrote:
>>>>>
>>>>> Guys, this is no solution to my problem,
>>>>>
>>>>> escaping basically tells the the quoted expr to be resolved outside
>>>>> the macro as Lutfullah did. However in my case, escaping a function call
>>>>> doesn't work for some reason.
>>>>> And for that matter, esc should be recursive though...
>>>>>
>>>>>
>>>>> On Monday, February 15, 2016 at 6:44:58 AM UTC-8, Joshua Ballanco
>>>>> wrote:
>>>>>>
>>>>>> On February 14, 2016 at 21:49:30, Julia Tylors ([email protected]
>>>>>> (mailto:[email protected])) wrote:
>>>>>>
>>>>>> > Hi fellows,
>>>>>> >
>>>>>> >
>>>>>> > I was coding a macro, and I am having a prefix issue with
>>>>>> functions.
>>>>>> >
>>>>>> > basically the problem is: Every single one of available functions
>>>>>> (_ex_func) which i want to be globally accessible are prefixed with the
>>>>>> name of the module(X) in which the macro f is defined
>>>>>> >
>>>>>> >
>>>>>> > Here is the code example:
>>>>>> >
>>>>>> > julia> module X
>>>>>> > export @f
>>>>>> > macro f(x)
>>>>>> > st = string("_",x)
>>>>>> > sy = symbol(st)
>>>>>> > esc(quote
>>>>>> > function ($sy)()
>>>>>> > println("st")
>>>>>> > end
>>>>>> >
>>>>>> > function ($(symbol(string("_1",x))))()
>>>>>> > ($sy)()
>>>>>> > println("sty")
>>>>>> > end
>>>>>> > export $sy
>>>>>> > export $(symbol(string("_1",x)))
>>>>>> > end
>>>>>> > )
>>>>>> > end
>>>>>> > @eval @f ex_func
>>>>>> > end
>>>>>> > X
>>>>>> >
>>>>>> > julia> using X
>>>>>> >
>>>>>> > julia> _
>>>>>> >
>>>>>> > _1ex_func __precompile__ _ex_func
>>>>>> > julia> _1ex_func.env.defs.func.code
>>>>>> > AST(:($(Expr(:lambda, Any[], Any[Any[],Any[],0,Any[]], :(begin #
>>>>>> none, line 12:
>>>>>> > (X._ex_func)() # none, line 13: # i want this to be not prefixed by
>>>>>> X
>>>>>> > return (X.println)("sty")
>>>>>> > end)))))
>>>>>> >
>>>>>> > julia> macroexpand(:(@f ex_func))
>>>>>> > quote # none, line 7:
>>>>>> > function _ex_func() # none, line 8:
>>>>>> > println("st")
>>>>>> > end # none, line 11:
>>>>>> > function _1ex_func() # none, line 12:
>>>>>> > _ex_func() # none, line 13: # it seems OK, here!!!
>>>>>> > println("sty")
>>>>>> > end # none, line 15:
>>>>>> > export _ex_func # none, line 16:
>>>>>> > export _1ex_func
>>>>>> > end
>>>>>> >
>>>>>> >
>>>>>> >
>>>>>> > as you may see , I may well define _ex_func in other modules and
>>>>>> use it from the function X._1ex_func().
>>>>>> > But this prevents me doing it.
>>>>>> >
>>>>>> > How can i solve this problem?
>>>>>> >
>>>>>> > Thanks
>>>>>>
>>>>>> OH! I know this!
>>>>>>
>>>>>> Actually, I do believe this is a bug in macro hygiene and have been
>>>>>> meaning to file it. In the mean time, double-escaping should work for
>>>>>> you:
>>>>>>
>>>>>> julia> module X
>>>>>> macro p(y)
>>>>>> quote
>>>>>> println($y)
>>>>>> end
>>>>>> end
>>>>>> macro q(y)
>>>>>> quote
>>>>>> println(:($($y)))
>>>>>> end
>>>>>> end
>>>>>> end
>>>>>> X
>>>>>>
>>>>>> julia> using X
>>>>>>
>>>>>> julia> test = "Hello, world"
>>>>>> "Hello, world"
>>>>>>
>>>>>> julia> @X.p(test)
>>>>>> ERROR: UndefVarError: test not defined
>>>>>>
>>>>>> julia> @X.q(test)
>>>>>> Hello, world
>>>>>>
>>>>>
>
