Julia: शो स्रोत कोड उत्तर से

यदि हम प्रत्येक विधि परिभाषा के स्रोत (संपीड़ित) को संवादात्मक रूप से चलाते समय संग्रहीत करते हैं, तो यह आसानी से किया जा सकता है और स्रोत फ़ाइलों के बदलने पर भी सही ढंग से काम कर सकता है और तब भी जब स्रोत लाइन एनोटेशन बिल्कुल सही नहीं है। आप # 265 ( इस चर्चा को भी देखें) के साथ मदद करेंगे क्योंकि आप चीजों को फिर से शुरू करने के लिए स्रोत का उपयोग कर सकते हैं। हम एएसटी को संपीड़ित रूप में भी स्टोर कर सकते थे - छह बनाम आधा दर्जन।

नहीं, यह # 265 के साथ मदद नहीं करेगा। हमारे पास पहले से ही सभी जानकारी है, यह अब स्रोत कोड जैसा नहीं दिखता है। यदि आप मूल कोड को देखना चाहते हैं, तो सबसे अच्छा तरीका यह है कि आप इसे फ़ाइल से पढ़ें।

@JeffBezanson से सहमत

फ़ाइल से पढ़ने के साथ +1।
बेहतर फिक्स https://github.com/JuliaLang/julia/issues/2594 , यह वास्तव में विंडोज उपयोगकर्ताओं को मारता है जब start एक मूल cmd कमांड और notepad वाक्यविन्यास को उजागर कर सकता है। न तो लाइन नंबर के लिए शो / जंप।
edit वास्तव में एक उपयोगी कार्य है, अगर हम इसे ठीक कर सकते हैं / बेहतर बना सकते हैं।

बस समझने के लिए, यहां यह महसूस किया जा रहा है कि विधियों के स्रोत कोड को प्रतिध्वनित करने के लिए एक फ़ंक्शन नहीं होना चाहिए, बल्कि उस उद्देश्य के लिए 'संपादन' पर भरोसा करना है? यह IPython वेब नोटबुक के साथ अच्छी तरह से नहीं खेल सकता है जो एक दूरस्थ जूलिया कर्नेल के साथ बातचीत कर रहा है, क्योंकि मुझे लगता है कि फ़ाइल क्लाइंट के बजाय कर्नेल मशीन पर खुलेगी।

इंटरएक्टिव मोड में इसके लायक क्या है, मैं फ़ाइलों में क्या है, इस पर भरोसा करने के बजाय, स्रोत कोड को इधर-उधर रखना चाहूंगा। मैं उन चीजों के स्रोत कोड को देखने में सक्षम होना चाहता हूं जो उत्तर के माध्यम से इनपुट थे। # 3988 भी देखें।

पेजर समर्थन # 6921 इस की उपयोगिता पर कुछ चिंताओं को नकार सकता है।

मुझे यह आईपाइथन में बहुत सुविधाजनक लगता है ( func?? माध्यम से), हालांकि - इसके विपरीत जूलिया के मामले में हो सकता है - कुछ फ़ंक्शन छिपे हुए हैं (उदाहरण के लिए अंतर्निहित / साइथॉन फ़ंक्शन)।

इसके अलावा, <strong i="5">@less</strong> func(x) लगभग वैसा ही करता है जैसा @astrieanna माँगता है (पेजिंग के साथ), लेकिन यह बाहरी $PAGER पर निर्भर है।

<strong i="5">@less</strong> func(x) इंटरेक्टिव फ़ंक्शंस के लिए काम नहीं करता है, लेकिन ऐसा लगता है कि एक समस्या है जिसे एक अलग मुद्दे में rephrased किया जाना चाहिए।

यदि निम्नलिखित दो सुविधाएँ उपलब्ध थीं

• उत्तरोत्तर या रनटाइम से एएसटी कोड पूर्व स्रोत प्राप्त करना
• चर / प्रकार / कार्य / प्रकार को पुन: परिभाषित / साफ करना

इसके बाद टाइम कोड लिस्टिंग / ट्रैवर्सल / मैनिपुलेशन / जेनरेशन चलाना संभव हो सकता है।

julia> q=:( function a(i::Int) ; return i+4 ; end ; b=4 ; println(a(b))  )
quote 
    function a(i::Int) # none, line 1:
        return i + 4
    end
    begin 
        b = 4
        println(a(b))
    end
end

julia> function exprdescend(ex) ; if (isa(ex,Expr)) ; println("Descending Expr:",ex) ; println("head:",ex.head); println("args:",ex.args) ; println("type:",ex.typ)  ; for i in ex.args ; exprdescend(i) ; end ; else ; println("*:",typeof(ex),":",ex)  ; end  ;  end
// # ''try it ... long output''

टिप्पणी के जवाब में: JeffBezanson ने 20 मार्च 2013 को टिप्पणी की
"नहीं, यह # 265 के साथ मदद नहीं करेगा। हमारे पास पहले से ही सभी जानकारी है, यह अभी स्रोत कोड की तरह नहीं दिखता है। यदि आप मूल कोड को देखना चाहते हैं, तो सबसे अच्छा तरीका यह है कि आप इसे फ़ाइल से पढ़ें। । "

तो आपको लगता है कि यह संभव है? क्या होता है जहां शामिल हैं / बयान और अन्य चीजों की आवश्यकता होती है?

// # str = read_whole_file_into_a_string(filename)
julia> str="for i in [1,2,3,4] ; println(i) ; end "
julia> s=parse(str)
:(for i = [1,2,3,4] # line 1:
        println(i)
    end)
julia> exprdescend(s)
Descending Expr:for i = [1,2,3,4] # line 1:
    println(i)
end
head:for
args:{:(i = [1,2,3,4]),quote  # line 1:
    println(i)
end}
type:Any
Descending Expr:i = [1,2,3,4]
head:=
args:{:i,:([1,2,3,4])}
type:Any
*:Symbol:i
Descending Expr:[1,2,3,4]
head:vcat
args:{1,2,3,4}
type:Any
*:Int64:1
*:Int64:2
*:Int64:3
*:Int64:4
Descending Expr:begin  # line 1:
    println(i)
end
head:block
args:{:( # line 1:),:(println(i))}
type:Any
*:LineNumberNode: # line 1:
Descending Expr:println(i)
head:call
args:{:println,:i}
type:Any
*:Symbol:println
*:Symbol:i

@hgkamath मुझे डर है कि मैं इस सवाल को नहीं समझता, लेकिन यह उपयोगकर्ताओं की मेलिंग सूची के लिए बेहतर अनुकूल है। कृपया मैनुअल के मेटाप्रोग्रामिंग और प्रतिबिंब अनुभागों को पढ़ें।

एक अन्य उपयोग मामला @generated कार्य (https://groups.google.com/d/topic/julia-users/4pkWhcap1Zg/discussion से) होगा।

ओह, क्या मैंने इसे # 22007 में हल किया है?

सॉर्ट - मुझे अभी भी लगता है कि आरईपीएल मोड में हमें प्रदर्शन के लिए मूल स्रोत को स्टैश करना चाहिए।

अनाम कार्यों को प्रदर्शित करने का भी सवाल है, जहां मूल एएसटी प्रदर्शित करने में सक्षम होना अच्छा होगा।

julia> x -> x+1
(::#5) (generic function with 1 method)

सुपर उपयोगी नहीं है। ( प्रवचन भी देखें)

REPL मोड में

हम पहले से ही मूल रूप से करते हैं, यह केवल उपयोग करने के लिए कष्टप्रद है:

let h = Base.active_repl.interface.modes[1].hist,
    replno = match(r"REPL\[(\d+)\]", $filename)

    replno === nothing || h.history[h.start_idx + parse(Int, replno[1])]
end

"पहुँच के लिए कष्टप्रद" == "काफी उपयोगी नहीं है जिसे हल किया जाए"

मैं मानता हूं कि यह उपयोगी होगा। मैं बार-बार एक फ़ंक्शन को संशोधित करके और उनकी तुलना करने के लिए विभिन्न REPLs में विभिन्न भिन्नताओं को चलाकर डिबग करता हूं। कभी-कभी मैं ट्रैक खो देता हूं जिसमें आरईपीएल किस भिन्नता से मेल खाता है। वर्तमान में परिभाषित फ़ंक्शन को प्रिंट करना तब अच्छा होगा।

Https://github.com/MasonProtter/LegibleLambdas.jl द्वारा प्रदान की गई याओ में एक उपयोग का मामला

हर ब्लॉक में क्वैबिट्स की संख्या का तर्क है, और हम इसे बार-बार लिखना नहीं चाहते हैं, इसलिए जब आप इस नंबर को फीड नहीं करते हैं, तो यह ऑटो-कर दिया जा सकता है, जैसे।

julia> using Yao

julia> control(2, 1=>X)
(n -> control(n, 2, 1 => X gate))

तो उपयोगकर्ता इस बात से अवगत होंगे कि यह एक ब्लॉक नहीं है, आगे के मूल्यांकन के लिए इस संख्या की मात्रा की आवश्यकता है। इससे पहले कि हमारे पास LegibleLambdas हो, यह #42 जैसी एक संख्या के साथ काफी भ्रामक है। यह भी फ्लक्स के लिए होता है जब ऑप्टिमाइज़र पहले एक लैम्ब्डा लौटाते हैं।

लेकिन ऐसे बहुत से कोने मामले हैं जिन्हें हम लेगिबललैम्बस में समर्थन नहीं कर सकते हैं, यह अच्छा होगा, कि हम बाहरी पैकेज के बजाय संकलक के समर्थन से सीधे आरपीपीएल में इन सूचनाओं को प्राप्त कर सकते हैं।

यह अभी भी मुझे विकृत लगता है कि हम इसका समर्थन करते हैं

julia> <strong i="6">@code_native</strong> 1 + 2
    .section    __TEXT,__text,regular,pure_instructions
; ┌ @ int.jl:53 within `+'
    leaq    (%rdi,%rsi), %rax
    retq
; └
; ┌ @ int.jl:53 within `<invalid>'
    nopw    %cs:(%rax,%rax)
; └

और इस

julia> <strong i="10">@code_llvm</strong> 1 + 2

;  @ int.jl:53 within `+'
define i64 @"julia_+_13402"(i64, i64) {
top:
  %2 = add i64 %1, %0
  ret i64 %2
}

और इस

julia> <strong i="14">@code_typed</strong> 1 + 2
CodeInfo(
1 ─ %1 = Base.add_int(x, y)::Int64
└──      return %1
) => Int64

और इस

julia> <strong i="18">@code_lowered</strong> 1 + 2
CodeInfo(
1 ─ %1 = Base.add_int(x, y)
└──      return %1
)

लेकिन यह नहीं

julia> <strong i="23">@code_source</strong> 1 + 2
ERROR: LoadError: UndefVarError: <strong i="24">@code_source</strong> not defined
in expression starting at REPL[23]:1

हम जूलिया का उपयोग करने वाले हर व्यक्ति को पढ़ना और लिखना जानते हैं, सिवाय एक विधि के सभी अलग-अलग संभावित संस्करणों को आत्मसात कर सकते हैं। मैं इसे "मदद चाहता था" के रूप में चिह्नित करने जा रहा हूं यह इंगित करने के लिए कि यह एक वैकल्पिक मोड के लिए भाषा के लिए एक स्वागत योग्य अतिरिक्त होगा जहां हम एक फ़ंक्शन के स्रोत प्रतिनिधित्व को याद करते हैं। इसे इंटरैक्टिव मोड में डिफ़ॉल्ट रूप से चालू किया जा सकता है लेकिन गैर-इंटरैक्टिव मोड में डिफ़ॉल्ट रूप से बंद कर दिया गया है।

इसी तरह की कार्यक्षमता अब https://github.com/timholy/CodeTracking.jl द्वारा कार्यान्वित की जाती है, जो Revise.jl का हिस्सा है। मैं इसके साथ थोड़ा खेला, और जब तक यह सही नहीं है, यह अधिक बार नहीं की तुलना में काम करता है। दस्तावेज़ का कहना है कि यह बहुत बेहतर है जब Revise का उपयोग कर रहे हैं।

इस चर्चा में यह सुझाव दिया गया था।

यह स्वचालित भेदभाव (जैसे https://github.com/FluxML/Zygote.jl) के साथ संयोजन में उत्कृष्ट हो सकता है, क्योंकि आप तब व्युत्पन्न को जूलिया कोड के रूप में दिखा सकते हैं