2015-11-03 15 views
7

ho seguito la documentazione di julia:?Perché julia esprime questa espressione in modo così complesso?

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

Ora che :(a in (1,2,3))==:($(Expr(:in, :a, :((1,2,3))))), perché Julia esprimono questa espressione in questo modo e che cosa fa $ significa esattamente? Mi sembra che $ valuti solo la prossima espressione in un ambito globale. Ho trovato la documentazione poco chiara su questo.

+0

Fare riferimento alla lingua di Julia ** Metaprogramming ** documentazione: http://docs.julialang.org/en/latest/manual/metaprogramming – SalchiPapa

risposta

9

La ragione :(a in (1,2,3)) viene visualizzato goffamente come :($(Expr(...))) è perché la funzione show per Expr digitato oggetti (show_unquoted in show.jl) non comprendere la in operatore infisso e ricadute in un formato di stampa generico.

In sostanza è lo stesso di :(1 + 1) tranne che show_unquoted riconosce + come operatore infisso e lo formatta in modo corretto.

In ogni caso, :(...) e $(...) sono operatori inversi in un certo senso, quindi :($(..thing..)) è esattamente come ..thing.., che in questo caso è Expr(:in,:a,:((1,2,3))).

Si può vedere questa stranezza in :(1+1) per esempio. L'output è di tipo Expr, come conferma typeof(:(1+1))==Expr. In realtà è Expr(:+,1,1), ma digitando Expr(:+,1,1) sul REPL mostrerà :($(Expr(:+,1,1))) - lo stile di formattazione generico degli oggetti tipizzati Expr.

Il fissaggio show.jl per gestire in potrebbe essere un bel cambiamento. Ma il problema è innocuo e riguarda la visualizzazione della formattazione.

+6

Si noti che almeno da julia 'v" 0.5.0-dev + 1020 "', ': (a in (1, 2, 3))' mostra esattamente ': (a in (1,2,3))', come previsto da @Chong Wang. ' – SalchiPapa

5

$ è il comando di interpolazione, Julia utilizzare questa notazione di interpolare le stringhe così come Expression:

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

Quando si digita un comando in Julia REPL, si cerca di valuta il comando e se il codice non si avere ; char alla fine stampa il risultato, quindi è più relativo alle funzioni di stampa, che a quello che verrà visualizzato su REPL, quando viene eseguito un comando.
quindi se volete vedere i veri contenuti di una sola possibilità variabile è quello di utilizzare dump funzione:

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 

E 'chiaro dalle prove di cui sopra, che le due espressioni utilizzano una struttura dati comune Expr con head, args e typsenza alcun $ all'interno di.
Ora provate a valutare e risultato di stampa:

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

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

Sappiamo già che sia comando Crea una stessa struttura, ma REPL non in grado di mostrare il risultato di :(a in b) meglio che un Expr del risultato di un altro Expr ed è il motivo per cui non ci in un $ all'interno. Ma quando si tratta di :(a+b), REPL fare in modo più intelligente e capisce che questo:

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

è pari a :(a+b).

Problemi correlati