コレだけはガチ。続きは書くかもしれないけど、たぶん書かない。


P.S

Schemeが好きです。Gaucheが好きです。でもういんどうずだとGaucheさんはちょっとアレなので、社内ソフトがWindowsしか対応してないとか、データ保護ソフトがWindowsしか対応してないとか、社内システムがIE限定だとか、ういんどうずを使わざるを得ない人には使えません。Pythonサイコー


どう書く?orgでScalaを書いてくれる人もでてきたので、超一部の方向けにScalaのことでも書いてみようと思います。言うなれば、基礎を終えた人のScalaミニtips。知っている人は知っている、でもあまり知られていないことを並べていきます。

下に行くほどマニア度あがります、たぶん。FPよりの話が多いかもしれません。はやりのYコンビネータの話とか。たぶん。

ではいってみましょう。

Predefされているものは把握しておきましょう

Scalaにはscala.Predefというオブジェクトがあります。この中で定義されているものは常にインポートされていて使える状態になっているので把握しておきましょう。

例:

def exit(status: Int): Nothing = {
  java.lang.System.exit(status)
  throw new Throwable()
}

def assert(assertion: Boolean) {
  if (!assertion)
    throw new java.lang.AssertionError("assertion failed")
}

def print(x: Any) = Console.print(x)
def println() = Console.println()
def println(x: Any) = Console.println(x)

C言語ライクなforはどうかくの?

こうです。

val a = Array(1,2,3,4,5)
var i= -1;while({i += 1; i < a.size;}) {
  println(a(i))
}

setterを使おう

setHogeみたいなのは、カッコわるいです。RubyのアクセッサーしかりPythonのpropertyしかり、 instance.name = value 形式で扱えるのがモダンな言語というものです。

class Test {
  var _name = "default"
  def name_=(newValue:String) { _name = newValue }
  def name = _name
}

val a = new Test
a.name = "new"
println(a.name)

単項演算子も定義できます。

できます。

class Test {
  var _name = "default"
  def name_=(newValue:String) { _name = newValue }
  def name = _name
  def unary_- = "unary:" + name
}

val a = new Test
a.name = "new"
println(-a)

applyでオブジェクトをメソッドのように呼び出せるよね? hoge(index) = value はオーバーライドできないの?

できますよ。なんとupdateというすげーふつーの名前のメソッドを定義するんです。

object dictionary {
val data = Array(null, "A","B","C")

def apply(x:String) = x match {
  case "one" => data(1)
  case "two" => data(2)
  case "three" => data(3)
}

def update(x:String,y:String) = x match {
  case "one" => data(1) = y 
  case "two" => data(2) = y
  case "three" => data(3) = y
}

}
dictionary("one") = "X"   
dictionary("two") = "Y"
dictionary("three") = "Z"
println(dictionary("one")+","+dictionary("two")+","+dictionary("three"))

可変長引数は取れますか。また、リストや配列を展開してメソッドにわたせますか。

もちろん。

def sumPlus(plus: Int, n: Int*) = plus + sum(n :_*)

JAVAのObject型可変長変数をとるメソッドはどう呼びますか?

ちょっとめんどくさいですが、こうです。

String.format("%d %s", List(1, "hoge").map(_.asInstanceOf[AnyRef]).toArray)

インスタンスのメソッドを束縛できますか?そのとき、メソッドがオーバーロードされている場合はどうしますか?

こうします。オーバーロードされている場合は _ の後ろに型をつけます。

val format = (new SimpleDateFormat("dd")).format _:Date => String

ここからFPよりです。

カリー化はできますか?

Function.curriedを使います。uncurriedもあります。

def test(i:int, j:int) = {
  printf("i:{0}, j:{1}", i, j)
}
val f = Function.curried(test _)(1)
f(1)

遅延評価は?

lazyを使います。Streamも使いこなせるとハッピーです。

たとえば、無限フィボナッチ数列は以下のように定義します。

lazy val fib: Stream[Int] = Stream.cons(0,
     Stream.cons(1, fib.zip(fib.tail).map(p => p._1 + p._2)))

先生、関数合成がしたいです・・・

Haskellでは短く直感的にかけるからいいですよね。

Scalaでは正直、逆に長ったらしくなりますが、どうしてもというなら・・・

({ x:int => x + 1 } andThen { x:int => x * 2 })(3) // => 8
({ x:int => x + 1 } compose { x:int => x * 2 })(3) // => 7

forはモナドに使える構文です。リスト内包表現用ではありません。

リストはモナドですし、HaskellのMaybeに相当するOptionというモナドもあります。map, flatMap, filterメソッドを実装すればforで書けるオブジェクトを定義できます。

Yコンビネータとかいうものの話が(一部で)盛り上がってますが、そういうのってScalaでできるんですか。型があるから複雑だと思うんだけど。

えーと、無名関数で再帰したいんでしょうか?こんな感じでどうでしょう?ふつーはこんなの使いませんけどね。

def Y[A,B](f:((A=>B),A)=>B,x:A):B = f((x1:A)=>Y(f,x1),x)

println(
  Y(
    (f:((int,int)) => int, arg:(int,int)) => arg match { case (x, y) => x match {
      case 0 => y
      case _ => f((x - 1, y + x))
    }} , (10, 0))
)

さて、数少ない日本人Scala好きの皆さん。どれくらいご存知でしたでしょうか。まぁ、基礎からちょっとScalaやればこれくらいは皆さんご存知だと思うんですが、やはりScalaはカオスな言語なので、なかなか見つけられない機能も多いんで、最近Scalaやりはじめた人は参考にしてもらえるとうれしいです。


誰もが一度使うと便利さと気軽さに感動するRubyが誇るライブラリ、 Rake

プログラムのビルドもそうなんですが、雑多なタスクを簡単に書けて、整理できるのがなんといっても魅力的。RailsなんかではDBの作成から何から、ばんばんRakeタスクにされていますよね。

 

さて、俺はPythonistasなので、PythonでRakeみたいなのがほしいわけです。ビルドに限っていえばPythonは Scons という素晴らしいツールがあります。C言語はおろか、JAVA、PDF、PostScriptなどなど、さらにはSubversionもサポートしていますし、並列コンパイルもでき、実績も多数で申し分ありません。

でも俺がしたいのは、雑多なタスクを放り込む、コレ。そういうのを簡単にやるライブラリってPythonではないんでしょうか。RubyではRakeが標準添付されるというのに。いえ、あります。前からあるんです。それが distutils

distutils(およびその拡張のsetuptools)はPythonの標準的なパッケージ配布システムとして有名です。でも実は自分でコマンドを定義してRakeのように使うことができることはあまりしられていないのではないでしょうか。

distutilsでコマンドを定義する

distutilsでコマンドを定義するにはdistutils.core.Commandクラスを継承し、色々オーバーライドします。説明もつけられますし、オプションもとれて、sub_commandsで依存関係(コマンド分割)を設定することもできます。

class MyCommand(Command):
  description = "コマンドの説明"
  user_options = [("host=", "h", "hostname")] # オプション
  sub_commands = [("pre_task", None)] # サブコマンド
  def run(self): pass # 実行する内容
  def initialize_options(self): # オプションの初期化
    self.host = None
  def finalize_options(self):
    if not self.host: raise "Error"

setup(cmdclass={"my_command":MyCommand})

といった具合です。非常にPythonicなやり方ですね。ただ、いろいろオーバーライドしないといけないので面倒です。そこで、俺がコピペで使っている自家製テンプレの登場です。

もっと簡単にdistutilsでタスク

30行程度のテンプレを足して、簡単にタスクを定義できるようにしましょう。namespace機能はPython2.5以上限定です。

from __future__ import with_statement
from distutils.core import Command, setup
from contextlib import contextmanager

_cmds = {}
_namespace = []
_get_ns = lambda:_namespace and "_".join(_namespace)+"_" or ""
class CommandType(type):
  def __new__(cls, class_name, class_bases, classdict):
    d = dict(user_options=[], finalize_options=lambda s:None)
    d.update(classdict)
    def _(self):
      [setattr(self,i[0].rstrip("="),None) for i in d["user_options"]]
    d["initialize_options"] = _
    d["boolean_options"] = [i for i,j,k in d["user_options"] if not i.endswith("=")]
    def _(self):
      map(self.run_command, self.get_sub_commands())
      return classdict["run"](self)
    d["run"] = _
    name = _get_ns()+class_name.lower()
    cls = type.__new__(cls, name, class_bases + (object,), d)
    cls.description = cls.__doc__
    if class_name != "BaseCommand" : _cmds[name] = cls
    return cls
class BaseCommand(Command): __metaclass__ = CommandType

@contextmanager
def namespace(name):
  _namespace.append(name)
  yield _get_ns()
  _namespace.pop()

これだけです。これでかなり簡単にタスクが作れるようになります。例を示しましょう。

with namespace("db") as ns:
  with namespace("create") as ns:
    class Test1(BaseCommand):
      """test1 discription
      """
      user_options = [ ("host=", "h", "hostname"),
                      ("port=", "p", "port"),
                      ("force", "f", "force execute")]
      def run(self):
        print self.host
        print self.force
        print "hello, ", self.__class__.__name__

      sub_commands = [(ns+"test2",None)]

    class Test2(BaseCommand):
      """test2 discription
      """
      def run(self):
        print "hello, ", self.__class__.__name__


  class Test3(BaseCommand):
    """test3 discription
    """
    def run(self):
      print "hello, ", self.__class__.__name__

class Test4(BaseCommand):
  """test4 discription
  """
  user_options = [ ("host=", "h", "hostname") ]
  def run(self):
    print "hello, ", self.__class__.__name__

  def finalize_options(self):
    if not self.host:
      raise ValueError("host must not be None")


setup(cmdclass=_cmds)

かなり直感的になったのではないでしょうか。withを使えば名前空間も結構簡単に実現できます。コマンドのヘルプを見てみましょう。

# python task.py --help-commands
Standard commands:
  build            build everything needed to install
  build_py         "build" pure Python modules (copy to build directory)
  build_ext        build C/C++ extensions (compile/link to build directory)
  build_clib       build C/C++ libraries used by Python extensions
  build_scripts    "build" scripts (copy and fixup #! line)
  clean            clean up temporary files from 'build' command
  install          install everything from build directory
  install_lib      install all Python modules (extensions and pure Python)
  install_headers  install C/C++ header files
  install_scripts  install scripts (Python or otherwise)
  install_data     install data files
  sdist            create a source distribution (tarball, zip file, etc.)
  register         register the distribution with the Python package index
  bdist            create a built (binary) distribution
  bdist_dumb       create a "dumb" built distribution
  bdist_rpm        create an RPM distribution
  bdist_wininst    create an executable installer for MS Windows

Extra commands:
  db_test3         test3 discription

  db_create_test2  test2 discription

  db_create_test1  test1 discription

  test4            test4 discription


usage: task.py [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
  or: task.py --help [cmd1 cmd2 ...]
  or: task.py --help-commands
  or: task.py cmd --help

こんな感じで、標準コマンドに加え「Extra commands」という形で定義したタスクが使えるようになります。もちろん、distutilsのビルド機能、パッケージ管理機能も使えますよ。

db_create_test1のヘルプを見てみましょう。

# python task.py db_create_test1 --help
Common commands: (see '--help-commands' for more)

  setup.py build      will build the package underneath 'build/'
  setup.py install    will install the package

Global options:
  --verbose (-v)  run verbosely (default)
  --quiet (-q)    run quietly (turns verbosity off)
  --dry-run (-n)  don't actually do anything
  --help (-h)     show detailed help message

Options for 'db_create_test1' command:
  --host (-h)   hostname
  --port (-p)   port
  --force (-f)  force execute

usage: task.py [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
  or: task.py --help [cmd1 cmd2 ...]
  or: task.py --help-commands
  or: task.py cmd --help

ちゃんとオプションが表示されていますね。最後に、db_create_test1タスクを実行してみましょう。

# python task.py db_create_test1 --host=localhost
running db_create_test1
running db_create_test2
hello,  Test2
localhost
None
hello,  Test1

サブコマンドのdb_create_test2が実行されていること、きちんとオプションがselfの属性として設定されていることがわかりますね。


標準的な機能だけでもRakeのようなタスクはつくれますが、30行程度の工夫で断然便利になります。Rakeと違いrakeコマンドのような外部コマンドも必要なく、pythonのスクリプト1つで実現できるのも手軽です。というわけで、雑多なタスクはdistutilsでまとめてみてはいかがでしょうか。