Re: The philosophy of ruby

[Peter B. S. <vs...@ho...>]

Max Belugin wrote:
> PBS> Что значит "меньше реюза"?
> статическая типизация нее позволяет использовать a+b для любых
> объектов, на множестве которых определен +

При чем здесь статичность типизации? На определенность оператора
"на множестве" каких-либо типов влияет только его (оператора)
осмысленность для этих типов. В случае с Питоном добавляется еще и лень
автора языка. :) Попробуйте сложить оператором + (или +=) коллекцию и не
коллекцию, например, [1] и 2, или 1 и "2", или "1" и 2. Все эти
операторы - сахар, не больше. Ну нельзя в Java определять операторы - и
что? Кому надо, делает интерфейсы с методами add/sub/div/mul/что_там_еще
и реализует их в нужных классах.

> напиши на Java аналог функции map - у тебя не получится именно из за
> того, что Java - язык статически типизированный.

:) Что Вы привязались к этой типизации? Если расскажете, какая разница
между tuple и list, сделаю, как в Питоне.

=== Test.java ===
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Test
{
  public static void main(String[] args)
  {
    Test t1 = new Test();
    t1.test();
  }

  void test()
  {
    LinkedList l1 = new LinkedList();
    l1.add("Yops");
    l1.add(new Integer(2));

    LinkedList l2 = new LinkedList();
    l2.add("l2::zombuk");

    LinkedList l3 = new LinkedList();
    l3.add("l3::1");
    l3.add("l3::2");
    l3.add("l3::3");

    List[] a1 = {l1, l2, l3};

    List rv;

    System.out.println("Gonna call map(None, l1, l2, l3)");
    rv = BuiltIn.map(null, a1);
    System.out.println("rv=" + rv);
    dumpList(rv);

    System.out.println("Gonna call map(f, l1, l2, l3)");
    rv = BuiltIn.map(f, a1);
    System.out.println("rv=" + rv);
    dumpList(rv);

    System.out.println("Gonna call map(f2, l1)");
    rv = BuiltIn.map(f2, l1);
    System.out.println("rv=" + rv);
    dumpList(rv);

    System.out.println("Gonna call map(None, <modified l1>)");
    l1.add(null);
    l1.add("l1::after_null");
    rv = BuiltIn.map(null, l1);
    System.out.println("rv=" + rv);
    dumpList(rv);
  }

  static void dumpList(List l)
  {
    int i = 0;
    for (Iterator li = l.iterator(); li.hasNext(); i++) {
      System.out.println("l[" + i + "]='" + li.next() + "'");
    }
  }

  static final Function f = new Function() {
    public Object call(FunctionArguments args) {
      System.out.print("f: ");
      for (int i = 0; i < args.size(); i++) {
        if (i > 0) { System.out.print(", "); }
        System.out.print("args[" + i + "]=" + args.get(i));
      }
      System.out.println("");
      return null;
    }
  };

  static final Function f2 = new Function() {
    public Object call(FunctionArguments args) {
      System.out.print("f2: ");
      for (int i = 0; i < args.size(); i++) {
        if (i > 0) { System.out.print(", "); }
        System.out.print("args[" + i + "]=" + args.get(i));
      }
      System.out.println("");
      return null;
    }
  };
}

=== BuiltIn.java ===
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class BuiltIn
{
  public static List map(Function func, final List[] lists_arr)
  {
    if (func == null) func = identityFunction;

    final LinkedList rc = new LinkedList();

    final int lists_count = lists_arr.length;
    final Iterator[] lists_iters = new Iterator[lists_count];

    final FunctionArguments args = new FunctionArguments();
    boolean more_items = true;
    while (more_items) {
      args.clear();
      more_items = false;
      for (int i = 0; i < lists_count; i++) {
        Iterator li = lists_iters[i];
        if (li == null) { 
          li = lists_iters[i] = lists_arr[i].iterator();
        }
        args.add(li.hasNext() ? li.next() : null);
        more_items |= li.hasNext();
      }
      rc.add(func.call(args));
    }
    return rc;
  }

  public static List map(Function func, final List list) {
    if (func == null) func = identityFunction;
    final LinkedList rc = new LinkedList();
    final FunctionArguments args = new FunctionArguments();
    for (Iterator li = list.iterator(); li.hasNext(); ) {
      args.clear();
      args.add(li.next());
      rc.add(func.call(args));
    }
    return rc;
  }

  private static final Function identityFunction = new Function() {
    public Object call(final FunctionArguments args) {
      return args.size() == 1 ? args.get(0) : new LinkedList(args);
    }
  };
}

=== Function.java ===
public interface Function
{
  public Object call(FunctionArguments args);
}

=== FunctionArguments.java ===
import java.util.LinkedList;
public class FunctionArguments extends LinkedList { }


> или хотя бы аналог такой функции
> def sum(Xs):
>    r=Xs[0]
>    for x in Xs[1:]:
>        r=r+x
>    return r
> print sum([1,2,3])
> print sum(['1','2','3'])
> print sum([[1,2],[2,3]])
> print sum('1234')

Объясните смысл последней конструкции?

import java.util.List;
class MyMath
{
  static double  sum(double[] a);
  static float   sum(float[] a);
  static long    sum(long[] a);
  static int     sum(int[] a);
  static byte    sum(byte[] a);
  static boolean sum(boolean[] a);

  static String  sum(char[] a);
  static String  sum(String[] a);

  static List    sum(List[] a);
}

Реализацию, думаю, необязательно приводить?

> - оператор for работает с коллекциями (будет в тигре, знаю)

Вы читали, как он на самом деле работает? Такой же сахар, как и
оператор +.

> - все литералы, про которые я думаю как о коллекции является
> коллекцией (в том числе строка)

А что мешает на Java написать класс наподобие такого:

import java.util.List;
public class Q
{
  static List newCollection(String s);
  static List newCollection(char[] a);
  static List newCollection(CharBuffer cb);
  static List newCollection(StringBuffer sb);
  static List newCollection(о_чем_еще_я_думаю_как_о_коллекции z);
}


> - все эти коллекции доступны единообразно и существует множество
> "синтаксического сахара" для работы с коллекциями

В Java они доступны не менее единообразно - java.util.*

> - функции - это объекты

И что?

> - строковые литералы могут быть как со специальными символами, так и
> без их учета (для Java я себе даже сделал скриптец в фаре, который
> удвояет бекслешы) а в питоне достаточно написать r'c:\Programs
> files\test' - особенно помагает с регулярными выражениями.

Да, удобно. Еще мне нравится list comprehensions. Такой мини-SQL. :)

> мне нравится, кстати, отсутствие скобок (все равно я отступы так
> ставлю, зачем еще и скобки)

А не угнетает, что вместо 'i++' надо писать 'i+=1'? А бэкслэш в конце
строки ставить, если хочется выражение на несколько строк разбить? Мы
не про синтаксис говорили. Я, по крайней мере.

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

Ну так берется и пишется класс, городящий это все за меня.

> PBS> Надеюсь, "подвох" не в количестве строк? :)
> именно в них.

На программах такого размера это выглядит особенно эффектно. Только
практической ценности в них - ноль.

> теперь напиши аналог такого скрипта
> for line in file('1.py'):
>         print '>>>'+line
> хочется ли тебе ради одноразового скрипта писать все эти Buffered
> readerы и т.д.?

Мне вообще никогда ничего не хочется писать. Хочу щелкнуть пальцами и
получить готовую программу. Хотя, иногда даже пальцами щелкать лень.
Buffered reader'ы буду использовать из-за оправданности этого
использования, а не из-за n-разовости использования скрипта.

> для скриптинга лаконичность важна.

Лаконичность можно и в Java сделать, написав пакет
scripting.your_favourite_scripting_language.

--
0xdeadbeef