[x*y for x in xx for y in yy]

Дао Perl 6:
1. Любой набор символов в любой кодировке является синтаксически правильным Perl 6 кодом.
2. Всегда есть бесконечное количество различных способов сделать это.
3. Любой человек, писавший до этого на любом языке, может сразу писать на Perl 6. Он может даже не догадываться, что пишет на Perl 6. Если, конечно, не будет забывать ставить 1; в конце модулей.
4. Можно перегружать 1;. Можно перегружать пробелы. Можно перегружать сорц-фильтры с помощью регулярных выражений, которые тоже можно перегружать.
5. Perl 6 имеет эталонную реализацию, написанную на Perl 6 и не способную быть выраженной ни на каком другом языке[2]. На Perl 6 эталонная реализация может быть выражена, но не за конечное время. Мы работаем над этим. Когда мы закончим, наступит Армагеддон (который тоже можно будет перегрузить).
1;

# Python for if for if чтоа?
[(x,y) for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 == 1]

% Erlang. По сути, перечисление условий для получения X и Y.

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

// Эквивалентная математическая запись что-то в стиле

{ x,y | x ∈ range(5), y ∈ range(5), x mod 2 = 0, y mod 2 = 1 }

[(x,y)  for x in range(5)  if x%2==0  for y in range(5)  if y%2==1]

 [x*y for x in xx for y in yy]

gather for @yy -> $y { for @xx -> $x { take $x * $y } }

@xx X* @yy

@xx X* @yy

gather for @yy -> $y { for @xx -> $x { if ($x>1) take $x * $y else take $x + $y } }

5 октября 2015 года на площадке Канбар форума в Сан-Франциско Ларри Уолл официально представит финальную реализацию языка программирования Perl 6. Спонсором мероприятия выступает компания Craigslist (текущий работодатель Ларри Уолла).

This is why we say all languages are religious dialects of Perl 6.

method method1(%params ($arg1!, $arg2!, $arg3)) {
  ...
}

T>method method1(%params ($arg1!, $arg2!, $arg3)) {
T>  ...
T>}
T>

function test(options:{
    id: number;
    description?: string;
    code: number;
}) {
    return options.id * options.code;
}

test({id: 1, code: 15});

class User {
  public constructor(
    public Name:string,
    public Title: string
  ) { }
}

class Group {
  public constructor(
    public Name:String,
    public Options: number) 
  { }
}

function printName(entity: {Name: string}) {
  console.log(entity.Name);
}

// Несмотря на то что это разные классы, они удовлетворяют требованию о наличии поля Name
printName(new User("Test", "test"));
printName(new Group("Test", 1));

// Или вообще так:
printName({Name: "Inline" });

// При этом всё равно проверяются типы:
printName({Name: 123}); // Ошибка

// Можно сказать что Name может быть числом или строкой
function printName2(entity: {Name: string|number}) {
  console.log(entity.Name);
}

// и тогда этот вызов будет корректным
printName2({Name: 123}); // Теперь не ошибка

M># Python for if for if чтоа?
M>[(x,y) for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 == 1]

M>% Erlang. По сути, перечисление условий для получения X и Y.

M>[{X, Y} || X <- range(5), Y <- range(5), x rem 2 == 0, y rem 2 == 1 ]
M>

>>> [(x,y) for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 == 1]
[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]

>>> [(x,y) for x in range(5) for y in range(5) if x % 2 == 0 if y % 2 == 1]
[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]

>>> [(x,y) for x in range(5) for y in range(5) if x % 2 == 0 and y % 2 == 1]
[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]

-module(lc).

-export([lc/0]).

lc() ->
 [{X, Y} || X <- lists:seq(1, 5), Y <- lists:seq(1, 5), X rem 2 == 0, 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 (_cor10) ->
              case _cor10 of
            <[X|_cor1]> when 'true' ->
                ( letrec
                  'lc$^1'/1 =
                      fun (_cor11) ->
                      case _cor11 of
                        <[Y|_cor4]>
                        when try
                              let <_cor5> =
                              call 'erlang':'rem'
                                  (X, 2)
                              in  let <_cor6> =
                                  call 'erlang':'=='
                                  (_cor5, 0)
                              in  let <_cor7> =
                                  call 'erlang':'rem'
                                      (Y, 2)
                                  in  let <_cor8> =
                                      call 'erlang':'=='
                                      (_cor7, 1)
                                  in  call 'erlang':'and'
                                      (_cor6, _cor8)
                          of <Try> ->
                              Try
                          catch <T,R> ->
                              'false' ->
                        let <_cor12> =
                            apply 'lc$^1'/1
                            (_cor4)
                        in  ( [{X,Y}|_cor12]
                              -| ['compiler_generated'] )
                        ( <[Y|_cor4]> when 'true' ->
                          apply 'lc$^1'/1
                              (_cor4)
                          -| ['compiler_generated'] )
                        <[]> when 'true' ->
                        apply 'lc$^0'/1
                            (_cor1)
                        ( <_cor11> when 'true' ->
                          ( primop 'match_fail'
                            ({'function_clause',_cor11})
                            -| [{'function_name',{'lc$^1',1}}] )
                          -| ['compiler_generated'] )
                      end
                  in  let <_cor9> =
                      call 'lists':'seq'
                      (1, 5)
                  in  apply 'lc$^1'/1
                      (_cor9)
                  -| ['list_comprehension'] )
            <[]> when 'true' ->
                []
            ( <_cor10> when 'true' ->
                  ( primop 'match_fail'
                    ({'function_clause',_cor10})
                -| [{'function_name',{'lc$^0',1}}] )
              -| ['compiler_generated'] )
              end
      in  let <_cor2> =
          call 'lists':'seq'
              (1, 5)
          in  apply 'lc$^0'/1
              (_cor2)
      -| ['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

[List comprehensions в Питоне:] Слишком многословно, из-за чего все, что сложнее [x*x for x in list] становится нечитаемым, а создание сколько-нибудь сложных comprehension'ов — нетривиальным.

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

[{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

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

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]

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                   ); }

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>Взял наугад файл из 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);

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

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>

   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));

   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);

_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))