Здравствуйте, ironwit, Вы писали:

I>Влад. тут мы почитали внимательно...

Кто, мы?

I>Такое ощущение что тебе нужен не специалиированный язык. типа универсального бойца. Верно? или это обманчивое впечатление?

Мне нравится идея универсального инструмента который можно тоноко заточить под конкретную задачу/предметную область. Потому собственно я и обращаю внимание на метапрограммирование.

Здравствуйте, deniok, Вы писали:

D>Здравствуйте, VladD2, Вы писали:



VD>>Проблема в том, что это могут с уверенностью сказать только продвинутые Хаскелисты. Лично я знаю только одно — Хаскель очень агрессивно использует композицию фукнций и по умолчанию он все рассматривает как композицию однопараметровых функйи. Так что казалось бы невинная запись "factorial n — 1" может превратиться в черт знает что. Причем в иногда это будет давать тот же результат как ты можешь интуитивно предполжить, а иногда получается такое, что ты даже выполнив код не сможешь понять, что же произошло.

D>Не, Влад, тут всё прозрачно. Применение функции имеет больший приоритет, чем любой оператор, поэтому в "factorial n — 1" сначала применится функция, а потом произойдёт вычитание. Другое дело, что из-за нетерминированной рекурсии получается, что должно вычисляться (n*(n*(n*(...)-1)-1)-1) — типичная экспансия Y-комбинатора.

Собственно что "нет"? Об этом я и говрю. Просто в отличии от тебя, я "знаю" Хаскель по паре введений прочитанных мной. Серьезно его не использовал. Но попытки балоства с языком показали, что я сразу начинаю перестраховываться и все брать в скобки (часто безосновательно).

Тем кто съел собаку на Хаскеле, может это уже и кажется нормальным. Но это не более чем привычка, а вообще, это не интуитивно.

Потому я и обратил внимание любителей локаничности на то, что не все так просто как кажется.

D>А вот внешние скобки в примере — действительно лишние, из тех же самых соображений приоритета применения функции перед оператором (умножения). Так что версия факториала от Another junior Haskell programmer без лишних скобок такова
D>

D>fac 0 = 1
D>fac n = n * fac (n-1)
D>

Проблема в том, что даже эти скобки требуют немалого объяснения. Ведь ни один С-шник без специальной подготовки не допрер, до того, что речь идет о передачи кортежа или даже о взятии выражения в скобки. Для них это будет синтаксис вызова метода, а это не так.

D>Вообще, в Хаскелле круглые скобки используются в выражениях по своему прямому математическому назначению

Вот это не правда. Никакого математического назначения туту нет и в помине. Это чистые проблемы Хасклеля с приоритетами. Такие проблем есть толко ML-подобных языках.

Да и математик уже давно не имеет прямого отношения к программированию. Так что не стоит на нее пенять. А том ожно начать вспоминать, что Ричи выбирая семантику вызова фукцнии в С как раз использовал математическую нотацию.

Здравствуйте, igna, Вы писали:

I>

D>>fac 0 = 1
D>>fac n = n * fac (n-1)
I>

I>То есть все-таки так, как оно и должно быть.
Забавно, что вот так:

fac 0 = 1
fac n = fac (n-1) * n

насколько я понимаю уже нельзя.

Здравствуйте, IT, Вы писали:

IT>Я о том, что пока всё просто, такая запись выглядит неплохо. Но, боюсь, что в реальном коде перегрузка метода не только по типу, но ещё и по значению не добавит простоты и понятности.

В Хаскеле нет перегрузки методов. Только паттерн-матчинг.
Да и "перегрузка метода по значению" — это какая-то фигня.

В общем, что-то ты не допонимаешь.

Здравствуйте, lomeo, Вы писали:

L>Ну про первую пару согласен, но в С-like языках вторая пара необходима,

В С-подобных языках это будет семантика вызова метода. А тут совсем иная. Так что это сокрее вводит в заблуждение.

L>Хотя интуиция такая вещь, если честно. Опыт то у всех разный.

Как показывает практика опыт то разный, но интуиция очень даже бизкая.

Здравствуйте, deniok, Вы писали:

D>Внутренние-то почему лишние? Возможно моя интуиция слишком "математизирована", но в

D>x * sin x — 1
D>vs.
D>x * sin (x — 1)

D> по-моему всё однозначно и понятно

Что тебе понятно?

Здравствуйте, lomeo, Вы писали:

L>т.е. такая запись возможна только если factorial — локальная функция? или я тебя неверно понял?

Именно так. Только я чуть ошибся. Точный синтаксис будет таков:

def factorial(n)
  | 0 => 1
  | _ => n * Factorial(n - 1)

Здравствуйте, lomeo, Вы писали:

L>Т.е. мой пример распишется как

L>

L>sign(n : int) : int
L>    | _ when n < 0 => -1
L>    | _ when n > 0 =>  1
L>    | _            =>  0
L>

L>так?

Можно и так. Хотя для столь вырожденных случаев нужно if использовать:

if (n < 0) -1 else if (n > 0) 1 else 0

в прочем if/else — это макрос который один фиг в match раскроется. Так что это синтаксический сахар.

Здравствуйте, VladD2, Вы писали:

VD>Это пока (лично для меня) вопрос будущего. Пока что параллельность была практически ненужна. Но конечно в будущем это стаенет одной из самых актуальных тем.
VD>Вот только лино я хотел бы чтобы язык позволял бы добавить нужную поддержку имеющимися срествами (в виде фрэйморка).
Не реально.
Эффективно и надежно паралельность можно сделать только на уровне ВМ. Никаким метапрограммированием хорощо паралельность не сделать.
Как минимум по тому что нужно очень сильно корежить менеджер памяти для того чтобы он хорошо работал в условиях многопоточности.

Здравствуйте, WolfHound, Вы писали:

WH>Здравствуйте, VladD2, Вы писали:

VD>>Это пока (лично для меня) вопрос будущего. Пока что параллельность была практически ненужна. Но конечно в будущем это стаенет одной из самых актуальных тем.
VD>>Вот только лино я хотел бы чтобы язык позволял бы добавить нужную поддержку имеющимися срествами (в виде фрэйморка).
WH>Не реально.
WH>Эффективно и надежно паралельность можно сделать только на уровне ВМ. Никаким метапрограммированием хорощо паралельность не сделать.
WH>Как минимум по тому что нужно очень сильно корежить менеджер памяти для того чтобы он хорошо работал в условиях многопоточности.

Ну частично, думаю, можно достичь определённых результатов, если логику параллелизма вынести на уровень какого-нибудь DSL, где уже использовать нужные алгоритмы, правда ограничения исходного рантайма преодолеть не придётся, да.

Здравствуйте, WolfHound, Вы писали:

VD>>Это пока (лично для меня) вопрос будущего. Пока что параллельность была практически ненужна. Но конечно в будущем это стаенет одной из самых актуальных тем.
VD>>Вот только лино я хотел бы чтобы язык позволял бы добавить нужную поддержку имеющимися срествами (в виде фрэйморка).
WH>Не реально.
WH>Эффективно и надежно паралельность можно сделать только на уровне ВМ.

ВМ — это какая-та новая абревиатура термина "человек разумный" ?

Здравствуйте, Коваленко Дмитрий, Вы писали:

КД>ВМ — это какая-та новая абревиатура термина "человек разумный" ?

VM или ВМ — виртуальная машина, насколько я понимаю

Здравствуйте, WolfHound, Вы писали:

WH>Не реально.
WH>Эффективно и надежно паралельность можно сделать только на уровне ВМ. Никаким метапрограммированием хорощо паралельность не сделать.
WH>Как минимум по тому что нужно очень сильно корежить менеджер памяти для того чтобы он хорошо работал в условиях многопоточности.

Подходы к обеспечению параллельности есть разные. Например, Эрланговский. Конечно со спец. поддержкой в ВМ было бы проще, но и без ее много можно сделать.

Что до GC, то он и так рассчитан на многопотчность.

Здравствуйте, VladD2, Вы писали:

VD>Забавно, что вот так:

VD>

VD>fac 0 = 1
VD>fac n = fac (n-1) * n
VD>

VD>насколько я понимаю уже нельзя.

Можно. Говорю же у функций приоритет больше, чем у операторов.

Здравствуйте, VladD2, Вы писали:

L>>т.е. такая запись возможна только если factorial — локальная функция? или я тебя неверно понял?

VD>Именно так.

Э-э-э так что насчёт моего вопроса? Чем вызвано такое ограничение?

Здравствуйте, VladD2, Вы писали:

L>>Ну про первую пару согласен, но в С-like языках вторая пара необходима,

VD>В С-подобных языках это будет семантика вызова метода. А тут совсем иная. Так что это сокрее вводит в заблуждение.

А вот ты о чем! Теперь понял. Прикольно, я не думал, что с этим возникают проблемы.

L>>Хотя интуиция такая вещь, если честно. Опыт то у всех разный.

VD>Как показывает практика опыт то разный, но интуиция очень даже бизкая.

Практика у всех тоже разная

Здравствуйте, VladD2, Вы писали:

VD>Подходы к обеспечению параллельности есть разные. Например, Эрланговский. Конечно со спец. поддержкой в ВМ было бы проще, но и без ее много можно сделать.
VD>Что до GC, то он и так рассчитан на многопотчность.
А region inference ты как будешь делать не имея полной информации о потоках?
А на одном ГЦ действительно быструю систему не сделать.
Да и просто генерить код можно по разному в зависимости от того какие сценарии многопоточности лучше работают на конкретной железке.

Здравствуйте, Коваленко Дмитрий, Вы писали:

WH>>Не реально.
WH>>Эффективно и надежно паралельность можно сделать только на уровне ВМ.

КД>ВМ — это какая-та новая абревиатура термина "человек разумный" ?

Это сокращение от виртуальная машина.

Что касается человек разумный то без этого никуда. Но колупаться с многопоточностью без поддержки со стороны инструментов геморой еще тот. А наиболие мощьный инструмант это ВМ.

Здравствуйте, Курилка, Вы писали:

К>Ну частично, думаю, можно достичь определённых результатов, если логику параллелизма вынести на уровень какого-нибудь DSL, где уже использовать нужные алгоритмы, правда ограничения исходного рантайма преодолеть не придётся, да.
ДСЛ это лишь сахарок. Без примитивов работы с многопоточностью всеравно ничего не сделаешь. А вот качественную реализацию правильных примитивов можно сделать только на уровне ВМ ибо нужно учитывать специфику конкретного железа на котором работаешь.

Здравствуйте, lomeo, Вы писали:

VD>>

VD>>fac 0 = 1
VD>>fac n = fac (n-1) * n
VD>>

VD>>насколько я понимаю уже нельзя.

L>Можно. Говорю же у функций приоритет больше, чем у операторов.

Вот только обычны человек прочтет это код как "fac ((n-1) * n)"