Tại sao julia thể hiện biểu thức này theo cách phức tạp này?

Question

Tôi làm theo các tài liệu của julia:

julia> :(a in (1,2,3)) 
:($(Expr(:in, :a, :((1,2,3))))) 

Bây giờ :(a in (1,2,3))==:($(Expr(:in, :a, :((1,2,3))))) rằng, tại sao julia bày tỏ biểu thức này theo cách này Và những gì $ chính xác có nghĩa là? Dường như với tôi rằng $ chỉ cần đánh giá biểu thức tiếp theo trong phạm vi toàn cục. Tôi thấy tài liệu không rõ ràng về điều này.

Answer 1

Lý do :(a in (1,2,3)) được hiển thị lúng túng như :($(Expr(...))) là do show chức năng cho expr gõ các đối tượng (show_unquoted trong show.jl) không hiểu các nhà điều hành in ghi vào và fallbacks sang một định dạng in ấn chung.

Về cơ bản, nó giống như :(1 + 1) ngoại trừ show_unquoted nhận ra + là một toán tử kết hợp và định dạng nó độc đáo.

Trong mọi trường hợp, :(...) và $(...) là nhà khai thác nghịch đảo trong một nghĩa nào đó, vì vậy :($(..thing..)) hoàn toàn giống với ..thing.., mà trong trường hợp này là Expr(:in,:a,:((1,2,3))).

Bạn có thể thấy sự kỳ quặc này trong ví dụ :(1+1). Đầu ra là loại Expr, như là typeof(:(1+1))==Expr xác nhận. Nó thực sự là Expr(:+,1,1), nhưng gõ Expr(:+,1,1) trên REPL sẽ hiển thị :($(Expr(:+,1,1))) - kiểu định dạng chung của các đối tượng đã nhập Expr.

Sửa show.jl để xử lý in có thể là một thay đổi tốt đẹp. Nhưng vấn đề là vô hại và quan tâm đến định dạng hiển thị.

Answer 2

$ là lệnh nội suy, Julia sử dụng ký hiệu này để suy Strings cũng như Expression:

julia> a=1; 
julia> "test $a" # => "test 1" 
julia> :(b+$a) # => :(b + 1) 

Khi bạn gõ một lệnh trong Julia REPL, nó cố gắng để đánh giá các lệnh và nếu mã không có ; char ở cuối nó in kết quả, do đó, nó liên quan nhiều hơn đến các chức năng in ấn, rằng những gì sẽ được nhìn thấy trên REPL, khi một lệnh thực thi.
vì vậy nếu bạn muốn xem các nội dung thực sự của một một khả năng biến là sử dụng dump chức năng:

julia> dump(:(a+b)) 
Expr 
    head: Symbol call 
    args: Array(Any,(3,)) 
    1: Symbol + 
    2: Symbol a 
    3: Symbol b 
    typ: Any 

julia> dump(:(a in b)) 
Expr 
    head: Symbol in 
    args: Array(Any,(2,)) 
    1: Symbol a 
    2: Symbol b 
    typ: Any 

Rõ ràng từ các xét nghiệm trên, rằng cả hai biểu thức sử dụng một cấu trúc dữ liệu phổ biến của Expr với head, args và typmà không cần bất kỳ $ bên trong.
Bây giờ hãy thử để đánh giá và kết quả in:

julia> :(a in b) 
:($(Expr(:in, :a, :b))) 

julia> :(a+b) 
:(a + b) 

Chúng tôi đã biết rằng cả hai lệnh tạo ra một cấu trúc tương tự nhưng REPL không thể hiển thị kết quả của :(a in b) tốt hơn mà một Expr kết quả của Expr khác và đó là lý do tại sao có trong một số $ bên trong. Nhưng khi giao dịch với :(a+b), REPL làm thông minh hơn và hiểu rằng đây:

Expr 
    head: Symbol call 
    args: Array(Any,(3,)) 
    1: Symbol + 
    2: Symbol a 
    3: Symbol b 
    typ: Any 

bằng :(a+b).