Why it’s hard for programmers to write a program to flatten a list?(shekhargulati.com)

  (flatten '((1) ((2 3 ((4) (5 6)))))

  (flatten [[1] [[2 3 [[4] [5 6]]]]]

  flatten =: [: ; <S:0

  def flatten(nested_list):
      output_list = []
      for elem in nested_list:
          if type(elem) == list:
              output_list.extend(flatten(elem))
          else:
              output_list.append(elem)
      return output_list

  import collections

  def flatten(nested_list):
      if isinstance(nested_list, collections.Iterable):
          return [a for i in nested_list for a in flatten(i)]
      else:
          return [nested_list]

  sub flatten { map ref($_)? flatten(@$_) : $_, @_ }

  sub flatten
  {
      my @in = @{$_[0]};
      my @out;
      while (@in) {
          my $item = shift @in;
          if (ref $item eq 'ARRAY') {
              unshift @in, @$item;
          } else {
              push @out, $item;
          }
      }
      return \@out;
  }

   import org.junit.Test;
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.List;
   import java.util.stream.Collectors;
   import java.util.stream.Stream;
   
   import static junit.framework.TestCase.assertEquals;
   
   public class FlattenList {
   
       @Test
       public void test() {
           // [1, [2, 3], [4, [5, 6]], [7, [8, [9, 10]]]]
           final FlattenableList<Integer> list = new FlattenableList<>();
           list.add(new SingleFlattenable<>(1));
   
           list.add(new ListOfSingles<>(Arrays.asList(2, 3)));
   
           list.add(new Flattenable<Integer>(){{
               add(new SingleFlattenable<>(4));
               add(new ListOfSingles<>(Arrays.asList(5, 6)));
           }});
   
           list.add(new Flattenable<Integer>(){{
               add(new SingleFlattenable<>(7));
               add(new Flattenable<Integer>(){{
                   add(new SingleFlattenable<>(8));
                   add(new ListOfSingles<>(Arrays.asList(9, 10)));
               }});
           }});
   
           assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), list.flatten());
       }
   
       public static class FlattenableList<T> {
   
           final List<Flattenable<T>> list = new ArrayList<>();
   
           void add(final Flattenable<T> item) {
               list.add(item);
           }
   
           List<T> flatten() {
               return list.stream().flatMap(Flattenable::flatten).collect(Collectors.toList());
           }
   
       }
   
       private static class Flattenable<T> {
   
           final List<Flattenable<T>> contents = new ArrayList<>();
   
           Stream<T> flatten() {
               return contents.stream().flatMap(Flattenable::flatten);
           }
   
           void add(final Flattenable<T> content) {
               contents.add(content);
           }
   
       }
   
       private static class ListOfSingles<T> extends Flattenable<T> {
   
           final List<T> list;
   
           ListOfSingles(final List<T> list) {
               this.list = list;
           }
   
           @Override
           Stream<T> flatten() {
               return list.stream();
           }
   
       }
   
       private static class SingleFlattenable<T> extends Flattenable<T> {
   
           final T item;
   
           SingleFlattenable(final T item) {
               this.item = item;
           }
   
           @Override
           Stream<T> flatten() {
               return Stream.of(item);
           }
   
       }
   
   }

   isinstance(el, collections.Iterable) and not isinstance(el, str)

    def flatten(x):
        def flatten_generator(x):
            if type(x) == list:
                for y in x:
                    for z in flatten(y):
                        yield z
            else:
                yield x
        return list(flatten_generator(x))

    assert(flatten([1, [2,3]]) == [1,2,3])

    ary = [1, [2,3], [4, [5,6]]]
    print flatten(ary)

    [item for sublist in l for item in sublist]

    return args.toString().split(/[\s,]+/).filter(/* ... */);

    sub flatten {
       map { ref $_ eq 'ARRAY' ? flatten(@$_) : $_ } @_ 
    }

  def flatten(array):
      queue = [array]
      result = []
      while len(queue) > 0:
          item = queue.pop(0)
          if isinstance(item, list):
              for sub_item in item:
                  queue.append(sub_item)
          else:
              result.append(item)
      return result

  a = [1,[2,3], [4, [5,6]]]
  print 'input:', a, '\noutput:', flatten(a)