udpn

Не могу воспринимать спорт в телевизоре иначе, чем prolefeed. Какие-то мужики часами бегают, пытаясь доказать превосходство своих стран. И какие-то люди с не вполне развитым сознанием это ещё и смотрят. Нет бы просто счётом потом поинтересоваться. Пиздец. Рафинированный дебилизм.

Двунаправленные статически типизированные XSLT.

Увы, проприетарщина, но есть чему поучиться.

Я узнал, что интересующая меня разновидность метапрограммирования называется non-intensional MP. Нет ничего глупее операций над AST.
via Multi-Level Languages are Generalized Arrows
via http://sorhed.livejournal.com/568495.html

Проблема специального полиморфизма, похоже, так и не раскрыта. Я подумал поначалу, что instance arguments в Agda это уже всё. Это совсем не всё.

http://lambda-the-ultimate.org/node/3837#comment-58130
http://www.cas.mcmaster.ca/~kahl/Publications/Conf/Kahl-Scheffczyk-2001.html

ПАЦАНЫ, Я СЕГОДНЯ СИДЕЛ В ЖЖ И УВИДЕЛ КОММЕНТ, ГДЕ ЛЖЕЮЗЕР ИЗЛИВАЛ СВОЮ ЛЮБОВЬ К HASKELL. НУ Я ПОДСКОЧИЛ И РЕЗКО ПЕРЕЕБАЛ ЕМУ В ЩЩИ С ВЕРТУШКИ И ПОЯСНИЛ КРИКОМ "НЕ ЛЮБЛЮ HASKELL", ПОТОМУ ЧТО Я УГОРЕЛ ПО AGDA, ПАЦАНЫ ДУХ ТОТАЛЬНОГО ПРОГРАММИРОВАНИЯ ЖИВЁТ ТОЛЬКО В ЗАВИСИМЫХ ТИПАХ, ГДЕ ПАЦАНЫ ЖИВУТ СТРОГО ПОЗИТИВНОЙ РЕКУРСИЕЙ НА ТИПАХ, ИНДУКТИВНЫМИ ТИПАМИ, ЗАВИСИМЫМ СРАВНЕНИЕМ С ОБРАЗЦОМ, ГДЕ ЕБАШАТСЯ ПО ПРЕДИКАТИВНОСТИ И ЕБУТ СИСТЕМЫ ТИПОВ В РОТ! ТОЛЬКО ЗАВИСИМЫЕ ТИПЫ AGDA, ТОЛЬКО ХАРДКОР!!! ЮНИТИ УЛЬТРАХАРДКОР ЗАВИСИМЫЕ ТИПЫ!!! пацаны ебашьте сишников, лисперов, хаскеллистов, угорайте по аксиомам Пеано, любите теоркат, Барендрегта и LtU! ГОВОРИТЕ ОТКРЫТО И СМЕЛО ПРЯМО В ЛИЦО! AGDA!

В ответ на это: http://juick.com/jtootf/1812621

Agda это то, что я искал долгие годы. В ней нет синтетических конструкций вроде мультипараметрических классов типов с функциональными зависимостями и подобной высосанной из пальца фигни, которой пытаются покрыть Тьюринг-полный метаязык. Зависимые типы это совсем не типы даже, это способ производить метавычисления произвольной сложности и глубины. Ну и при наличии чекера завершимости ещё и способ доказать корректность программы или какую-нибудь другую теорему. На ближайшие несколько лет у меня есть задача по созданию чего-то зависимо типизированного, тотального, но эффективного и не такого страшного синтаксически как какой-нибудь ATS.

Жуйк, увы, гребёт.
Registration is temporary disabled. Please, come back later.

Кто-нибудь знает, как на XPath написать аналог ( . | a | b | a/a | a/b | b/a | b/b | ... ), т.е. выражение, совпадающее с любой цепочкой вложенных тегов a и b? Есть, конечно, более общий случай, //, но здесь вложенные теги любые, а потому он мне не подходит.

Почему списки — говно.

Впрочем, любой, кто почитает исходники std::list, убедится, что в С++ списки реализовал отряд обезьян специального назначения, поэтому нужно больше тестирования.

Есть задачка, которая уже пару дней калёным железом выжигает мне мозг.

Нужно с помощью операций min, max, + и - выразить if a < b then b else 0, либо доказать, что это невозможно. Использовать константы нельзя. а и b целые неотрицательные.

Пробовал решать перебором по деревьям выражений и моделированием, без успеха.

Тут пришлось по долгу службы решать следующую задачу. Есть некий пока-не-указанный формат XML. Заказчик даёт набор XSD схем, нужно из этой XML'ки сгенерировать XML'ки, соответствующие этим XSD схемам. На XSLT, конечно же. Проблема в том, что XSD большие, и XSLT, генерирующие правильные XML, написать без ошибок не выходит. Поэтому я решил сделать XSLT преобразование из XSD в XSLT. А потом ещё оказалось, что XSD имеют внутри инклюды. В XPath запросе можно, конечно, указывать document(), но мне нужно подтягивать complexType по его имени либо из самого файла, либо из инклюдов. Чтобы не извращаться чересчур с document()// | document()// | // повсюду, я сделал ещё один XSLT, который подставляет в XSD схему все её инклюды. Печально, что ни в одном из трёх форматов я не разбираюсь. Всемогущий Петя, помоги мне это отладить.

Поупражнялся в знании родственных связей.

Никто не знает, как можно сократить определение предиката 'кто'?

Пояснение: 7 лет непрерывного упарывания на VB6 забивают хаскелл на диаграмме до того, что он Other.

Понял, что меня сильнее всего отталкивает о Х-а. Табуляция. В С++ ставишь табы и знаешь, что по одному табу идёт на каждые фигурные скобки. Более того, можно на тот же уровень табуляции ещё и вернуться. А в Х-е совершенно контринтуитивная система табов, где даже if и else нельзя на одном уровне написать. Землю из под ног выбивает просто. Либо блевать тянет от вёрстки кода, либо программа некорректна. Если голова свежа, то ладно, перевариваю. А вот ближе к утру... Наверное, поэтому я написал какую-то херню на мартовском конкурсе по ФП. Сижу, жду избиения сами знаете какими тряпками.

Долгое время я агитировал жж-юзеров пользоваться сервисами http://codepad.org и http://ideone.com.

Первым пользоваться я больше советовать не буду, ибо http://codepad.org/CQly9eSY.

Ну и автор отказывается настроить права доступа для Haskell так, чтобы оно наконец-то находило стандартные либы вроде Control.Monad. (Ну или почему оно там у него не работает, я даже предположить что-то ещё не могу)

Задача про текст, который если сохранить в COM-файл и выполнить, выводит сам себя, решена.

Решили те самые ребята, что в прошлом году чуть было не порвали москвичей на руцтфе. Ожидаемо.

Как сравнять с говном говноалгоритм, наглядное пособие в одном комменте.

Вдобавок к мануалам Агнера Фога очень полезной будет вот эта ссылка

http://ref.x86asm.net/geek.html

Это словарь всех документированных и недокументированных команд интеловских процессоров за всё время их выпуска.

Уии.

Сижу я, значит, вечером, починяю примусы, никого не трогаю, и тут некто sharpc пишет мне, мол, а слабо написать xyz на qwe, причем так, чтобы он ещё и abc? А я ваще прям фшоке, как можно написать xyz на qwe вообще, не то, чтобы его можно было abc, отвечаю, мол, слабо. А он говорит, мол, а я вот написал, на, держи. Грит, спорим, никто даже не догадается, что это такое? А я так прям и отвечаю, что стопудов никто не догадается. Запостил он в ЖЖ, и ни один мехматовец и матмеховец так и не догадался. Такие дела.

Может, у вас потенции мозга хватит? Тут всего-то несколько букв.

-ZZ-DZ-AKP-OZ-AZ-AZ-AZ-AG-AA-AAP-OZ-AZ-AK-AJ-AA-AAP-ZZ-PC-AAP-ZZ-ZD-KA-AAP-MGP-ZA-ZA-KA-AAP-AZ-AZ-AZ-AZ-AIP-ZZ-ZS-ZA-ZA-RAP-CZ-AZ-AK-AN-AAPTГ

1. Не используйте лексикографический мономиальный порядок.
2. Никогда не используйте лексикографический мономиальный порядок.
3. Не используйте алгоритм Бухбергера.

Proof. Попробуйте вручную для a + b = 5 /\ a * b = 6

Я думал, что в демотиваторе использован какой-то рандом, а оказалось, что это вполне реальный и полезный алгоритм, Cooper quantifier elimination in Presburger arithmetic.

OMG

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

Господа, если вы пишете такой софт и люди могут получить к нему доступ где-либо, кроме вашего компьютера, идите сами знаете куда, честно.

UPD Ну и да, совсем какой-то непорядок, когда helloworld.exe занимает 7 Мб, а после strip — 3 Мб.

Самый продвинутый макроассемблер.

Не стесняйтесь использовать почаще.

Другое мнение состоит в том, что никакой семантики не существует в принципе: всё, что происходит в мозгу, всего лишь манипулирование синтаксисом, которое осуществляется и в компьютерах.

Это наиболее точно выражает моё мнение о семантике, в том числе программ. Если семантическая эквивалентность формально задаётся набором синтаксических преобразований, о чём вообще идёт речь?

По-моему, использование понятия "семантика" является предрассудком, люди предполагают, что языки программирования могут быть оценены с помощью лингвистических методов, или попросту никогда об этом не задумывались.

Ребят, что делать в такой ситуации?

http://codepad.org/AecV5zr3

Люди разработали кучу клёвых ЯП.

Есть С++. Язык с zero overhead, на котором написано дофига кода.
Есть Haskell. Красивый язык, на котором тоже дофига кода, но работает медленно.
Есть Agda. Просто офигенный язык, который уже практически нельзя использовать.
Есть ATS. Клёвый, но похож на говно. И зависимые типы в нём не зависимые, а так, говно.
Есть DDC. Это Haskell, в котором эффекты и монады не одно и тоже, поэтому не-говно.

А одного языка, настолько клёвого, чтобы перечисленные были не нужны, нет. Давайте перечислим по частям то, что нам нужно:

1) zero overhead
2) высокая производительность
3) абстрактность (высокий code reuse)
4) доказательное программирование
5) хороший синтаксис
6) использование имеющихся библиотек
7) рефакторинг legacy кода на месте

Ограничений много. Начинать нужно с того, которое добавить тяжелее всего. Глядя на то, как уже долгие годы люди пытаются догнать С++ (Си я не рассматриваю, потому что почти строгий сабсет), можно сделать вывод, что это zero overhead (хотя это может быть и неправдой).

Можно писать с нуля. Для этого нужно в голове держать больше понятий, чем можно удержать.
Можно транслировать. Если транслировать только из своего языка в C++, может получиться что-то хорошее.
При этом не нужно забывать, что транслировать, рассчитывая, что код будет сразу откомпилирован, нельзя, потому что библиотеки и legacy код на С++.

Можно добавить дополнительный синтаксис в язык, который будет биндить определения транслируемого языка (которые будут выглядеть как примитивы) к определениям С++. Например, сказать, что в
data Bool = True | False
нужно
bind Bool type 'bool'
bind True value 'true' -- может, r-value? здесь должны использоваться понятия С++
bind True value 'false'

Но тогда наши определения не будут покрывать всех возможных определений на С++. Значит, нужно крутить вообще от самого синтаксиса С++.

Написание полного парсера и/или анпарсера для С++ является почти неподъёмной задачей. Поэтому понятно, что нужно использовать чужой, доступный (свободный) код.

Можно написать свой синтаксис для всего, что есть в С++, и очевидным образом загнать его в чужой бэкенд С++ наподобие Clang'овского. Legacy код придётся переписывать руками, что никому не нужно.

Значит язык обязан поддерживать синтаксис С++. Так как мы собираемся добавлять в него ещё всякие ништяки, обычный бэкенд не подойдёт, он нашего синтаксиса не знает.

Можно переписать чужой бэкенд. Если он написан на С++, задача становится неподъёмной, потому что там сотни KLOC какого-то пьяного угара (это я про gcc, и в существенно меньшей мере, про clang). На других языках я не нашёл.

Хотя можно и не углубляться в семантический анализ и обойтись синтаксическим, вырезав его, например, из Scalpel или Elsa. Или обойтись частью семантического анализа вроде иерархии символов.

Сейчас я полностью понимаю идею Страуструпа начать с Си и допиливать его дальше. Просто по-другому язык с zero overhead написать было бы сложно. Я также сочувствую ему, ведь до сих пор находятся люди, которые не используют новые возможности, несмотря на то, что от них ничего страшного с временем исполнения не случится (я про перегрузку операторов и шаблоны).

Короче говоря, сейчас ставлю себе свежую test suite для компиляторов С++ версии 1.48.0, настраиваю VS2010 (надеясь, что она это потянет), чтобы откомпилить Scalpel, и собираюсь окончательно попрощаться с адекватностью.

Ребят, подскажите, пожалуйста, статей по персистентным структурам данных.

Хотелось бы узнать как работать хотя бы с персистентными строками (на самом деле нужны деревья), получая доступ ко всем её версиям с хорошей асимптотикой и без слишком большого оверхида.

Очевидный вариант с T_access(n, s) = O(1), M_needed(n, s) = O(n * s) слишком плох, потому что n (количество правок) и s(размер структуры) большие.

Рискуя быть избитым сами знаете какими тряпками, расскажу вам, с чего я вообще стал программистом. Дело было давно, поэтому если где рассказал не точно, уж извините. Хотя вы всё равно ведь свечку не держали.

Началось всё с того, что бабушка очень любила готовить. Я сидел на кухне, меня это интересовало, и она разрешала тоже чего-нибудь помешать. Обнаружил, что смешивать соду с лимонной кислотой очень забавно. Потом мне ещё много чего рассказывали разные люди, я интересовался. Уж не помню как, но в моих руках оказалась книжка по химии, и уже в первом классе я умел химичить всякую забавную хрень вроде пороха. Ну короче где-то то же самое, что сейчас умеют абитуриенты, прослушав школьный курс химии фурсенковского образца.

Родители у меня математики, и из какого-то лютого троллинга отвели меня к школьному преподу химии. Он работал ещё и на местном оргсинтезе, подрабатывал тем, что готовил ребят к олимпиадам. Весёлый был мужик короче. И тоже тролль. Поскольку принялся меня учить. Довольно быстро я освоил неорганику и простенькую органику (не дальше понятия об изомерии и реакции Вюрца), чем мои потребности пироманьяка были весьма удовлетворены. Но одна вещь не давала мне спокойно спать: называть органические соединения по-номенклатурному было очень неудобно, и я подозревал, что есть соединения, которые банальными -ол, -ан, -ид'ами не назвать, но не мог таковые найти (правда, потом в энциклопедии Аванта+ Химия узнал про гетероциклические соединения и соединения с конденсированными циклами).

Помню этот момент как сейчас, восьмилетний пацанчик, еду с отцом в вонючем Икарусе (автобус такой, если у кого не ходили в постсоветские времена) домой, рассказываю ему об этом, а он и говорит, запрограммируй, мол, на каком-нибудь Basic'е. Рассказал потом преподу химии. Его сын как раз учился в институте Visual Basic'у. Жребий пал, короче.

Не знаю, стал бы я программистом, увидев консольку и богомерзкий Паскаль.

(Где-то здесь, или в середине следующего абзаца) я был в деревне. Долго был. Купался-загорал, но это было очень скучно. Поэтому я в деревенской библиотеке нарыл самую красивую книжку, бейсик в картинках. Когда потом уже у бати на работе тестировал на каком-то очень древнем консольном бейсике навроде gwbasic (где я его тогда отрыл?), жутко обижался на то, что меня в этой книжке наебали с командой, которая играет мелодии из строки символов, описывающих ноты. Потом, правда, сделал такую на VB6.

Но в магазине на $10, подаренных когда-то на день рождения крёстным, я купил книжку "Практика Visual Basic for Applications" какого-то невразумительного русского автора. Разницы между VBA и VB не понимал ведь. Да и Эксель везде есть. Юзерформочки творил, радовался жизни. Правда, очень долго тупил из-за того, что там использовались глобальные переменные в модулях, которые были волшебно доступны из других. Я просто не понимал этого. Это из-за книжки, пожалуй, там особо такие аспекты не разъяснялись. Были по большей части длиннющие бойлерплейты на 50 строк, где автор одно за одним копировал значения текстбоксов в глобальные переменные. Это меня, кстати, тоже бесило.

Потом нашёл в киоске с пиратскими дисками подборку всех VB, от 1 до 6го, и почти сразу очень хорошую книгу Гарнаева. VB6 после VBA был волшебен. Наигравшись вдоволь с окнами, графикой, базами данных, самостоятельно открыв кучу паттернов, я полез на книжную полку, писал всяких Крамеров, ЧМки. Решал задачки наподобие подсчёта количества счастливых билетов, которые вылезали у меня в голове. Самой крутой вещью, наверное, был GameCheater, который прописывал через SendKeys по одному нажатию клавиши в игру чит. Интерфейс был отрисован во Flash'е, в коде использовалось полсотни апишек для красивых WinXP-стайловых полос прокрутки, короче свистелки и перделки процветали. Ну это самое крутое из того периода, если не считать перевод на VB6 Jakarta Regexp. Кода было нафигачено несколько мегабайт, часть я потерял, и потому уже точно не сосчитать. Без всякого бойлерплейта! Массивы, функции и структуры (а больше в VB почти ничего нет) я использовал по максимуму.

Даже своих друзей-одноклассников заинтересовал. Один начитался потом журналов Хакер и сейчас учится на защите информации в Москве, подрабатывая на веб-дизайне. Второму же не так повезло, он делал всякие автораны для СDшек коллекции мультиков про масяню, и сейчас учится в местной шараге.

Всё это было бы невозможно без нынче почти умершего митуя. Когда мне начало казаться, что 99% аудитории тупее меня (школоло, секретарши со своими сраными макросами и тролли же), включая топовых юзеров, и срачи были особенно ожесточёнными, я познакомился с ребе sharpc. А он был и до сих пор остаётся знатным и тонким троллем. Именно он (когда я был классе в 10м), будучи студентом ВМК МГУ, заставлял меня учить С++. Это удавалось почти никак, поскольку фигурные скобочки, точки с запятой и невразумительные += и ++ сильно противоречили моим понятиям о красоте. Да что там, до сих пор противоречат. Но требования к использованию WinAPI всё возрастали, большая часть примеров была на С++, и мне жутко захотелось заиметь свой собственный язык, который был бы похож на Бейсик, транслировался бы в С++, и был полон всяких странных придуманных мной возможностей. Их я до сих пор нахожу в разных языках, от Перла до Хаскелла. Где-то лежат диздоки, но доставать их лень. Может, когда буду олдфагом, опубликую. С тех пор в развитии идеи своего компилятора я уходил всё глубже. Впервые похожие (да что там, почти идентичные) идеи я встретил у nponeccop.

Один чувак подсунул работку на PHP, на достаточном для написания говносайтов уровне я его заботал где-то дня за два-три. Задача первая была ещё гадкая, сайт-опердень для какого-то финансового говна. Даже заказчик нихера не понимал, что ему нужно. Она тогда и стала последней, я проект доделал до логического завершения, отдал чуваку на доработку, а сам свалил и денег не потребовал.

Заразился от друга настроем кулхацкерства. Но так как рушить я не люблю, начал строить всякую жесть, которая непрерывно краулит по вебу, собирает всякую инфу, всё такое. Долбался с cURLом, регекспами, XPath и пр. калом. С появлением соцсетей, пока там ещё прайваси была не приоритетным направлением и не было паранойи, я почувствовал себя ну просто мегакруто. Можно было найти что угодно, о ком угодно. Свои соцсети даже были в нашей локалке провайдера, где я смог силами веб-паука и какой-то либы распознавания лиц (даже не помню уже) найти акки нескольких знакомых. Умиротворение и уверенность в себе из меня просто сочились. И это уже был первый курс.

Где-то тогда же, мне по долгу сессии пришлось заботать С++. Код я отправлял на рецензирование sharpc, он немедля отправлялся в одну из категорий, "говно" или "блядь, мои глаза". Регулярно получал от него всякие пинки в сторону ЧСВ. Метапрограммирование на шаблонах из его уст казалось такими недостижимыми вершинами технологии, что я серьёзно начал сомневаться, что когда-либо смогу это вообще понять.

Потом я завёл себе ЖЖ, и скачал SICP. Френдлента сформировалась быстро, здесь программисты образуют плотную такую клику. Читая ЖЖ и SICP я понимал всё сильнее: я дебил.

Понимаете ли, отдельный пост или даже комментарий nivanych, deniok, ivan-ghandi, thedeemon, diam-2003, nponeccop, thesz и других способен уничтожить мозги напрочь. В ЖЖ много людей, которые образованнее меня в разы, особенно в своей области (теоркате, ФП, трансляторах). По отдельности они демотивируют, а образуя френдленту кажутся чуваками с совершенно недостижимым уровнем развития. Ведь не упомнишь, кто и что написал.

SICP я за два месяца прорешал до того места, где начались quote и set!. Таки я чуял, потому что это действительно говно. Как и сама Scheme. Как и языки с S-expressions вообще.

Сейчас, спустя два с половиной года ботвы ФП, я понимаю, что это вам не какие-нибудь шаблончики. Haskell сильно повлиял на мои представления о том, что такое формализовать задачу. Теперь я просто не могу думать о многих концепциях иначе, чем будто бы это были ADT. Так как в первую очередь меня всегда интересовало "почему есть такая возможность", а не "как ей пользоваться", сейчас мне удалось понять, на кой нужны классы типов вообще, MonadPlus всякие в частности, что приблизительно творится внутри GHC, но это даже не приблизило меня к умению писать идиоматический код на Haskell. Мне _нужны_ нормальные массивы с нормальным синтаксисом, которые будут сохранять асимптотику операций, и меня блевать тянет от того, как это выглядит сейчас. Аналогично с эффектами. Особенно гадко то, что выделение памяти не считается эффектом. Вообще как-то очень многое не продумано и абсурдно, и это подтвердилось в обсуждениях в ЖЖ. Может, на LtU зарегаться? Там-то мне мозги и вправят. Или теоркат таки выучить...

На данный момент state of the art компилятора для меня это адова смесь ATS, Agda и DDC, интерпретируемая, на которой отрабатывает код юзера, код либы Ynot, перенесённой с Coq, лютая жесть на decision procedures и генератор бинарников.  Причём без адекватной IDE это всё было бы в любом случае говном. И без стандартных либ на все случаи жизни это было бы говном, что требует human-assisted трансляторов с языков вроде С, С++, Java и Fortran.

Короче, глубину своего незнания я понял, а выбираться ещё очень долго.

И да, хаскелл похож на бейсик и кодогенерирует си-- внутри.

Что-то я не вижу прогресса в области разработки IDE. Чем дальше, тем ужаснее они становятся. Причём из-за глубочайшего уровня убожества IDE, то же самое происходит и с кодом.

Давайте рассмотрим один из самых классических случаев.
Пусть (код)
1) есть вариантный тип T. Чтобы не смущать читателей, не знакомых с Haskell и ADT, пусть это будет частный случай — перечислимый тип.
2) для него есть несколько конструкторов (значений): A, B.
3) есть несколько функций, где тип T используется в качестве аргумента, а внутри используется switch (case .. of, pattern matching, не суть): f, g.

Мы можем производить два типа операций с кодом:
1) добавить новый конструктор
2) добавить новую функцию

Если мы используем switch, при добавлении нового конструктора нам нужно переписать исходники всех функций. Нелокальные изменения кода — зло, поэтому ищем другое решение.

ООП предлагает следующее решение (код).
Каждый из конструкторов считается неименованным конструктором класса, унаследованного от T.
Для функции f в классе T создаётся абстрактный метод f_switch. Разные ветки switch'а попадают в реализации этого метода в классах-наследниках.
Теперь добавление нового конструктора выглядит очень просто: мы создаём ещё один класс, наследующий от T, и имплементируем все методы *_switch.

Однако, если мы захотим создать ещё одну функцию со свитчем, нам придётся имплементировать соответствующий метод во всех наследующих классах. Снова нелокальное изменение кода.

Способов добиться локального изменения кода в обоих случаях одновременно нет, кроме как сделать умную IDE, в которой будет два ракурса просмотра кода: по конструкторам и по функциям.

Готов поспорить, что существует мод для emacs'а, чтобы это можно было делать в какой-нибудь джавке, но средняя температура по больнице больше похожа на комнатную.

Ещё есть такая забавная штука в C#: partial class. Если класс определён таким образом, можно дописать его с помощью ещё одной конструкции partial class. Это позволяет добавлять новые функции, не разбегаясь по коду, как и новые конструкторы. Но после того, как код будет накачен (от "катить") несколько раз таким образом, в нём можно потеряться.

Пруфпик:

UPD Вот здесь автор предлагает добавить partial определения типов данных. С ними будет такая же проблема, как проиллюстрировано на картинке выше. И на самом деле что-то такое уже реализовано в O'Caml (спасибо tomotom, что когда-то рассказал мне об этом).
( Нет, ребят, так дело не пойдёт. )

http://hackage.haskell.org/packages/archive/BASIC/0.1.5.0/doc/html/Language-BASIC.html

Ёбаный, блядь, нахуй! Заставьте меня развидеть эти типы! У них числа — функции!

Буквально пару часов назад, если бы у меня спросили, почему животные развиваются именно так, как они развиваются (почему у них определённое количество конечностей определённой формы и всё такое), я бы сказал, что это какие-то жуткие белковые процессы, не имеющие специфичного участка ДНК, их кодирующего, и вообще сделать шестирукого человека химическим путём не выйдёт ещё лет сто.

Но нет. http://en.wikipedia.org/wiki/Hedgehog_signaling_pathway

Всё давно известно.

Как это можно сделать проще?

int w = 4, h = 3;
int mn = min(w, h), mx = max(w, h), s = w+h-1;
for (int i = 0; i < s; ++i) {
    int lim = i < mn ? i : i < mx ? mn - 1 : s - i - 1;
    for (int j = 0; j <= lim; ++j) {
        int x = i < w ? i - j : w - 1 - j;
        int y = i < w ? j : j + i - w + 1;
        cout << x << ", " << y << endl;
    }
}

Когда-то я упоминал в комментариях, что мутаторы в классах это идиотизм, и нужно просто уметь использовать правильные типы данных (в языках, где это возможно). Нет, моё мнение ничуть не изменилось. Просто я написал удобный header для этого и хотел бы им поделиться.

UPD Кстати говоря, было бы очень приятно увидеть что-то подобное на Haskell. Я ведь правильно понимаю, что с помощью классов типов (без расширений) решать это нельзя, поскольку возникнут такие же проблемы, как и с двойными instance для Ord?

#ifndef LIMITED
#define LIMITED

#include <iostream>
#include <stdexcept>
#include <string>

template <typename T>
inline bool const_true(T) { return true; }

template <typename T>
inline bool positive(T x) { return x > 0; }

template <typename T>
inline bool nonnegative(T x) { return x >= 0; }

template <typename T, T default = T(), bool is_correct(T) = const_true>
class limited {
    T value;
public:
    operator T() { return value; }
    limited(T const & value = default) : value(value) {
        if (!is_correct(value))
            throw std::domain_error("Domain error");
    }
};

template <typename T, T default, bool is_correct(T)>
std::istream & operator >> (std::istream & istr, limited<T, default, is_correct> & x) {
    T value;
    std::istream & ret = istr >> value;
    x = limited<T, default, is_correct>(value);
    return ret;
}

typedef limited<int, 1, positive> nat;
#endif

Использование:

#include <iostream>
#include <stdexcept>
#include "limited.hpp"
using namespace std;

int main() {
    nat x;
    for (;;) {
        try {
            cin >> x;
            cout << x << endl;
        } catch (domain_error const & e) {
            cout << e.what() << endl;
        }
    }
}

Решал задачку от ребе darkus на С++.

Обнаружил, что set<bitset<k>> создать нельзя. WTF.

Кажется, одна из самых сложных разновидностей практических задач — поиск объектов, удовлетворяющих заданным свойствам. Чего стоит только способ выворачивания сферы наизнанку без чрезмерных изгибов, описанный в парадоксе Смейла. Хочу предложить читателям задачу того же рода, пусть и попроще.

Дана квадратная сетка NxN из точек. Нужно провести цепь (несколько отрезков, конец i-го является началом (i+1)-го) из минимального количества отрезков, чтобы каждая точка лежала как минимум на одном из отрезков.

Если вы вручную сможете найти ответ хотя бы для N=4, можете считать себя интеллектуалом. Впрочем, я в гору не пошёл, а попросту написал солвер.

10x http://antilamer.livejournal.com/384142.html

#include <iostream>
using namespace std;
#define forc(i, n, k) \
    for (unsigned c, r, i = (1 << k) - 1; \
        i < (1 << n); \
        r = i + (c = i & -i), \
        i = (((r ^ i) >> 2) / c) | r)
int main() {
    forc(i, 5, 2) {
        unsigned ii = i;
        for (int j = 0; j < 5; ++j) {
            cout << (ii & 1);
            ii >>= 1;
        } cout << endl;
    }
    system("pause");
}

По следам этого и этого.



Код здесь.

P.S. Как же слезятся глаза, ну просто ж не надо болеть.

Ребе nicka_startcev задал любопытный вопрос:

Какое наименьшее общее кратное у 6 и 7.2 ?

"Хм" подумал я, и набросал следующее.

#include <iostream>
#include <cmath>
#include <cstdlib>
using namespace std;

struct double_ {
    double val;
    double_(double val = 0) : val(val) {}
    operator double() { return val; }
};
double_ operator % (double_ x, double_ y) {
    return x - y * int(x / y);
}
const double eps = 1e-10;
double_ gcd(double_ x, double_ y) {
    while (fabs(y) > eps) {
        double r = x % y;
        x = y;
        y = r;
    } return x;
}
double_ lcm(double_ x, double_ y) {
    return x * y / gcd(x, y);
}

int main() {
    double_ a = 6.0, b = 7.2;
    cout << lcm(a, b) << endl;
    system("pause");
}

Внезапно, 36.

Навеяно этим.

Предлагаю такую задачу. В точке А находятся 3 чувака с двуместным велосипедом. В точку Б на расстоянии 20 км от А они хотят попасть. Чувак может идти со скоростью 4 км/ч, ехать со скоростью 36 км/ч (один или вдвоём). Через какое минимальное время всем трём чувакам удастся попасть в пункт назначения? Предполагается, что время слезания/заседания на велосипед равно нулю.

Следуя традиции, начатой ребе darkus, предлагаю решить задачу на любимом языке программирования в максимально общном виде. Книжек с авторской подписью предложить не могу, не писал, так что только for fun.

Кодообменники: http://codepad.org http://ideone.com

Почему 1 :: (Num a) => a, а "1" :: String?

Если бы "x" :: (Name a) => a, можно было бы
instance Name Expr where
    fromString = Variable

И аналогично со многими другими типами. Но что-то здесь не так.

inline int f(int x) { return f(x); }
int main() { return f(5); }

Будь мужиком, сынлайни функцию, блеять!

for :: (Monad m) => a -> (a -> Bool) -> (a -> a) -> (a -> m b) -> m [b]
for init test inc body = sequence $ map body $ takeWhile test $ iterate inc init

main = for 0 (<10) (+1) (\i -> print i)

Неопровержимое доказательство того, что ОО-языки, в т.ч. Java и C#  — говно.

ООП и сильная типизация попросту несовместимы.

Лента наполнилась двумя волшебными ссылками

http://nponeccop.livejournal.com/222326.html
http://users.livejournal.com/_winnie/319844.html