funattii's small small world

引越し

あんまり更新ないブログでしたが、

http://d.hatena.ne.jp/funatti/

に引越ししました。コンテンツはそのままです。

scala.swing.FrameでWindowClosingをキャンセルしたい

javaでSwingのJFrameを扱う場合、[×]ボタンをキャンセルしたいと思ったら

setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE)

ってできるのに、scala.swing.Frameじゃできない！

うぅぅ困ったと思っていたら、実はFrameにはpeerというメンバがあり、それがjavax.swing.JFrameだということを発見！

ってことはFrame内で、

peer.setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE)

と書けばいいんじゃないか…？と思ったらビンゴ＾＾

しかもウィンドウが閉じられる直前にcloseOperaion()が呼ばれることも知ったので、

override def closeOperation(){
(Windowの終了処理)
}

を書けばおk

スクリプトに対応したアプリケーションを作る

Scalaを始めてもうすぐ１週間。やっとScalaに慣れてきました。

ところで、Scalaというのはスクリプト言語であると言われます。スクリプト言語とは、あるアプリケーションの上で動かせる言語のことですが、実際、自分の作ったアプリケーションにスクリプトを組み込むにはどうすればいいんだろうとふと思いました。

実は、スクリプト言語には必ずコンパイラもしくはインタプリタが準備されていて、ライブラリのどこかに隠されているんです。

例えばLuaは、C/C++で書かれたプログラムに簡単にスクリプトを組み込むことができます。

（参考リンク）
"C++からLuaスクリプトを実行する"
http://blog.livedoor.jp/akf0/archives/51600634.html

"C言語アプリケーションに Pythonを組み込む"
http://d.hatena.ne.jp/Wacky/20060103/1136292735

ではJavaではどうするかといえば、Bean Scripting Framework(BSF)を使う方法が１つと、C/C++の場合と同様に、言語ごとに準備されているコンパイラ/インタプリタを呼び出すという方法があります。

（参考リンク)
"Embedded Scala Interpreter"
http://speaking-my-language.blogspot.com/2009/11/embedded-scala-interpreter.html

"Java技術最前線　11月のお題「Java関連スクリプト言語」第2回"
http://itpro.nikkeibp.co.jp/article/COLUMN/20051114/224543/

以下は、Scala上でScala＆JRubyを走らせる方法です。しかも同時に走らせてみようという無謀なものです。

Scalaで組み込みインタプリタを実行すると、実行時にscala-compile.jarとscala-library.jarが上手く読み取られず、"object scala not found"というエラーが出てしまいます。そのあたりの細工をちょこっと行っているため、JRubyインタプリタに比べて冗長な表現になっています。。残念。。

（ただし以下のコードを実行するには、jruby.jarをプロジェクトのライブラリとしてリンクしておく必要があります。その方法はNetBeansのリファレンスや、JARの読み込み方法を解説したブログなどを参照してください。）


package scalaonscala

import scala.tools.nsc._
import scala.util.DynamicVariable

import org.jruby.Ruby


class Evaluator {
  val settings = new GenericRunnerSettings(println _)
  val i = new Interpreter(settings)

  {
    val origBootclasspath = settings.bootclasspath.value
    val compilerPath = jarPathOfClass("scala.tools.nsc.Interpreter")
    val libPath = jarPathOfClass("scala.ScalaObject")
    val pathList = List(compilerPath,libPath)
    settings.bootclasspath.value = (origBootclasspath :: pathList).mkString(java.io.File.separator)
  }

  def eval(line: String): Any = {
    i.interpret(line)
    Evaluator.result.value
  }

  def jarPathOfClass(className: String) = {
    val resource = className.split('.').mkString("/", "/", ".class")
    val path = getClass.getResource(resource).getPath
    val indexOfFile = path.indexOf("file:")
    val indexOfSeparator = path.lastIndexOf('!')
    path.substring(indexOfFile, indexOfSeparator)
  }
}

object Evaluator {
  val result = new DynamicVariable[Any](())
}

object EvalTest {
  def main(args: Array[String]): Unit = {
    val e = new Evaluator
    
    println("Hello, Scala!")
    var r = e.eval("println(\"Hello, Scala on Scala!\")")
    println(r)

    r = e.eval("println(\"Hello, Scala on Scala!!!!\")")
    println(r)

    val runtime = Ruby.getDefaultInstance();
    runtime.evalScriptlet("puts \"Hello, Ruby on Scala!\"");
    runtime.evalScriptlet("puts \"Hello, Ruby on Scala!!!!!\"");
  }
}

object Hoge {
  def somefunc = "mogemoge"
}

実行してみた結果がコレ↓

おぉ！ちゃんと実行されています！

ただし、インタプリタが起動するには時間がかかるらしく、Ruby, Scalaのいずれも最初の１行を処理するのに数秒かかり、次の１行からは瞬時に実行されました。

ここでびっくりするのは、Scala上でScalaが動いているということ。ちなみに、Javaの上でJavaを走らせることも可能です。

実際、このような方法でスクリプトはアプリケーションに実装されています。GimpやBlenderはPythonを実装していますし、MaxはJava/JavaScript/Pythonを実装しています。

これで自作ソフトでもスクリプトが使えるようになりますね！すばらしすすす。

集合と写像

おはようございます。数式をブログに貼り付けれる「Formula」というをサービスを見つけたので早速サンプル。



綺麗に表示されてますでしょうか？？本当はWikipediaでいうところのTexのタグがほしいところだけど、まぁしょうがないか。

------

昨日Ackeyと一緒に圏論を勉強したら、関数型プログラミングの本質がだいぶわかってきました。

関数型指向では、全ての問題は集合Xから集合Yへの写像fがあるとして、



と表現できることがもっとも"扱いやすく"、美しいとされているみたいです。

その点、命令型指向では、モジュール（手続きをまとめた＝"抽象化した"まとまり）の記述には関数やオブジェクトを使うものの、ミクロな部分は手続きを記述することに終始します。このことが関数型と命令型の大きな違い。

特にその違いが出てくるのが、配列やリストの処理。

関数型言語では、配列やリストを「集合」であると捕え、写像する関数を使って値を処理するという風に処理します。具体的には次のような構文が使われます。

print( Array(1,2,3,4,5).map(_*2) ) // 2,4,6,8,10が表示される

命令型では、その手続きを考えて、一般には次のように処理します。

int[] a = {1,2,3,4,5};

   for(int i=0; i<5; i++){
     print( a[i]*2 );
   }

どちらが直感的かは、見て分かることと思います。

この処理の違いは、"関数が引数としてとれる"からと見ることもできますが、そうではなくて、"計算とは、ある要素からある要素への写像で表すことができる"という見方があり、その結果として関数が引数に渡せるようになっていると考えるのがベストだと感じました。

とりま、百聞は一見に如かず。

次回から、Scalaの能力をフルに生かしたプログラムを作っていこうと思います。

モナドと圏論

おはようございます。昨日はえらく勉強した１日でした。

ちょっと雑多ですが、自分の備忘録としてメモしておきます。厳密な解釈ではありませんのであしからず。

＞発見その１

関数型プログラミングというのは、”プログラムする＝計算する”という行為をきちんと定式化するために、

　ラムダ計算

という演算をベースにして考えられたもので、その「副産物」として、

　関数と数が等価　＝　関数が一等市民である

という便利な性質が生まれた。

これを応用すれば、関数を引数や戻り値として渡すことができるし。構文がすっきりして、独自の制御構造を作ることができる。

＞発見その２

関数プログラミングには難点があって、純粋関数型言語では「遅延評価」をベースとしているがために、「副作用」を持つ処理を苦手としている。これを解決しているのが

　関数型＋命令型

という考え方で、ScalaやRuby、Pythonなどはこの考え方を採用しているけれど、Scalaには”関数リテラル”という関数型プログラミングを強力にバックアップする仕組みが提供されているという点で、関数型言語のHaskellなどに近く、強力な関数型言語かつ命令型のハイブリッド。しかもScalaは、その性質に”完全なオブジェクト指向”ということが強力な機能としてプラスされている。

もうここまでくるとScalaを選ばない理由はないようにさえ思えてくるのは気のせいかな。

＞発見その３

前述の”副作用”の回避のために、モナド(Monad)という概念がある。これはとても単純なもので、モナドとは「コンテナ」であると考えることができる。モナドとよばれるそのコンテナは、次の機能を持つ。

[1] ある要素xを与えられたとき、それをコンテナに入れるための（＝モナドMxに変換する写像としての）関数Unit(x)が準備されている。→ ユニットコンストラクタ

[2] あるモナドMxが与えられたとき、そのモナドに含まれる要素xを取り出して、”関数fと要素yを引数にとり、y = f(x)を適用し、それをコンテナに含めて返す（モナドMyに変換して返す）”という関数を返す関数Bind(Mx)が準備されている。 → バインド

この２つの操作が準備されているコンテナのようなもの（つまり、そういう関数が定義されている集合）のことを、モナドという。これはオブジェクト指向でいうところのクラスとメソッドとして定義されている。

これを使うことによって、例えばリストからの取り出し・収納、リスト全てに対するフィルタの適用（要するにforeach文）、コンテナの結合＝ベルトコンベア式な計算の結合、副作用を排除したI/O操作などができるようになる。

ただし副作用を排除したI/O操作に関しては、Scalaでは命令型の操作が可能なので、どちらを使ってもよい。

＞発見その４

圏論という考え方を使うと、数値や集合、型や関数といった考え方の見通しをすっきりとすることができる。特に、従来の手続きを「写像」に置き換え、配列を「集合」に置き換えて、集合X、Yについて写像 f:X→Y を適用するという考え方は（プログラマとして）画期的。

要するに、

論理の美しさ（論理性、安全性）と、その実用性（柔軟性、簡潔性）を併せ持ったScalaは、すばらしい言語だということがよくわかった。

これは間違いなくNext Javaだろうし、.NET Frameworkでも動くという事実から、C++/Javaに代わる新スタンダード言語になるのは時間の問題だと思う。

あとは、インストールの簡単さと、日本語文献・ユーザ数が一定数を越えさえすれば、きっと多分事実上の最強言語になる。

残っている問題は、

・”暗黙の型変換”(Scala) vs ”動的型付け”(Ruby)
・関数型言語の実行速度 vs 動的型付け言語の実行速度

の対決かな。僕はこの問題に関してもScalaに一票で、特に後者に関してはScalaは命令型とのハイブリッドなのでほとんど問題ないらしい。

けど、あとはプログラマの技量と知識力がついてくるかっていう問題があるし、画期的であってもその良さが知られなかったら、HaskellとかPrologeみたいに普及しないかもしれない。

この辺は中村先生もいつも言ってるように、僕みたいなユーザがきちんとその良さを伝えていかなくちゃ。

…それにしても、Ackeyはホントすばらしすす。圏論を解読してくれてありがとう。

きっとこれからのプログラマは、もっと数学とか物理学みたいな「モデル」を勉強しなきゃいけないのかもなぁ。

ラムダ計算

現在Scalaを勉強中なのですが、関数型言語はラムダ計算というものを基礎に置いていると聞いて調べてみました。

＜参考文献＞
"ラムダ計算 - Wikipedia"、 "ラムダ計算入門"

ラムダ計算というのは、大雑把に言えば、

「数や計算というものを、関数"そのもので"定義してみよう」

という考え方です。

ちょっと変わった考え方なので、理解するまでに苦労しますが、考え方がわかれば関数が数と同等という不思議な世界が生まれます。（だから例えば自然数（0,1,2,3…）とかいうのも”関数そのもの”で定義されているのがすごく不思議！）

個人的にとても驚いたのは、ラムダ計算を使えば if とかも定義でき、trueやfalseなども定義できるし、なによりすごいのは処理構造も定義できるということ。

しかもそれをλと文字、.（ピリオド）、()（括弧）、というたった４種の記号で定義してしまうのが驚きです。関数と数を同等に扱うという計算自体の性質から、数・構造・関数の「同等な扱い」が可能になるので、驚くほど綺麗に処理構造が記述できるのがすごい。

ちょっとここに書ききれるほどの文章量じゃないので、自分の分かる範囲で追々追々書いていきます。

org.freedesktop.Hal.Device.Volume.UnknownFailure

知り合いのパソコンが壊れてしまった＝ブルーバック頻発で起動すらしないので、なんとか復旧しようとKNOPPIX 6のUSB起動を試してみたところ、大成功。

よーし、これでOKだと思って数日かかってKNOPPIXでデータ救出していたところ、ある日急に

　org.freedesktop.Hal.Device.Volume.UnknownFailure

というメッセージとともにWindowsドライブがマウントできなくなり、完全に認識できなくなってしまいました。

もういい加減ドライブが逝ってしまわれたのかと思っていたところ、どうやらそうでは無い様子。次の方法を試したら直ったので、是非データ復旧でお困りの方は参考にしてください。

１）/etc/fstabをテキストエディタで開き、そこに記載されている

/dev/sda1 /media/sda1 …

に類似する行を見て、/dev/〜 → ドライブ名、/media/〜 → それに対応するマウントポイント名の関係を把握します。

２）ターミナル（Terminal）を開き、sudo -sと入力。これでroot権限でUNIXにアクセスできるようになります。

３）cd /media と入力し、フォルダ/mediaへと移動。

４）mkdir 〜でフォルダを作ります。（〜には１で確認したマウントポイント名を入力し、もしドライブが複数ある場合は適当or全種類フォルダを作る。）

（メモ）(5)が上手くいかない場合はここでKNOPPIXを再起動。

５）mount /dev/〜 /media/〜でディスクをマウント。/dev/〜以下は、１で確認した(ディスク名)＋半角スペース＋(マウントポイント名)を入力します。

６）これで上手くいけばWindowsドライブがマウントされます。ふぅ。

Scala-processing IDE

Scala-processingの開発キットには、SPDEというものがありますが、推測変換などの支援やヘルプが使えないので、僕としてはNetBeansでの開発するのが楽チンです。

＜Scala-processingをNetBenasにセットアップする方法＞

■１：ScalaをNetBeans 6.8で使うを参照して、Scalaプラグインをインストール。

■２：以下のフォルダを適当なところにコピーする。

・Windows → (Processing本体のフォルダ)¥java¥lib
・Mac → Processing => パッケージの内容を表示 => Contents/Resources/Java

■３：NetBeansで、ファイル → 新規プロジェクト → Scala Applicationを作成

■４：ファイル → プロジェクトプロパティをクリック、Librariesを選び、[Add JAR/Folder]でさっきコピーしたフォルダ内のJARファイル（例えばcore.jar、必要に応じて他のJAR）を追加する。

（メモ）NetBeans6.8の段階では、上手く読み込まれないので、追加したら一度NetBeansを再起動する。

■５：次のコードが動けば完成！！クラス名やパッケージ名は、開発環境によって変えてくださいね。

package scalaprocessing1

import processing.core._

object Main extends PApplet {

   override def setup(){
     size(400, 300, PConstants.P3D)
   }

   override def draw(){
    background(20)

     var i=0
     while(i < 100) {
          pushMatrix
          fill(random(255))
          translate(mouseX, mouseY, random(-30, 30))
          box(random(10, 70));
          popMatrix
          i += 1
     }
   }

     def main(args: Array[String]){
          var frame = new javax.swing.JFrame("Test")
          var applet = Main
          frame.getContentPane().add(applet)
          applet.init
          frame.pack
          frame.setVisible(true)
     }
}

ScalaをNetBeans 6.8で使う

ScalaプラグインをNetBeansにインストールすると、コードの色分けや推測変換が使えてとっても便利になります！

でも、日本語文献が少なかったので、備忘録として書いておきます。（インストール方法の出典は以下ですが、ちょっと分かりにくい部分を補って意訳しています。。）

・"Scala Plugins for NetBeans 6.8 v1.x (RC1) - Install with NetBeans 6.8"
　http://wiki.netbeans.org/Scala68v1

＜ NetBeans 6.8にScalaプラグインをインストールする方法＞

■１：まず最新のScala-2.8.0ランタイムを以下よりダウンロードし、適当な場所に保存する。
http://www.scala-lang.org/archives/downloads/distrib/files/nightly/distributions/scala-2.8.0.latest.zip

　（メモ）Windowsでは、パスにスペースの含まれない場所へ保存すること。

■２：ダウンロードしたランタイムのあるフォルダを、$SCALA_HOMEとして環境定数に設定。(※1,2)

　（メモ）Macユーザの場合、(ホームディレクトリ)/.MacOSX/environment.plistをテキストエディタなどで作り、http://wiki.netbeans.org/MacOSXEnvForAppのソースコードを記載（full/path/of/your/scala/homeはランタイムのあるフォルダへのフルパス）。(※1,2)

■３：NetBean 6.8をhttp://netbeans.org/downloads/index.htmlからダウンロードしてインストール。

　（メモ）NetBean 6.8 Betaでは上手くインストールできません！それ以下のバージョンをお持ちの場合はインストールし直すことをおすすめします。

■４：Scalaプラグインを、https://sourceforge.net/projects/erlybird/files/nb-scala/6.8v1.1.0rc1/からダウンロードして、適当な場所に解凍。

■５：NetBeansを起動し、[ツール] → [プラグイン] をクリック。[ダウンロード済み]タブを開いて、[プラグインの追加...]をクリックして、４で解凍したフォルダにあるJARを全て選択。

■６：インストールしてNetBeansを再起動する。完了！

--- ※1 この作業が上手く行かない場合、（NetBeansインストールフォルダ）¥etc¥netbeans.conf （Macでは/Applications/NetBeans.app → パッケージの内容を表示 → /Contents/Resources/NetBenas/etc/netbeans.conf）をテキストエディタで開き、netbeans_default_options = " ... " の ... の中に、

　-J-Dscala.home=(ランタイムへのフルパス)

を追加すると上手くいきます。

--- ※2 なお、パスの通し方については以下を参照してください。

・Windows → http://pocketstudio.jp/win/xp/path.html
・Mac → http://homepage.mac.com/akihide/iblog/C1557102128/E1968370044/index.html

Scala-processing

最近更新が滞ってましたが、ぼちぼち再開します。

今日は、最近ホットなScalaとProcessingを使った、

　"Scala-processing"

という新しい文化と、その周辺について。

写真はProcessingのライブラリをScalaで(NetBeans上で)動かしたところです。ちゃんと動いてますし、構文は純粋なProcessingとほぼ変わりません。

つまり、ProcessingにScalaの強力な機能が追加できちゃってます。

Scalaについていろいろ研究してて、気付いた重大な発見が２つあります。

　(1) Javaの「上位互換」であること
　(2) JavaVM上で動く言語は「他にもある」こと

これは、実はとても驚くべきことで、例えば(2)に該当するのは、

　Scala、Jython、JRuby、Groovy

などいろいろあって、これらはすべて(1)をある程度満たすので、お互いの言語で書いたJavaのクラスファイルを「相互に読み取ること」ができます！

ということは、それぞれの言語を生かして、しかも自由にプログラミングができる環境が整いつつあるということです。

しかもScalaはちょっとの修正で.NET Framework上でも動くし、JRubyで書いたものも同じように、Ruby on Railsとかの強力なWebアプリケーションに早変わりする。この移植性は驚異的です。

で、それを生かしてProcessingが持つ最大の利点であって難点である、

　「Java言語に依存していること」

を払拭して、そのままScalaに移植してみたわけです。これができると、例えば次のような利点が出てきます。

　・Processingが、完全オブジェクト指向言語として使える。
　・Processingに、演算子のオーバーロード、制御構造の追加が可能。
　・Processingが、関数型言語に早変わり。

同じように、Ruby-processing、Groovy-processing、Jython-processingなーんていうのも可能です。すばらしすすすす。

うーん、なんだかワクワクしてきた。もっといろいろ遊んでみます。