プログラミング言語 Scala

The Scala Programming Language
ttp://www.scala-lang.org/

チュートリアル日本語訳
ttp://homepage.mac.com/takashi_miyamoto/scala/ScalaTutorial.pdf
どう書く？org Scala
ttp://ja.doukaku.org/lang/scala/

不感症になったのか、こーいうのみてもなんも感じなくなってしまった

日本語の入門書がでたら買う。

Java のライブラリがそのまま使えるってのは
ライブラリ実装の手間を省けるいいやり方だな。

Javaのgenericsはそのまま使えないと聞いた気が

>>5
http://www.scala-lang.org/downloads/changes.html
Version 2.7.0-final (released on 06-Mar-2008)
# [changed] - Generic Java types are now supported by default (was -Ygenerics).
# [changed] - Target jvm-1.5 is now the default.

>>5-6
試してみた

$ scala -version
Scala code runner version 2.7.0-final -- (c) 2002-2008 LAMP/EPFL

$ cat generics.scala
import java.util._
var list = new ArrayList[String]
list add "one"
list add "two"
list add "three"
println( list size )
println( list )

$ scala generics.scala
3
[one, two, three]

チュートリアル日本語訳
ttp://homepage.mac.com/takashi_miyamoto/scala/ScalaTutorial.pdf

↑を読んでたんだけど「ケースクラス」っていうのがよくわかんなかった。
多態性みたいなのが簡単に記述できますよってことなのかな
よくわかんないまま読み進めてたらいきなり微分の話が出てきて頭が爆発した。

>>8
MLとかHaskellにあるやつで、
要は強力なcase文、なはず

でもcase文だから下手に使うと拡張性を失うわけだよね

ものすごい説明でびっくりした。「MLとかHaskellにあるやつで」までしかあってないよ！

>>10
む、そんなに間違ってる?

拡張性と言ったのは、既存のコードを修正せずに型を追加できるかという話で、
型の定義の追加に関してはたいていの関数型言語では構文上無理な気がするが、
Scalaはcase classを別の場所であとから追加すれば可能な気がする。

一方、パターンマッチのコードは一カ所にまとめないといけないから、
拡張しようとしたら修正が必要では?

んー、言いたいポイントがよく理解できないんだけど、
まずmatch構文の中で特殊に使える「クラス定義」であって、case「文」じゃないでしょっていうのと、
MLやHaskellを引き合いに出して1行で説明しようとするなら「元々は代数データ型を模すためのもの」とでもいうのが適切では？と思った。

拡張性云々はOCamlのポリモーフィックヴァリアントと比較すると面白いかもしれないけど、
8に対するレスとしては飛びすぎではないかな。

>>12
>>8が多態性と書いていたので拡張性に関する話をふってみた。
代数データ型をといわれてもピンとこないんだが...
MLやHaskellを引き合いに出さない方がよかったか。

まだよくわかってないけど
「関数型言語ではよくあること」ってことね
JVMで動く言語って聞いたのでJavaの知識が役に立つかと思って触れてみたのだけど
Javaしか知らない俺には難しい

よく考えてみたら多態性は継承で実現できるのだから
ケースクラスってのは、多態性とは違う何か得体のしれない概念なのだろうなあ
pdfをもうちょっとよく読んでみるよ

ちょっとメモ
ttp://www.ibm.com/developerworks/jp/java/library/j-scala01228.html

>>14
case classもクラスの一種なので多態性を実現するのにも使える
ただ、case classで定義したクラスは
・クラス名(引数列)でインスタンスを生成できる
・パターンマッチングに使える
という特徴がある。具体例を示した方が早いと思うので示すと

abstract class Exp
case class Add(lhs :Exp, rhs :Exp) extends Exp
case class Sub(lhs :Exp, rhs :Exp) extends Exp
case class Num(value :Int) extends Exp

という定義があったとして、(5 - 3) + 1という式の構文木は次の
ように表記できる。

val exp :Exp = Add(Sub(Num(5), Num(3)), Num(1))

この式を計算する評価器はパターンマッチングを使って
次のように書くことができる(MLとかHaskell知っている人には
お馴染みだけど)。

def eval(exp :Exp) :Int = exp match {
case Add(l, r) => eval(l) + eval(r)
case Sub(l, r) => eval(l) + eval(r)
case Num(n) => n
}

ここでポイントは、インスタンスのクラスによる分岐と、インスタンスから
フィールドを取り出す操作が同時に行えていること。

>>16
なんとなく分かってきた
昔聞いたことのあるインタープリターパターンに似てる

メンバ変数を定義して、コンストラクタで代入っていうのを書かなくても
クラス名（引数列）　って書いたら引数列の部分がが勝手にメンバ変数になってくれるのか

Javaで構文木みたいなの作ろうとしたら
http://anond.hatelabo.jp/20080314064942
↑こんな感じになったよ （長い！）

eval()を外に出すと

public int eval(Exp exp){
　if(exp instanceof Add){
　　return exp.getHidari() + exp.getMigi();
　}else if(exp instanceof Sub){
　　return exp.getHidari() + exp.getMigi();
　}else if(exp instanceof Num){
　　return exp.getSelf();
　}
}

こんな感じにしないといけなくて
こんなif文をズラズラと書くよりだったら
それぞれのクラスの中でeval()するべきだろうって思っちゃうので
理解するのが難しかったんだ

あ、間違えた

　public int eval(Exp exp){
　　if(exp instanceof Add){
　　　return eval(exp.getHidari()) + eval(exp.getMigi());
　　}else if(exp instanceof Sub){
　　　return eval(exp.getHidari()) + eval(exp.getMigi());
　　}else if(exp instanceof Num){
　　　return exp.getSelf();
　　}
　}

こうか

>>18
>>19
ごめん。Subを計算するときにも足しちゃってた。
正しいのはこう。
def eval(exp :Exp) :Int = exp match {
case Add(l, r) => eval(l) + eval(r)
case Sub(l, r) => eval(l) - eval(r) // Subなのにミスって足してた
case Num(n) => n
}
あと、パターンマッチングは本質的にはif(a instanceof A) ... else if(a instanceof B) ...を
簡潔に書くための仕掛けでしかないけど
・フィールドからの値の取り出しを同時に行える
・パターンをネストできる(後述)
・パターンが網羅されているかを静的にチェック可能(後述)
のがポイント。パターンがネストできるというのは、例えば
exp match {
case Sub(Add(e1, e2), Add(e3, e4)) => println("(e1 + e2) - (e3 + e4)")
case _ => println("failure")
}
のようにすることで、複雑な構造に対してマッチングを行うことができること
を示している

続き。
パターンが網羅されているかを静的にチェック可能というのは、
例えば次のようなコードを書いたときに(Numのパターンの書き忘れ)、コンパイラが
warningを出してくれることを指している。
def eval(exp :Exp) :Int = exp match {
case Add(l, r) => eval(l) + eval(r)
case Sub(l, r) => eval(l) + eval(r)
}
ただし、Scalaでこの場合にwarningを出すためには、宣言を
abstract sealed class Exp
case class Add(lhs :Exp, rhs :Exp) extends Exp
case class Sub(lhs :Exp, rhs :Exp) extends Exp
case class Num(value :Int) extends Exp
のように、抽象クラスであるExpをsealedとして宣言しておく必要がある。

とりあえず A Scala Tutorial for Java programers を読んだのですが
次は何を読めばいいですか？
どうもプログラミング言語の学習の仕方がいまだによくわからなくて困ってます。

>>22
とりあえず、何かネタを決めて適当なプログラムを書いてみるのが
良いと思う。Scalaやってるってことは他の言語は既に知ってるってこと
だろうから、とにかく書いて慣れるのが一番。あと、ScalaReference.pdfは
読むのにやや知識が必要だけど、Scalaにどんな機能があるのかを知るのに
有用だから、暇なときに眺めてみるのも良いかも

日本語の入門書がまだないのはしょうがないとして。。。
洋書だったらなんかある？

>>20-21
丁寧にありがとう！

sealed（シールド） class なんてのがあるんだ
また守備力があがってしまうな

Java 系だから final でいいと思うのに
C# 風の名前付けしてるんだな。

>>26
いや、実はfinal classもあるんだけど、sealedとは意味が違うという罠
final classはJavaのそれと同じで、そのクラスから継承することができない
という意味。sealed classは同じコンパイル単位でならそのクラスから継承する
ことができる

>>24
洋書では、Programming in Scalaという本が(今年中？)出る予定。
現在は、PrePrint版を購入することができる。
http://www.artima.com/shop/forsale

>>27
なるほど。

>>27
なるほど

ttp://www.scala-lang.org/docu/files/ScalaReference.pdf
を読んでたんだけど（読めないけど）
予約語の一覧に「public」が見当たらない

しかも
AccessModifier ::= (‘private’ | ‘protected’) [AccessQualifier]
って書いてある。

もしかしてScalaには「public」修飾子がない？
クラスもメンバもみんなデフォルトでpublic？

>>28
サンクス
今年中か。。
英語の勉強でもしとくか・・・

試してみればよいのか


scala> var public = 1
public: Int = 1

scala> System.out.println( public )
1


あぁ…　無いんだ

>>31
うん。Scalaではアクセス修飾子はデフォルトでpublicなので
用意されてない。

>>27
jarのマニフェストに書くSealedと同じようなものか。

>>8
case classは、
pattern matchのある
C言語でいうところのunionです。

一つの型にマージしたいところに使います。
例えばポインタがどのケースも指す可能性がある場合。

Rubyとどっちが強いの？

Scalaです。普及度以外は。

Rails相当のものはありますか？

Javaの標準ライブラリなら何でも使えるの？

traitとabstract classの違いって何ですか？
なんか、同じのような……。

>>40
多分そうです。

>>41
abstract class は抽象クラスで trailtはmixin
継承元としての抽象クラスはひとつしか指定できないけど、mixinはなんぼでも指定できる。

abstract class 通信機
trait テレビ
trait おサイフ
class 携帯電話 extends 通信機 with テレビ with おサイフ {
　…
}

class A extends B とした場合、
継承だと B に A の実装を追加したものが A になるし、
mixin だと A に B の実装を追加したものが A になる。
継承と mixin の大きな違いはここにある。

>>1 のチュートリアルにある例で言えば、
Ord の実装の中に

　def <=(that: Any): boolean =
　　(this < that) || (this == that)

ってのがあるけど、Ord の中には == の実装どころか宣言すらない。
mixin 先に == があれば使えるし、無ければ使えない。
== が既にあるクラスに mixin されることを前提に作られている。

つまり、mixin の場合は A にある実装を B で使うことができる。
継承では派生クラスの情報を基底クラスで使うことになるから、
こういうことは基本的にはできない（CRPT は例外だが）。

CRPTって何?

http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern

要するに親クラスが派生クラスの実装に依存できる。
boostのiterater_facadeで非常にうまく使われてる。

mixinがあれば継承はなくてもいいのかな
overrideができないのかも知れないが

Scala的に望ましい言語仕様と、JVMのセマンティクスとの軋轢ってないの?

YASVﾏﾀﾞｰﾁﾝﾁﾝ。

>>22
次に読むべきはたぶん、このへん。
http://www.pana-wave.com/news_lr.html

「スカラー値」とかの普通名詞じゃなくてなんかの固有名詞で
響きが脳みそのどっかにひっかかってたんだけど

これだったか・・・

The Scala Language Specificationとかにさっと手が伸びるような人は
画面で読んでるのでしょうか?
印刷して読んでるのでしょうか?

印刷一読、画面参照

初ほしゅ・・・って、まだ不要なのか？

なぜ素直にJRubyをつかわないのか

JRubyってアプレット作れるの？

作れるけどなに？

Rubyは危険な宗教だから近づきたくない

モルモン教か

>>54
やっぱスピードじゃない？

>>54
型チェックに魅力を感じるからじゃない

代入式がUnitを返すのですが、こういう仕様なのですか？

うん

Scalaは面白いしそこそこ使えそうではあるんだけど
構文を導入せずに見た目の帳尻だけ合わせてる部分が
長い目でみればマイナスに表れるという感がぬぐえない。
丁度C++のような立ち位置だと思うこともあって、将来的な筋の悪さを感じる。
(C/オブジェクト指向/C++ と Java/関数型/Scala という対比。)

>>63
C++のような立ち位置といのは言い得て妙だな

途中で送信してしまった。
ただ、構文を導入せずに見た目の帳尻だけ合わせてるってのは
どの辺だろう？case class/pattern matchingの辺り？

>>63
おいおい、Scalaは設計センスはすごくいいぞ。
ありとあらゆる言語をよく研究した結果作られた言語。
問題は流行るかどうか。

うまく作りすぎてるんで、
perl/python/rubyなんかのなんちゃって言語よりは、
最初のハードルが高いし。

ScalaってHaskellかOCaml
強いて言えばどっちに近いですか？

OCamlじゃないかな。評価戦略とオブジェクト指向。

>>66
> ありとあらゆる言語をよく研究した結果作られた言語。

は

> おいおい、Scalaは設計センスはすごくいいぞ。

の根拠にはならんだろう。

>>67
強いて言えばOCamlだけど
OCamlは関数型言語にOOするための機能を入れた言語
ScalaはOO言語に関数型プログラミングをするための機能を入れた言語
って感じでScalaの方がよりOOよりな感じはするね

型システムは、メジャーな言語ではC++0xが一番近いよ。
後はHaskellとかGとか。

JavaとかノーマルなOCamlはクラス指向が非常に強いから似てない。

C++0xってメジャーな言語なのか？

おお、Scalaのスレができてる
Scala自体はいい言語だけど、Javaのライブラリがうんこだよな

ライブラリのどの変がダメ？

Scalaのライブラリはどうですか？

>>74
粒度が細かすぎて使いづらいというのはよく言われていることだけど、
それをScalaから使うというのがまたしんどい
結局Java使ってるのと大差ない気がしてくる

>>76
Scalaから使うときは簡単なラッパーをかましてやるのが良い使い方だと思う
本当のところ、早いところScala独自のライブラリが充実して欲しいんだけど
簡単なラッパー作るくらい大した手間じゃないし自作するのが手っ取り早い
たとえば、IOならこんな感じ

// 定義
def withReader[T](File path)(proc :BufferedReader => T) :T = {
val reader = new BufferedReader(new FileReader(path))
try {
proc(reader)
} finally {
reader.close
}
}

// 使用
withReader(new File("hoge.txt")){reader =>
//readerを使ったコード
}

ちなみにscala.io.Sourceは色々と微妙で、使いづらい

それだと使う側のセンスが問われそうだな
俺だと劣化Rubyライブラリになってしまいそうだ
標準ライブラリで言語のポテンシャルを示してほしいところなのだが
つーかこんなラッパーが全世界で何百と作られてんだろうなあ

というかラッパーが物凄く簡単に書けて、
再利用性も高いのが言語の売りの一つなので。

Lisp方言並に溢れかえるラッパーにｗｋｔｋ

>>48に誰も反応してくれなくて寂しい俺が来ましたよ
# あれは正確には、「JVM命令セット群のセマンティクス」と書くべきだった

ライブラリの話も出てるし、言語として完成度上げるには、やっぱそろそろJava依存抜けようか。
って無理か。

どうしても隠せないのは実装に近いところ。
例えばboxing/unboxing関係のAnyVal/AnyRef。

ScalaOverview.pdfの
def + (x: Nat): Nat =
if (x.isZero) this else succ + x.pred
って、
def + (x: Nat): Nat =
if (x.isZero) this else this.succ + x.pred
のことなんだな。ちょっと混乱したので書いとく。

>>81
配列周りはScalaの処理系が凄いがんばって他のgenericなクラスと同じように
見せようとしてるなあと思った。JVMでは配列が特別扱いされてるから、
genericなクラスのように見せかけるのはなかなか大変



>>83
暗黙のthisはJavaでもほぼ同じだから、そんなに混乱しないと思ったけど、どうなんだろう。
Java以外の言語からScala入った人？

operation invocationに()がないから混乱した。
Java以外にも関数型言語も分かるので、
curry化されてるのかな？と思ってしまった。

>>82
> boxing/unboxing関係のAnyVal/AnyRef。
なんとなく想像は付くんだが、具体的にはどんな例がある？

>>85
ああ、なるほど。invocationの()省略できる辺りは、なんか
構文的にRubyっぽい感じがするね。Scalaは細かいところで、
色々syntax sugarが多いから、慣れない内は混乱の元にも
なるなと思った

あ、省略できるってのはちょっと不正確だったのでちょっと補足。
Scalaで0引数のメソッドを定義する方法は二つあって、
一つは

class HelloWorld {
def print :Unit = { println("Hello, World!") }
}

という形。この形の場合、
val hello = new Hello
hello.print
という形でのみ呼び出すことができ、hello.print()という呼び出し形式は
コンパイルエラーになる。もう一つは、

class HelloWorld {
def print() :Unit = { println("Hello, World!") }
}

という形。この形の場合、hello.print()と書いてもhello.printと書いても
OK。

>>86
BoxedArrayはあれば便利だけど、なくても何とかなる。
どうしてもArrayの要素をポインタ共有したい時は、
セルクラスに入れてからArrray[セル]にすればいいから。
けどJavaではBoxedArrayがあるから、作っとかないと困る。

>>84のいうようにうまく処理されているとは思う。
Nothingがあるからprimitive = null;問題も起きないし。

あんま愚痴っててもしょうがないので、
ありがちなところで、Ruby風文字列、正規表現ラッパーを作ってみた
と言っても、まだ半分も実装できてないけど

http://hexx.sakura.ne.jp/scala/RubyString.scala

使い方は、こんな感じ

import ruby._
import ruby.RubyString._

println("hoge %d %s" % (1, "fuga"))
// → hoge 1 fuga
// Rubyでは
// "hoge %d %s" % [1, "fuga"]

"a\nbbb\nccccc\n".each(l => print(l.length))
// → 246
// Rubyでは
// "a\nbbb\nccccc\n".each {|l| print(l.length)}

println("abcde".sub("(a)b(c)d(e)") { m =>
val lm = RubyRegexp.lastMatch
lm(1).upcase + lm(2).upcase + lm(3).upcase
})
// → ACE
// Rubyでは
// "abcde".sub(/(a)b(c)d(e)/) { $1.upcase + $2.upcase + $3.upcase }

今のところ、Rubyに比べて嬉しいのは、EmacsのFlymakeがよく効くところだな
悪いところは、スクリプトで使うと、やっぱり起動が遅い

>>90
遅いよねぇ。

開発をスクリプトでやってデプロイはコンパイルしてって感じになるのかな。
でもあの起動の遅さはリズムが崩れる。

NetBeansでScalaが書けるって聞いたんだけど
試してみた人いる？

>>90じゃあ開発者の楽しさとしてはやっぱりRubyのほうがいいんだね。実行するたびにモタつくなんてなぁ。

>>93
> 開発者の楽しさ

俺はコンパイラに指摘される型エラーをつぶしていくのが楽しい
だからMLも好き

同じJVMをつかっているのに、なぜJRubyよりも性能がいいのですか？
Rubyをなんちゃって言語というほど高尚なのですか？Rubyより悪い点はどこですか？

>>95
性能がいいのは主に

・静的型付けであり、かつ比較的Javaに型システムが近いこと
(メソッド呼び出し時にinvokevirtualなどVMのメソッド呼び出し命令をそのまま
利用できるし、数値演算もVMの命令を利用できる)

が理由だろうな。他の理由もあるだろうけど、たぶんこれが一番大きい。

楽しさって言われてもなあ、スクリプトの起動がそれほど気になるならそうかもしれないけど
対話環境で開発することも多いだろうし、Scalaはスクリプトの方がメインではないだろうし

Rubyとの違いは、やっぱり型が静的か、動的かにつきるんじゃないの？
静的な型でもここまでできると思うか、
やっぱり面倒臭いから静的な型なんていらないと思うか

あとは関数型から引き継いだパターンマッチ、ケースクラスとか
ErlangからパクったActorがどれくらい役に立つか

JRubyより性能いいの?
JRubyってJavaのバイトコードをターゲットにしたコンパイラなの?
独自バイトコードインタープリタなら遅くて当たり前だけど…

>>97
あと、mixin-compositionがあるのが重要。

ああ、そういえばScalaは後からmixinを足せるんだったな
確かに使い方によっては強力な感じはする

ぶっちゃけmixinはあんまり要らんなーと個人的には思う
caseクラスとかマッチングあたりはうれしいけど
Actorはまだ触ってないのでなんとも

>>92
6.1betaに開発版プラグインの所を参照させて出来たよ。

actorやmixinはプログラミングモデルだから、
慣れてない人は有り難みは分からない。
使って慣れるのみ。

>>101
mixinはライブラリ書くとき嬉しいよ
例えば、コレクションぽく見せかけたいものに対して、scala.Iterable[T]をmix-inして、
elements :Iterator[T]だけを実装すれば、Iterable[T]にある便利な高階関数やらを
全部使えるとか。たとえば、Reader系のクラスをサブクラス化してIterable[String]
を実装するなどが考えられる。

>>98
昔のJRubyは普通のインタプリタだったはず。その頃は凄く遅かった
最近のJRubyは内部でJVMのバイトコードにコンパイルして実行するようになった
ので速くなった。でも、Scalaには性能で遠くおよばない(言語の特性上仕方無い
けど)

開発効率ではJRubyに遠く及ばない（言語の仕様上しかたないけど）

どうせJRubyもScalaも使ったことないくせに

JRubyは使ってるよ。Scalaはこれから試すよ。
仕様が汚ないけど、型があるからRubyより性能は良いってことだろ。

マジレスだったのかよ！
で、Scalaの仕様のどの辺が気に食わないのよ
開発効率が遠く及ばないというほどの何かがあるの？

rubyの話いらね

>>104
多重継承の代用？
多重継承ではなくmix-inが欲しくなる場面の例はありませんか？

基本的にmixinは多重継承の代用でしょ
mixinそのものの有用性については
Rubyが先駆者だからRubyの事例を調べた方がいいと思うよ
(またRubyの話になっちゃったけど…)

機能的にはリッチ版だよ。
name conflictやmutliple pathを解決するための機構をプログラマに対して与える。

どれもがコンクリートクラスになりがちなクラス指向のプログラミングモデルから、
機能mixinを集めてくっつけて実用クラスを構成する〜モデルになる、というかする。

name conflictやmutliple pathはmixする時に解決できるから、
このクラスとあのクラスはうまく多重継承/結合出来ないというケースがぐんと減る。

代用とかじゃなくて、機能が増えたのがmixin。
元祖はLisp Machine LispのFlovors。
基本フレーバーを調合して、香水を作るって考え。
コンポーネント志向が強い。

もちろんmixinなくても同じことはできるよ。
アセンブラあればなんでもできるという意味では。

え、ちょっとよくわからない
どの辺が多重継承よりリッチなの？

つ 版

版？

機能は多いだけじゃだめだとおもう。わかりやすくないと。
Rubyはその辺のバランス感覚に優れているからね。

Ruby信者もバランス感覚を覚えて欲しい

だからもっと具体的な話しろよ
Scalaの仕様のどこがいいとか悪いとか、mixinの話も>>111に答えてやれよ

と嗾けるだけでもなんだから
俺がScalaで良いと思ったのはカリー化と無名関数だな
Rubyのブロックはへんてこ構文だったけど、Scalaはすっきりしてると思う

部分適用はあるが、カリー化なんてあったっけ?

カリー化はFunction.curriedでできるが、
ここで俺が言いたいのはカリー化された関数を直接書けるということだな
言葉足らずですまんが

これか

def add(a: Int)(b: Int)(c: Int) = a + b + c

add(1)(2)(3) // 6

>>119
それならお前が答えればいいのに

>>122
うん、それ
Rubyではわざわざブロック構文を導入しているが
Scalaではそれと無名関数を組み合わせて、
同じようなことがすっきりとできるじゃん
というだけの話なんだけど

>>123
いや、俺はmixinは制限付き多重継承だと思ってるから
だから>>113が答えてやれよと
まあ多重継承の定義の問題なんだろうな

> 俺はmixinは制限付き多重継承だと思ってるから

kwsk

mixin 多重継承でググれば、mixinは多重継承の一種だという説明が多い
Rubyのまつもとさんによれば、mixinは多重継承のサブセットらしい
俺もそう思っていたというだけの話
Scalaのmixinに何か特別な機能があるかどうかは知らない

>>126
基本的にそういう認識(mixinは多重継承のサブセット)でいいと思う
Scalaのmixinに何か特別な機能があるかと言えば、たぶん無い
俺がScalaで好きなのは、ExtractorとViews、implicit parameterだな
これらの機能がある言語は、今まで見たことがなかったので新鮮だった

開発効率の話について言えばScalaがRubyに遠くおよばないなんて
ことは無いと思う。静的言語ゆえの制約(evalできないとか)はもちろんあるけど、
そもそもそういうのを濫用したプログラミングはそうそうする必要は無いし
for-comprehensionやextractorなどRubyに無い便利な機能もあるし

Scalaのmixinは多重継承にならないよう配慮してるね。
別クラスから継承して作ったtraitはmixinできないとか。

>>128正論だとはおもうが、そゆ発言はRuby厨を刺激するのでは

簡潔にかける!=わかりやすい、というのを体現した言語だなあ。
確かに個々の機能は優れていると思うが、表現の幅がひろすぎて自分とスタイルの違う書き方がほんと馴染まない。
Rubyのほうがコードの一貫性という意味では良いのかもしれないね。

文法的にはRubyにforとパターンマッチが入った程度だろうに
ほんとにScala使ったことあるのかよ

>>131
Rubyと違って仕様が一貫してそうですが

>>132
＞文法的にはRubyにforとパターンマッチが入った程度だろうに
あなたもちゃんと使ったことがあるのか疑問があるんだが
どうせ、ちょっとTutorial見ただけで、決め付けただけなんじゃないの？

特にScalaの型システム(implicit conversion, higher-kind generics, path-dependent typeなど)
調べてみれば、とてもRubyにforとパターンマッチが入った程度なんて言えない
もちろん、それらがどれくらい使い勝手に影響があるか、という評価は必要だが

>>134
ちゃんと使ったことあるというのがどのレベルかはわからないがプログラムはある程度書いたよ
他にRubyよりわかりにくくなるほど簡潔にかけるところあるか？
型絡みは簡潔にはなるという方向じゃないでしょ

>>135
だからViewsやジェネリクスでRubyより簡潔にはならないでしょ
>>131は簡潔に書けすぎたり、表現の幅が広すぎてRubyより一貫性がないって言ってんだから
そういうレベルの話だよ

つーか、なんで俺が文句言われるのがわからん

相変わらずRuby厨が無駄に湧くスレだなぁ

阿呆は放置推奨

逆にRubyやったことがある人に向いてる言語と思うんだけどなあ。

Rubyと比較しただけでRuby厨呼ばわりはひどいですね。
Rubyから来た私とJavaからの移行組の同僚のコードがスタイルバラバラになったんで感想を延べただけなんですが。

同僚って、もう仕事でしかも共同開発って使ってるの？すごい

Scalaで仕事？

>>140
コーディングスタイルについては、Rubyだってかなり幅が広くて、
書く人によって全然違うコードになったりすると思うんだが、違う？
というか、○○言語だったらコーディングスタイルを均質化できるというのが
そもそも幻想な気がする

馬鹿だから厨と言われてるんであって、Rubyはむしろ被害者。

>>139
Rubyなんて触ったことすらない

>>143
そのとおり。というか>>131は、
Rubyでしか一貫性のあるコードが書けない（書く気がない）という気がする

確かにrubyに似ているんだけど、{}スタイルのブロックは俺には必要だなと再認識した。
haskellでみた変態的コーディング表記も緩和されてわかりやすいスタイルになっている。
一部なんとなく気にくわない所もあるけど仕様上しかたないことなのかな?(arrow回り)
それと変数名が先にくるのは後で何かよいことあるの?
あとdefineじゃなくてdefならさー、objectじゃなくてobjくらいにしてくれたほうがいいなぁ。

と、c++もjavaもrubyもhaskellもMLもlispも全然できないvb6厨の俺が見た目だけで評価。

>>147
型宣言が後置で良いことがあるかと言えば、まあ好みの問題なんで
なんとも。ただ、一般論として型宣言が後置の方がパーザ書きやすくなるという
話はある。

なんか、配列やマップ（ハッシュ）の参照も()なのが紛らわしい・・・
なんで同じにしたんだろ。

リテラルじゃなくてapplyで実装されてるからな
Rubyみたいに大クラス主義ならリテラルと相性が良いと思うが
Scalaの場合、Javaのものと合わせて大量にコレクションクラスがあるから、
リテラルの恩恵があまりないという判断なんだろうな

ツアーを読み始めてからjavaのよく分からない
機能(アノテーションとかジェネリック?)とかを調べ始めているうちに
まったく放置していたC#って言語が出てきて、これにも結構近いなぁ。
c# extends c++ interface 関数型言語,vm
に対して、
scala extends ruby,java,変態的言語

C++0xもおもしろそうだがまだvb6の総合的な簡潔さにはかなわない気がする。

>>149
genericsのために、既に[]は使っちゃってるからぶつかる
っていうのが主な理由じゃないかと

ところで、()使うのがそんなに紛らわしいかな？別に区別が付かない場面なんて
そうそう無いと思うんだが。あと、実用上のご利益として、関数引数を
要求してるとこに、配列やらMapをそのまま突っ込める、というのがある
val f : String => Int = Map("A" -> 1, "B" -> 2, "B" -> 3)
なんてのがＯＫなわけだ

これって知らなかったが、PartialFunctionを先祖で継承しているからなのか？
関数を継承してるコレクションって珍しいな

>>154
YES。
確かに、単に関数っぽい、じゃなくて、実際に関数として扱うことができるコレクションという
設計はあまり見かけない気がするね

>>149
Fortranと一緒だと思えばいい

〜.run()とか〜.invoke()じゃなくて〜()って出来る

こういうのが浸透してきたから、
コレクションの要素取得にも一般化したんでしょ。

他に、関数と配列で同じ表記使う言語あったかなと思ったら、
BASICもそうだったなｗ

なんか、型推論があれば、
動的型付けなんかいらないみたいな事が書いてあったけど、
本当にそうなの？

>>159
動的型付けや型推論の定義によるけど
動的型と言っても結局実行時には何の型であるかを決めて変換しないと実行できないので
それをコンパイル時にやってるのが型推論ということだとすれば
実行時まで型がわからない状況以外は全部型推論で片付くことになる
ただ実行時まで型がわからない状況ってevalくらいしか思いつかないのだが・・・

動的型付けだと、状況によって型が違う関数とかが発生するでしょ。
例えば Lisp 系なんて、何でも入るリストがデータ構造の基本なんで、多くの関数の型は引数とかに依存する。
型を決めて変換するってよりは、型に応じて分岐処理したりするような世界だから、推論は難しいと思うけど。

型に応じて分岐処理ってポリモーフィズム？

>>161
何でも入るっていっても、本当に実際に何でもつっこむような使い方って
Lisp系でもそんなにしない気がするんだが、どうだろう。Lispのエキスパートじゃないので
自信があるわけじゃないけど。で、もしこれが真ならvariant(VBのじゃなくて、MLとかの
やつね。Scalaで言うとcase class)があれば大体事足りるのではないかと

>>159
「型推論」じゃなくて「強い型付け」の間違いですか?

Scala at Waves (SaW):
　問題をガリガリ破壊していくフレームワークのような何か。白装束を着ないと自分も破壊される。

なんでgenericsに<>使わないの? Foo<Bar<Bazz>> ←ここの問題とかだったりしたら orz

{ブレース}使って見た目の「普通感」があるのはJavaneseに取ってもいいことだと思うんだけど、
それをメリットとして軽く触れられた後で<>が[]です、[]が()です、型は後置です、って言われても
やっぱり見慣れない感が。
理論的・技術的に問題ないのと、今までの目の慣れにやさしいかは別問題。

C++はC++0xで>>とくっつけて書いていいようになりました。
要するに文脈依存でlexer頑張れと。

>>167
lexerに文脈を表す状態を持たせる必要……この道はいつか来た道。 ←ruby/parse.y orz

<>でも[]でもどっちでもいいじゃん

{}でもdo..endでも でもどっちでもいいじゃん

それは{}でお願いします

>>166
Javaのgenericsにその問題はないから別の理由だろ

>>166
本当のところ、理由はわからんが、記号がかぶらん方が、パーザにとって
色々都合が良いという話はある。例えば、 A[B] Cという式があったとして、
これがA<B> Cだったら、記号表みないと、A < B > Cという式と区別つかんとか。

>>173の例はミス。A[B] Cだとまずかった。書き直すと、

a.b[C](d)という式があったとして、これがa.b<C>(d)だったら、
記号表みないと、a.b < C > dという式と区別つかんとか。

>>174は処理系実装と言語仕様の思考分離を(ry

>>175
いや、もちろんわかってるよ。ただ、処理系(というかパーザ)の実装のしやすさを
考えて、問題無い程度に構文を変えるというのは普通にあり得る話だと思う

D 言語なんかまさにそうだな。
実装しやすいような言語仕様にするってのを１つの柱にしている。
D 言語は構文解析と意味解析が 100% 分離可能。
逆に C++ とかは泥沼。全言語の中で最もパーサが作りづらい。

>>176
同意。ただ>>173のような例が「問題がある」程度の実装の難しさを引き起こすかな。
テーブル見る必要があるのはスマートじゃないけど、見慣れた記号の意味が変わらない、というのは
一つのメリットになり得るから、トレードオフとして検討する価値はあるんじゃないかなぁ。

けど、[とか]が単独で演算子として使われたことはないだろうから、それを<と>の代替として選んだ
Scalaの中の人は確かにちゃんと考えてるなーと思う。

>>177
C++なぞ問題外 (^^)

とりあえず参考資料 っ

>　* Features of Ruby
>　　+ Simple Syntax
(from README)

Pseudo simplicityとか言い張ってるやつだな。どこがpseudoって、parse.yの大きさ見れば分かる。

Rubyの主張は、見た目の良さと実装難易度は直交するということじゃまいか。
たしかにBrainf**kなんか挙げればそれっぽい気もするが、ある程度の複雑さを備えた実用的な
言語仕様でも上記が主張できるかどうかは、意見が分かれるところだろう。
(見た目がシンプルなら実装も簡単になりやすいんじゃないか、等々)

>>180
「見た目の良さ」だと曖昧だな。理解のしやすさ、くらいか。まぁその指標自体が曖昧だが。

>>174
不等号を連続させられないようにする、という選択肢もあるね。

>>180
> Pseudo simplicityとか言い張ってるやつだな。どこがpseudoって、parse.yの大きさ見れば分かる。

それだけだと単にyaccが適切な道具じゃなかったという可能性が否定できないよ。

>>183
Rubyの文法は、lexer/parserを分離する事が前提の構文解析アルゴリズム
は向いてない可能性はあるね。

Cが駄目だね。> 分離

>>183
LALR(1)が、なら同意だけど、単にyacc(bison)が、ならあんまり同意できないかも。
parse.y覗いたことある? あんなことやってたら他のパーザジェネレータ使ってもコードが太りそう。
結局は>>184のが本質ついてるのかも。

とりあえず誰か、Scalaの超絶技巧を使って[Type]を<Type>と書けるようにするライブラリの実装ヨロスコ
// TypeじゃなくてKlassか?

>>187
さすがにそりゃ無理があるw
Camlp4みたいに標準的な構文拡張のための方法が用意されてるならともかく
Scalaではそういうのは無いはずだし

>>186Rubyをわかってねーな。プログラマのためにあえてあーなってんだろうが。

>>189
んと、言語として「プログラマのためにあーなって」るのは否定も嫌悪もしてないっす。
ただ、とりあえず現状の(というか「lexer/parserを分離する事が前提…」であると?)
実装は、大変そうだな、と。lex_stateとかlex_stateとか。

だからといって、プログラミング言語の文法に置ける、人にとってのsimplicityの定義:
　　LALR(1)に収まること。
っていうのは違うよなぁ。

おぉっと、Scalaな話からそれてしまう。いいかみんな、共産ゲリラたちが発する電磁波は……

>>189
Ruby書きづらいし遅くて使い物にならないけど

Scalaの日本語版Wikipediaには影響を受けた言語にRubyが入ってるけど、英語版にはない。

>>192
それはひどいな
捏造かよ

もうRubyはいいって。
内容のある比較もないし。

>>191
負け惜しみ乙。どこがどう書きづらいんだよw

てかscalaとrubyってユーザそんなに被らないと思うけどなあ
RoRとかが出てきてから流行に乗っかるような「現実的な」ユーザにとっては
今のscalaはまだ使う価値がないと思うし

Ruby信者はRubyより優れている所があると言われる言語にでていく習性があってだな…
格下認定(HSP,PHP,LISP,VBあたり)されるか、信者（HaskellとかErlang？）が突撃してくるかくらいしか選択肢がない。

>>195
うわぁ・・・Ruby信者いいかげんにしろ

こたえられないんですね。

完膚なきまでに論破。

信者なのかアンチの嫌がらせなのかの区別がつかない。
どちらにしてもScalaの絡まないRubyの話は
Ruby関連のスレかLLスレでやってほしい。

Railsにブチ切れた外人がフレームワーク作った模様

InfoQ: David Pollak氏 lift と Scala を語る
http://www.infoq.com/jp/news/2008/03/liftweb

>>189,191,198,199あたりはRubyを貶めようとする輩の自作自演の可能性が高い。
本当のRuby信者がRubyの心証が悪くなるような行動をするわけがない。

まつもとゆきひろが率先してやってる件について

>>202
>>195が抜けてるけど>>195ですか？

すまん、訂正する。>>189,191,195,198,199あたりはRubyを貶めようとする輩の自作自演だろ。

なんでもかんでもアンチのせいにしてごまかそうとしてるな酷すぎる

>>202-206
>200
>どちらにしてもScalaの絡まないRubyの話は
>Ruby関連のスレかLLスレでやってほしい。

どうでもいいけどRubyスレのほうが盛りあがっててワロタ
良く釣れる連中だから遊んでもらえるんだな

そんなことより2.7.1RC1が出てるぞ
バグフィックス中心だけど、簡単な正規表現ライブラリも追加されている

正規表現だってー！！

java.util.regex.*でいいじゃん...

鬼車キボン

またRuby厨が沸きそうなネタを…

PEGの方がいいじゃん

>>210
いや簡単なjava.util.regexのラッパー

自前LL作るときにJVM利用する価値があるのは同意する。
しかしライブラリまでラッパでおk、ってのはいかがなものか。
たしかにJavaの豊富かつ実績のあるライブラリが使えるのはすげーメリットだが、
自前言語に合った、使いやすい物をもっと作れるはずだろ。インタフェース的な意味で。

藻前らが独自言語を設計してもJVMの命令列に落とすのと同じだ。
独自インタフェースのライブラリを設計して、標準ライブラリを利用しろよ。
Java標準パッケージ脳乙。

ということを繰り返し書いている漏れは……うー。
もしこれ以上雑多な拡張が必要になる将来が来るなら、それよかPEGにしたらいいと思う。 >regex

なんだregexリテラルくらい作ってくれればいいのに

>>216がフラグ立てた。(リテラルっぽい表記をライブラリで実現する的な意味で

まあ、"abc".r で正規表現オブジェクトができるから短かくは書けるけど

>>217
Scala触ったこともないんだけどだいぶ待ってもらっていい？
……と書こうとしたら>>218でオワタ

/abc/と書けないのは中途半端だな。

>>213
scalaにPEGライブラリってあったっけ？

>>221
無いけど、Parser Combinatorがそれに近い

PEGとParser Combinatorってどうちがうの

>>218
いっそのこと、文字列から正規表現への暗黙の変換を定義するというのはどうだろう
以下のような感じで(2.7.1.RC1じゃないと動かないので注意)

import scala.util.matching.Regex
implicit def string2Regex(s :String) :Regex = new Regex(s)
for(r <- "[0-9]+" findAllIn "123 456 789") println(r)

> 文字列から正規表現への暗黙の変換

実にPerlish……けど型が保証されるから問題無しか。すげ

毎回やるのは嫌すぎるぞ。Emacsのようにキャッシュ利かせるとかしないと。

個人的にはこのくらいで変換はしない方がいいと思うが
じゃあどういう基準で変換すべきかというのがわからんな
新技術はこういうところが困る

キャッシュねえ…こんな感じ？

import scala.util.matching.Regex
import scala.collection.mutable.HashMap

object RegexConversion {
private val cache = new HashMap[String, Regex]
implicit def string2Regex(key :String) :Regex = {
cache.synchronized {
cache get key match {
case Some(regex) => regex
case None =>
val regex = new Regex(key)
cache(key) = regex
regex
}
}
}
}
import RegexConversion._
for(r <- "[0-9]+" findAllIn "123 456 789") println(r)

>>227
まあ、自分で書いといてなんだが、俺もこういうケースで
implicit conversion使うのが良いかっていうのはちと疑問ではある
ただまあ、実害があまり無い使い方ではあると思う

これはひどい

>223
PEG: 文法の記法
Parser Combinator: パーザの実装方法の一つ（ちょっと違うけどそんなもん）

パーザコンビネータつうのは文法とか文法解析のアルゴリズムとは独立してるもんなの？

>>232
実際に使えるパーザコンビネータはほとんど再帰下降型（＋バックトラック）だと思う
ただ、LRなどのボトムアップ型も作れないことは無い、はず

ScalaってWindowsでまともなプログラム書けますか？
サーバーサイドじゃなくって
Scala.netって止まってるような気がするけど・・・

うぜぇ。文句があるならRubyでも使ってろ。

WindowsユーザはScala使うな

知的水準の低い人はScalaを使わなくて結構です

なんだ。関数型言語ってやっぱり学者しか使わないか・・・

ごめん、嘘です。気を悪くしたらスマソ。

「自分がやられて嫌なことは、他人にしたらいけない」って死んだ猫いってたのを思い出した・・・

何この流れw

>>234
ScalaでWindowsのGUIプログラム書けるかって話なら
Swing/AWT使うか、SWT使うくらいしか選択肢は無いんじゃない？

「まとも」＝「GUI」！

>>241
.NET対応がちゃんとしてくれるんなら、それでいいっす^^

>>242
234の文章から、234の考える「Windowsのまともなプログラム」を推測すると、
俺もそうなる。

>>242
>>244の書いてる通り、234の文章から、234が考える「Windowsのまともなプログラム」
＝ＧＵＩプログラムのことと推測したまで。俺自身が「Windowsのまともなプログラム」＝
ＧＵＩプログラムのことだと考えてるわけじゃない

SWT使えば見栄えも問題ないよ

あんな低レベルのGUIに満足してるの？

俺はGUI全く使わない。

GUIも使えるけどあえて使わないってこと？今だにキャラクタベースのUIのほうが玄人っぽいとか、そんな発想？
あなたのような人には文字ベースで十分なのかもしれないけれど、一般的な用途にはGUIが必要とされる時代なんです。いい加減わかってください。

お前のことはお前が決めろ。

>>247
世の中はOSと違うインターフェースは敬遠されるらしい

必要なものを自分で作る能力のないプログラマが飛び付く言語じゃない。

>>242>>244
おそらく、>>234=>>243なので、さらにその内容を合わせると
>>234の考えるまともなプログラム
　＝「.NET Framework を使ったGUIプログラム」
というように読める。

どちらかというと言語がプログラマの要求についてこれれてない部分があるっつーことでしょ。
その辺を他言語と比較されるとすぐファビョりはじめる奴がいるのが困りものだね。

.NET対応ってそんなに要求あるのかな？
Java VMで十分な気がするけど

Introduction to SDT
http://www.codecommit.com/blog/misc/introduction-to-sdt/
期待。

Emacsにも補完つけてほしい

Stream.const がはじかれるんですが、これっていつからの関数ですか？

Stream.consのことか？

>>259
いや。実際にStream.constというメソッドがある。
たとえば、Stream.const(1)とすると、1のみを含む無限Streamが生成できる。

ふと聞きたいのですが、Scala以外にどんな言語に興味ありますか？

Scalaを使ってらっしゃる方が普段どんな言語つかっているのか知りたいです。

JavaとRuby

JavaとRubyかな。最近はErlangに手を出し始めてる

>>193
small talkも知らない馬鹿が書いているんだろｗｗｗ
無視しろ。

ScalaはRubyの影響をうけているよ。

>>265
まあ、受けてる可能性は否定できないけど、明らかに影響を受けてる
という程じゃないなあ。Groovyくらいそっくりだったら、話は別だけど。

>>264
他人を罵る前にだ。

Smalltalkを区切るな、ボケw

>>264
くだらない釣りはヤメロよ

JJUG Cross Community Conference の Scala のセッション、えらい盛況でワロタ:-)

http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=all

既出かもしれんけどscalaの動画が紹介されてた。
関数型言語mlのすれ

Scala 2.7.1.final
http://www.scala-lang.org/downloads/changes.html

>>271
Scalaの動画ってこれか

http://www.youtube.com/watch?v=SCl0pkrQn1A

>>271
ニコニコ動画で見つけました。
関数型言語Scalaの動画もう一つ
http://www.nicovideo.jp/watch/sm2902315

>>274
>>1乙ｗｗｗｗ

>>1 なのかwww

Rubyの人とけんかしてるので仲良くして欲しいwww

記法が柔軟性あるみたいだけど、そのためIDEのインテリセンスつくるの大変そうだね。
EclipseのJavaエディタ並みの賢い開発環境があればJavaから乗り換えたいけど。

>>274
「スレを立てる」ｸｿﾜﾛﾀ
その結果がこのスレかｗｗｗ

emacsで充分

>>278
開発中のEclipse用プラグインが割と頑張ってる感じ

>>281
そうなのか、使ってみる。

Eclipse で実行のたびに Run Configuration が増殖するのは仕様ですか？

Scalaって文の区切りに；が必要ないの？
なんか怖いです。

誰でもはじめては怖いもんだ

>>284
関数型言語などでは　;　が必要ない方が普通。
HaskellやOCamlなんかでも;は必要ない。

ありますよ。

必要だけど必要じゃない。

Lispだとセミコロンはコメントアウトだな。

JavaとRubyとScalaの比較
http://codezine.jp/a/article/aid/2464.aspx

Scalaの文法でDみたいなネイティブコンパイラって作れないかな。

単にネイティブバイナリがほしいだけだったらgcjであれこれ挑戦してみたら委員では

inforno :: Scalaでスタック指向言語をサクッと実装する
http://inforno.net/articles/2008/05/17/simple-stack-oriented-language-implemented-using-scala

scalaって遅延評価あるんだな。
最初からそれ言ってくれたら切り捨てたりしなかったのに。

お前の方が切り捨てられたんだよ。

煽られたら乗るよ？
scalaに意志はないから切り捨てるも切り捨てないも人の意志にゆだねられる。
scalaと人を混同しないでくださいね。
それとも、scalaたんとかいって擬人化してるキモオタくんですか？

scalaたんの擬人化マダー？

>>296
君、さぞ国語の成績が悪かったろうな。

>>296
乗るにしてもその乗り方はないだろ。
>scalaに意志はないから切り捨てるも切り捨てないも人の意志にゆだねられる。
って、どんな返しだよ。

というか、返しにすらなってないか・・・。

>>296
煽られたら乗るよ？
> scalaに意志はない（後略）
まず、議論の前に、どのような哲学的立場をもとにしているのかをハッキリしてもらおうか。

>>296
scalaにはMartin Oderskyの意思が宿っている

と返して欲しかったんですね。
わかります。

キモオタとか言って煽ってる本人が
なんか凄くオタクに詳しいっぽいのがたまらんね

沸いた頭で煽りを書き殴ったら、自分が普段言われてるモノが出てきました、みたいな

どんな言い方してみても>>294が付いて行けなかった事にかわりはない。

>>294の書いたscalaたんが観たかった…

codezineのメルマガのタイトルに scala が出てきて吹いた

◆【Web】私がScalaを選んだ理由
最近自分の中でScalaという言語が熱い。RubyやPython等のスクリプト言語や、
JavaやC#等現在のエンタープライズ領域を支える言語、HaskellやErlangといった
関数型言語もある。そんなにいっぱいいい言語がある中で，なぜ今Scala
なんだろう？そんな理由を解説してみたいと思います。
http://codezine.jp/a/article/aid/2464.aspx

>>303
scalaを一見したらどう見えるかというと、
・JAVAのクラスファイルはくの？つまり所詮はJAVAの亜種ってこと？JAVAにはウンザリなんだよなぁ
・クラス？なんだ、またオブジェクト指向言語か。ツマンネ。
・アルジェブライックデータタイプなし？キモ。おいおい、どこが関数型言語だよ。
・しかも見た目は完全手続き型言語っぽい。

遅延評価以外これといった特徴無いですよね。

>>306

英語docの読めない香具師はScalaに手を出すなｗ

>>307
既存のプログラミング言語が多すぎて新しい言語が出てきても大して興味もでないのに、
ドキュメントまで見ようと思うわけがないだろ？ｗ
ブログを見ていて、たまたま言語の紹介があったら読む程度。
言語に興味を持つか持たないかが決まるのはせいぜい5分程度だ。
まぁ、言語の特徴を説明しきれていない糞ブロガーが全部悪いわけだがwww

そうやってすぐ雑草を生やす

まぁ、小物アプリ作者の俺としてはネイティブ吐いてくれない時点でアウト

遅延評価以外これといった特徴無い言語に興味を抱いて、ここに来たの？

>>311
遅延評価が実装されている言語を挙げてみろ。
思いつく限りでは片手に収まる。

>>312
Haskell
Scala
Clean
UnLambda

>・JAVAのクラスファイルはくの？つまり所詮はJAVAの亜種ってこと？JAVAにはウンザリなんだよなぁ
>・クラス？なんだ、またオブジェクト指向言語か。ツマンネ。
さすがにこの釣り餌は、おいしそうじゃないな。

じゃあ食いつくなよｗ

ごめｗ

自分が食いついた餌の低質さをいくら口にしたところで、相手のレベルじゃなく
「そんなのに食いついた自分のレベル」の低さをアピールするだけなのにね（相手には1ポイント入る）。

ごめん、わるかったって

>>312
OCaml
pypy

>>306
頭悪そうだね

>>312
> 思いつく限りでは片手に収まる。

なんて無知な…

なんだここの奴ら・・・
まだHaskellスレの方が「できた」人間が多いぞ・・・

スレ住人の人間性を見てもわかる。
この言語はJavaの系列なんだな。

Javaじゃないのが最大の利点。

JVMに縛られたローカル言語

>>322-324
Haskellの名前だけ挙げてPD.Martin Oderskyに直接何も言えないのって恥ずかしいよな

もうJVMを次期windowsに埋め込めばいいんじゃね？

>>326
俺はscalaのこと何もしらねーもん＾＾
俺が批判してるのが言語scalaだと思っていたら大間違いだぜ。
お前らを含めたコミュニティと広報活動全般についてなんだよ。
「外」の人間がどう感じるか感想を言ったまでさ。
お前ら被害妄想ひどすぎwww

>>328
> 俺はscalaのこと何もしらねーもん＾＾
（ ´,_ゝ｀）ﾌﾟｯ

>>329
頭の可哀想な子に触るの禁止ーーー!!

俺が思うに、コミュニティが健全であるためには、Javaとのつながりを完全に切った方がいいと思うんですよ。
>>329-330のような奴らをJavaに隔離すべきだと思うんです。

っていうかさ、数学出来ないやつが関数型言語さわるなよ＾＾＾

「このマスにとまったら、ム板のScalaスレを荒らしてくる」
とかいうゲームなんだよ。

>>328
> お前らを含めたコミュニティ

2chをコミュニティ認定しないでくれ

>>334
馬鹿にそんなこと言っても始まらないだろ。

>>334
妄想がどうのと言い出す人が、むしろ自分こそ激しい妄想を前提としているのはよくある話。
つまり、自分が言われると致命的な指摘を、先に相手になすりつけておく手法。

自己投影化ですねわかります

>>328
人間やコミニティまで批判するのはやめような。
フレームにしかならないよ

>>338
ああ悪かったな。
「活動」を批判すべきだったなｗ

もう引くに引けなくなってるのねｗ

>>332
関数型さわって慣れてから、数学勉強するのでいいと思う。

興味持てないのにいちいち荒らしにくる＞ツンデレ

というか、このところのScalaの取り上げられ方を見て
「なんか落ち着かない気分になった」Ruby信者では。

序盤に遅延評価を連呼していたあたり、遅延評価で切り捨ての子じゃないのか？

C#並にIDEの支援が充実してくれるといいんだが・・・・

;が省略可なんて仕様はIDEにとって厄介者にならないのだろうか？

;を書かなくていい言語が変に思うヤツは、プログラミング言語知らなさすぎ。
他の言語も知っといた方がいい。勉強しろ。

勉強の問題じゃないが。

アホが勉強しろとか言ってるの見ると滑稽でたまらん

そういや、VBのインテリセンスは完璧だったな

Haskell知ってるヤツと、Javaしか知らないヤツのコードを見ると、同じScalaでも全然違う。
あたりまえだが。

荒れてるなあ
とりあえず、Algebraic data type相当の機能はScalaにもあるよ
あと、Scalaの特徴と言ったらやっぱりimplicit conversion/parameterとか
Extractorとかじゃないかと個人的には思う

>>345
Visual StudioとかEclipse並にはまだ程遠いけど、Scalaで書き直された
新Scala Eclipse Pluginは結構補完頑張ってるよ。implicit conversionで
追加されたメソッドとかも補完してくれる。

>>343言い得て妙だな。まさにそんなのが身近にいるのでツボった。

またいつもの浮気癖か＞Ruby信者
浮気するくせに浮気相手にRubyを求めるからなあ。

；と｛ばかりの言語しかやったことない俺涙目
そんな人は何からやればいいですか？やっぱりHASKELLとかですか？

あと、SmalltalkとSchemeかな。

>>354信者のふりしたアンチに騙されてるんだよ。Rubyistは向上心のある人格者が多い。

間を取って、Ruby信者とRubyistは違うということでこの話はお開き。

>355
ここは forth で

本家ホムペ落ちてる！＞＜;

・・・

大幅リニューアルということか？

>>360
いつまで落ちてたのか知らんが、もう復旧してるよ
Webページのデザインは以前と特に変化無し

1つだけ、def　という適当な予約語が気に入らない

じゃあdefunで…

>>362
じゃあ、defineだったら良かった？予約語って特に頻繁に
使用するものは、省略形を使ってでも短くした方が良いと思う
どうせ予約語の数なんて知れてるし、覚えることの労力よりも、
短くすることのメリットの方が大きいと思う

あと、defって予約語自体は結構メジャーなものだと思う。俺が知ってる言語では
Ruby,Python,Groovy,Scala,Nemerle,が採用してるな。Nemerleはかなりマイナーだと
思うが

クラスの宣言がclassなんだから、
メソッドの宣言はmethodでいいじゃん。

def か fun がいいな

ユニットテストフレームワークは何を使っていますか？

JUnit、TestNG、SUnit、ScalaTest、と色々な選択肢があるので迷っています。

def, fun は飽きた。df, fn とかしてほしい。

ディスク残量の表示をファンクションキーに割り当てたいんですね。わかります。

Scala の関数プログラミングが理解できません。

ScalaTutorial.pdf を読んでみました。Martin Odersky は scala で OOP
language と functional programming を統合して compose program を目指
していると理解しています。

でも tunctional programming は状態を持たないこと、変更できるデータが
存在しないことが特徴です。関数呼び出しに side effect がないことが特徴
です。 Python は、既存の関数に side effect があることから本格的な
functinal programming には踏み込もうとしません。Scala では関数の
side effect をどうやって防いでいるのでしょうか？

私には Scala の関数プログラミングは side effect を許しているとしか思
えません。もしそうだとすると、scala の関数プログラミングは偽関数プロ
グラミングだとも言えると思います。

tunctional programmingと言われても…

Scalaは関数型言語じゃないよ。

機能として見た場合、参照透明自体はそんなに重要じゃないでしょ
並列処理とか遅延評価のときに都合がいいだけで
それに純粋な関数型言語っていわゆる関数型言語の中でも一部分であって
純粋じゃなかったら偽というのも極端な気がするけど

371 です。

>純粋じゃなかったら偽というのも極端な気がするけど
同意します。

でも、side effect 使いまくりの pattern match: match .. case ... を書
いていたら、それは偽関数プログラミングと言っても良いでしょう。そして
scala は、それを許しているように思えます。Stateless, immutable にす
るのはユーザーの努力に委ねられているように思えます。違いますでしょう
か。

それはプログラミングスタイルの話で、言語がどうかって話とはちょっと違う気がする。

ん？よくわからん
パターンマッチと副作用がどう関係してるんだ？

>>374
>それは偽関数プログラミングと言っても良いでしょう。

誰にも会わずに一人で呼ぶ分には別に良いんじゃない？

>Stateless, immutable にするのはユーザーの努力に委ねられているように思えます。

という言語は別にScalaが最初という訳じゃないというか歴史に何度も登場したものに思われ。

ttp://user.ecc.u-tokyo.ac.jp/~tt076524/onlispjhtml/functionalProgramming.html

>関数的プログラミングとは，副作用ではなく，値を返すことで動作するプログラムを書くことだ．
>副作用とはオブジェクトの破壊的な変更（rplacaの使用等）や変数への代入（setqの使用等）を含む．
>副作用を使う数が少なく，その影響範囲もローカルなものであれば，
>プログラムの読み取り，テスト，デバッグは簡単になる．
>Lispのプログラムが必ずこの方法で書かれてきた訳ではないが，
>時を追ってLispと関数的プログラミングは次第に分かち難いものになってきた．

371 です
>パターンマッチと副作用がどう関係してるんだ？

Pattern match は functional programming の機能だと思います。ここで書
かれるコードは副作用のないものに限定されるべきだと思います。クラス・
データ・メンバーを設けて、それを操作するなんてしてはならないと思いま
す。そうでなかったら、compose program なんて実現できないでしょう。

>>378
> Pattern match は functional programming の機能だと思います

なこたーない

>>378
マッチングのときに副作用が起きるのがいけないということ？
それともマッチングの後の話？
compose programというのもよくわからんな

>>379
パターンマッチって関数型由来じゃないんだっけ？

>>378
要するにMartin Oderskyの謳い文句が煽りっぽくて気に入らないなら本人に言った方が良いよ。

副作用なしでプログラミングを行うという意味論的なテーマと、
単なるシンタックス(Pattern match)の議論がごっちゃになってる気がする。
「条件分岐の意味論」と「条件分岐が楽に書けるか」は全然別の話。

意味論の定義については偉い人に任せる。
ttp://d.hatena.ne.jp/soutaro/20080530/1212163155

>>369
そこで defun ですよ。Lisp 的に。

join計算では破壊的変数操作は許されるのですか？

>>381
由来は知らんがPrologとかにもあるだろ
だいたいパターンマッチングで副作用を否定したらawkの立場はどうなるんだよｗ

371 です

>マッチングのときに副作用が起きるのがいけないということ？
>それともマッチングの後の話？
cast ... ==> の後に書かれるコードで副作用があるものを呼び出さないの意味です。

>compose programというのもよくわからんな
下の Martin Odersky 自身の説明から持ってきました。彼はプログラムの部
品化を本気で可能にしようとしています。
http://video.google.com/videoplay?docid=553859542692229789
http://lampwww.epfl.ch/~odersky/talks/google06.pdf

>パターンマッチって関数型由来じゃないんだっけ？
関数型由来由来でしょう。switch case 文で置き換えられる代物ではないでしょう。

Pattern match は functional programming の機能
と
Pattern match は functional programming に由来
は別物だぞ
関数型言語以外でもパターンマッチングが見られるから前者は間違い
wikipediaによるとKen Thompson(Unixの作者)が作ったエディタや
SNOBOLが由来だから後者も間違い

なんちゃって知識を抱えて、新規言語に刃向かいに来たボクちゃんってことで決着ですか？

>381
『由来』と『機能』は別物。
Lispみたいにパターンマッチ前提にしていない関数型言語は普通にあるよ。
逆にC++のオーバーロードとかだって一種のパターンマッチだし。

>378
そんなつまらん理由で『べき』なんて断定するもんじゃないよ。

・Pattern Matchに失敗したときの挙動が複雑すぎて制御不能
・追加したパターンマッチの影響が他の関数に波及するリスクがある。
  状態の管理が困難になる
とか具体的な理由ぐらい書いたら？

状態（副作用）の本質についてはガウディ本が詳しいので、一回読んでみたら。

>>386
だったら、通常のifとパターンマッチを区別して、パターンマッチを特別視する理由は？
パターンマッチって便利なifみたいなもんだと思っているんだけど

なんか不毛な議論になっとるなー
>>374の言っているのに合致するのって、HaskellとCleanくらいじゃね？
あと、パターンマッチについては強力なif文という認識くらいで良いと思うなー

パターンマッチ＞判定にパターンのみ使用可＞判定に副作用無し

Scalaのクラスフィールドは暗黙のゲッタ・セッタ呼び出し＞
ゲッタ・セッタの明示定義でもフィールド名のみで呼び出し＞
意図せざる副作用はそれらで相殺可

OCamlだとパターンマッチ使って、
let (x,y) = mouse_point in
　printf "%dだお, %dだお" x y

とかできるけど、scalaだとどんななんだろ。

scala> val (a, b) = (1, 2)
a: Int = 1
b: Int = 2

こんなのなら動くよ

Tuple以外でも使えるけど、なんか違和感があるな

case class TypeA(val a:Int,val b:Int)

val TypeA(a,b)=TypeA(10,20)

println(a)
println(b)

>>395
違和感あるってのは単にパターンマッチ自体に慣れていないという
事じゃないかなあ。Scalaに限らず、SML,OCaml,Haskellなどでも同様の
事はできるわけだし

ちなみに1行目caseつけるならvalは要らない。

case関係なくval要らなくね？

>>398
いや、要るでしょ。case classにしなきゃパターンマッチの
対象にできない。もちろん、別途unapply定義したobjectを
定義すれば別だけど

あ、ごめん、意図を取り違えていた。case classじゃなきゃ、そもそも
valのあるなしに関わらずパターンマッチできないわけで、確かに
必要ないわな。

細かいことだが、unapplySeqでもおｋ

val s = "([0-9]*)(.*)".r

val s(x,y) = "123いちにさん"

println(x) // 123
println(y) // いちにさん

case classでは暗黙にvalだが、case以外でもvalやvarで
コンストラクタ引数もメンバ化できるのだだだだだだ

Javaでは

String.class

のように書くと、対象のクラスのインスタンスを作成せずに
Class型のオブジェクトを取得することができますが、
scalaで同様のことをするにはどのように書けばよいのでしょうか？

つ type

つ classOf[String]

>>405
ありがとうございます。探していたのは正にこれでした。

>>404
type a = b で型の別名が作れるんですね。
今回探していたものとは違いましたが、参考になりました。

def getFunc(fun:Option[String => _ <: AnyRef]) = {
fun match {
case None => null
case Some(f) => (i:String) => f(i).notify()
}
}

上記のコードをコンパイルすると notify()　の部分でエラーになりました。

fがStringを引数に取る関数であるというところまでは推論できているのに、
fの戻り値がAnyRefを継承した型である事を推論できないのはなぜなのでしょうか？

Existential Type周りの推論の仕組みは正直よくわかっていないので
確定的な事は言えないのですが、推論できていないというより、どうもバグな気がします
たとえば、上記のコードを

def getFunc(fun:Option[String => _ <: AnyRef]) = {
fun match {
case None => null
case Some(f) => (i:String) =>
val a: AnyRef = f(i); a.notify()
}
}

とすると、コンパイルが通ることから、少なくともf(i)の返り値が
AnyRefのサブタイプであることは(コンパイラによって)認識されている
ように見えます。色々試してみたところ、以下のようなコードの場合

val fun: Option[String => _ <: AnyRef] = Some((s: String) => s)
val Some(f) = fun

コンパイラが
error: fatal error: bad type: ?(class scala.tools.nsc.symtab.Types$WildcardType$)
というメッセージを吐いて落ちるようです。この辺の事から推測すると、
Existential Typeとパターンマッチを組み合わせたときのバグのような気がしますが、
本当のところはわからないので、本家ScalaのMLで聞いてみるのが良い気がします

回避策ですが、Function Typeは、返り値についてcovariant
annotationが付加されているので、わざわざExistential Typeを使わずに、単純に

def getFunc(fun:Option[String => AnyRef]) = {
fun match {
case None => null
case Some(f) => (i:String) => f(i).notify()
}
}

とすれば良いです。これで、ちゃんと
getFunc(Some((s: String) => s))
などのコードをコンパイルできます

>>408-409
いろいろと試して頂き、ありがとうございました。
Existential Typeを使わないようにすることで、無事、動くようになりました。

英語は苦手なのですが、
そのうち、本家ScalaのMLでの質問にも挑戦してみようと思います。

ScalaのEclipsePluginは、Eclipseのどのバージョンで動きますか？

ttp://www.scala-lang.org/tools/eclipse/index.html

プログラミングしりとり
http://game14.2ch.net/test/read.cgi/575/1010948472/l50

Webサイトが変わった

Renewal ですな
NetBeans 用プラグインも追加されてる > ヘルプも含めて IDE 本体のオール
日本語化は NetBeans の方がダンゼン速いので日本人にとっては良い知ら
せか
ただし 6.5 以上だけど (現在日本語はまだ GUI のみか日本語開発版のみ)

Scala本5月には出版っていってたのにまだプレプリントか。

Scala本待てない人は、単なる個条的抜き書き程度のしろものですが
それまではこちらをどーぞ
ttp://www.h7.dion.ne.jp/%7Esamwyn/Scala/scalaindex.htm

うはｗ　こういうのうれしい。
英語のリファレンス読むのメンドくさくて、いまいちちゃんと理解できてなかったんで、
すげーうれしい。

>>417
これ、ただの機械翻訳じゃないの？

>>416
http://www.artima.com/shop/programming_in_scala
そろそろ出るんじゃないの？

機械翻訳はこういう文章を吐かないと思う
なんていうか、プログラマというよりは人文系の方が書いたような文章

プログラマ向け、でなくJavaとJavaScriptならわかる、という人を想定したら
こんな文章に。
Scalaは、そんな人たちの(関数型言語)入門学習用に向く言語仕様である
ように思われたので。
(つーか私自身にとっても最新の関数型言語の入門学習目的で言語仕様
原文から外せない部分を抜き出す形でまとめました(直訳はおろか意訳で
すらねぃです、でも原文読む参考程度にはなるはず)。ちなみにコンカレント
云々はまだわからない程度のレベルな私)

あーあといちばん最初に訳した言語仕様要約は直すべき部分が最多ですが
今はいろいろあって直すヒマがないのであしからず(私自身によるコメント部分
に集中してるので、そこの変なのは無視してくだされ。要約でない解説諸ペー
ジの方のが正しいです)。

＞If you purchase just the PDF eBook for $27.50, you will be entitled to receive periodic updates as the authors
＞complete the book, as well as the final PDF when the book is finished, for no additional charge. If you purchase PDF
＞+ Paper Book combo for $59.99, you will be entitled to the PDF eBook updates, and we'll ship you the paper book
＞when it is published, on or around August 30, 2008. (Once the book has been printed, you'll be able to purchase just
＞the paper book here for $49.99.)

すいません。これ訳してください。

こんな感じか？

$27.50でPDF買ったら、本が完成するまで
追加料金なしでPDFのアップデート受けられるよ。
$59.99でPDFと紙の本買ったら、PDFのアップデートできるし、
10月30日くらいに出版されたら紙の本も送るよ。
出版後は$49.99で紙の本買えるよ。

August 30
8月30日、ですね

>>425-426
ありがとうございます！
もうすぐ発売日じゃないですか！

>>417
ひさびさに電波ぽい文章を見た

>>428
だなｗ

頑張ってくれたのに悪いが、行間びっちりな上にろくに段落を区切ってないから、
文章ではなくなんかの模様に見えてしまう。そんなだから最初の一文すら読む気が起きない。

>417
むむむ……典型的な『頭の良い人が書いた難しい文章』だな。
・文が長すぎ／意味詰め込みすぎ
・読者に必要な前提知識が多過ぎ
・話が発散しすぎ
ということでおいらもムリ。

自分も素人なんであんまり偉そうなことは言えないけど、
・一文の意味／意図が一つになるように文を解体する。
　- ()の解説は多用しない。注釈で飛ばした方が良い。
　- 直前の文までに出てきた言葉だけで文章を組む。新規の言葉は解説する。
・段落の基本構造（序破急）を意識して文章を構築する
・文章の基本構造（起承転結）を意識して段落や章を構成する
あたりだけでも注意すればずいぶん違うんじゃない？

いちばん最初のページの水平線から下は「言語哲学的意味論」なのでいわゆる
リファレンスとしては読む必要はまったくないです (つまり、この水平線は、ここから
下は「Scalaという言語に対する(個人的)注解」である、という意味です)
水平線から上の部分にザッと目を通したあとはそのまま「1階受付」へとお進みく
ださい (そこからはいくらかでもマシになってるかと)

あと行間は、私は逆に空いてると読みづらい方なので、直すかどうかは微妙です
Firefoxなら「スタイルシートを利用しない」すればほんの少しだけ行間が空いて字
ももう少しだけ大きくなるよーですが ...

行間以前の問題だろ＞読みづらさ

>>417
論文ではなく、仕様書を書くようになればみんなの気持ちが分かるようになるよ。

>>430
頭がよいのとおかしいのと狭間くらいだと思う

これで難しいって、どれだけ土方なんだよ。

スタイルシートは変更したけど。

読みづらさについては申し訳ないですが、いずれこのScalaページは6月頃に
書いたもので (必要な人はググって自力で見つけるだろうと思いこちらでとく
には宣伝しませんでした; まだいろいろと不完全であるためもありますが)、今
はほかにやるべきことができてしまって当分私自身による修正は無理っす

ぬか喜びさせてしまって申し訳なひ、おのおの方

スタイルは俺も無効にしたｗ
これぐらい特殊な文体でもいいんじゃないかな。もちろんわかりやすいほうがいいが、
クセがあって読みにくいぐらいの文章でも、Scalaの雰囲気としてはあってるような気がする。

>>430
序破急! うーーーーん。

序破急 > 導入・展開・参考
起承転結 > 理由・これまでの過程・話者の新しい意見・新旧の比較

とゆーことではないかな?
ちなみに序破急は能の作劇論、起承転結は漢詩の構成論が由来

技術文書の段落に序破急はおかしいだろw
>>440の頓珍漢さに苦笑

>441
じゃあ導入->展開->結び で良いや。
さすがに段落ごとに全部この構成にするのはムリがあるけど、意識しないで
破綻するよりはマシですな。

>440
起承転結は序章の話になりますな。
各階の説明は概要->詳細の二段構成でも十分かな。

活用例は>440みたいな感じだけど、起の部分は『文章の全体像・説明範囲を規定する』という内容になるかと。
読者にまず「この文章は何について言及するのか？」というスコープを提示するわけですな。

ちなみに、序破急は能じゃなくて雅楽から来た言葉らしいよ(Wikipedia)

>>434
それは論文に対して失礼だw
>>417には悪いが、少なくとも、コンピュータサイエンス系の論文で>>417くらい読みづらい
文章は見た覚えがないよ

417のサイトは他のページの方が電波ゆんゆんでいい感じだ

Programming in Scalaって本当に8月30日くらいに発売されるの？
アマゾンとかに全然来てないんだけど・・・

417は括弧部分をごっそり削ると、ちょっとだけ読みやすくなるぞ。
ちょっとだけ、だけどな。

Amazonとかの普通の流通に乗るのかなあって気も。

え！？そんな立ち位置なの・・・
Scalaのサイトでしか発売されないのかなあ・・・

>>417とか人によませるブログとか一度書いてみた方がいいと思うよ

ところでProgramming in Scalaってどんな内容なの？
ＰＤＦ読んだ人いますか？

pdf読める携帯買ったんで突っ込んでみたが、読みにくくて読んでないな

>>450
> どんな内容なの？

読め

Programming in Scalaって結局出版されたんですか？

日曜に本屋で見た。

マジで？
日本の本屋？

うそだろ。ホームページ見たら
when it is published, on or around September 30, 2008.
ってなってた。また延期です。

この言語、groovy, jython, jrubyなどに対する利点は？

>>457
一つは速度

おお、それは凄い！
残りの二つ目以下２６項目も挙げてくだされ。

jython > 本家にかなり遅れている
jruby > 元来 Rails と Java の共用が目的で、それ以外にあえて使う理由がない
groovy > Java 版 Rails のための言語だが失敗。Rails 利用者は Java を要せず、
Java 利用者は Rails を要せず
scala > 関数型パラダイムを Java に持ち込むための言語で、上 3 つとの類似は
あくまでその結果 (Python と Ruby が関数型パラダイムの影響を非常に
強く受けているため)
つーわけで利点云々以前に、もともとの存在理由がまったく異なります

え
その逃げはないっしょ

都合の悪い展開になったから逃げ呼ばわりするという逃げは
どうかと思います。

は？俺に都合のいい展開って何？各言語信者の醜い貶しあい？

結局Scalaのアドバンテージは特に無い、という展開。

Scalaの利点ねえ。
あえて挙げるならきちんとした型システムがあるとことかかな。

>>464
Javaで書くより100倍楽だけど、性能はJavaと同等。
でもEclipseのScalaプラグインはもうちょっとがんばって欲しい。
今だとまだEmacsのscala-modeの方が使い易い。

メッセージ駆動並行なコード書くのに
JMSとJMXでMDBと、ScalaのActorどっちが楽？

俺は断然Actor派

Erlang派

プログラミングしりとり
http://schiphol.2ch.net/test/read.cgi/575/1010948472/l50

Computer Language Benchmarks Game
ttp://shootout.alioth.debian.org/u64q/index.php

Javaは何だかんだで早いよなぁ。
やっぱり俺の本命はErlangじゃなくてScalaだ。
次世代ゲーム機もScalaWithJavaAPIでいいと思う。

>>988
古い規格だと、ISO 9899:1990　セクション　3.4 で　"byte" が定義されている。
同 セクション6.3.3.4 に The sizeof operator yields the size (in bytes) of its operand.
とある。
sizeof(char)は1で単位はバイト。

終了。
　

>>988
古い規格だと、ISO 9899:1990　セクション　3.4 で　"byte" が定義されている。
同 セクション6.3.3.4 に The sizeof operator yields the size (in bytes) of its operand.
とある。
sizeof(char)は1で単位はバイト。

終了。

誤爆しかも連投ごめんなさい。

C99なんてもう誰も知らんぞ・・・

今度こそProgramming in Scalaって出版されましたか？

いいえ

10月30日以降にまた延期でっす!!

またかよ！
完成してから発売日発表しろよ！！

>>478
商売の基本は、発売前にマーケティング開始することだからなあ・・・
売れないのがわかったら出ないもんだし

ぁゃしぃebookだってそうだろ？
最初にまず、市場調査→セールス文を書く→マーケティングをしかける→商品作る→売れそうなら発売
が基本ってしってた？

> 商売の基本は、発売前にマーケティング開始することだからなあ・・
商売の基本は、商品完成前、発売前にマーケティング開始することだからなあ・・

執筆はどの時点で終わってるの？

ScalaByExampleのサンプルで動かなかったので質問
9.3章の最後
val intSort = msort((x: Int, y: Int) => x < y)
val reverseSort = msort((x: Int, y: Int) => x > y)
最後に'_'がない

10.3章
for { i <range(1, n)
　　　j <range(1, i)
　　　if isPrime(i+j)
} yield {i, j}
List.range()になってない
最後が(i,j)じゃない
これってサンプルのミスってことでいいの？

昔のバージョンではメソッドから関数への変換は _ つけてなかったし、タプルリテラルも中括弧だった（不評のためすぐに小括弧になった）。rangeは覚えてないけどそうだったんだろうね。

rangeは単にミスか省略か前提があるのかも。

ただのミスでしょう。ScalaLanguageSpecificationやScalaByExampleには新版ではエラーに
なる旧版のままの例のほかにもひと目でわかるタイプミスもときどきあります

解答サンクス
仕様変更にリファレンスが追いついてない状態なのね
本の出版が遅れるのも納得だわ

見つけたScala Language SpecificationやScala By Exampleのミスは、
MLで報告してあげると良いかも。英語で質問するのは敷居高いと思うかも
しれんが、適当な英語でもそれなりに意味を汲み取ってくれるので、大丈夫

2.7.2 RC3でた

http://pragprog.com/titles/vsscala/programming-scala

>>489
> March 30, 2009.
orz

あー489はOdersky本とは別ですよ。タイトル同じだけど。

これも別ね。
http://blog.aspectprogramming.com/2008/10/6/writing-a-book-on-scala

タイトル、微妙に違うくね？

Programming in Scala is at the Printer
http://www.nabble.com/-scala--Programming-in-Scala-is-at-the-Printer-td20098100.html#a20098100
> most likely we'll be shipping printed copies to all those who bought them the second and third week of November.

まだ先かー。

今日は、Scala勉強会@東北の日。東北と言っても、開催するのはネット上。夜の8時から。

エロい人ならScalaでグラフ構造ってどうつくるんだろう？
自分でつくると、JAVAで作ったのと変わらない物ができてしまう・・・
caseクラスとか駆使して、もっと、かっちょよく作れないもんかな。

そんなメタな構造なら、どんな言語で作っても基本は同じになるんじゃない？
それにメタであるだけに、応用によって実装のしかたは変わるし。
「アルゴリズムがJavaならオブジェクト指向に！」みたいな違和感がある。

Scalaって下がJavaだから仕方ないんだろうけど、
他の関数型言語だと構文で解決するようなものを
動的な仕組で無理矢理そう見せてる部分が筋がよくなくてどうにも気持ち悪い。

tatoeba?

>>497
んなこたあ無いと思うが、具体例は？

>>497
え？動的な仕組で無理やり解決？それってむしろ他の関数型言語でしょ。
Scalaは静的な仕組みで無理やり解決だよ。

リストの構築子も :: なんてそれっぽいものを用意してはあっても
所詮はメソッドのお化粧なのでパタンに書けないとか。

パタンマッチするのにケースクラスなんてものを導入せざるを得なかったのが
そもそもそうだと思うし。

ポイントがよくわからんので具体的なコードで他言語と比較してほしいなあ。

>>501
なんとなくわかった。
ちょっと違うが、JavaのGenericsのような無理や不自由さがあるということか。

余計わかんねー。Javaのジェネリクスって動的な仕組みなの？

>>501
えーと、::はListクラスのメソッドであり、かつcase classだからパタンに書けるんだが…
それはともかく、ケースクラスを導入せざるを得なかったってのは違うと思うな
パターンマッチングという機能をプリミティブで拡張性の無いものでなく、ユーザが
後付けでパタンを定義できて拡張性のあるものにするためにどうすればいいのか
という問題に対する解の一つがケースクラスなりExtractorであるってことだと思う
MLとかのパターンマッチに関する有名な問題の一つとして、抽象データ型に
対してパターンマッチできん、というのがあるけど、Scalaではこの点はそもそも
問題にすらならない

>>504
仕組みや目的はまったく違うけど、VMの仕様が言語に影響して無理があって不自由なところが一緒かと

JVM 上の Scheme とか普通にあるし、VM の仕様より、既存の Java ライブラリとの親和性を
重視してるかどうか、の違いでわ?

なんつーか、JVMの仕様からくる言語使用上の制約は実際あって思いつくけれども、
最初に動的とか非関数型的とかって書いたのはテキトーでしょ？
いずれにせよもうちょっと具体的に語ってくれればその通りだねとかいやそれは違うとかいえるんだけどさ。

>> 507
動的な型の言語と比較するのはあまり意味がないと思われる。

>>506
Javaからも呼び出せるように class としてバイナリを作成するがために、言語仕様に制約が出ているんじゃないかってことと考えて良い？

>>501
そりゃ構文の話で、動的とか静的とか関係ないだろ。

>>505
case classを使ったパターンマッチを、
クラス上のデザインパターンにするって主旨の設計だからねえ。
データ構造に依る分岐構造を、
データ構造上のcase classにまとめて整理しようって考え。
Scalaは型大好きだから。

パターンマッチ作法が強制されるけど、
整理の仕方としては面白いわね。

オカマっぽい

>>513
すまん。女です。

ワロタ

2.7.2 RC4でた

RC5でた

RC6でた

RC7でた

いや、マジで 今 RC6

RC8来たよ

マジかと思って見てみたらRC9が出てるし

Programming in ScalaってAmazonとかで買えるようになるんですかね？

そうして RC365 まで毎日でるわけですね

>>524
そこまでRubyの真似をしなくていいよwww

>>525
Vimのまねだったらやだな。

D言語みたいに、0.99から0.100になるよりは期待感なくてよいじゃないの

scala・・・この言語イマイチだねえ

とにかく中途半端な印象しかない

とにかくイマイチ絶対に例を挙げない

あくまで実用本位で言語オタク受けは眼中にないからな

えっ！？

rubyの気持ち悪さ異常

ruby や groovy は、いいときはミラクルなまでにサクサク進むけど
バグるとプロでもさじを投げるぐらいデバッグが超絶困難なようだね

コミュニティの性格に似てるかもな。
好きなスタイルで気分良くモノを進めている時は非常に良い顔を見せるが、
好まないスタイルとの出会いや不機嫌に耐性が無く、そういう時は非常に排他的で非生産的になる。

>>534
普段、静的型付け言語とRubyつかっているけど、たまに頭のモード切替が不十分で
静的みたいに書いちゃって、なかなか気づかないバグ残したことがあるよ。

この前ハマったのは、クラスのプロパティをattr_accessorだかで定義して、
自クラス内でプロパティ名そのままでアクセスしようとして、上手くいってなくて、
1日悩んだ挙句、self.プロパティ名、でアクセスしないといけないことに気づいたことかなｗ
アホか俺は、と思ったけどｗ

スレ違い

Actor の link って何に使うのか良くわからん・・・・

別のアクターが終了したのを検知する（あるいは一緒に死ぬ）ため。

ありがとうー。
Exit メッセージが来るってことですね。

てっきり、複数のアクタをグループ化して、メッセージのマルチキャストみたいなことができるのかと勘違いした。

あぁ、そうか。プロセスと同じように考えればいいのか。
親プロセスが死んだら、子プロセスも死なすって考えればいいのか。

メッセージのマルチキャストは、仲介役のアクタを用意して、自前でやるってことか・・・
http://www.nabble.com/Scala-actors-and-message-broadcasting-td19442504.html#a19442504

Scala 2.7.2 final キタ！

次は final2 がリリースされるんですね、わかります。

Programming in Scalaって出版されましたか？

11月25日前後を刮目して待て！

刮目して待ちます！

Programming in Scala 出版age

紙の本はまだだな

紙のほうは日本で買えるんですか？

アマゾンで買えるようになんじゃね

下は公式サイト（確か・・）で取ったサンプルコードなんだが、
作成アクター数（nActors)が500くらいからエラー吐きまくり・・

2.7.1の頃は、nActors = 1000でもちゃんと動いたんだが、
なんか知ってるエロい人いない？

import scala.actors._
import scala.actors.Actor._

object Message {
def main(args: Array[String]) {
val n = try {
Integer.parseInt(args(1))
} catch {
case _ =>
println("Usage: examples.actors.Message <n-actors> <n-times>")
Predef.exit }
val nActors = 1000
val finalSum = n * nActors
Scheduler.impl = new SingleThreadedScheduler

// 続き１
def beh(next: Actor, sum: Int) {
react {
case value: Int =>
val j = value + 1; val nsum = sum + j
if (next == null && nsum >= finalSum) {
//println(sender)
println(nsum)
System.exit(0)
} else {
if (next != null) next ! j
//println(sender)
beh(next, nsum) }}}

// 続き２
def actorChain(i: Int, a: Actor): Actor =
if (i > 0) actorChain(i-1, actor(beh(a, 0))) else a

val firstActor = actorChain(nActors, null)
var i = n
while (i > 0) {
firstActor ! 0
//if (i % 100 == 0) println(i)
i -= 1 }}}

nActors >= 473 で
以下を延々吐くみたい

at Message$$anonfun$beh$1$1.apply(message.scala:34)
at Message$$anonfun$beh$1$1.apply(message.scala:25)
at scala.actors.Reaction.run(Reaction.scala:78)
at scala.actors.SingleThreadedScheduler.execute(Scheduler.scala:174)
at scala.actors.Scheduler$.execute(Scheduler.scala:80)
at scala.actors.Actor$class.send(Actor.scala:411)
at scala.actors.Actor$$anon$1.send(Actor.scala:93)
at scala.actors.Actor$class.$bang(Actor.scala:583)
at scala.actors.Actor$$anon$1.$bang(Actor.scala:93)

StackOverflow が出てるんだけど、-Xmsをいくら増やしても改善しない。これはバグかもわからんね・・・

Programing in Scala v6(PDFと紙で買える奴な)
で、p73に

val greetStrings = new Array[String](3)

って言うコードがあるんだけどさ
2.7.2 final でインタプリタモード立ち上げて打ったら

scala> val greetStrings = new Array[String](3)
java.lang.NullPointerException
at scala.runtime.BoxedArray._deepToString$1(BoxedArray.scala:134)
at scala.runtime.BoxedArray.deepMkString(BoxedArray.scala:139)
at scala.runtime.BoxedArray.deepToString(BoxedArray.scala:127)
at scala.runtime.ScalaRunTime$.stringOf(ScalaRunTime.scala:163)
at RequestResult$.<init>(<console>:4)
at RequestResult$.<clinit>(<console>)
at RequestResult$...

だってさ　＼(^o^)／

2.7.1は全く問題なし　＼(^o^)／

とってもBuggyです本当ny

何気にインタプリタでArrayを内容表示する方式が変わったんだな。
昔は [L 方式で、新しいのは中身も表示してあげようとして要素のtoString呼んじゃってるようだ。
ArrayのtoString自体には問題ないようなのでインタプリタ固有の表示ルーチン持ってるんかな。

昔は単純にオブジェクトのtoStringを呼んでたんだけど、
新し目の版ではScalaRuntime#stringOfってメソッドを追加してそっちを使っているようだ。
stringOfはval a = null みたいなのについて例外を出さなくしてくれるのだが、
ArrayについてはtoStringじゃなくdeepToStringを呼ぶようにしていて、
このdeepToStringは要素のnullには（たぶん昔から）対応していないんだな。

val greetStrings = Array.make[String](3, "")
でとりあえず回避可

>>556
-Xss でかくするとか

>561
スマソ、556は-Xssのtypoでした。
Xmx,Xssとも増やしてもだめだった。＞＜

ちょっとソース眺めてみたが、Actorまわりは結構手が入っている模様。
（スケジューラはインターフェースも変わっている）
もしかしたら、SingleThreadedSchedulerはそれらに対応できていないのかもしれない。

http://lampsvn.epfl.ch/trac/scala/changeset?old_path=%2Fscala%2Ftrunk%2Fsrc%2Factors%2Fscala%2Factors%2FScheduler.scala&old=13978&new_path=%2Fscala%2Ftrunk%2Fsrc%2Factors%2Fscala%2Factors%2FScheduler.scala&new=16207

ちなみに、上記のソースも
Scheduler.impl = new SingleThreadedScheduler
をしなければ、動くはず。

java -Xss64M -cp scala-library.jarのパス:. Message 1000 1000
こちらではこれで動きますた

ちなみに
Scheduler.impl = new SingleThreadedScheduler
をしてる方
あと、デフォらしい -Xss512K では StackOverFlow しましたが
-Xss1024K なら大丈夫でした

>563
むむっ・・・本当ですね・・・
当方、環境変数JAVA_OPTSで設定していたつもりが、
なにか間違っていて設定が効いてなかったみたいです。orz

結局、単純に2.7.2でスタックの消費量が増えてたってことっすね・・・

>>551
本当にアマゾンで買えるのかなあ？
いまだに上がってない・・・
3月発売予定の達人のほうは上がっているのに・・・

まだみたいだね
http://www.amazon.com/dp/0981531601/

買えるようになったな

今日、やっと pattern matching の凄さを、下にある OCaml の 加減乗除算式を変形する
コード例で理解できました。

　http://www.ocaml-tutorial.org/ja/data_types_and_matching

pattern matching だけならば python でも近いことが実装できそうな気がしますが、「
Warning: this pattern-matching is not exhaustive.」と警告を出すことは不可能とし
か思えません。

でも OCaml ではライブラリの蓄積に限りがあります。本格的に OCaml をやるのは躊躇わ
れます。Scala の pattern matching でも OCaml と同等の「this pattern-matching
is not exhaustive.」警告を出してくれるのならば OCaml ではなく Scala に挑戦してみ
たいと思います。

Scala の pattern matching でも 「this pattern-matching is not exhaustive.」警告
を出してくれるのでしょうか？ 少し google しても、下のようなことも書かれています。

　http://lampsvn.epfl.ch/trac/scala/ticket/335

Scala の 「pattern-matching is not exhaustive.」警告について教えてくださいませ。

>>21を読めばいい

>>570 >>21を読めばいい

御指摘、ありがとうございます。

若干のバギーな面があるにしても OCaml に近い pattern matching 処理を scala でも書
けそうですね。

Scala に喰らい尽きたくて涎が出ています。ただ、scala に移ってくる programmer の割
合が心配です。Java programmer の殆どは scala には移ってこないだろうと思っていま
す。Python から scala に来る programmer の方が多そうに思えます。

>>571
誰がどこから移ってくるとかどうでもいい

どうでもいいと思ってるなら書かなきゃいいのに。
いちいち自分の興味ない話題に「どうでもいい」なんてレスしてたらキリないぞ。

「どうでもいい」厨にレスしなくていいよ。
どこにでもいるから。
専用ブラウザのあぼーんに設定しておけばそれで済む話

自意識が分相応なところに落ち着く前の年齢なんでしょ。

「この俺が、他ならぬこの俺が、どうでもいいと思った！
この話題自体はどうでもいいことだが、この俺がどうでもいいと思ったことは
なんとしても書き込まれねばならない重大ニュースだ！」

なんて中身の無いスレだ

Scalaでスカラ

珍しく書き込みが続いたと思ったらこれかよ

3っつもレスがつくなんて>>572も書き込んだかいがあったな

>>569 です。scala へ飛び込むための背中押しをお願いします。また Java は殆ど使って
いないので誤解があったら指摘してやってください。

Java の generics は C++ generics/python duck typing とは別物だと思います。実質
的には、collection に対する cast を省略するために導入された構文だと極論しても許
されると思います。

本来の generics programming は、method 構造の共用を利用したプログラムの共用だと
思います。例えば __add__ method と __len__ method が共用されている全てのインスタ
ンスについて、下のような平均ルーチンを共用できることが generics programming だと
思います

T mean(listOfT):
　　T tAt = 0
　　for elm in listOfT: # sum up loop
　　　　tAt = elm.__add__(tAt)

　　return tAt/len(listOfT)

この意味で C++ template と python duck typing は似ています。必要があれば boost
library をpython に移植できます。一方で boost library を Java に移植するなんて無
理だと思います。

------------------------------
ここで質問です。 scala の generics は Java と同じ／別物どちらでしょうか。
boost library などの C++ template program を scala に移植することは可能でしょう
か。

これが可能ならば scala に飛び込みます。よろしく教えてやってくださいませ。

Scalaやらないでいいよ。

>>580
書き方を見るに、C++ templateすらろくに理解してなさそうだけど
(boostをpythonに移植できるなんて簡単に言う辺りがそう。boostはC++
templateのメタプログラミング機能を利用した部分も多くあって、duck typing
があれば大丈夫程度の代物じゃないよ)
あえて言うと、ScalaのgenericsはJavaのgenericsのシステムがベースに
なっていて、かなり似てはいる。もちろん、Javaのgenericsには無い特徴も
多くあるけど。

>>569 です。ご意見ありがとうございます。

>書き方を見るに、C++ templateすらろくに理解してなさそうだけど
>(boostをpythonに移植できるなんて簡単に言う辺りがそう。boostはC++
>templateのメタプログラミング機能を利用した部分も多くあって、duck typing
>があれば大丈夫程度の代物じゃないよ)

同意します。boost は必要に迫られた範囲でしか追っていません。私の環境では、
boost に積極的に関わったら、周囲から浮き上がってしまうだけだからです。

「C++ のSTLを使ったプログラムを scala に移植できますでしょうか？」と話を狭めます。
STL を使っただけのプログラムなら、大部分は duck typing で対応させられます。でも
Java の generics では無理でしょう。


>もちろん、Javaのgenericsには無い特徴も多くあるけど

580 さんは、私よりずっと知っていそうです。できたら「Javaのgenericsには無い特徴」
で主要だと思われる数点をあげてもらえますでしょうか。

>>583
>>582では、筆が滑って偉そうな書き方になってしまった。申し訳無い。

＞「C++ のSTLを使ったプログラムを scala に移植できますでしょうか？」と話を狭めます。
＞STL を使っただけのプログラムなら、大部分は duck typing で対応させられます。でも
＞Java の generics では無理でしょう。

現在のJavaの標準ライブラリだと苦しいと思いますが、JavaでもSTL風のライブラリを
組めば近いことはできると思います(実際、STLを意識した設計のJavaコレクション
ライブラリがありました)。もちろん、STLの使われ方によっては難しい場合もあると
思いますが、一般的なケースでは十分可能ではないかと思います。

＞580 さんは、私よりずっと知っていそうです。できたら「Javaのgenericsには無い特徴」
＞で主要だと思われる数点をあげてもらえますでしょうか。

・genericsの共変/反変
詳しい説明は省きますが、Genericな型T[A]とT[B]があったときに、
A <: B(AがBのサブタイプである、と読む)ならばT[A] <: T[B]であるとき、
genericな型Tは共変である、といいます。その逆に、A <: BならばT[A] >: T[B]
であるとき、Tは反変である、といいます。具体例を出すと、ScalaのList型は
共変になっていて、List[Any]型の変数にList[String]やList[Int]を入れたり
することができます。このような機能はJava(やC++)にはありません(C++なら
templateを駆使した技巧によってあるいはできるかもしれないけど、素の
機能としては無いです)。

レスが長くなったので分割しました。

・structural type
いわば静的に型チェック可能なダックタイピングのようなもので、
例えば、
type A = { def hello: Unit }
とすると、A型は、Unitを返すhelloメソッドを持つ全ての型に適合するようになります。
この機能自体はgenericsに直接関係するわけじゃないですが、genericな型の
制約として、structural typeを使うことができるため、型パラメータTがhelloメソッド
を持っているべき、などの制約を表現することができます(いくつか実装上の
制約がありますが)。

・型パラメータのlower bound指定
Javaのgenericsでは、型パラメータTがある型のサブタイプであるべき、という制約は
表現できますが、Tがある型のスーパータイプであるべき、という制約は表現できません。
これは、上で書いた共変/反変の機能とセットで使うことで威力を発揮します。

他にもありますが、とりあえずこの辺で。

えー、Javaでも反変あるでしょ？
Scala特有なのはvariance annotationで自動的に共変なり反変なりになるところだと思う。

$ scala helloWorld.scala
/work/helloWorld.scala:1 error: not found: value println
println("hello, world!")
^
one error found

それからScalaのジェネリクスがC++とJavaのどちらと多くを共有しているかっていったら問答無用でJavaのほうだよ。
それでScalaやらないでC++やるっていうんだったら好きにすればいいと思う。
「C++にできてJavaにできない○○があるが、Scalaではどうか？」って聞いてくれればがんばって答えてみるかも。

>>586
ワイルドカードの下限境界の事言ってる？あれは「型を使う側」で明示的に指定しない
といけないという点で違うし、制限も強い。ワイルドカードに相当するのは、Scalaだと
Existential Typeだね。

いや、だから反変がJavaにはないっていうのは違うでしょ？

いや、A <: B => T[A] <: T[B]であるような、厳密な意味での反変はやはり無いと
言って良いと思う。Javaの場合、A <: B => T[A] <: T[? extends B]なわけだし。
ただまあ、誤解を招く書き方ではあったかもしれんとは思うけど。

すまん。共変と反変が逆になっとる。正しくは、以下。

いや、A <: B => T[B] <: T[A]であるような、厳密な意味での反変はやはり無いと
言って良いと思う。Javaの場合、A <: B => T[B] <: T[? super A]なわけだし。
ただまあ、誤解を招く書き方ではあったかもしれんとは思うけど。

>>569 です。582 さん、詳細に答えて下さり感謝します。

「Java の generics では、下のように extends を使う。デフォルトでは Object を継承
する」との説明を読んで、これは制限が強すぎると感じました。List, Vector, Map など
の素直なコレクション・ライブラリを記述するには型チェックが有効に働くでしょう。で
も使いもしないメソッドにまで型チェックが利いてしまうのでは、generic なライブラリ
を作るほうが大変だろうと推測していました。

　　public static <T extends Comparable<T>> boolean greater(T t1, T t2) {
　　　　return t1.compareTo(t2) > 0;
　　}

だからこそ、List(Any) と書けるようにしたのだと思います。


反変／共変は理解できていませんが、皆様の議論を見ていると scala では型チェックを
重視・活用しているように思えます。OCaml でのようにコンパイル段階でエラーを検出・
指摘することに拘っているのだろうと推測します。

Python duck typing のように、実行時にエラーを吐き出していたのでは、ビジネス用途
で使い物にならないのだと思います。C++ template でのように、大量の意味を掴みにく
いエラーメッセージを吐き出すことは、scala ではないのだと思います。

もうすこし調べてみます。ありがとうございました。

相対論スレかと思った

scalaを使うと並列処理がとても上手く書けると聞いた
そのメカニズムを教えてくれないか？

関数型だから？？

つ http://www.scala-lang.org/node/50

>>587
あえて print1n にしてエラーメッセージ出させるとうちの 2.7.2 final では
(fragment of HelloWorld.scala):1: error: not found: value print1n
print1n("Hello, world!")
^
one error found
!!!
discarding <script preamble>
となる
エラーメッセージ冒頭が違うのは何故？

なんか結局Java7にクロージャ入らないらしいので
結構本当にScalaの時代が到来するのではないか。

ないないw
エッジな人達はとっくに関数型に行ってるし
そうでない人にScalaは無理
下級兵士はこれからもJavaだよ

俺もScalaの時代が来るかについては否定的だけど
Javaな人に関数型の考え方を知ってもらう教材としてScalaは悪く無いと思う
適切なドキュメントさえあればScalaを学ぶのはそう難しいことではない

エッヂな人達って関数型に行ってもやっぱり実際に物作るのはC++とかスクリプトとかじゃないの？

エッチな人なので関数型言語でWEBクローラつくりました

>>599
RubyでいうRuby on Railsのようなキラーライブラリの爆発のようなもの必要だな

Liftはあるが、採用実績はまだこれからだ
Lift Web Framework: Home
http://demo.liftweb.net/

↓後はLiftのようなものを流行らせるなら、こういう記事がもっと増えて、
InfoQ: David Pollak氏 lift と Scala を語る
http://www.infoq.com/jp/news/2008/03/liftweb

さらにこういう本まで出版しないと
Amazon.co.jp： JavaからRubyへ ―マネージャのための実践移行ガイド: Bruce A. Tate, 角谷 信太郎: 本
http://www.amazon.co.jp/dp/4873113202
http://images-jp.amazon.com/images/P/4873113202.09.MZZZZZZZZZ.jpg

おれ自身はRuby好きだけど、静的の魅力も知っているとScalaにすごく期待したくなるわけだよ

liftよりWeb Flavorに期待してる。あと、WicketはJavaよりScalaの方が書き易そうな気がするんだ。

昔はEJBが駄目すぎたけど今や
生産性なんて言語やフレームワークでそんなに違うかって思う
それより絶対性能の高さや簡単に数十台規模のシステムを開発できる
フレームワークでも作ってくれた方がありがたい

>>601
Javaな人に関数型を知ってもらうなら、Groovyでどうよ？

>>606
実際は大して違わないんですよ。

それよりも大事なのは
10分でブログが作れます、的なアトラクションや
コードが少なくてすみます、的な表向きな利点（実際はテストコードてんこもりで大して変わらん）

他に・・・

何がいると思いますか？

>>607
Groovyは関数型の要素が少な過ぎると思う。無名関数くらいじゃない？
しかも、そのくらいなら今どきの言語のほとんどが持っている機能だし
それにGroovyは関数型的な(immutableな)データ構造を作成するのを助けてくれないよね
Scalaは関数型的なデータ構造を作りやすい構文になってるので、その点でもScalaの
方が良いと思う

「関数型的なデータ構造」なんて曖昧な言葉は使わずに、
「代数的データ構造」と言いましょう。

>>610
代数的データ構造と言っちゃうとかなり範囲を限定しちゃうでしょ
immutableなデータ構造全般を指すつもりで関数型的なデータ構造と書いた

コンストくらいしかないような

>>598
Ubuntuでsynapticから入れたんですけど、
エラーになるんです。

$ scala -version
Scala code runner version unknown version -- (c) 2002-2006 LAMP/EPFL

こんなになるんです。

2.3.0 のようです
ttp://ubuntuforums.org/showthread.php?t=662629
ちなみに Debian の Etch も 2.3.0

Java 系はプラットフォームを汚すことはめったにないので、
Scala ホームサイトから直落としでも良いかと
Debian の Java は GNU 系に力を入れてるんで、 Sun 系の
方はまだまだです

>>614
アドバイスありがとうございます。
tar落としてきてやってみたらうまくいきました。

http://neopythonic.blogspot.com/2008/11/scala.html

>>616
最初の学習曲線が厳しいようだ
私は Odersky の文章のまずさ (英語ネイティブでないのでしかたないのだが)
が最初にして最大の壁になるだろうな、と言語仕様を読んでて思ったが

>>617
俺は英語能力あまり無いのでOderskyの文章のどの辺がまずいのかあまり
よくわからんかったのだが、たとえば言語仕様のどの辺の文章？

どの辺というか、全体的に大ざっぱすぎたり専門的すぎたり、てか
書きぶりなどからして文章書いてる時間的余裕がなさげな感じ
明白なミスはほとんどないんだけど (616 紹介中の文章で can learning と
かあってわらたw)、肝心なところで何十回も読まないと何が言いたい
のか的を得なかったり、もっと簡単に言えるところを妙にまわりくどく
表現したり
まあさすがに数十回も読み直すうちに慣れましたが
(だから、例の本も当人が書くと知ってちょっと不安に思いますた、買う
予定ないけど)

私は、どうしてこういう機能や文法が必要なのか、
その説明が少ないんじゃないかなと思いました。
特に代数データタイプに通じてない人は
何が何やらさっぱり分からないんじゃないかと。
どうしてこういう形式を採用したのかが。

仕様書はどこでも大体そんなもんでしょう。By Exampleは読んだ？

http://www.scala-lang.org/node/143
も結構よんでいるから俺は全然問題ない。
ただこういうのを読まずに始めたい人、
代数データタイプの知識のない人、
そういう人への「解説」がない。

英語に文句を言う前に
「的を得ない」という間違った日本語を使わないようにしようぜ。

scalaの公式サイトに雪が降ってるじゃないか！

凄い！！

>621
てか、英語日本語ともネット上で読めるものはすべて読みました、でも結局、
622 さんの言うように、OCaml、Haskell さらにジョイン計算理論まで目を通した
上で読み返してはじめて得心しました
ちなみにそんな私の Scala 評価は、
増築しまくりな OCaml よりはすっきり
原理原則にこだわって常時遅延評価を意識する必要が (少なくとも使用初
期には) ある Haskell よりは気が楽
オブジェクト指向はジョイン計算の具現と知って納得
といった感じス

>>626
他の言語の仕様書(英語)は読んでみたことある？
俺はScalaの言語仕様の文章が特にわかりにくいとは感じなかったな。

>623
古来中国では「的を射ない」ことを「失鵠」とも表現していました (鵠 はこの場合的の
中心の黒丸のこと; 正鵠など)
だから「失う = 得ない」で「漢字の用法」としては必ずしも間違っておらず、事実厳密
な議論では「どちらも可」となっているようです
ただなるほど国語辞典などでは「的を射る」の方しか載ってないので、「普通の日本
語」としては「的を得ない」は非推奨、ということになるようです
実際には「的を得ない」の方がはるかに広く使われてるようですが

>>627
Java、ECMAScript と E4X をざっと
ほかは Scheme や Haskell などは日本語訳でだけス
てか、これらの文章が良すぎだったのかな？

>>629
PrologのISO規格書が面白いのではないか。スタックモデルで説明している。
BNFも併記されてたと思うけど。

Prolog は、MSX のころに 98 用 BASIC で記述されたミニマム Prolog を移植して
ちょっと遊んで以来
ちなみに自分初の処理系移植実装な経験 (懐
もしかして誤解されてるかもですが、別に言語仕様マニアではなく、Scala では
チュートリアルでも ByExample でも「全体像」がさっぱり会得できなくてしかたな
く言語仕様にトライするしかなかっただけなのでス

まあ少しずつやっていきなよ。

>>628
漱石枕流乙

ジョイン計算理論って何よ

>>634
たぶんJoin-calculus
http://en.wikipedia.org/wiki/Join-calculus
のことだと思う。全然知らないけど、分散計算の形式的な計算モデルの一つらしい

>>634
ラムダ計算を並行性の観点から鍛え直したのがパイ計算
ttp://web.yl.is.s.u-tokyo.ac.jp/kobalab/kadai99/picalc.html
で、それにさらに場所階層性を導入したのがジョイン計算
ttp://jijixi.azito.com/cgi-bin/diary/index.rb?date=20070531
(すごい分かりやすい pdf があったけどパスワード封鎖されたようで、
現状で日本語での記事はこの程度しか見あたらず、2 項目の JoCaml
の部分)
ちなみに OCaml から JoCaml を作る過程で練り上げられた理論っぽい

なるほど
Scalaのどの辺がそれに基づいてるの

「Scala開眼」を書いた人がこの中にいるな

>>637
Scala.Actorsとか。
こういうのは仕様書やライブラリのAPI見れば分かる話じゃないよ。
知っているのと知らないのでは理解の速度が全然違うし、
モデルの把握もしやすくなる。

>>626の言うようにScalaはいろいろといいところがあるんだけど、
解説文が少なくてあまり理解されてないと思う。
まあ>>622にある論文読めばいいんだけどw

Scala のオブジェクト指向導入は ML 系からのアバウトな逸脱ではなく、ジョイン
計算の場所階層性 (プロセスは「場所」に属し、チャネルはその場所階層を上
位へとさかのぼりつつ目的のプロセスを検索する) をクラス階層と解釈しての
きちんとした理論を背景とするものである、ということ
これで何がうれしいかというと、プログラムの実行時エラー皆無性が計算で事
前に証明可能になる、つまり静的型のエラー回避性が動的結合にも延長でき
るようになる
ということらしい

> つまり静的型のエラー回避性が動的結合にも延長できるようになる

面白そうですが、今の型システムで回避できなくて、join計算で回避できる
ようなエラーってどういうもの？

先の今は見れない pdf では純粋にプロセス間通信に限ればそこにおける
予期せぬエラーが理論上ゼロとなることを証明してました 、たしか
むろん、ハードのエラーとかプロセス間通信以外に起因するエラーは回避
不能なはずですが
ちなみに、パイ計算の方はたしか理論上どうしても無限回帰になってしま
う場合があったはず (非理論的なメタ制約を与えれば回避できるようですが)

>>639
Actorとπは別もんだろー。

Scalaのpattern matchingは、
Join calculusとの関係が深いです。例えば、
ALGEBRAIC PATTERN MATCHING IN JOIN CALCULUS
http://arxiv.org/pdf/0802.4018
そのpattern matchingを使えば、
多くの並列計算モデルが、
「ライブラリとして」実装できるというのが、
Scalaの核の一つです。
Scala.Actorsはその実装の一つで、
ライブラリのソースも公開されています。
ちなみにお父さん言語のFunnelでは、
もっとJoin calculus丸出しの文法でした。

【Programing in Scala】ついに届いた(笑)

自主学習進みすぎて、最早入門書は要らないんだがな・・

ついに購入者が！！
どこで注文したの？

>>646
Artimaのサイトで9月くらいから予約済

2.7.3 RC1
http://www.scala-lang.org/node/417
はやっ

ちゃんと日本にも発送してくれるんだ
かなり待たされたね

で、結局Amazon.co.jpではいつまでたっても買えないんだろうか？？

Scalaで実行時にScalaのソースファイルをコンパイルして
出来たクラスのメソッドをリフレクションで実行したい時ってどんな風に書く？

>>624
ほっとくとめっちゃCPU食うよ
職場着いたら部屋が微妙に暖かかった…

プログラミングしりとり
http://schiphol.2ch.net/test/read.cgi/575/1010948472/l50

>>650
Scala コンパイラソースの
scala/tools/nsc/Interpreter.java interpret メソッド (475 - 520 行)
427 - 432 には compileSources、437 - 438 には compileString なんてメソッドも
ただし当然 scala-compiler.jar もクラスパス組み込みのこと

あと、883 - 898 の loadAndRun: メソッドで名前どおりリフレクションロード & 実行

>>653-654
thx!

http://www.ibm.com/developerworks/jp/java/library/j-scala04298.html
＞trait が実際にクラスの一部として組み込まれるまで
＞trait の振る舞いの定義はチェックされません。
＞あるいは別の言い方をすれば、trait を使用するクラス定義の中に
＞組み込まれるまで適切さをチェックされないメソッドを定義することができます。

これはどういう意味か教えてください

あとclassに出来てtraitに出来ないことってnewだけで、
他は何でも出来るという理解でいいのでしょうか

「late binding」ってことだけど。
C++0xだとtemplate/conceptで使うlate_checkってキーワードが増えてます。
これがないと、

> あとclassに出来てtraitに出来ないことってnewだけで、
> 他は何でも出来るという理解でいいのでしょうか

となって全く使えない。

ibm.comが調子悪かったからみれなかったけど、
具体例でちゃんと説明書いてあるじゃん。
良く読みこなそう！

C++はブロックごとに指定。

template <Semigroup T>
T add(T lhs, T rhs)
{
return x + y; // Semigroup<T>::operator+
}

template <Semigroup T>
T add(T lhs, T rhs)
{
late_check {
return x + y; // class Tのoperator+
}
}

C++ 0xのlate_checkはコンセプトじゃなくて
生成したソースコードで判断するというものですよね
traitはそれに近いようなことをやってるということですか？

具体的にどういうコードを書けば遅延バインディングされるんですか？

http://www.ibm.com/developerworks/jp/java/library/j-scala04298.html
のどの部分が分からないの?

>>660
＞trait が実際にクラスの一部として組み込まれるまで
＞trait の振る舞いの定義はチェックされません。
＞あるいは別の言い方をすれば、trait を使用するクラス定義の中に
＞組み込まれるまで適切さをチェックされないメソッドを定義することができます。

この文章以外は分かりました
traitのメソッドでも定義されていない変数なんかを使えば普通にコンパイルエラーになるので
適切さをチェックされないメソッドというのがどんなものなのかが分からないのです

trait 中の定義は、実際にはそれを実装するクラスか、あるいはスーパークラス
内のプライベートメンバとしてその本体は別名定義され、trait 中のシグネチャが
それにアクセスするゲッタセッタの形になります
また、trait からはそれが指定される位置以前のほかの trait などの名前が見え
るようになっています。このため、指定順を入れ替えると動作が変わることもあ
りえます

>>661
Orderd[A]の例だと
def compare(that: A): Int
の定義の存在はチェックされずに、Ordered[A]をコンパイルできます。
Object withするまで定義の存在はチェックされないわけです。
宣言の正当性はチェックされているのですが。

scala.xml.NodeSeqの\\メソッドでXPath式っぽいのをかけるけど
これXPathにしなかったのはなんでだろう。
素直にXPathが使えればもっと簡潔にかけるのに。
あと属性のパターンマッチできないのも中途半端。これは属性定義が順序をもたないからだろうか？

>>662-663
なるほどありがとうございます

XPathを完全に実装しようとおもったらノードの構造をZipperとかにしないといけなくなる。

本家サイトで XML の鉄人の参加を募集してることからして、そっちの方は
まだ十分にカバーできてないっぽい感じ

>>666はよく考えたら違うな。
XPathをフル実装してかつ不変な構造にしたかったら、だな。
なんか関数型言語脳になってきたのかもしれん。

Scala 2.7.3 RC2 キタ！

2.7.3 finalｷﾀ

なんかliftのMLでもmartin oderskyがXMLライブラリメンテナの勧誘活動してたけどそんなに深刻なんかいな。
ScalaチームでXMLの研究してた人1人しかいなかったの？

XMLまわりは下手に言語仕様に組み込むより、XSLをDSLとして扱えるとかでよくね？
今の仕様がいけてるとは思えん。中途半端な独自仕様はかんべん。

「言語仕様」と書いたのは誤解をうけそうだけど、そのへんニュアンスで。

>>671
最近、YAMLやJSONに人が流れてませんかね。
下手すりゃXMLはSGML, ASN.1の後を追うことになっちゃう。
XHTML→HTML5って流れもあるし。

無知乙。HTML5はXHTMLでもある

XMLでないHTMLは4で打ち止めでXHTMLオンリーのはず(by w3c)だったのに、
WHATWGが立ち上がって、W3Cの方向性を変えたんだよ。
詳しくは↓あたりを読んでね。
http://www.html5.jp/trans/whatwg_html5faq.html#What_is_the_WHATWG.3F

well-formedでないHTML排除は延期された。永遠に延期かもしれない。

XMLって立ち上がりの時期はいけすかない感じだったけど
なんだかんだでスキーマとか数学的基礎とか処理効率とかについて
頭のいい人たちの研究が蓄積されてるんじゃないの？
それが流行でYAMLやJSONに置き換わるっていうとなんかもったいないなあ。

XMLが苦もなく扱える人なら、Lispで事足りるんじゃないだろうか。

>>676
そのドキュメントにもXHTMLシリアライゼーションのこと書いてあるだろ
HTML5でXHTMLが消える訳じゃない。XHTMLの未来もHTML5なんだよ
残念ながらXHTML2.0に希望はない

span.xxsmall {font-size: xx-small; }
<span class="xxsmall">XHTMLの将来</span>

Programming Scalaってサブタイトルにマルチコア云々って書いてある割にページ数は少なそう

amazon.co.jpでProgramming in Scalaが注文できるようになってるね。
在庫切れになってるけどカートには入れられる。

すから↑
スカ↑ラ（ドラクエ風）

アクセントはどこよ

どうでも良いことだが、俺にとってのドラクエ風はス↑カ↓ラ↓

ス↓カ↑ラ↑といえばラ・スカーラ。
まだ「ディスコ」と言われていた時代だ。

Odersky 氏が「スケイラでも可」のようなことを言ってたビデオがあったから、
スカ↑ラの方かと

スカラはイギリス的
スケイラはアメリカ的
スカイラはオーストラリア的

ｓｃアァは日本的

Scala初心者なんですけど
val a = List(1,2,3,4)

とした後

a.foreach( println( _ ) )
a.foreach( x => println( x + 3) )

はエラーにならないのに

a.foreach( println( _ + 3 ))

はエラーになります。どうしてですか？

a.foreach( println( x => x + 3 ) ) 
と展開さえてエラーになってるみたいだね。
理由や原理は分からないけど。

expanded functionなんたらっていうエラーメッセージはそういう意味なんですか。
この略記法みたいのは、展開のしくみがよくわからないから複雑なのには自重しときますか。
ありがとうございました。

　_ を使った式ががprintlnに対して展開されてるってことですね。foreachではなく。
そう考えるとa.foreach(println(_))はよくforeachに対して展開されてますね。

どう展開されるかはコンパイラの気分次第ってことか？

println( _ + 3 ) は「+ 3」を解決するために _ を評価しなければならなくなる
からでわ？
println( _ ) だと println を評価するまで _ の評価を遅延できるのに対して

_が予約語ってどうなの？
困らない？

_ 単独で変数名とかクラス名にするやつがいるとは思えないんだが。

_の正確な意味を知るにはScala言語仕様の6.23 Anonymous Functionの
Placeholder Syntaxを読むのが良いと思う。特に英語圏のブログでScala
やってる人が多用してる気がするけど、正確な意味を解説した記事ってないんだよな。

不正確だけどおおざっぱな説明としては、_を囲む最も内側の式が無名関数化される。
だから、println(_)だと、(x) => println(x)になるけど(_を囲む一番内側の式がprintln(_)
だから)、println(_ + 3)はprintln((x) => x + 3)になる(_を囲む一番内側の式が_ + 3だから)
あと、無名関数化される式はsyntactic category(文法定義上の非終端記号みたいなもの)が
Exprである必要がある。

基本的に、_がどう展開されるかは純粋に構文的に決まり、型とかは一切関係しない。

println((_)) とかやると内側の括弧で阻害できるのか？

>>698
試してみるとわかるけど、それはできない。
仕様書にはproperly containsという文言があるんだけど
単に式を囲む(_)は構文解析で_と同じになっちゃって、
(_) properly contains _とはみなされないということだと思う。

>>697
おお、わかりやすい説明ありがとう。
それでちっとまた実験してみた。

val a = List(1,2,3,4);

a.map( x => x)
はエラーにならないけど

a.map( _ )
はエラーになった。

この場合は
a.map( _ + 3)
にするとエラーにならない。
なるほど。

酔っぱらっているので一つだけ。(>>697の括弧が構文解析できないレベル)
Scalaの_は、C++のboost/bind.hppの_1, _2, _3から来ているんだと思う。
>>697が解説してくれているけどそっくり。おやすみ

しかし算術式はなにかとくべつなのかな？

a.filter( 2 < 1 + _ )

はエラーにならない。
1 + _ が最も内側の式ではなく　2 < 1 + _を最も内側の式と見てくれる。

でも
a.filter( (2).<( 1 + _　) 　)

だと1 + _　を最も内側の式と見てエラーになる。

2 < 3 は (2).<(3)と同じことだと読んだような気がするけど 、上の場合は挙動が違う。

あ、でも

a.filter( 2 < 1 + _　)
はエラーにならないけど

a.filter( 2 < (1 + _ )　)
はエラーになる。
この場合は ( 1 + _ )が最も内側の式とみなされるから。

明示的にかっこでくくちゃうと、そこでもっとも内側の式とみなされるけど
演算子の優先順位のためにかっこがいらなければセーフなのか。

ただし明示的な括弧といっても ( _ )は意味がないl。　_ とおなじ。
それ以外の場合は括弧の段階で一番内側の式とみなされる。

>>701
>>702
その辺の挙動は、>>697で最後にさらっと書いたsyntactic categoryというのが絡んでくる。
>>697では最も内側の式という風に書いたけど、実はもうちょっと正確に言うと、もっとも内側で、
syntactic categoryがExprの式が無名関数化される。

まず、
a.filter(2 < 1 + _)
についてだが、1 + _の部分だけではInfixExprとみなされる。その外側の
2 < 1 + _も同じくInfixExprだが、メソッド呼び出しの引数の位置に来ることによって
Exprに昇格(適当にでっち上げた用語だが)し、結果として、2 < 1 + _が(x) => (2 < 1 + _)
のように無名関数化される。

a.filter( (2).<( 1 + _　) 　)

については、1 + _は同様にInfixExprだが、メソッド呼び出し引数の括弧の位置に
現れたことによって、Exprに昇格してしまう。そのため、1 + _が無名関数化される。

a.filter( 2 < (1 + _ )　)

でも、やはり1 + _はInfixExprだが、式をグルーピングする括弧があることによって、
Exprに昇格してしまう。そのため、1 + _が無名関数化される。

_はどのくらい強いの？
括弧以外は突き抜けられるぐらい強いの？

>>707
基本的にはメソッド呼び出しの引数の括弧 or 式のグルーピングの括弧が区切りになっているという
認識で良いと思う。あとは、使っているとなんとなくわかるようになってくる感じ。上では言語仕様の
記述を元に挙動を説明したけど、そこまで知っていなくてもまあだいじょうぶだと思う。

>>706
697さん、詳しくわかりやすくどうもありがとう！
すっきりして寝れます。

amazon.co.jpの洋書でScala本、ただいま在庫切れだけど注文できるようになってて人気がすごいぞ。

http://www.amazon.co.jp/Programming-Scala-Comprehensive-Step-step/dp/0981531601/ref=sr_1_2?ie=UTF8&s=english-books&qid=1233803774&sr=1-2

Amazon.co.jp ランキング: 洋書 - 455位 (洋書のベストセラーを見る)
各カテゴリー内でのランキング：

1位 ─ 洋書 > Computers & Internet > Programming > Java
2位 ─ 洋書 > Computers & Internet > Programming > Software Design, Testing & Engineering > Object-Oriented Design
2位 ─ 洋書 > Computers & Internet > Programming > Languages & Tools

すげー！

>>710
米国での期待の大きさが現れてる。同時に、
Haskellの棺桶の釘を打つ音でもある。

そういう二者選択は馬鹿げてると思うよ。

>>712
あくまで、米国のソフトウェア界のはなし。

> 米国のソフトウェア界

藁

>>712
洋書を買うのは物好きだけだろjk

現在のランク：
6位 ─ 洋書 > Computers & Internet > Programming > Software Design, Testing & Engineering > Object-Oriented Design
8位 ─ 洋書 > Computers & Internet > Programming > Java
28位 ─ 洋書 > Computers & Internet > Programming > Languages & Tools

日本での順位に米国の話をレスとしたのがまちがい。>>711は撤回します。

ScalaにJavaみたいなenumないのですか？

Enumerationってのがあるみたいなのですが

object Main extends Application {

　　 object WeekDays extends Enumeration {
　　　　val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value
　　}

　　def isWorkingDay(d: WeekDays.Value) =
　　　　 ! (d == WeekDays.Sat || d == WeekDays.Sun)

　　 WeekDays filter (isWorkingDay) foreach { d => Console.println(d) }
}



printlnでの出力もMain$WeekDays(4)という形式です。
JavaのenumだったらFriとかよみやすい値です。メンバを加えたりもできました。

Javaのenum使えないのですか？

多少コード量が増えるけど、

http://blogtrader.net/page/dcaoyuan/entry/erlang_plugin_for_netbeans_in
を参考にして、Weekdaysにメンバを追加するか、

abstract sealed class Weekdays
object Weekdays {
case object Mon extends Weekdays
case object Tue extends Weekdays
case object Wed extends Weekdays
case object Thu extends Weekdays
case object Fri extends Weekdays
case object Sat extends Weekdays
case object Sun extends Weekdays
}
val x: Weekdays = Weekdays.Mon
println(x) //Mon
のようにして、case objectを使う手段がある。

>>718

ブログのよりあなたのやり方のほうがJavaのenumっぽいですよね。
実質、個々のenum値が独自クラスのシングルトンになってるあたり。
でもJavaの場合はコンパイラが自動的にやってくれるので短く書けるけどScalaだとちょっと面倒ですね。
使いようによってはcase classのぶん便利なこともあるのかな。
ちょっと気になって質問したので、具体的にどう使うか目的があって質問したわけじゃないけど。

詳しくどうもありがとうございました。

enumにメソッド追加ってかなりJava独自じゃないですか？
必要ない気がするんですけどJavaラーは活用してるんですかね。

２版のEffective Javaに活用した例があっておもしらかった記憶があるけど
自分自身はつかったことない。

enumのメソッド追加は便利。
ステートパターンが書きやすい。

メモリ効率を重視する必要がある時に使ってる。
自分でナンバリングして整数型で扱うよりずっと型は強い。

Scalaって実際どんな時に使うもんなんでしょ。
Javaだとサーバーサイドでしか使えないイメージがあるけど・・・
みんな基幹とか、webサービスのサーバー側に使ってたりするのかな？
webフレームワークはleftくらいしか見かけないけど

>>724
先入観で凝り固まりたいように見える

>>725
うーん、実際の話をしているんですが、どうなんでしょうか？

>>724
> Javaだとサーバーサイドでしか使えないイメージがあるけど・・・

こういう人に答えても仕方ないしね。

煽りを聞きたいのではないのですが・・・

そもそもScalaがJavaで書かれているのに、
サーバーサイドしか使えないってw

>>724

スレの上の方でも議論があるけど、π計算の延長上にある言語だから
ＳＯＡとかメチャ無茶やりやすいぞ。

デスクトップクライアントが作りたいならSwingでやればいい
SwingがPoorで嫌だと言うのであれば、3月まで待って、Qt4.5(LGPL)を使いなさん

>>729
＞そもそもScalaがJavaで書かれているのに、
あんまりいい表現じゃないな・・・

>>724
liftだろ

というかソース見ればわかるけど、今のScalaはScalaで書かれてる。
1.XのときはJavaで書かれてたらしいけどね。

Scala をコンパイルするための Scala をコンパイルするための・・・

なに！ScalaはJVMで動作するのか！？
無駄スグルwww 一体何のために。。。

無知すぎるwww

JVMつながりと言えば、Clojureのスレがないな……。
まぁS式嫌いなのでどうでもいいが。

ありがとうございます。
>>733 を見てうやむやが氷解しました。

Scalaを書くためのScala。
何か関数言語的な美しいひびきを感じます。
使う気がしてきました。

+ や * はメソッドだって聞いたけど、
2 + 3 * 4 は 14ってちゃんと評価してくれるんだね
メソッドチェーンになるから、20が戻ってくると思った

これって遅延評価のおかげ？
Scalaのソースをちゃんと読まないといけないんだろうけど

+や*がメソッドだというのは間違ってないけど、中置式のメソッド呼び出しに
関しては、演算子の最初の1文字で優先順位が決まるというルールになってる。
このルールのおかげで、算術式に関しては直感的な動作をしてくれる。
Scala言語仕様6.12.3 Infix Operationsによると、優先順位は以下のようになってる。

letter ＜ '|' ＜ '^' ＜ '&' ＜ '<', '>' ＜ '=', '!' ＜ ':' ＜ '+', '*' ＜ '/', '%' ＜ all other special characters

たとえば、

"HOGE" charAt 0 + 1

という式があった場合、charAtの最初の文字はletterなので、+よりも演算子としての優先順位は低い。
そのため、

"HOGE".charAt((0).+(1))

と解釈される。

訂正。s/letter/all letters/

ありゃりゃ。コピペして不等号加えるときにミスったorz
正しくは、以下。

all letters ＜ '|' ＜ '^' ＜ '&' ＜ '<', '>' ＜ '=', '!' ＜ ':' ＜ '+', '-' ＜ '*', '/', '%' ＜ all other special characters

>>740
サンクス

BigDecimalでも試したけど、ちゃんと掛け算・割り算を優先するってありがたいな
RemoteActorの動作がいまいちわからなかったり(コンパイルした後、scalaコマンドで動かないのに、javaコマンドからだったらちゃんと動くとか)
わからんことだらけなんだけど、しばらく弄ってみることにする

RemoteActorっていったら、
メッセージ送った分だけヒープが貯まっていくのな・・

Asyncで(actor ! msg な)メッセージ送ると、反応しないことが多々ある
インタプリタで使う限りは問題ににならないけど、コンパイルした途端にダメ・・

ありえねぇ･･･(;´Д`)

>>774
まさかとおもってやってみたら、思い切りOutOfMemoryしやがった(笑)

java.lang.OutOfMemoryError: Java heap space
at java.lang.Class.getDeclaredMethods0(Native Method)
at java.lang.Class.privateGetDeclaredMethods(Unknown Source)
at java.lang.Class.getDeclaredMethod(Unknown Source)
at java.io.ObjectStreamClass.getPrivateMethod(Unknown Source)
at java.io.ObjectStreamClass.access$1700(Unknown Source)
at java.io.ObjectStreamClass$2.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.io.ObjectStreamClass.<init>(Unknown Source)
at java.io.ObjectStreamClass.lookup(Unknown Source)
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
at java.io.ObjectOutputStream.defaultWriteFields(Unknown Source)
at java.io.ObjectOutputStream.writeSerialData(Unknown Source)
at java.io.ObjectOutputStream.writeOrdinaryObject(Unknown Source)
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
at java.io.ObjectOutputStream.defaultWriteFields(Unknown Source)
at java.io.ObjectOutputStream.writeSerialData(Unknown Source)

（続き）
at java.io.ObjectOutputStream.writeOrdinaryObject(Unknown Source)
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
at java.io.ObjectOutputStream.defaultWriteFields(Unknown Source)
at java.io.ObjectOutputStream.writeSerialData(Unknown Source)
at java.io.ObjectOutputStream.writeOrdinaryObject(Unknown Source)
at java.io.ObjectOutputStream.writeObject0(Unknown Source)
at java.io.ObjectOutputStream.writeObject(Unknown Source)
at scala.actors.remote.JavaSerializer.serialize(JavaSerializer.scala:37)
at scala.actors.remote.NetKernel.sendToNode(NetKernel.scala:32)
at scala.actors.remote.NetKernel.namedSend(NetKernel.scala:39)
at scala.actors.remote.NetKernel.forward(NetKernel.scala:71)
at scala.actors.remote.DelegateActor$$anonfun$act$1$$anonfun$apply$1.apply(Proxy.scala:168)
at scala.actors.remote.DelegateActor$$anonfun$act$1$$anonfun$apply$1.apply(Proxy.scala:125)
at scala.actors.Reaction.run(Reaction.scala:78)
at scala.actors.Scheduler$$anon$2.run(Scheduler.scala:77)
at scala.actors.FJTaskRunner.run(Unknown Source)

>>744 ですた(苦笑)

うーん、こういう不具合が未だにActor周りがver 1.0 にならない理由なのかな
2.7.2ではメモリーリークの不具合があったっていうし

初学者にやさしい100〜500行くらいで書けるようなお題くれ

つ「正規表現マッチャ」
http://www.oreilly.co.jp/editors/archives/Btfl_Cd_01.pdf
http://www.oreilly.co.jp/editors/archives/000158.html

>>748
% 問題・・９時台から１６時台(17時閉店)までの勤務表を作れ。
%
% 勤務表は1時間単位とする。
% 要員はAya、Koh、Sho の３名である。
% 最小勤務単位は２時間であり、一時間だけの勤務は認められない。
% 一人勤務は１時間までであり、もし一人勤務に就いたときは
% 次の少なくとも1時間は勤務につけない。
% 以下の時間は、それぞれ用事があり、勤務できない
% Aya・・１４時台、Koh・・１１時台と１４時台、Sho・・９時台と１１時台。

OreillyやAPressもScala本を出すみたいだね

http://oreilly.com/catalog/9780596157746/index.html#top
http://www.apress.com/book/view/9781430219897

Oreillyのほうは、Twitterの中の人が書いて
Apressのほうは、Liftの中の人が書いてるみたいです

>>737
Clojureは人口が少ないからね。scalaよりは。スレを作ってもarcスレみたいになりそう。
ircとgoogle groupをみてると盛りあがってるんだがね。
ScalaとClojureはライバル関係みたいだがなぁ。

ところでScalaでどのくらいの人口なの？

clojureやarcは「yet another my own Lisp」でしょ。
面白いところはあるけど、Scalaとは無縁。

>>753
調べた上でそういってるなら正しいが

仮に調べてなくても正しいものは正しい。

>>755
それは率直にいうと頭が悪いな

>>753が間違っていると思う人は根拠を言ってみれば?
Scalaは静的な言語ですが、clojureやarcはそうではありません。
clojureなんて動的馬鹿といっていいような仕様です。
型システムや関数/メソッド呼び出しも全然違います。
OCaml辺りの方がずっとずっと近いです。

clojureやarcはLisp SchemeスレかARCスレがあるし、
ココで語る意味のある言語とは思えん。

Lift 1.0が出たとか

>>758
出ましたね。
APIドキュメントとか、Lyxで書いたドキュメントはいまいち整っていませんが・・

Terracottaの中の人(Scala OTPの作者)が、QCon Londonで発表するスライドも
SlideShareにupされています　
ttp://www.slideshare.net/jboner/pragmatic-real-world-scala-45-min-presentation

>>757
最近見かけたのは、 scala と clojureの共通点は java VM上の言語だってことだが
それだけじゃなくて、並列処理のことが念頭にあるみたいなのね。だからその並列処理
の考えかたの違いもあって、どっちが。。。みたいなことが話題として出てきてる。

だから、無縁だと考えるのは視点の違いから来てるね。悪いけど>>757は視野が狭いとしか
思えないね。言語の系統を語ってるだけなら無縁だからね。だから、言ってることはもっと
もなことを言ってるし、そこでライバル関係だとは誰も言わないだろう。

もっとも、たまたま、>>737で話題になって>>752で答えたにすぎないし、
対立を煽ったり、>>752や>>757にあるように、他の言語をどこか馬鹿にするようなことも
言う気はないよ。

>>761
>>752じゃなくて>>753だね。
おまけとして、
http://japan.internet.com/column/developer/20090224/26.html
でもみればいいよ。

> あるみたいなのね
こういうの勘弁

マギー司郎の声でよめば大丈夫だ

ScalaはJava互換あるし、第一言語がJavaで、
Haskellもちょっとだけかじった俺なら余裕だろと思ったら、
Listのインスタンス化に2時間ハマったぞWWWWWWWW
ArrayListをnewしようとちょっとずつ構文変えて頑張ってた健気な俺涙目WWWWWWWWW

ていうか巷のブログ書いてるやつら、動くコード書いてくれよWWWW
断片だけじゃわからないからWWWWWWWWW
コンパイルする身にもなれってのWWWWWWWWWWWWWW

マニュアル嫁

Haskellかじったらリストのインスタンス化思い当たるんじゃん

>>765
ScalaByExample和訳
ttp://www29.atwiki.jp/tmiya/pages/23.html

リストのインスタンス化で2時間悩むとか、プログラム初心者ならともかく、どうかしてるだろ
Scala Listでぐぐって出てくる最初のページにすら、やり方出てくるぞ。

こういうのを書きたかったんだ
List<File> list = new ArrayList<File>();

で、ググってでてくるのかね？

ああ、すまん。Javaの方のListを作りたかったわけね。それなら、Listでぐぐっても
出てこないわ(それだと、ScalaのListが出てくるし)。調べるべきは、Listの作り方じゃなくて、
ScalaでのGenericsの使い方の方だったね。Scala Genericsでぐぐれば、色々出てくる。

var list = new ArrayList[File]

コレクションは特別な理由がない限りScalaライブラリのを使ったほうがいいとおもうけどなあ。

関数型言語について勉強中の者です。

関数型言語らしいプログラムの書き方ってどういうのを言うんでしょうか?
「リスト」を最初に作り、それに関数を適用して行くという形式で行くのが大事そうだ、というのは解りました。

ただ、これを読んでかえって解らなくなってしまいました。

刺激を求める技術者に捧げるScala講座---目次：ITpro
第7回 関数脳のつくり方　First Season
ttp://itpro.nikkeibp.co.jp/article/COLUMN/20090224/325385/?ST=develop

これを書いている人はなんか理解したようなのですが、読んでもちっとも解りません。
特に
ttp://itpro.nikkeibp.co.jp/article/COLUMN/20090224/325385/?ST=develop&P=6
>しかし，オブジェクトの技術を使わず，純粋に手続きで考えてみたのですが，頭がパニックになりそうでした。
>最初のNode(XMLタグ)を取得して，その子要素をとってループをまわす。
>その子要素がDirの場合は，childでさらにその子要素をとってループを回す。
>Fileの場合は中身のファイル名を表示する。Dirの子要素にまたDirが含まれていたら，さらにchildを適用して…。

このあたり。
手続きだって再帰すればすぐだと思うのですが。
手続きって言った場合、再帰は含まないのでしょうか?

駄文読まずに>>8のチュートリアル翻訳版読めば？

>>773
その文章、体裁はともかく内容としては
人に何かを説明することを目的として書かれたという感じがしない。
自分の頭を自分なりに整理してみただけの感想文という感じ。

ScalaってJavaで作られた過去の遺産をそのまま使えるという点では素晴らしいけどさ
Scala使うなら関数型の技法を習得必要があるじゃん

だってScalaでJavaの書き方使うってんなら、Scala使う意味がないんだもん

大変残念だけど日本のほとんどのシステム開発の現場では採用されないだろうね
先鋭的な技術会社なら別だけど

>>776
> Scala使うなら関数型の技法を習得必要があるじゃん

scalaを学べば十分

だからScalaを習得するってことは関数型言語を習得するってことと同義だろ？

Scala使って関数型言語のメリットを利用しないってのは意味がない
Javaだけ使ってればいいんだから
学習コスト高すぎってことだ

リストを使うっていうよりは一般的に副作用を最小化する心がけを持つといいんじゃないかな。
そして副作用のないコレクションの代表選手がリストなのでリストはよくつかわれる。
その記事で何を手続き的として想定してるかはわかんないけど、同じ再帰を使うのでも、
たとえばツリー構造からある条件で抽出するときに、
「結果を格納する変更可能なコレクションを用意しておいて再帰しながらその入れ物に追加していく」だとかなり手続き的だけど、
「再帰呼び出ししながら戻り値であるリストの和集合をとっていく」だとちょっと関数的になる、みたいな。

scalaって関数型にしては癖が強いと思うよ。それはjavaを使った人向けに作られた
関数型言語でもあるからだよ。

日本で採用されるかどうかってのは、海外で普及して権威付けされるかどうかでしょ。
右に習えしか出来ないんだからね。先陣を切ってやるような多少？のリスクを背負っ
て進めるようなところはないだろうから。まだ、ベンチャーが育つ土壌があるならば、
可能性はあると思うが、海外で普及したあとの2、3年まちってところではないかな。

並列プログラミングが重要さを増せば変わってくると思う。

学習コストは手続き型しか知らないような人にとってみれば未知への恐怖というコスト
が高いと思うが、基本的なところは然程難しくないと思うよ。この手の事で保守的な
ことを言って無理だと言う人って、一般的に融通が利かない人の傾向があるよ。そんな
人が多いんかなぁ。プログラマってひとたちは。。。

javaプログラマ向けの関数型言語になってるから学習コストはさほど高くないと思うんだが。

>>778
全然そうは思わない。ScalaはScala、関数型言語ではない。

>>780
>>782
Scalaと関数型言語の特性については無知だったようですまねぇ

でもね、俺みたいな2次請け3次請けで働いてるプログラマってプログラマの多数派なわけじゃん
そんな多数派の「現場」ではRubyすら使われる気配がないし、ましてや関数型言語なんて採用されるわけがない
ってことを言いたかっただけなんだが

>>783
ごめん。言いすぎた。
言うようになかなか採用されないと思ってるよ。

Scalaは関数型言語ではなくて、
関数型言語の機能、特徴[も]兼ね備えている言語。
今では特に珍しいことではない。

http://www.scala-lang.org/node/25
Introducing Scala
> It smoothly integrates features of object-oriented and functional
languages

http://www.scala-lang.org/node/1305#Func
Learning Scala
> If you come to Scala with a functional programming background
> you will find most of the more advanced functional programming
style familiar.

http://www.scala-lang.org/node/959
Book "Programming Scala"
> "Programming Scala" will show you the fundamentals of functional programming using Scala.

ちょっと件のページのデータを踏襲した例を作ってみた。
まずこれは再帰を使ってるけど手続きっぽいでしょ。resultが順次更新されていくから。

import scala.xml._
import scala.collection.mutable._

val result = new ArrayBuffer[Node]
def find1(node: Node)(pred: Node => Boolean): Unit = {
if (pred(node)) result += node
for (child <- node.child) find1(child)(pred)
}
find1(xml) { case <file>{_*}</file> => true; case _ => false }

こうするとちょっと関数型っぽくなる。

def find2(node: Node)(pred: Node => Boolean): List[Node] = {
if (pred(node)) List(node)
else node.child.toList.map(find2(_)(pred)).flatten[Node]
}
val result = find2(xml) { case <file>{_*}</file> => true; case _ => false }

find2は便利メソッドのflatMapを使ってこう書いても同じ。

def find3(node: Node)(pred: Node => Boolean): List[Node] = {
if (pred(node)) List(node)
else node.child.toList.flatMap(find3(_)(pred))
}

>>773
関数型言語の勉強なら「プログラミングの基礎」がいいよ。
http://www.amazon.co.jp/dp/4781911609/

Scalaは関数型の要素抜きのGood Javaで使っても結構いい線いけてるから、
なかなか関数型まで行き着かないんだよね。
同じJavaVMで動くといってもJavaと食い合う言語だなと思ったよ。
確かに関数型だけを学びたいならHaskellやML系の言語を先にやったほうが手っ取り早いかもしれない。

OCaml亜種のF#がC#や他の.NETグループの言語と組み合わせる前提の
設計になってるのと対比すると特徴的だな。

http://jp.techcrunch.com/archives/20090326get-ready-for-java-on-appengine/
コンパイルしたScalaもつかえそう。

いや、当然APIが制限されてるって。
Python版がそうであるように。

PragmaticProgrammersのScala本がβで出たんで書いておく。

でも、Liftの中の人がAPressで出す奴のほうが出来良いな・・
言葉遣いがかなりぶっきらぼうなんだが、例文がためになる

>>738

去年まで俺がいた部署はJython使ってたんだが何か？

スマソ

× >>738 ○ >>783 だった

>>791
実際のところはわからんが、.jarファイルをライブラリとして置けるなら
使える可能性は十分あるんじゃないか？scala-library.jarだけ同梱すればいいわけだし。
仮にそれが無理だったとしても、ProGuard使ってscala-library.jarとかもまとめて一つ
のjarにしてしまえば、原理的には可能だと思う。

しかし、普段は寂れてるのになんか話題振られると結構レス付くんだな、このスレ。

俺も思った
普段は過疎ってるけど結構チェックされてるんだな

Droolsとか宣言型＋Webはやってるからかな？

>>795
だからjar置いてもそのjarから全てのAPIを使えるわけじゃない。
その辺りどうなっているかPython版で勉強してきてください。

ちょ，ちょっとだけヒントでも
配置には特に公式サイトのFAQで〜調べればいいとか

AppEngineのことはこっちで聞いたほうがいいかもしれない

Google App Engine
http://pc11.2ch.net/test/read.cgi/php/1207754942/

>>799
Google App Engineに詳しいわけじゃないが、仮にjarに関して制限あっても
ProGuardとかFatJarとかで1jarに固めてしまえば、さすがに原理的には制限
しようが無いんじゃね？使えるJava APIに制限あると言っても、Scala処理系が
生成した.classファイルがそんなに色々なAPI使うわけじゃないし。

http://code.google.com/appengine/docs/python/runtime.html#The_Sandbox
を読んだら>>801行けば?
まあいろいろなJVM系言語でGoogleApp版処理系(制約あり)が作られると思う。

ただスレッドを扱えない時点で、
scala.actorに依存したScalaの多くの部分が失われる。
上のJoin calculusの話とか、その辺のソースコードとかも読んで。

むしろactorは単なるライブラリなので単純に切り離せると思うけど。。

actorなくなるとhttpの基本ライブラリも関連も書き直しだな。
TcpServiceが使ってるから。Google Appが提供するhttp APIにしないと。

twitterでscala使われるらしいね

>>806
使われるというか、既に部分的には(メッセージキュー)使われてる。

GAEでJavaが使えるようになるなんてまだ噂段階なのにここまでもりあがるとはwww

は？

http://www.atmarkit.co.jp/news/200904/08/gae.html
まあかなり記者の憶測入ってるけど。

JRuby on Railsが動くんだったらLiftも動くんじゃないかなー

clojureでも動いているから、大丈夫ちゃうか。

http://froth-and-java.blogspot.com/2009/04/scala-on-google-appengine.html
It was fairly trivial だったそうです。

あるある

Twitter、Ruby on RailsからScalaへ
http://slashdot.jp/developers/09/04/10/0421223.shtml

Will it play in App Engine
http://groups.google.com/group/google-appengine-java/web/will-it-play-in-app-engine

ScalaとGAEについては、
http://pc11.2ch.net/test/read.cgi/php/1207754942/755
Officalブログで、「They even use alternate languages on the JVM, like Groovy, Scala, and JRuby.」
>816で
Scala
- Scala works out of the box.
- Scala Actors do not work, because they are implemented using Threads (which are not supported).
- The Lift web framework does not work out of the box, because it depends on Actors and JDBC.
あとは、ネットワーク接続は、HTTPしか使えないみたい
http://code.google.com/intl/ja/appengine/docs/java/overview.html
GAEで、Litfいじってる人はいるね。
http://groups.google.com/group/google-appengine-java/browse_thread/thread/642d7b97457b02bf/4fe712e3b4764ae7?lnk=raot
http://groups.google.com/group/liftweb/browse_thread/thread/7f33caf5e9db677b

scalaって継続つかえますか

KEIZOKU?

グーグル先生に「Scala continuation」で聞いてみたら？

６個のreal型変数ｘ１、ｙ１、ｘ２、ｙ２、ｘ３、ｙ３を定義しそれぞれに実数つを読み込んで、ｘｙ平面上の３点
（ｘ１、ｙ１）（ｘ２、ｙ２）（ｘ３、ｙ３）を頂点に持つ三角形の面積を計算して、その値を表示するプログラムを作成してください。
・公式：底辺ｘ高さ÷２を使って計算してください。
お願いします！！

>>818
あえて答えると、言語としてファーストクラスの継続は持ってない。
でも、ライブラリレベルで継続モナドみたいなのを作ってやるのは
できる(別にScalaに限った話でもないけど)。

>>821
マルチ乙
http://pc12.2ch.net/test/read.cgi/tech/1237091698/493
http://pc12.2ch.net/test/read.cgi/tech/1232055225/770
http://pc12.2ch.net/test/read.cgi/tech/1217575832/499
http://pc12.2ch.net/test/read.cgi/tech/1235927586/774
http://pc12.2ch.net/test/read.cgi/tech/1212498448/876
http://pc12.2ch.net/test/read.cgi/tech/1212409946/66
http://pc12.2ch.net/test/read.cgi/tech/1217575832/499
http://pc12.2ch.net/test/read.cgi/tech/1192201659/808
http://pc12.2ch.net/test/read.cgi/tech/1205156417/821
http://pc12.2ch.net/test/read.cgi/tech/1238032584/16
http://pc12.2ch.net/test/read.cgi/tech/1224719784/934

>>823
てなことを、１０スレ以上で言って回ってるのかおまえは？　おヒマですね
マルチポストがどーたらを言ってる奴自身、ろくな回答してねえのが多いんだよな

# 加えてクロスポストを知らなかったりするし

うわぁ>>824がマルチポスト

見なかったことにしよう

超法規的措置ですね

>>821-824 までがコピぺｗ

誰か一人いっしょに流されてないか？

ちなみに継続は Responder

大学で学部生(情報系学科)のプログラミング入門にJavaを使ってるんだけど、Scalaに変えようと提案したら一蹴されてしまった。
日本語の教科書がないのと、講義担当教授(専門は信号処理)が全然知らないのが決定的らしい。残念。
演習担当助教としてはまちがいだらけの講義もなんとかして欲しいところなんだけどなあ。

やっぱり2chに書いてたか。

お前人のこと言えるのかと。

情報系なら、3年次ぐらいに関数型言語の講義があるんじゃ。
C言語から始めずにOS・ネットワーク周りとか何で実習するんだろう。
JAVAから入れば、Cぐらい読めると思うが。

>>830
scalaってまだバグだらけじゃないの？なんでscala？

ところで
class Ex[T](t:T) {
　def ?:(o:Option[T]) = o match {
　　case Some(v)=>v
　　case None=>t
　}
}
implicit def any2ex[T](t:T) = new Ex(t)

val l = List(1,2,3)
l.find(_>3) ?: 5

でfindがNoneのときは5を返すようにしたかったのだが
java.util.NoSuchElementException: None.get
というエラーになってしまう。

5.?:(l.find(_>3)) だと
error :type mismatch
found :Doule
required: Option[Option[Int]]
とさらに意味がわからないことに…

val foo:Int=>Int = {case x => x}
はありだけど
def foo(i:Int):Int = {case x => x}
はcaseに渡される型が失われてる、というエラーになるのはなんでだろ。

>>834
{case x => x}の型はfunction typeだから、
val foo: Int => Int = ... の場合、受け取る型がInt => Intであることから、{ case x => x }の
型が推論されるけど、
def foo(i: Int): Int = ... の場合、受け取る型がIntなので、{ case x => x }の型が正しく
推論できない。

というか、2番目の場合、仮に型をつけて
def foo(i: Int): Int = { case x:Int => x }
としても正しいプログラムじゃない(implicit conversion定義してあれば別だが)。

>>833
＞java.util.NoSuchElementException: None.get
Scala 2.7.3 finalで試してみたけど、正常に動いたよ。Scalaのバージョンはいくつ？

＞error :type mismatch
＞found :Doule
＞required: Option[Option[Int]]
＞とさらに意味がわからないことに…

これ、はまる人ときどき居るんだけど、5.がDoubleのリテラルとみなされて、
(5.) ?: (l.find_ > 3))
になるのが原因。コンパイラのバグじゃないよ。

>>835,836
なるほど、case文は関数型のオブジェクトを生成して返してるのか。
1番目の式を見れば当たり前か。
俺はPartialFunction周りを理解できてなさ杉だな

>>837
すんません、こちらでもうまくいきました。
コンソール上でいろいろ試してたんでゴミができてたのかも。
コンソール起動しなおしたらうまくいった。

数値がDoubleとみなされるのは、そもそもどんな型でも取るような
implicit def は使わないほうがいいか

>>830
教科書を自分で書くw

liftって、公式wikiのコードサンプルでも、もう互換性無くなって
動かなくなってるのが至る所にある……

Scala 2.8 プレビュー
http://www.scala-lang.org/node/1564

結構変わりそうなのね。ある程度の互換性は確保して欲しいと思います。

バイナリ互換性は無くなる。ソース互換性は基本的に保たれる、はず。

Scalaは1Kコア時代のための布石みたいなもんだしな。
バイナリ互換は一切気にせず、改良に努めれば良いと思う。

2

2.7.4.final キタ

大学の授業でScalaはインタプリタがあるっていう点ではJavaよりもいいかもね。
カリキュラム組むのは大変そう。
現Scalaユーザは他言語経験者だろうからプログラム入門者がScalaを習得する道程に考えが及ばないかもね。

Stanfordは既に授業にしてるみたいだけどな、

ttp://www.stanford.edu/class/cs94si/

>>848
最低二つのプログラミング言語の授業を既に取っている必要があって、
さらにCを使う"Computer Organization & Systems"の授業推奨だから、
>>847の言う意味とはまったく違うけどな。

情報工学、科学を専門にする学生に対して最初に教える科目ではない罠
低レベルな言語と高級な言語を並列して教えるのがやっぱ妥当

素人にScalaを教えようとすると、JVMで動作するって説明で、もうアウトだろうし・・
型推論の説明がこれまた面倒臭い。
教養や専門にちょっと足突っ込むくらいのレベルならC,Javaあたりがいいかもな。

純粋に教養レベルでいいなら灯台みたいにRubyでいいんじゃね？

>>850
＞ 純粋に教養レベルでいいなら灯台みたいにRubyでいいんじゃね？

灯台ｗ
ラビ教えてんの？
木違い沙汰

東大のrubyって文系理系共通科目の話だけどな。
情報系の授業は別にある。

http://www.artima.com/scalazine/articles/programming_style.html
http://lotrepls.appspot.com/
>>> var name = "Samidare"; val nameHasUpperCase = name.exists(_.isUpperCase); println(nameHasUpperCase)
true
>>> var name = "satukibare"; val nameHasUpperCase = name.exists(_.isUpperCase); println(nameHasUpperCase)
false

文字列がイテレータで扱えるのはいいと思うんだけど
マルチバイトな文字をどうしたらいいかわからないんだ・・・

>>853
http://www.h7.dion.ne.jp/~samwyn/Scala/scalag.htm
"" 文字列型のmanipulate は、java 風に indexOf, startsWith, endsWith
'' 文字型のmanipulate は、C 風に ==, != みたいにやればいい

>>> var name = "細雪"; var nameHasUpperCase = name.exists(_ == '細'); println(nameHasUpperCase)
true
>>> var name = "細雪"; var nameHasUpperCase = name.exists(_ == '太'); println(nameHasUpperCase)
false

>>852
そうするといまは、
Ruby、Scheme、C、ML、（LINUXシステムプログラミング）、VHDL、（MPI＋OpenMP）
て感じなのか。
ttp://www.is.s.u-tokyo.ac.jp/vu/vu_lessonlist.php

ある意味全方位だな。VM系以外
MLの代わりにならいけるんだろうけど、Java触らないからな・・・

http://code.google.com/p/itunesexport-scala/source/browse/trunk/src/main/scala/com/ericdaugherty/itunesexport/formatter/Formatter.scala#
Loan Pattern
http://blog.goo.ne.jp/anoydevl/e/e9c37b0f1326a1dc47f8ce7fc8f884f6

なんかよくわからんけどファイル入出力処理に重宝するような
ものなのだろう・・・

公式サイトに「Getting Dynamic productivity in a Static Language」へのリンク記事が掲載されていた。
「Feel Of Scala」という講演に合わせた要約っぽい記事になってた
ttp://www.artima.com/forums/flat.jsp?forum=106&thread=253855

記事にも書いてある内容だとおもうけど、講演内容の半分は、
Scalaは簡潔に（個人的な解釈は自然言語っぽく）書けるからJavaみたいなつらいテストじゃないものが書ける。
動的言語的なダックタイピングをしながら、IDEでチェックもリファクタリングもしやすい。
コンパイル時にスペルミス（初期化ミス）のチェックなどにも、いろんな手法でチェック出来るようになってる。
みたいな感じだった。
使っていたテストスイートは、
・Test Methods (Suite,TestNGSuite）
・Test Fanctions （FunSuite）
・BDD （Spec）
でした、けっこう重要な講演だったと思う。

Groovyも（JRubyも？）Javaのテストが簡潔に出来るところが売りの一つだけど、
Scalaの特徴を活かした静的でかつ分かりやすいテスト環境が発展していて、
テストに使うにしても、総合的に上回りつつあるのかもしれないね。

しっかり単語補完出来るIDEってどれ？
EclipseもNetBeansも中途半端すぎてあんまり使えないんだけど。

映像で使ってたのは、IntelliJ IDEA@OSXだった。
ttp://plugins.intellij.net/plugin/?id=1347

http://www.geekontheloose.com/images/stories/programming/Scala_Cheatsheet.pdf

http://www.artima.com/scalazine/articles/origins_of_scala.html
>We wanted to create something that would be at the same time
>practical and useful and more advanced than what we could achieve
>with Java. We started working on this language, which we came to
>call Scala, in about 2002. The first public release was in 2003.

age 7. にして 聡明な

Scalaって何がいいすかね？

http://scala.sygneca.com/patterns/start

Scala紹介のスライドだけどライブラリがまとまってる
ttp://www.google.com/search?q=http%3A%2F%2Fwww.wankuma.com%2Fseminar%2F20081108toyama01%2F4.pdf

>>864
> ■Web Flavor
の
> keisuken(日本の方) という人が作ってるらしい
吹いたｗｗｗ プレゼンした人じゃねーかｗｗ

http://www.ibm.com/developerworks/java/library/j-scala05059.html?S_TACT=105AGX54&S_CMP=C0507&ca=dnw-1018&open&cm_mmc=5277-_-n-_-vrm_newsletter-_-10731_113818&cmibm_em=dm:0:16807808
Listing 13. Cracking XML

失禁してしまいそうな位
鮮やかだ…

>>866
これのどのへんが「失禁してしまいそうな位鮮やか」なのか教えて欲しい。
Perlあたりで書いてしまったほうが楽そうなんだが

>>867
866じゃないが、失禁してしまいそうな位鮮やかは言い過ぎにしても、かなり簡潔に書けてるとは思うが。
PerlだとCPANのXML操作ライブラリとか使うことになるんじゃないか？

CPANのライブラリ使ってもいいが、Perlの方が楽はねーよ。
C#のLINQと比べるならまだわかるが。

そういや、C#は従来のDOMそのまんま系と、LINQ用に導入された奴とで、
2系統有るんだよな。

Scalaは、XMLリテラルとか言語に入れてるし、今後も1系統なんだろうな。

Perl最強
Scalaなんて書いたこともないけど
単なるJVMの寄生厨でしょｗ

井の中の蛙落とし

みんなが失禁したScalaのコードがあったら教えてよ。

失禁はしてないけど、liftは色々とScalaらしいなーと感心したよ。
ドキュメントがダメで全然まとまってないけど、今月ぐらいに本が
出るらしいから、ちょっと期待。

出る本は皆糞本ですよ
Scalaなんて糞だろｗ

糞だと思うならこんなマイナー言語スレにいちいち出張ってこなくてよろし
別に一時期のRails程のブームになってるわけじゃなし。TwitterがScala
使い始めたってのでちょっと注目されてるくらいですぐ収束するだろう。

>>876
Perlよりいいとかアホなこと2度と書き込むなよ
それと謝罪しろ土下座しろよ

Perlを騙っただけじゃないかな。

いろいろ調べてたら、Apressから出る本は、liftの開発陣が書いてるみたいだね。
ttp://www.apress.com/book/catalog?category=32
Beginning Scala, By: David Pollak
ttp://www.apress.com/book/view/1430219890
The Definitive Guide to Lift: A Scala-based Web Framework, By: Derek Chen-Becker , Tyler Weir , Marius Danciu

今OHP内探してたら、「Exploring Lift: Scala-Based Web Framework」 作者同上、が消えてるな？5/5にはあったんだが。

え、一気に3冊もlift本出るの？
amazon.co.jpだと『Exploring Lift』しか出てこなかったら、迷わず注文しちゃったのに。
消えた？

ML見た印象で言うと、作者のDave Pollakって人は
あんまり説明が上手くないような気がする。

リンクつけ忘れた。
The Definitive Guide to Lift: A Scala-based Web Framework
ttp://www.apress.com/book/view/1430224215


Terracottaのコミッターのひともいろいろ記事とコードを書いてた。
ttp://jonasboner.com/archives/
・Real-World Scala
- Erlang-style Supervisor Module for Scala Actors (Scala OTP)
- AOP-style Mixin Composition Stacks in Scala
・Clustering Scala Actors with Terracotta

Pragmatic Real-World Scala presentation
ttp://jonasboner.com/2009/01/30/slides-pragmatic-real-world-scala.html

ttp://www.scala-lang.org/ の右サイドメニューにも「Exploring Lift」しかでてない
自分もExploring Liftをアマゾンで注文したよ。

Dave Pollakの本は、scalaの本でした。

書籍一覧はここにあるぞ
出版元の解説にも飛べる

Books on Scala
http://www.scala-lang.org/node/959

liftの作者のくせに出す本がlift本じゃないとか、紛らわしすぎだろ。

>>877
わけわからん。別にPerlと比較した覚えは無いが。

似たような本ばかし何冊も出して意味あるのかな
Scalaの概要を知りたいなら、とりあえずProgramming in Scala1冊でいい気がする
他の本がもうちょっと実践的な側面に焦点当ててるならまた違うだろうけど

O'Reillyのは、twitter社内でAPIをRubyからScalaで書き直した人？ので、
artimaにインタビュー記事があった。
ttp://www.artima.com/scalazine/articles/programming_style.html

Pragmatic programmersのやつは、
Agile DeveloperのVenkat Subramaniam（トレーナー、メンター）が書いた物
.NET Gotchas、Agile Developer、Programming Groovyを書いた人

ぱっと見のひとには、programming in scalaより薄いし、ここら辺が売れるような気がする。

CUPのは、ギリシャの人たちみたい。どういう経緯なのか分からんｗ
ttp://www.nabble.com/-scala---ANN--Steps-in-Scala:-Introduction-to-Object-Functional-Programming-td22554993.html

細かい差はいいから、日本人でも読みやすいのはどれだよ？
変な修辞をこねくり回したり、アメリカンジョークや文学の引用が無い奴。

やはり言語をデザインしたMartin Oderskyの本ではないかと。
CならK&R、C++ならStroustrup、Rubyならまつもとの本が一番いいのと一緒だ。

ttp://www.jroller.com/sebastianKuebeck/entry/object_oriented_programming_2_0
C++の定跡で有名なCoplienのつくったDCIパターン？の解説の記事に、Coplienのアジャイル開発に
関する新著（草稿）へのリンクがある。
この本、当然C++で書かれてるんだが、8.6のBeyond C++のところの最初にScalaを持ってきてました。
Programming in Scalaの出た去年の後半ぐらいからほんとにすごい立ち上がりになってるね。

http://code.google.com/p/scaml/
http://code.google.com/p/scala-deque/source/browse/trunk/Deque.scala

試みとして、何か書いてみようかというふいんき（何故か変換できない
は、とても感じる・・・

http://www.parleys.com/display/PARLEYS/Home#title=The%20Feel%20Of%20Scala;talk=27131945;slide=1

視聴中わかりやすい英語

ﾐｵﾜﾀ
decorateToString のとこに違和感があた
中盤の test コードの所は眠かた
最後ラ変５項目辺りは面白かた

>>887
夏頃に、Ｐｒｏｇｒａｍｍｉｎｇ Scalaの翻訳が出るよ。

それまで待て。

>>893
ちょっとまて、どこの出版社だ？

>>894
ビアソンか翔泳社かオライリーだと思われ。

ソフトバンクかアスキーか技術評論社かマイコミかもね。

>>891
音楽にﾌｲﾀ

>>896
著者から言って、そこは望み薄。

訳本鉄板と名高いテクノロジーアートだろ

>>899
鉄板か？コード書こうともしないモデリング屋は信頼できないんだが・・

>>900
推薦図書の荒し

>>900
鉄板で駄訳って意味だろ常識的に考えて

>>899
×テクノロジーアート
○テクノロジックアート

The Goals of Scala's Design
http://www.artima.com/scalazine/articles/goals_of_scala.html

martin の英語、話している題目も関係してるのかも
しれないけど読みにくく感じる… guido さんも修辞と
語彙が凝ったかんじだけど、何かまた違ったかんじで
訳わからなす… また artima.com…ぐぬぬ…

http://www.riffraff.info/

sinatra 風な cotroller が 30 行で書けるなんて
実質 9 行で書ける…これにキーワード引数が追加
されれば、いやいやホンマかいなと首を傾げる

Scala and XML - Part 1
http://www.eishay.com/2009/05/scala-and-xml-part-1.html
>[3] An emphasis on the string as a value in the curly brackets.
>Some (like myself) placed there an Int or other primitives
>expecting something like string concatenation. Well, it won't
>work and you'll get this error:

tag 内 curly brackets は 変数として展開される。
それは文字列で、ほかの要素の場合はエラーとなると

scala.xml.XML.save
scala.xml.XML.saveFull
のコードがおかしいと思う。マルチバイト文字は使用できない

デフォルトエンコーディングが iso-8859-1 だから、エンコーディング指定版使わないと

lift本はこういう事らしい。
http://groups.google.com/group/the-lift-book/browse_thread/thread/70fc38d4e6ba941

"Exploring Lift"から"The Definitive Guide to Lift"に名前変わった。
amazonが間違ってるから出版社に連絡しとくわい、と。


あと、今気づいたけど、先月から日本人のコミッターが加わってたんだね。
http://groups.google.com/group/liftweb/browse_thread/thread/354b7e939a7de971

最近common lispにかぶせるパターンマッチ拡張言語Qiとかいうのできたけど
かぶせて拡張が流行ってるのかねえ

最近できたのはQi IIだろ

OHPの今度の紹介記事は、Scala on Google App Engineだった。
ttp://www.scala-lang.org/node/1831

Googleの人がガイドを寄稿してたのに、あわせたものみたい。
Documentation ≫ Quick Guides ≫ Programming Guides ≫ Scala on Google App Engine
Scala on Google App Engine
ttp://www.scala-lang.org/node/1826

liftの作者もいろいろ確認してるそうだ。
ttp://lift-example.appspot.com/

Javaでいうクラススコープの変数はScalaではどうやって定義するの？

// Java
public class JavaClass {
　　private static int staticVar; // <-- これ
}

>>912
staticは無い。objectに定義する。

object はシングルトンなのでその内部変数は Java の static としてバイトコード化される
また object 名はインスタンス名なので同名の class が可 (インスタンス名とクラス名は別の名前空間に属する)

>>914
thx

companion オブジェクトでしたっけ。

companion objectはScala関係の記事でもあまり話題にならないね。
実際、知らなくてもまあ問題無いけど、知ってると便利なこともある。

2.8 collections
http://permalink.gmane.org/gmane.comp.lang.scala.debate/2882
http://cache.gmane.org//gmane/comp/lang/scala/debate/2882-001.bin

2.8 の collection の資料

http://www.codecommit.com/blog/scala/scala-as-a-scripting-language
http://www.eishay.com/2009/05/iterating-over-map-with-scala.html

Hashcode & Equals in the Scala 2.8 Collections Library
http://scalide.blogspot.com/2009/05/hashcode-equals-in-scala-28-collections.html

http://programming-scala.labs.oreilly.com/

Lift本届いた。結構読みやすい英語。索引が無い。
でも、これでやっとLiftにもまともなドキュメントが出来たという感じ。

うちも届いたよ。

Apressの本は、Google Booksにもサンプルあるからので、出てきたようだ。
http://books.google.com/books?id=5lPmFLC6sHAC

一部草稿かもしれないけど、3月時点のやつはCC改変不可ライセンスで配布してるみたいなので、
興味がある人はみてね。
http://www.google.com/search?hl=ja&q=lift+exploring+pdf&lr=

製本では付録(ABC)がなかったので、コピーしておこうかな。

よくみたら、付録はABCじゃなくて、A-Gだったよ・・・

Lift本読んでやっとScalaでJavaScriptコード生成するあたりの意味が分かった。

オブジェクトのコピーを作るとき、明示的にクラスを指定せずにやりたいんだけど、どうしたらいい？
下の例だと、引数かメソッド定義で指定してしまっていてカコ悪い。

object Main {
def main(args: Array[String]) = {
var foo: Foo = new Foo("xyz")

println(foo)
println(foo.copy)
println(foo.copy2[Foo]) //引数でクラス指定
}
}

class Foo(var id: String) extends Cloneable {
override def toString(): String = super.toString + " : " + this.id

// メソッド定義でクラス指定。サブクラスでは再定義が必要。
def copy:Foo = this.clone.asInstanceOf[Foo]

// メソッドの引数でクラスを指定。呼び出し側でクラスが一意に決まらない場合に対応不能。
def copy2[T]: T = this.clone.asInstanceOf[T]

// コンパイル不能。こういう感じで汎用的なコピーメソッドを定義したい。
// def copy3: this.getClass = this.clone.asInstanceOf[this.getClass]
}

これでOK。

class Foo(var id: String) extends Cloneable {
override def toString(): String = super.toString + " : " + this.id
// this.typeは実際のクラスの型に応じて変わるので、再定義不要。
def copy: this.type = this.clone.asInstanceOf[this.type]
}

class Bar(id: String) extends Foo(id)

val bar: Bar = (new Bar("bar")).copy //ちゃんとcopyの返り値の型がBarになっている
println(bar)

>>926
できた。ありがとう。

アマゾンからオススメされた
http://www.amazon.co.jp/gp/product/1430219890/

>922
本文中にAppendixの何とかを参照せよって書いてあるのに、
巻末にAppendixが存在しないじゃねえか落丁かよって思ったら、
http://www.apress.com/book/view/1430224215
のBook Extras の下の Appendixes でダウンロード出来た。

2.7.5.final キタ

C#のnew制約にあたるものはありますか
このプログラムのコンパイルエラーをなくしたいです

class BaseRow
{
}

class BaseTable
{
}

class Row[+TTable <: BaseTable] extends BaseRow
{
val Table: TTable = null.asInstanceOf
}

class Table[+TRow <: BaseRow] extends BaseTable
{
def NewRow: TRow = new TRow() //class type required error
}

Javaと同じくerasureによるジェネリクスだから型変数でnewすることはできないんじゃないかな。。

>>932の書いてる通り、まあ無理なわけだが
scala 2.7.3くらいから実験的に入った機能にscala.reflect.Manifestというのがあって、
それを使えば、静的な安全性を犠牲にしてもいいならできなくも無い。

mport scala.reflect.Manifest
class Creator[T](manifest: Manifest[T]) {
def create(): T = {
manifest.erasure.newInstance().asInstanceOf[T]
}
}

object Creator {
implicit def creatorOf[T](implicit manifest: Manifest[T]): Creator[T] = {
new Creator(manifest)
}
}

def makeObj[T](implicit c: Creator[T]) = c.create

println(makeObj[java.util.ArrayList[String]]) //ArrayListが作れる

>>932
コンストラクタだけは継承先で書かないといけない感じですね
ありがとうございます。

こういうのみると.NET(Mono)だったらって思う。
あるいは、C++Template的なものがあれば。

結局、無料サーバが無いんじゃイラネってなる

無料とまでいかなくても月額1000円以内は欲しいな

Google App Engineでも使ってろ

>>933
その後いろいろとやってみましたが、
makeObjのTには型引数をそのまま渡すわけに行かないようで、
Tableクラスの中でnewRowを記述することはできませんでした。

>>939
うーん。>>933のテクニックを使えば原理的には可能なはずなんだけど。
implicit parameterの指定を忘れたりしてない？

>>940
こんなコードを書いてみて
abstract class Table[+TRow <% Row[_]] extends BaseTable
{
def create[T](implicit manifest: Manifest[T]) =
manifest.erasure.newInstance().asInstanceOf[T]
def newRow: TRow = create[TRow].asInstanceOf
}
コンパイルエラーがでました。
generics.scala:25: error: no implicit argument matching parameter type scala.reflect.Manifest
def newRow: TRow = create[TRow].asInstanceOf
^
「Manifest型仮引数にマッチしている暗黙実引数がない」という意味？

Tがクラスの場合だけManifest[T]型の暗黙実引数を渡しているのではないかと
思いました。

>>941
この場合だと、implicit manifest: Manifest[T]の部分はコンストラクタの引数に書かないと
ダメ(クラス定義の中では、TRowは消去されて、単にRow型として扱われてしまうので)。
たとえばこんな感じ。

import scala.reflect.Manifest
trait BaseTable
trait BaseRow
class Table[+TRow <: BaseRow](
implicit manifest: Manifest[TRow]
) extends BaseTable
{
def newRow: TRow = {
val c: Class[_] = manifest.erasure
println(c getConstructors() toList)
c.newInstance().asInstanceOf[TRow]
}
def printRow {
println(newRow)
}
}
class MRow() extends BaseRow

object Main {
def main(args: Array[String]) {
val t = new Table[MRow]
t.printRow
}
}

完動サンプルまで書いていただきありがとうございます
implicit parameterはコンストラクタでないといけないと言うこと
理解しました
思い描いたとおりに動作しました
またListのサンプルも参考になります
インスタンス化しないならtraitにするのも参考になりました
↓こんな感じにまとめました