За что не любят Common Lisp?

сишные «*» и «&» в разных количествах и порядках просто образец читаемости

тут не поспоришь, но таки жить можно, это же не (()()((())))

жабское многословие

есть благо для читаемости(кроме случаев с анонимными классами, ждем лямбд)

почему паблик и статик?

дело именно в жирном рантайме (что на диске, что в памяти)

При правильной сборке конечного образа: puify и toplevel для sbcl например, в памяти и будет 1-2 мег для простых случаев.

почему паблик и статик?

копипаста же

спасибо, посмотрим

ты точно упорот: в твоём любимом ЯП ты как конец оператора обозначаешь?

\n обычно.

Я вот голову ломаю

Гм. Не пробовал применять её по назначению?

таки жить можно, это же не (()()((())))

у тебя какая-то жопа с форматированием кода. ты на цэ и жабке тоже такой же говногод шпаришь?

жабское многословие есть благо для читаемости

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

«Паблик статик файнал Борщ борщ нью Борщ, пожалуйста.»

«Структ суп ньюсуп структ суп маллок сайзоф структ суп, пожалуйста».

та же скаля куда выразительнее и фичастее.

и нечитаема, заодно. а так да, прелестный язык

CL это функциональный язык, но

1) Много скобочек

2) выражения в лиспе внешне мало похожи на математическую запись и куда труднее читаются, в том числе и из-за п 1)

\n обычно.

бэйсик или пайтон? Если пайтон, то ты ещё за отступы не ответил (:

Гм. Не пробовал применять её по назначению?

вот в лиспе её и применяешь по назначению - код пишешь. А операторы отделяются скобками. Всегда. Лисп конечно УГ для инопланетян, но синтаксис там логичный и единообразный, а ни как в перловках/сишечках.

и нечитаема, заодно.

наглое 4.2, прекрасно читаема, как и лисп, в общем-то. хотя у лиспа есть некоторая специфика, это да.

это же не (()()((())))

а что это за скобки? CL намекает на рукожопие написавшего. Или это из вашей жабы?

CL это функциональный язык, но

уже первый пункт неправильный, как и все остальное ;-)

CL это пластилин

Хамят иногда за попытку задать вопрос, который есть в одной из первых пяти глав PCL. Например, «как вызвать функцию?» Да, такое бывает. Часто.

Хамят иногда. Часто.

Браво.

а что это за скобки? CL намекает на рукожопие написавшего. Или это из вашей жабы?

это просто скобки, ваш CL разве не так выглядит?

• не достаточно библиотек на все случаи, приходится пилить свои
• не совсем качественные библиотеки, приходится снова брать напильник

Вот поэтому берём питон и быстро пишем.

Успокойся, в той же сишке скобок порой и больше.

Из-за того, что одно и тоже можно написать совершенно разными способами, эффективность которых может зависеть от выбора имплементации.

ну да, главное потом руки вымыть хорошо

наглое 4.2, прекрасно читаема

в области преобразования колекций все эти map, flatMap, foldLeft и прочие плюшки ужасно читаемы.

в той же сишке скобок порой и больше.

это какой такой порой?

как и все остальное ;-)

что неправильно?

Ты считаешь, что запись функции на CL внешне похожа на математическую?

все эти map, flatMap, foldLeft и прочие плюшки ужасно читаемы.

бугага, что я могу сказать. башевый «cat | grep |sort | sed» тебя не смущает, а скалевый «list filter sort map» уже ужас-ужас.

жабскую версию на итераторах даже и не напишешь вот так вот, в одну строчку-то...

ню ню ;)

это просто скобки, ваш CL разве не так выглядит?

нет. Не так. В сишечке в конце каждого оператора ставится (}|;|,), а в лиспе - всегда ). Потому «лишних» символов в CL нет.

вот например сравни две эквивалентные программы:

(defun factorial (x)
  (defun iter (y c x)
	(if (> c x)
	  y
	  (iter (* y c) (+ c 1) x)))
  (iter 1 1 x))

(print (factorial 6))

#include <stdio.h>


int factorial_iter(int y, int c, int x)
{
	if(c > x)
		return y;
	return factorial_iter(y * c, c + 1, x);
}


int factorial(int x)
{
	return factorial_iter(1, 1, x);
}

int main()
{
	printf("%d\n", factorial(6));
	return 0;
}

ЗЫЖ и сравни сложность кода...

жабскую версию на итераторах даже и не напишешь вот так вот, в одну строчку-то...

зато понятно все будет.

башевый «cat | grep |sort | sed» тебя не смущает

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

бэйсик или пайтон? Если пайтон, то ты ещё за отступы не ответил (:

Haskell

вот в лиспе её и применяешь по назначению - код пишешь.

Маленький секрет: код чаще читают, чем пишут. И голову при этом приходится применять тоже чаще.

синтаксис там логичный и единообразный, а ни как в перловках/сишечках.

Синтаксис в Лиспе безумный, и, к тому же, зачем-то утяжелённый скобочками.

Если пайтон, то ты ещё за отступы не ответил (:

Haskell

хых.

«В конце каждого оператора» - что-то непонятное. Правильно говорить, что в конце каждого выражения ставится точка с запятой, а в конце блока - закрывающая фигурная скобка. В этом плане синтаксис си очень прост. ИМХО в си можно запутаться только в комбинациях *, & и const.

И вообще ты перечитал SICP и зачем-то неправильно тянешь его в CL.

в с так не пишут. «лишние» символы имеют разную семантику и повышают читабельность.

считаешь, что запись функции на CL внешне похожа на математическую?

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

ЗЫЖ и сравни сложность кода...

(defun factorial (x)
  (defun iter (y c x)
	(if (> c x)
	  y
	  (iter (* y c) (+ c 1) x)))
  (iter 1 1 x))

factorial (x) {
    int iter(y, c) {
        return c > x ? y : iter(y * c, c + 1);
    }
    return iter(1, 1);
}

да - на С (хоть и чуть нестандартном - под gcc с nested functions) попроще будет

а посчитай-ка мне таким макаром факториал 100500

CL это функциональный язык

арчимага на тебя нет. :)

Haskell

facepalm

Маленький секрет: код чаще читают, чем пишут. И голову при этом приходится применять тоже чаще.

я в курсе. вот тебе пример на твоём любимом ЯП

qsortOneLine s = case s of{[]->[];(x:xs)->qsortOneLine [y | y<-xs, y<x] ++ x : qsortOneLine [y | y<-xs, y>=x]}

Синтаксис в Лиспе безумный, и, к тому же, зачем-то утяжелённый скобочками.

мда...

В этом плане синтаксис си очень прост. ИМХО в си можно запутаться только в комбинациях *, & и const.

конечно. Только твои const, *, & в сишечке встречаются чуть более, чем везде.

И вообще ты перечитал SICP и зачем-то неправильно тянешь его в CL.

какая разница? В схеме скобок что-ли меньше?

в с так не пишут. «лишние» символы имеют разную семантику и повышают читабельность.

если это не однострок, то лишние символы вообще не нужны. А если однострок, то всё и так непонятно.

да - на С (хоть и чуть нестандартном - под gcc с nested functions) попроще будет

чем проще-то? Строк меньше? Ну запиши (if одной строкой, будет столько же. А вот скобок столько же. Да и нестандартно это...

а посчитай-ка мне таким макаром факториал 100500

а сделай-ка бинарник размером в 760 байт из кода на CL - я сразу дам тебе код для факториала 100500, да - в C для этого надо использовать библиотеки, зато это возможно, в отличие от

чем проще-то? Строк меньше?

iter (y c x) vs iter(y, c)

а посчитай-ка мне таким макаром факториал 100500

а какая разница? тебе библиотек для больших чисел мало?

конечно. Только твои const, *, & в сишечке встречаются чуть более, чем везде.

В сишечке чуть боле чем везде встречаются одинокие * и const. Константный указатель на указатель на указатель на константный инт встречается относительно редко и трудночитаем.

какая разница? В схеме скобок что-ли меньше?

Просто прокомментировал твой CL-код. Не говоря даже, что на си так не пишут.

кстати, clisp:

 (factorial 100500)

*** - Переполнение программного стека. СБРОС

Переполнение программного стека. СБРОС

LOL, а gcc выкидывает рекурсию

ЕМНИП clisp не умеет оптимизировать хвостовую рекурсию.

тут разные юзкейсы.

к черту юзкейсы, читаемо или нет? что именно от тебя ускользнуло?

понимать они будут чуть менее чем ничего.

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

ну либо покажи как ;)

дык

 (defun factorial (x)
  (defun iter (y c)
(if (> c x)
  y
  (iter (* y c) (+ c 1))))
  (iter 1 1))

На С вообще можно было не выеживаться, gcc отптимизирует рекурсию и в «обычной» реализации факториала.

Когда я (правда несколько лет назад) сравнивал сколько места в памяти отжирает запущенный лисп с рядом часто используемых модулей - что sbcl, что ecl отожрали по 5-7 Гб,

Учитывая что у меня на 128 мб. ОЗУ в одном образе крутятся XSLT и морды на mcclim и tk и вская всячина из зависимостей, то твой набор из «часто используемых модулей» на «5-7 Гб» - достточно безумен.

то лишние символы вообще не нужны.

очень даже нужны - за них взгляд цепляется при чтении.