Perché il compilatore F # entra in torsione con seq {0L ..- 5L ..- 10L}?

Question

Ho un po 'di problemi nel dichiarare una sequenza decrescente di int64.

Quello che voglio è questo:

seq{0L..-5L..-10L};; 

Tuttavia, ottengo un errore:

seq{0L..-5L..-10L};; 
    ---^^^^^^^^^^^^^^^ 

stdin(5,4): error FS0739: Invalid object, sequence or record expression 

interessante, funziona con la pianura int:

> seq{0..-5..-10};; 
val it : seq<int> = seq [0; -5; -10] 

Ancora più interessante, se inserisco spazi tra .., inizia a lavorare con int64 troppo:

> seq{0L .. -5L .. -10L};; 
val it : seq<int64> = seq [0L; -5L; -10L] 

Qualcuno può spiegare perché il compilatore entra nel tocco con seq{0L..-5L..-10L}?

Answer 1

Sono d'accordo che si tratta di un comportamento un po 'strano. In genere si consiglia (anche se questo non è strettamente richiesto dalle specifiche) di scrivere spazi intorno allo .. e funziona correttamente in quel caso. Così mi consiglia di utilizzare:

seq { 0 .. -5 .. -10 } 
seq { 0L .. -5L .. -10L } 

Perché questo è comportarsi in modo diverso per int e int64? È possibile notare che quando si scrive 1..-2 e 1L..-2, Visual Studio colorizza il testo in modo diverso (nel primo caso lo .. ha lo stesso colore dei numeri, nell'altro caso ha lo stesso colore di .. con spazi).

Il problema è che quando il compilatore vede 1., può significare un valore in virgola mobile (1.0) o può essere un inizio di 1.., quindi questo caso viene trattato appositamente. Per 1L., questo non è un problema - 1L. deve essere l'inizio di 1L...

Quindi, se si scrive 1..-5..-10, il compilatore utilizza la gestione speciale e genera una sequenza. Se si scrive 1L..-5..-10, il compilatore analizza ..- come operatore unario applicato a 5L. La scrittura degli spazi risolve l'ambiguità tra l'operatore unario e .. seguito da un numero negativo.

Per riferimento, ecco uno screenshot dal mio Visual Studio (che mostra 10.. nel verde, ma .. sulla seconda riga in giallo - Non differenza particolarmente evidente, ma sono diversi :-))