Про perl 6 - Компьютерные священные войны

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

M>>>В общем, прогнал я через компилятор, чтобы он выдал мне так называемый Core Erlang. По сути, разворачивается во вложенный цикл, и проверка идет для каждого элемента. То есть не после того, как пары сгенерированы, а во время генерации пар
EP>>Я о другом. После беглого взгляда — там ведь идёт проверка для каждой пары. Вот сколько раз у тебя берётся остаток от X-ов?
M>

M>А какая семантика у Erlang варианта? Подозреваю что фильтры применяться после того как сгенерируются пары, то есть неэффективно.

M>Нет. Фильтры применятся не после того как сгенерируются пары.

Пара сгенерировалась, и потом применился фильтр, и так для каждой пары, верно?

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

_NN>Проблема больше чем надуманна.
_NN>Редакторы умеют всё делать нормально.
Мне насрать, что там умеют редакторы, я пишу в том, что в данный момент под рукой.
Я терпеть не могу, когда удобства делают обязанностью. Мне не нужен надзиратель с палкой, который стоит и бьёт по пальцам, если отступ не четыре пробела, а два. Отступы и форматирование — категорически нужная штука, но не стоит их соблюдение возводить в ранг абсолюта. Это граничит с идиотизмом.

M>>

M>>А какая семантика у Erlang варианта? Подозреваю что фильтры применяться после того как сгенерируются пары, то есть неэффективно.

M>>Нет. Фильтры применятся не после того как сгенерируются пары.

EP>Пара сгенерировалась, и потом применился фильтр, и так для каждой пары, верно?

Да. Теперь понял, что в твоем вопросе «после того как сгенерируются пары» не означало «после того как сгенерируются все пары».

ЗЫ. Обнаружил (внезапно, да, хотя такая запись не удивительна), что можно и так писать

[{X, Y} || X <- lists:seq(1, 5), X rem 2 == 0, Y <- lists:seq(1, 5), Y rem 2 == 1]

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

Если кому интересно,

Скрытый текст

module 'lc' ['lc'/0,
         'module_info'/0,
         'module_info'/1]
    attributes []
'lc'/0 =
    %% Line 5
    fun () ->
    %% Line 6
    ( letrec
          'lc$^0'/1 =
          fun (_cor8) ->
              case _cor8 of
            <[%% Line 7
              X|_cor1]>
                when %% Line 7
                  try
                  let <_cor2> =
                      call 'erlang':'rem'
                      (X, 2)
                  in  call 'erlang':'=='
                      (_cor2, 0)
                  of <Try> ->
                  Try
                  catch <T,R> ->
                  'false' ->
                ( letrec
                  'lc$^1'/1 =
                      fun (_cor9) ->
                      case _cor9 of
                        <[%% Line 7
                          Y|_cor5]>
                        when %% Line 8
                          try
                              let <_cor6> =
                              call 'erlang':'rem'
                                  (Y, 2)
                              in  call 'erlang':'=='
                                  (_cor6, 1)
                          of <Try> ->
                              Try
                          catch <T,R> ->
                              'false' ->
                        let <_cor10> =
                            %% Line 7
                            apply 'lc$^1'/1
                            (_cor5)
                        in  ( [{X,Y}|_cor10]
                              -| ['compiler_generated'] )
                        ( <[%% Line 7
                        Y|_cor5]> when 'true' ->
                          %% Line 7
                          apply 'lc$^1'/1
                              (_cor5)
                          -| ['compiler_generated'] )
                        <[]> when 'true' ->
                        %% Line 7
                        apply 'lc$^0'/1
                            (_cor1)
                        ( <_cor9> when 'true' ->
                          ( primop 'match_fail'
                            ({'function_clause',_cor9})
                            -| [{'function_name',{'lc$^1',1}}] )
                          -| ['compiler_generated'] )
                      end
                  in  let <_cor7> =
                      %% Line 7
                      call 'lists':'seq'
                      (1, 5)
                  in  apply 'lc$^1'/1
                      (_cor7)
                  -| ['list_comprehension'] )
            ( <[%% Line 7
                X|_cor1]> when 'true' ->
                  %% Line 7
                  apply 'lc$^0'/1
                  (_cor1)
              -| ['compiler_generated'] )
            <[]> when 'true' ->
                []
            ( <_cor8> when 'true' ->
                  ( primop 'match_fail'
                    ({'function_clause',_cor8})
                -| [{'function_name',{'lc$^0',1}}] )
              -| ['compiler_generated'] )
              end
      in  let <_cor3> =
          %% Line 7
          call 'lists':'seq'
              (1, 5)
          in  apply 'lc$^0'/1
              (_cor3)
      -| ['list_comprehension'] )
'module_info'/0 =
    fun () ->
    call 'erlang':'get_module_info'
        ('lc')
'module_info'/1 =
    fun (_cor0) ->
    call 'erlang':'get_module_info'
        ('lc', _cor0)
end

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

M>ЗЫ. Обнаружил (внезапно, да, хотя такая запись не удивительна), что можно и так писать
M>

M>[{X, Y} || X <- lists:seq(1, 5), X rem 2 == 0, Y <- lists:seq(1, 5), Y rem 2 == 1]
M>

M>По-моему, не видел, чтобы кто-то так писал. Но при желании можно.

Значит всё-таки действительно монада List

M>Тогда проверка будет так, как тебе нравится.

Забавно что для Python'а у тебя сразу получился правильный вариант

EP>Значит всё-таки действительно монада List

Ну, если тебе от этого будет спаться легче по ночам, пусть будет монада лист

M>>Тогда проверка будет так, как тебе нравится.
EP>Забавно что для Python'а у тебя сразу получился правильный вариант

Для Питона я скопировал первое попавшееся

Нечитаемость и многословность Питона это не спасает.

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

EP>>Значит всё-таки действительно монада List

M>Ну, если тебе от этого будет спаться легче по ночам, пусть будет монада лист

Конечно, ведь теперь сразу понятна семантика.

M>>>Тогда проверка будет так, как тебе нравится.
EP>>Забавно что для Python'а у тебя сразу получился правильный вариант

M>Для Питона я скопировал первое попавшееся

Нечитаемость и многословность Питона это не спасает.

В этом конкретном примере это субъектив. Тут четыре символа разницы:

[(x, y) for x in range(5) for y in range(5) if x % 2 == 0 if y % 2 == 1]
[{X, Y} || X <- range(5), Y <- range(5), x rem 2 == 0, y rem 2 == 1]

Структурно — одно и то же

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

S>Лично у меня на перлах нарисованы некоторые сервисы, автоматизирующие нужное мне. Например, я сейчас снимаю таймлапс с этой камеры

А че так пусто?

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

S>>Лично у меня на перлах нарисованы некоторые сервисы, автоматизирующие нужное мне. Например, я сейчас снимаю таймлапс с этой камеры
Ops>А че так пусто?
Ну так чего возле фонтана жопу греть, когда за поворотом парк начинается, площадью более в 9 кв. километров

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

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

_NN>>Проблема больше чем надуманна.
_NN>>Редакторы умеют всё делать нормально.
S>Мне насрать, что там умеют редакторы, я пишу в том, что в данный момент под рукой.
S>Я терпеть не могу, когда удобства делают обязанностью. Мне не нужен надзиратель с палкой, который стоит и бьёт по пальцам, если отступ не четыре пробела, а два. Отступы и форматирование — категорически нужная штука, но не стоит их соблюдение возводить в ранг абсолюта. Это граничит с идиотизмом.

А зачем нужны лишние элементы? Само по себе форматирование в большинстве случаев завязано на структуру кода, и нет особого смысла ставить фигурные скобки/begin..end/прочее чтобы выделить то что уже выделено отступом.

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

S>А зачем нужны лишние элементы? Само по себе форматирование в большинстве случаев завязано на структуру кода, и нет особого смысла ставить фигурные скобки/begin..end/прочее чтобы выделить то что уже выделено отступом.

Да пожалуйста, ешьте, если нравится. Я против, что ли?
Но я есть это буду только в исключительных случаях, ибо хочу таки иметь возможность писать как то приблизительно так:

void CStringBuilderBase::preface(const int                 &val) { MON_SB_SPRINTF("%d"   , val                   ); }
void CStringBuilderBase::preface(const unsigned int        &val) { MON_SB_SPRINTF("%u"   , val                   ); }
void CStringBuilderBase::preface(const short               &val) { MON_SB_SPRINTF("%hi"  , val                   ); }
void CStringBuilderBase::preface(const unsigned short      &val) { MON_SB_SPRINTF("%hu"  , val                   ); }
void CStringBuilderBase::preface(const long                &val) { MON_SB_SPRINTF("%li"  , val                   ); }
void CStringBuilderBase::preface(const unsigned long       &val) { MON_SB_SPRINTF("%lu"  , val                   ); }
void CStringBuilderBase::preface(const long long           &val) { MON_SB_SPRINTF("%lli" , val                   ); }
void CStringBuilderBase::preface(const unsigned long long  &val) { MON_SB_SPRINTF("%llu" , val                   ); }
void CStringBuilderBase::preface(const double              &val) { MON_SB_SPRINTF("%f"   , val                   ); }
void CStringBuilderBase::preface(const char                *val) { MON_SB_CONCAT(m_string, std::string(val)      ); }
void CStringBuilderBase::preface(const char                &val) { MON_SB_SPRINTF("%c"   , val                   ); }
void CStringBuilderBase::preface(const unsigned char       &val) { MON_SB_SPRINTF("%c"   , val                   ); }
void CStringBuilderBase::preface(const bool                &val) { MON_SB_CONCAT(m_string, val ? "true" : "false"); }
void CStringBuilderBase::preface(const std::string         &val) { MON_SB_CONCAT(m_string, val                   ); }
void CStringBuilderBase::preface(const float               &val) { MON_SB_SPRINTF("%f"   , val                   ); }

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

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

_NN>>Проблема больше чем надуманна.
_NN>>Редакторы умеют всё делать нормально.
S>Мне насрать, что там умеют редакторы, я пишу в том, что в данный момент под рукой.
S>Я терпеть не могу, когда удобства делают обязанностью. Мне не нужен надзиратель с палкой, который стоит и бьёт по пальцам, если отступ не четыре пробела, а два. Отступы и форматирование — категорически нужная штука, но не стоит их соблюдение возводить в ранг абсолюта. Это граничит с идиотизмом.

Всё таки большинство проблем надуманно на мой взгляд.
Касательно твоего кода вот тебе язык на отступах в виде Python:
Полноценную функцию изволь с переносом, а простую в виде лямбды пожалуйста.

a = lambda x: print("a - {}".format(x))
b = lambda x: print("b - {}".format(x))
c = lambda x: print("c - {}".format(x))
d = lambda x: print("d - {}".format(x))

a(1) # a - 1

Еще можно использовать ";" если хочется побыстрому записать и проверить

def a(x): 
   print(x); print(x+1); y = x - 1; print(y)

Также внутри скобок можно писать как душе угодно:

def a( 
  x, 
      y, 
              z): 
     print(x, y, 
       z) 
     ( 
print("F**k indent haha") 
)

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

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

S>>Я терпеть не могу, когда удобства делают обязанностью. Мне не нужен надзиратель с палкой, который стоит и бьёт по пальцам, если отступ не четыре пробела, а два. Отступы и форматирование — категорически нужная штука, но не стоит их соблюдение возводить в ранг абсолюта. Это граничит с идиотизмом.

_NN>Всё таки большинство проблем надуманно на мой взгляд.
_NN>Касательно твоего кода вот тебе язык на отступах в виде Python:
_NN>Полноценную функцию изволь с переносом, а простую в виде лямбды пожалуйста.
_NN>Еще можно использовать ";" если хочется побыстрому записать и проверить
_NN>Также внутри скобок можно писать как душе угодно:

Вот и я о чём. Налицо ограничение возможностей оформления кода. Выйти за рамки "только отступы, только хардкор!" можно только с извращениями.

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

S>Вот и я о чём. Налицо ограничение возможностей оформления кода. Выйти за рамки "только отступы, только хардкор!" можно только с извращениями.

Ограничения вполне вменяемые.
Я что-то особо не замечал промышленного кода с плохими отступами.
В этом любом случае стараются следовать нормальным отступам или "хардкору" как говоришь.

Взял наугад файл из Linux и не поверишь выровненный код: https://github.com/torvalds/linux/blob/master/ipc/compat_mq.c

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

_NN>Взял наугад файл из Linux и не поверишь выровненный код: https://github.com/torvalds/linux/blob/master/ipc/compat_mq.c

Ты не поверишь...

    return __get_user(attr->mq_flags, &uattr->mq_flags)
        | __get_user(attr->mq_maxmsg, &uattr->mq_maxmsg)
        | __get_user(attr->mq_msgsize, &uattr->mq_msgsize)
        | __get_user(attr->mq_curmsgs, &uattr->mq_curmsgs);

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

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

_NN>>Взял наугад файл из Linux и не поверишь выровненный код: https://github.com/torvalds/linux/blob/master/ipc/compat_mq.c

S>Ты не поверишь...
Ну как бы код выровнен , а не хаотично написан.
S>

S>    return __get_user(attr->mq_flags, &uattr->mq_flags)
S>        | __get_user(attr->mq_maxmsg, &uattr->mq_maxmsg)
S>        | __get_user(attr->mq_msgsize, &uattr->mq_msgsize)
S>        | __get_user(attr->mq_curmsgs, &uattr->mq_curmsgs);
S>

Синтаксис Python требует либо '\' либо скобки и будет просто:

   return __(get_user(attr->mq_flags, &uattr->mq_flags)
        | __get_user(attr->mq_maxmsg, &uattr->mq_maxmsg)
        | __get_user(attr->mq_msgsize, &uattr->mq_msgsize)
        | __get_user(attr->mq_curmsgs, &uattr->mq_curmsgs));

С '\' согласен, не очень удобно будет, хотя в макросах C по другому никак и все живы

   return __get_user(attr->mq_flags, &uattr->mq_flags) \
        | __get_user(attr->mq_maxmsg, &uattr->mq_maxmsg) \
        | __get_user(attr->mq_msgsize, &uattr->mq_msgsize) \
        | __get_user(attr->mq_curmsgs, &uattr->mq_curmsgs);

Крч. Мы тут из пустого в порожнее переливаем.
Итого:
Питон зациклен на отступах, что несколько ограничивает варианты оформления кода. Это не означает, что питон плох. Просто он несколько ограничивает свободу. Это мне не нравится. Точка.
Но. Несколько извернувшись, таки можно оформлять код как хочется.

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

S>Крч. Мы тут из пустого в порожнее переливаем.
S>Итого:
S>Питон зациклен на отступах, что несколько ограничивает варианты оформления кода. Это не означает, что питон плох. Просто он несколько ограничивает свободу. Это мне не нравится. Точка.
Не только он , еще другия языки есть.
Кстати, а языки со сборщикам мусора тоже не нравятся наверное из-за ограничения свободы ?

S>Но. Несколько извернувшись, таки можно оформлять код как хочется.
Похоже в этом у нас разногласия.
Я как раз считаю это здравым смыслом, а для тебя извращения

Еще раз: из пустого в порожнее. Смысла в дискуссии дальше не вижу. Тебе меня не убедить, что требование к табам в питоне не есть ограничение свободы оформления кода. Мне тебя не убедить в обратном. Ты, похоже, гдето очень обжёгся на неотформатированном коде.

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

_NN>Полноценную функцию изволь с переносом, а простую в виде лямбды пожалуйста.
_NN>

_NN>a = lambda x: print("a - {}".format(x))
_NN>b = lambda x: print("b - {}".format(x))
_NN>c = lambda x: print("c - {}".format(x))
_NN>d = lambda x: print("d - {}".format(x))

_NN>a(1) # a - 1    
_NN>

Вот так тоже можно:

def a(x): print("a - {}".format(x))
def b(x): print("b - {}".format(x))
def c(x): print("c - {}".format(x))
def d(x): print("d - {}".format(x))

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

S>Еще раз: из пустого в порожнее. Смысла в дискуссии дальше не вижу. Тебе меня не убедить, что требование к табам в питоне не есть ограничение свободы оформления кода. Мне тебя не убедить в обратном. Ты, похоже, гдето очень обжёгся на неотформатированном коде.

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

	От:	Evgeny.Panasyuk
	Дата:	19.10.15 09:37
	Оценка:

	От:	Sheridan
	Дата:	19.10.15 09:44
	Оценка:

От:	Mamut	http://dmitriid.com
Дата:	19.10.15 09:58
Оценка:

	От:	Evgeny.Panasyuk
	Дата:	19.10.15 10:05
	Оценка:

От:	Mamut	http://dmitriid.com
Дата:	19.10.15 10:09
Оценка:

	От:	_NN_
	Дата:	20.10.15 06:14
	Оценка:	1 (1)