Соломон Страуструбер
> vladislav
> > Там еше прикол такой - типы параметров методов там не выводятся,
>
> В смысле?
Ну, нельзя написать
class A {
def sum2( a ) = {
a + 2
}
}надо писать
class A {
def sum2( a : Int ) = {
a + 2
}
}Соломон Страуструбер
> То есть при описании функции не надо явно говорить, какой тип она возвращает,
> это понятно по выражению, слоящему после return? Ну, фича хорошая, но для ИДЕ
> проблемы.
Ну, я указал, какая там проблема - случайно может измениться поведение.
object Main extends Application {
class A {
def sum2( a : Int ) = {
a + 2
}
}
class B extends A {
override def sum2( a : Int ) = {
a + 4
}
}
val a = new A
val b = new B
print(b.sum2(1) / 3)
}Программа напечатает 1.
А теперь в базовом классе поменяем 2 на 2.0
object Main extends Application {
class A {
def sum2( a : Int ) = {
a + 2.0
}
}
class B extends A {
override def sum2( a : Int ) = {
a + 4
}
}
val a = new A
val b = new B
print(b.sum2(1) / 3)
}Программа напечатает 1.6666666666666667.
laMer007
> > Ну, фича хорошая, но для ИДЕ проблемы.
> А при чем тут IDE? В нормальных языках вообще все переменные\константы,
> параметры методов и результаты функции могут выводится, если нет желания
> указывать их явно.
Ну, вот на хаскеле есть библиотеки (успешно портированные на scala), которые при неаккуратном обращении при выводе типов вешают компилятор. Да и плюсовые шаблоны - они тоже тьюринг-полные, и там можно забацать рекурсию...
Понятно, что обычно оно работает, но вот idea на scala часто глючит, особенно на больших проектах... Не знаю, как студия на F# или Nemerle (на C++ она изредка угадывает тип).
vladislav
> (на C++ она изредка угадывает тип).
Само собой, если там накостыляли шаблонов рекурсивных. Чтобы угадать тип - нужна фактически компиляция.
laMer007
> > Не переношу этот кодстайл
> К&R-style. Использую его только при обработке исключений:
Мы такой используем в студии на jscript, она там автоматически такой стайл делает.
По теме - скобки - это читабельность, глаз не зацепляется на лишних буквах бегин-энд. Текст становится прозрачнее, читабельнее раза в 2, т.к. слов раза в 2 меньше.
Еще бы for и switch , case и пр. заменить на значки.
BEDbMAK
> Текст становится прозрачнее, читабельнее раза в 2, т.к. слов раза в 2 меньше.
Текст на Дельфи прозрачнее и читабельнее раза в два, так как слов больше раза в два.
BEDbMAK
> Еще бы for и switch , case и пр. заменить на значки.
Брейнфак не нужен.
vladislav
> А теперь в базовом классе поменяем 2 на 2.0
> object Main extends Application {
> class A {
> def sum2( a : Int ) = {
> a + 2.0
> }
> }
И чё, Scala разрешает складывать целое с вещественным, неявно приводя всё к вещетвенному?
Фуууу.
В Аде вот хрен ты сложишь 1 и 2.0, и это защищает в то числе и от таких приколов.
laMer007
> Брейнфак не нужен.
Да ты чё, слов же меньше, язык сразу круче станет пыщь пыщь
Соломон Страуструбер
> И чё, Scala разрешает складывать целое с вещественным, неявно приводя всё к
> вещетвенному?
> Фуууу.
А чё не так? Преобразование не сужающее. Это за неявные сужающие бить линейкой по рукам стоит.
Хотя тогда вам OCAML должон понравиться с его различиям между вещественными и целочисленными операциями.
И чё, потомка к предку тоже явно приводить в этой Аде надо? Не проблема, но странно смотрится.
Grey304
> Преобразование не сужающее
Вроде очень даже сужающее.
int64 a = 100000000000000000000000000000 + 1;
double b = 100000000000000000000000000000 + 1.0
Grey304
> А чё не так? Преобразование не сужающее.
Преобразование 1/3 к вещественному тоже не сужающее, но приводит к известному приколу.
Ну и преобразование 999999999 к float уже сужающее.
Grey304
> Хотя тогда вам OCAML должон понравиться с его различиям между вещественными и
> целочисленными операциями.
Не, это как раз кривизна, я считаю, не могли что ли оператор перегрузить?
Grey304
> И чё, потомка к предку тоже явно приводить в этой Аде надо?
Я хз, наследование никогда не использовал.
Соломон Страуструбер
> Преобразование 1/3 к вещественному тоже не сужающее, но приводит к известному
> приколу.
> Ну и преобразование 999999999 к float уже сужающее.
Ну, 32-раз. инт в double должен влезть. Но тут многое от размерности данных зависит, какие конкретно преобразования становятся сужающими.
Соломон Страуструбер
> Преобразование 1/3 к вещественному тоже не сужающее, но приводит к известному
> приколу.
Какому конкретно? В слчае плюсов все логично, хоть и неочевидно - оба операнда целое, получите и распишитесь в целочисленной операции. Ведь и умножение целых может вызвать переполнение.
А 1.0/3.0 - так это ж дробное число. Его и в вещественной форме точно не представить.
p.s. А Ариан-5 все равно упал... Так что проблемы не только в йазыгах, но и в головах.
Grey304
> Какому конкретно?
float f = 1/3; // 0
В Аде это не скомпилируется просто.
Grey304
> p.s. А Ариан-5 все равно упал...
Молодец, нашёл.
Соломон Страуструбер
> float f = 1/3; // 0
а:
int i=1/3;
?
Соломон Страуструбер
> Молодец, нашёл.
Было бы что находить. Это давно на RSDN уже обсуждали.
Grey304
> а:
> int i=1/3;
> ?
А это скомпилируется. Будет ноль.
Да, в Аде 1/3=0, но 1/3 /= 0.0
Grey304
> Было бы что находить. Это давно на RSDN уже обсуждали.
А ссылку можно?
Тема в архиве.