Thanks Stephen.
than i will go by passing g as a parameter to f, but that will make me pass
g down to all other functions needing g along the way in the call stack of
f.
Thanks again.
On Wednesday, February 17, 2016 at 2:32:16 PM UTC-8, Stefan Karpinski wrote:
>
> The behavior of a function does not depend on where it is called from,
> that's a basic principle of the language and one that we are not going to
> change. So I think the bottom line is that by design there is no way to do
> what you're trying to do.
>
> On Wed, Feb 17, 2016 at 5:20 PM, Julia Tylors <julia...@gmail.com
> <javascript:>> wrote:
>
>> 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 <julia...@gmail.com>
>>> 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 <julia...@gmail.com>
>>>>> 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 <julia...@gmail.com>
>>>>>>> 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 (
>>>>>>>>>>>> julia...@gmail.com(mailto:juliatyl...@gmail.com)) 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
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>
>>>>>
>>>
>
