Julia: показать исходный код функции из repl

Если бы мы сохранили исходный (сжатый) источник каждого определения метода при интерактивном запуске, это можно было бы сделать довольно легко и работать правильно, даже когда исходные файлы меняются, и даже когда аннотация исходной строки не совсем идеальна. Это также поможет с # 265 (см. Также это обсуждение ), поскольку вы можете использовать исходный код для перекомпиляции. Вместо этого мы могли бы хранить AST в сжатом виде - шесть против полдюжины.

Нет, с # 265 это не поможет. У нас уже есть вся информация, просто она больше не похожа на исходный код. Если вы хотите посмотреть исходный код, лучше всего прочитать его из файла.

Согласитесь с @JeffBezanson, и это будет отходом от R, где ввод функции без скобок приводит к исключению исходного кода. Если исходный текст содержит более нескольких строк, он становится непригодным для использования (нет возможности прокручивать выходные данные afaik).

+1 с чтением из файла.
Лучше исправить https://github.com/JuliaLang/julia/issues/2594 , он действительно убивает пользователей Windows, когда start - это собственная команда cmd а notepad не может выделить синтаксис ни показать / перейти к номеру строки.
edit - действительно полезная функция, если бы мы могли ее исправить / улучшить.

Просто чтобы понять, есть ли здесь ощущение, что не должно быть функции, отображающей исходный код методов, а скорее полагаться на «редактирование» для этой цели? Это может не работать с веб-записной книжкой IPython, которая взаимодействует с удаленным ядром Julia, поскольку я думаю, что файл откроется на машине ядра, а не на клиенте.

Как бы то ни было, в интерактивных режимах я хотел бы сохранить исходный код, а не полагаться на то, что находится в файлах. Я также хочу видеть исходный код вещей, которые были введены через repl. См. Также №3988.

поддержка пейджера # 6921 может снять некоторые опасения по поводу полезности этого.

Я нахожу это очень удобным в ipython (через func?? ), хотя, в отличие от julia, некоторые функции скрыты (например, встроенные функции / cython).

Кроме того, <strong i="5">@less</strong> func(x) почти точно выполняет то, что запрашивает @astrieanna (с разбиением на страницы), но это зависит от внешнего $PAGER .

<strong i="5">@less</strong> func(x) не работает для интерактивных функций, но, похоже, это проблема, которую следует перефразировать в другом выпуске.

Если бы были доступны две следующие функции

• получение предварительно пониженного кода AST, т.е. исходный код из repl или во время выполнения
• переопределение / очистка переменных / типов / функций / типов

тогда можно будет выполнить листинг / обход / манипуляцию / генерацию кода времени выполнения.

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 это не поможет. У нас уже есть вся информация, просто она больше не похожа на исходный код. Если вы хотите посмотреть на исходный код, лучший способ - прочитать его из файла. . "

Так вы думаете, что это возможно? Что происходит, когда есть инструкции include / require и другие вещи?

// # 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 functions (из https://groups.google.com/d/topic/julia-users/4pkWhcap1Zg/discussion).

О, я решил это в # 22007?

Вроде - я все еще думаю, что в режиме REPL мы должны спрятать исходный код функций для отображения.

Также существует вопрос отображения анонимных функций, где было бы неплохо иметь возможность отображать исходный AST.

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

"раздражает доступ" == "недостаточно полезно, чтобы считаться решенным"

Допускаю, что было бы полезно. Я часто отлаживаю, изменяя функцию и выполняя различные варианты в разных REPL, чтобы сравнить их. Иногда я не понимаю, какой REPL соответствует какому варианту. Тогда было бы неплохо распечатать функцию, которая определена в данный момент.

Пример использования в Yao, предоставленный https://github.com/MasonProtter/LegibleLambdas.jl

Каждый блок имеет аргумент количества кубитов, и мы не хотим записывать его повторно, поэтому он может быть автоматически каррирован, если вы не скармливаете это число, например

julia> using Yao

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

Таким образом, пользователь будет знать, что это не блок, ему нужно это количество кубитов для дальнейшей оценки. До того, как у нас появятся LegibleLambdas, довольно сложно использовать просто число вроде #42 . Это также происходит с Flux, когда оптимизаторы раньше возвращали лямбду.

Но есть много угловых случаев, которые мы не можем поддерживать в LegibleLambdas, было бы хорошо, если бы мы могли напрямую получать эту информацию в REPL с поддержкой компилятора вместо внешнего пакета.

Мне все еще кажется неправильным, что мы поддерживаем это

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), поскольку затем вы можете показать производную как код julia