Почему компилятор F # втягивается с seq {0L ..- 5L ..- 10L}?

Question

У меня проблемы с объявлением нисходящей последовательности int64.

То, что я хочу это:

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

Однако я получаю сообщение об ошибке:

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

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

Интересно, что он работает с простой int:

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

Еще более интересно, если я помещаю пробелы между .., он начинает работать с int64 тоже:

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

Может кто-нибудь объяснить, почему компилятор попадает в поворот с seq{0L..-5L..-10L}?

Answer 1

Я согласен, что это немного странное поведение. Обычно рекомендуется (хотя это не требуется строго спецификацией) писать пробелы около .., и в этом случае он работает правильно. Поэтому я бы рекомендовал использовать:

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

Почему это ведет себя по-разному для int и int64? Вы можете заметить, что когда вы пишете 1..-2 и 1L..-2, Visual Studio раскрашивает текст по-разному (в первом случае .. имеет тот же цвет, что и числа, в другом случае он имеет тот же цвет, что и .. с пробелами).

Проблема заключается в том, что когда компилятор видит 1., это может означать, значение с плавающей запятой (1.0) или это может быть началом 1.., поэтому этот случай обрабатывается специально. Для 1L., это не проблема - 1L. должно быть начало 1L...

Итак, если вы пишете 1..-5..-10, компилятор использует специальную обработку и генерирует последовательность. Если вы напишете 1L..-5..-10, компилятор проанализирует ..- как унарный оператор, который применяется к 5L. Написание пробелов разрешает двусмысленность между унарным оператором и .., за которым следует отрицательное число.

Для справки, вот скриншот из моего Visual Studio (который показывает 10.. в зеленый цвет, но .. на второй линии в желтом - не особенно заметной разницы, но они разные :-))