basically you generate the code every time in the module of interest. but in my case, the function f is very huge and i don't want to generate it all the time. so that is not what i want to do either. I have seen that already. That is why i was asking "is there some sort of a special AST node, which resolves the function based on the current scope the code.????"
that would be a lot more helpful. Thanks On Wednesday, February 17, 2016 at 2:12:31 PM UTC-8, Stefan Karpinski wrote: > > module X > export @make_f > macro make_f() > :($(esc(:f))(x) = $(esc(:g))(x)) > end > end > > module Y > using X > g(x) = 3x > @make_f > end > > julia> Y.f(2) > 6 > > On Wed, Feb 17, 2016 at 5:01 PM, Julia Tylors <[email protected] > <javascript:>> wrote: > >> Yes, exactly. >> >> >> On Wednesday, February 17, 2016 at 1:53:57 PM UTC-8, Stefan Karpinski >> wrote: >>> >>> So you want to have a macro that defines f for you in Y such that it >>> calls Y's g? >>> >>> On Wed, Feb 17, 2016 at 4:48 PM, Julia Tylors <[email protected]> >>> wrote: >>> >>>> 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]> >>>>> 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 >>>>>>>>>> >>>>>>>>> >>>>> >>> >
