関数型言語ML(SML, OCaml, etc.), Part 4

関数型言語MLについて語るスレッドです。

MLは、確固とした理論的背景を持つ言語でありながら、
現実的なソフトの開発にも使用できる実用性を備えた言語です。
また、プログラミングの初心者が最初に学習する言語としても優れています。

総本山
Standard ML http://www.smlnj.org/
Objective Caml http://caml.inria.fr/ocaml/

前スレ
関数型言語ML(SML, OCaml, etc.), Part 3
http://pc8.2ch.net/test/read.cgi/tech/1103606223/

過去ログ、関連リンクは>>2-4あたり

■リンク集
http://lang.x0.com/func/ml/

■チュートリアル
Standard ML
http://www-2.cs.cmu.edu/afs/cs/usr/rwh/public/www/introsml/
http://www.dcs.napier.ac.uk/course-notes/sml/manual.html
http://www.dcs.ed.ac.uk/home/stg/NOTES/
http://yk.i.hosei.ac.jp/smlbook/smlbook.pdf
http://www.summa.jp/tutorial/plain/mlkouza.txt
Objective Caml
http://www.csc.vill.edu/~dmatusze/resources/ocaml/ocaml.html
http://www.sato.kuis.kyoto-u.ac.jp/~igarashi/class/isle4/mltext/ocaml.html
http://www.biocaml.org/~bannai/ocaml-intro/
http://www.ocaml.jp/archive/document/

■過去スレ
関数型言語ML(SML, OCaml, etc.), Part 3
http://pc8.2ch.net/test/read.cgi/tech/1103606223/
let t = 関数型プログラミング言語ML 2
http://pc5.2ch.net/test/read.cgi/tech/1058630709/
関数型プログラミング言語ML
http://pc5.2ch.net/tech/kako/1012/10124/1012445015.html
ＭＬ！！！！！！
http://pc.2ch.net/tech/kako/1002/10021/1002111468.html

関連リンク!!!!!!!!!!!!!!!!!!!

::::::::::::::　　　　　　　　::: ﾚ'⌒ヽ　　　　 こいつはくせえッー！
ヽ-───i＝＝＝i─-}ｧ'　 ﾉ　　　　ゲロ以下のにおいが
、` ｰ-＝==-ﾟ---ﾟ=＝‐'　／ プンプンするぜッ─ッ！！
､｀¨ﾌ＞;''ニニゞ,;ｱﾆニY´; ）　　　　　こんなクソスレには出会ったことが
_、;;）¨´,ﾆ=ﾟ='" ,.ﾍ=ﾟ:く {ｯﾘ'　　　　　　　　ねえほどなァ─ッ
i1(ﾘ　　　　　 　 r;:ドヽ Ｋ
ヾ=、 　 　 に二ニヽ ｀|;　)
_,ﾉ| i. 　 　 {⌒ﾞ'^ヽ.{　 ｉ;;　ヽ
　_,ﾉ!ｉ ヽ、　 ヾ二ニｿ　,';;;　 ;;冫=:､
_;(|.!.　　＼　　 ‐っ　/!;;;　;;/　､''"＼__　　お前は生まれついてのヒキヲタだッ！
'ﾄ､＼.　　　,ゝ､.二..ｲﾘ＼ / ー1＼'ﾆゝヽ_
:ヽ　　｀ニｱ　　 ,. -┴‐‐'　 ｰ-:ｌ :=ゞ=ｿ｣=ヽ　　　ム板の皆さん
:::::＼　ﾆ=ト､.i___`ｰ-┴-､ﾉ . 　 l　__l| ,ﾆﾄ､くヽ
l::::::::::＼ｰ:ﾄ　　　 　 __}/ﾄ､ﾞ ｰ-‐| ,ﾆ|ゞ=ﾊ ｀¨´ｰ-　　早えとこ
;ﾆ=ｰ:::::::ヾﾄ､._ 　 ￣ ﾉ|::ヽ ﾆ._‐-ゞ=' .ノ ::|:::::::::::　隔離しちまいな！

このスレって結構いろいろな人が見ているのかな？
だったらお願いですけど、関数型言語を習熟している中の人たちは
もう少しWebアプリの方向に手を広げてくれないでしょうか？
多くの人たちが救われるのではないかと思います。

寄付すれば多少良くなんじゃない

手を広げるっていってもなぁ。
OCaml には ocamlnet や mod-caml、 as/xcaml なんかがあって、実際に運用
されているわけだがそれでは不満？

ライブラリが未整備ということなのか、(日本語の)ドキュメントが不足してるっ
てことなのか、webアプリケーションフレームワークが欲しいってことなのか。
それとも単に実例が見てみたいとかそういうこと？

>>7
たぶん実例にそったプロジェクトＸな話が聞きたいものと思われ。

風邪の中の昴

ocamlfind でビルドする系のパッケージが
軒並みビルドに失敗するんですけど・・・
ocamlfind 自体のインストールはうまくいってると思うんだけど
（ocamlfind --list とかはきちんと動いてるっぽい）
ocamlfind ocamlc -c ... -package ...
系の実行が全て失敗する

同じようなことでトラぶった人います？最悪Makefile手で書き換えるしか
ないんだろうか

やっぱ Makefile で提供するのが一番。

とはいえ、OCamlMake とかも ocamlfind を前提にするように
なっているしなぁ
でもこんなの使わないで素直に書いてもそんなに
大変じゃないのにね

>10
トラブル起きたことないなぁ。 ocamlfind query とかの結果はどうなるの？　環境は？
list は上手く行くのに ocamlc -c すら失敗するというのは、 META ファイル
の内容がおかしいんじゃないの？
ひょっとして、たとえば camomile を使うのに pcre とか unix を -package で呼んでないとかいうオチはない？
依存関係とかは追ってくれないから自分で指定しないとダメだよ。これにやられたことはある。

>>5
SML#

Ocamlでは副作用が扱えるけれど
扱えない場合、たとえば Haskelとかではスレッド間の共有メモリを
どうやって実現するのだろうか

Monadで

とりあえず Haskell でわからん事があったら
訳もわからず Monad と言ってみるテスト

haskellで単純にやるとモナド使っている間はずっとロックしっぱなしになりそうだな。

F#になるけど、Chinese Chess というのが公開されてるよ

http://www.strangelights.com/fsharp/ChineseChess.aspx

.NET との連携を学ぶ良いサンプルだと思う

>>15
Haskellとスレッドという概念がマッチしないような気がする。

スレッドプールから起動するHaskell Servletなんてのを想像しても
どういう実行モデルになるのかイメージすら湧かない。

そりゃ発想が貧困なのでは……。

GHC にも Hugs にも普通に Concurrent っつーライブラリがあります。
並列計算を抽象化した STM モナドってのもあります。

また、最初から Concurrent を意識して設計された
Concurrent Clean っつー純粋関数型言語もあります。

つーかスレ違いです。

Java(オブジェクト指向）があれば関数型言語なんてひつようないだろ？

うん、そうだな。だからこんなスレにいないでJava(オブジェクト指向）スレに行こうぜ。

いや、まよえる子羊たちを救わないと。

迷える仔羊を Java へといざなうのでつね。

>>22
おいおい、逆だろ・・・

いってらっしゃ〜い。

まあ、Java で一度痛い目見ないと、関数型言語のありがたみがわからないかも知れないしね。

まあ、引きこもって妄想にふけってるうちは関数型言語で十分かもれないね。
現実をみつめないとJavaのすごさはわからないだろうねｗ

>>29 「Javaのすごさ」ってのは、
言語でなく、ライブラリやフレームワークだからな…

あの資産を、MLから利用したい気はする

# MLj とかいわないでね

現在のIT社会を支えるIT土方のみなさんに敬礼！

どっかのLispの人は半月もすればLispの方に軍配があがるとか言ってるわけだが、
MLの人はへたればかりですか？

Java 厨ってどこぞの一神教の信者と同じクオリティだよな。
神様なんざ、その時その時で都合の良いヤツを拝んどきゃ良いんであって、
何でもかんでも一つの神様で片付けようなんてナンセンスだってことに気付けよ。

コンピュータの世界ってのは日本と同じで八百万の神様の国なの。
全知全能の神なんてものは存在しない。

複雑な言語仕様の場合は覚える数を減らした方がよい。
なぜなら、一つを習熟し品質を高めれば似たような事をする場合に
早く高品質の物を作れるからだ。

大規模で複雑なプログラムを作る場合にも複雑な言語仕様に似た特性がでてくる。
そのため、一つの言語でやることでメリットが発生する。
しかし…

>>33　年取ってきて、宗教に関心がでてきた人ですか？

ま、車にたとえるなら、

Ｊａｖａ --- セルシオ
ＭＬ　　----- ミニ四駆ｗ

ってかんじだよ、実際の話さ。

使い分けなんて言ってないで全部(状況が許す限り)MLで書けば良いじゃん
MLってそれを指向した言語なんでしょ？

一神教：バイナリな区別をする人
多神教：物の区別ができない人

何この変な流れ

しばらくすればまた元に戻るさ。

MLが指向したのは定理証明系の構築だろ

coq厨乙

ＩＳＡＢＥＬ厨乙

OCamlでゲームでも作ろうと思って挫折した俺がきましたよ。
GUIライブラリくれとまではとか言わないけど、最低限Windowだすくらいまではなんとかならんものか。
SDL for OCamlはなんかインストール失敗したし。

インストール失敗厨、世に蔓延る

くりーんならかんたんにげーむがつくれるぞ

ＪＡＶＡなら、ややこしいところはぱぱっとつくれます。
本質的なところだけに集中できます。

>>44
Window出すぐらいなら、なんとかなるぞ。ほんとにそれだけだけど。
ttp://www.h2.dion.ne.jp/~pana/downdown/downdown.html

>>47
×ＪＡＶＡ
○Java

型 推 論 や　ら　な　い　か

widestudioのocamlバインディングって使える？
経験者談キボン

age

から揚げかよｗ

private row って何が嬉しいの? どう使えば便利なの?

HaMLetのwebページにあったSMLの構文拡張。俺的にはいい線いってる。
http://www.ps.uni-sb.de/hamlet/README-succ.txt

Successor ML とかいうSMLの拡張があるんだな。

private row types を利用すれば、こういうコードで型を
ボトムアップ的に拡張していけるのは理解できました。

type basic = [`Bool of bool | `Int of int]

module Props(X : sig type t = private [> basic] end) =
struct
let to_string (v : X.t) = match v with
`Bool b -> if b then "true" else "false"
| `Int n -> string_of_int n
| _ -> "other"
end

type extended = [basic | `Float of float]

module MyProps = Props(struct type t = extended end)

let to_string (v : extended) = match v with
`Float f -> string_of_float f
| #basic -> MyProps.to_string v

ところで、この MyProps.to_string を"上書き"して、`Float を含む
to_string に置き換えらるとさらに嬉しいのですが、スマートな方法って
ありますでしょうか？

ttp://jp.sun.com/communities/open/technology/01_language.html

> MLは利用が研究室や個人で閉じているためか、
> コミュニティの存在を確認することはできませんでした。
> 住井英二郎さんのMinCaml（美しい日本のMLコンパイラ）が公開されていますが、
> これについても同様です。

コミュニティがあっても、
言語を使って作るものよりも言語そのものに興味のあるコミュニティじゃあね。

>>57
ocam.jpは無視ですか。そうですか。

よく読むとひでえ偏った糞文章だな。

>>44

# #load "graphics.cma" ;;
# Graphics.open_graph "" ;;
- : unit = ()

ただの標準のOCamlでな。

>59
l が抜けてるし。

MLって正直、すごいよ。

kwsk

fun length [] = 0
| length (x::xs) = 1 + (length xs)

ML全然詳しくないけど、Prologみたいですね。

>>66
http://www.kecl.ntt.co.jp/icl/kpro/isozaki/standardml.html

http://www.cip.physik.uni-muenchen.de/~tf/raytracer/

このページで「Objective CamlとOCamlを比較してやるぜ」と、
レイトレーシング・プログラムで速度比較してるんですが、
正直なところそのふたつの言語の違いが分かりません。
OCamlってObjective Camlの略だと思っていたんですが・・・？

MLで何をプログラミングしてもいいんだけど、計算機科学とか
プログラミング言語基礎論のような専門的話題について理解がないと
MLでなくとも出来ることに限られてくると思います。
また専門的話題をネットだけで勉強するのはやはり無理というか
限界があるのでは…。

「田舎の学問より京の昼寝」というか、やはり（英語の）成書や大学なり
（国際）学会なりで、ちゃんと見聞きするのに比べると…。

>>69
誰に言ってるの？

>69
学会論文も英語の良書もネット公開されてたりするし、
ネットだけでアカデミックな勉強をするのも可能だと思うよ。
学会参加による顔と顔をつきあわせた議論のようなものは難しいけど、
メールのやりとりだってできるし、なんとかなるんじゃない？

大学なりで一度はちゃんと見聞きしてきた人なら
>>71みたいなことも出来ると思う。

Windows版(MSVC)のOcamlで各種モジュール使うときに
# Unix.getcwd();;
Reference to undefined global `Unix'
とかって出ちゃって、
# #load "E:\\Program Files\\Objective Caml\\lib\\unix.cma";;
これを打っておくと使えるようになるんだけどこういうもんなの？

もういっかい、大学入って勉強しなおしてみたいなぁ。とは思うなぁ

>>73
Linux版でもそうなります．
これはデフォルトのトップレベル(ocaml)に unix ライブラリが
リンクされてないから(だと思います)．
unix ライブラリをリンクしたトップレベルを作るには
$ ocamlmktop -custom unix.cma -o unixtop
みたいな感じで出来ます(Linux版の場合です．Windows版は詳しくないので…)．
後は
$ ./unixtop
で，いちいち#loadしなくてもUnixモジュールが使えます．

$ ocaml unix.cma
で宵と思われ

stdlib と otherlibs(unix 他) の違い:

stdlib: 全てのアーキテクチャで実装されている、はず
otherlibs: されていない可能性がある

例えば Unix モジュールは昔の mac os には実装されていなかったはず。
その代わり、最低限のファイル操作は Pervasives と Sys を通して
提供されている。

そういう経緯のためか unix はデフォルトでリンクされません。

そうなのかー。
とりあえず76のやり方でWindowsでもできた。どうもありがとう。

Unix モジュールは Windows で完全に動くことが保証されていないのでは。

http://caml.inria.fr/pub/docs/manual-ocaml/manual035.html
には Windows における対応状況が記載されてる。

けど、今どれくらい動くかについては知らないので何とも言えません。

UnixモジュールってのはWin使いにもLinux使いにも喧嘩売ってるよな

LinuxはUNIX(TM)じゃないから当然だな。

>>80
できれば何が不満か詳しく。

ドザ・犬厨お断りみたいなふいんき

Posixモジュールにすれば丸く収まったかもな。

歴史的・宗教的理由は知らないが、Unixというのは何か違う気がするね。
いまさら変える必要はないと思うが。あ、HaskellはPosixだね。

SMLもPosixだよ。
しかしどうでもいい。

なんだ、名前の問題？

OcamlのSyntax Errorって情報少なすぎないですか。

なあに、かえって免疫力が付く。

JavaがあればＭＬなんていらないだろ？

Java厨はMLにでも入っとけ

はいはいいらんいらん

いんらんいんらん

MLがあればλ計算なんていらないだろ？

なんかOcamlで実用的なプログラム作ってますか？

SMLofNJ授業でやったけど、マジ地獄だった。
なにこの言語、がんじがらめって感じ。
型推論とかいろんなお節介機能でコンパイルを妨害しまくるし。
cとかjavaの方が1000倍生産性高いわ。
なんの為に存在すんの？
売りはなに？

>型推論とかいろんなお節介機能でコンパイルを妨害しまくるし。
これがいいんじゃないか

>cとかjavaの方が1000倍生産性高いわ。
動いてからが地獄だけどね

>>97
志村、多分クマ。

>>97
じゃあ動きだしたら天国なのか？

>>98
？？？

>>99
天国とまでは・・・微妙
けどコンパイル通すまでにした苦労はむくわれるぞよ
コンパイル通った時点で少なくともＣのコードよりはバグが少ないはず

釣られるなよ，ってことでしょ

自分だけは C で安全な大規模なプログラムが書けると
思っているスーパー墓ーがいるスレはここですか？

ああ、大規模プログラム用の超高級言語という売りですか？
確かに地獄の門番が嫌がらせの用にコンパイルを阻んでくる分、
いざコンパイル通ったら信頼性は期待できますね。
でもそれでも同じ型だけど意図以外に書けてコンパイルも通ってしまう事例とか
結構ありそうなもんだが。
まあ大規模システム構築を将来しようと思った時の為に学んでおく価値があるんですかね。
SMLofNJって教育用でしたっけ？
実践用にはどれをやればいいですか？

バグの少ないコンパイラ造りにも一役買えそうな言語ですか？
なんかリスト処理とか得意でしたよね。
でもあんまこみいった処理は期待できないな。

骨組みをMLで作って細部はcとかですか？
明後日の方向行っちゃいましたか？

OCaml授業でやったけど、マジ天国だった。
なにこの言語、道が一本しかないって感じ。
型推論とかいろんな親切機能で正しくないプログラムのコンパイルを妨害しまくるし。
cとかjavaの方が1000倍バグの生産性高いわ。
なんの為に存在すんの？
売りはなに？

>>105
スーパーハカーが仰天超速コードを書ける事
(除Java)

責任の取れる人には自由を与えるべき

103 への解答を書いている内に書き込みが増えてしまってるけど、、、

ML type system で表現しきれないデータの invariance を壊せる
プログラムが書けてしまうという意味で 103 の指摘は正しい。
それは invariance を保つような constructer や access function
をちゃんと書いてから実装を隠蔽するとかやればかなり解決できる。
ただ、同じ問題は C, C++, Java にもあるし、同様に解決できるはず
だが、Java はともかく、 C や C++ はそれ以前の問題が多すぎ。
他人が書いた意味不明な seg fault を吐くコードのメンテしたいかい？

SML でも Caml でも Haskell でも、いちいちあげないが非常に複雑な
ソフトウェアシステムはいろいろ開発されているはず。
授業でやらされたからといって教育用の言語と言うわけではないよ。

ML 系のプログラムを学ぶ価値があるかだけど、今しばらくの内に
日本国内で企業で大規模プログラムを書く仕事につきたいのであれば、
逆に学ばないほうがいいかもしれんな。よりよい言語があるって
わかってるのに C でプログラムを書かされるのは正直辛そうだ。(w

自分で起業するか、既に ML に目覚めた開発をしている会社(海外とか
には幾つかある)に就職するとか、会社内で意識変革を起こす気概がある、
というのであれば別だけど…

私の見聞きした範囲では、プログラム開発グループ長ぐらいまでで、
新プロジェクトを C ではなく、 ML での開発とするということに理解を
示す人は、見識の広い人ならば十分いる。問題はそこから先、技術とか
わからん管理職が具体的な数字を示さんと動いてくれないのが問題だ
そうな。そうなると見切って spin-out するって手もあるが、日本では、
難しいか？

エスエムエルとかカムルもかハスケルとかの勢力図見して下さい＞＜
SMLofNJで培った常識で他にも容易に参入できますか？

（省略されました・・）
のところで笑ってしまった

勢力図ってなんだろ、地理的勢力図？
下手すると角が立ちそうだなー。
色々好嫌いはあるだろうけど
言語間の参入はまたく問題ないっしょ。

SMLofNJ OCaml Haskell
特徴解説きぼん

>>111
いずれも関数型言語。以上

時には Clean のことも思い出してあげてください。

なかなか複数の言語について自信を
持って言える人はいないのではないか。

Haskell 系と ML 系の違いなら分かるが、SML/NJ と OCaml の違いがあんまり分からない。
どっちも触ったが、わりと好みの方を使えばいいんじゃね？と思った。
SML/NJ は let 式に end がいるのがちょっと面倒なのだが、end を書きたいこともあるし。

Clean を触ったとき、example でついていた Hello, World! すら動かずに窓から投げすてたことがある。

>>115
http://www.ps.uni-sb.de/~rossberg/SMLvsOcaml.html

SML の方が余計な記号が少なくて好き。スッキリしてる。

そういう小奇麗さが欲しいときは Haskell 使う。
ML を使う時は大抵ばりばりプログラム書くときだから小奇麗さは気にしない。

そういう人もいる... と。

Ocamlって未使用オブジェクトはGCしてるんですか

ＭＬを保守的に拡張してｃにすればいいじゃん。

>>120 してないよ。

できたら OCaml もしくは O'Caml と書いてほしいなあ

週末のムード。。

Object(ﾟ�听)ｲﾗﾈ

MLでC++コンパイラ作ればバグ減るんじゃね？

コンパイラのバグは減る

ML プログラマが C++ のコンパイラを書いて、
んで、そのコンパイラを自分で使うのだろうか、、、
かなり自虐的だね。

コンパイラならC++で作るよりMLで作るほうが楽だよね

ML でコンパイラ作らないで何作るんだ。
ML は ML コンパイラを作るための言語であると揶揄されることさえあるのに。

でもMLコンパイラはML以外の既存言語で開発されたでしょ？
やっぱバグの疑いを拭いされないんじゃね？
ML的に完璧に正しくコーディングできても。

昔からコンパイラ開発はそのコンパイラ自身を使うことが
言語や処理系のパワーの証明となっているのですな。
だからMLもMLコンパイラでコンパイルすればいい。
gccがCで書かれてるのと同じようなもんだ。

でも最初はそれよりプリミティブな言語で初コンパイラを生成するはずでしょ？
自己記述？はその後でしょ？

もちろん、そのとおり。
でもMLみたいに言語記述に向いている言語なら
プリミティブな言語は使わないで、
最初からML自身で処理系を書けばいいんじゃないの?
という >131 へのコメントでした。
すでにいくつもMLコンパイラは出ているし、
それで困らないと思うんだけど。

ですね。
とは言え、バグの疑いを拭いされる日は多分永遠に来ないですね。

これからSMLofNJを教養としてたしなむ俺様に参考書薦めなさい。

ttp://www.amazon.co.jp/exec/obidos/ASIN/0201398206/
ttp://www.amazon.co.jp/exec/obidos/ASIN/052156543X/

ＪＡＶＡでＭＬのコンパイラ作ればいいじゃん
ＪＡＶＡなら安全性もあって、まともな言語だし、
所詮おもちゃのＭＬとはおおちがいだよ。

>135
バグの疑いを払拭できる日・・・それはどの言語、どの処理系を使っても無理ですねぇ。

ぜんかくえいすう...

>>137
即席であなたのカスタマレビューをつけたまえ。

おいMLはおもちゃ程度のアプリしか作れないのか？

チューリングマシン等価だから、（理論的には）世の中の全てのアプリが書けるよ。

労力というコストパフォーマンスは？
アプリ制作において。
エディタとか2chブラウザとか、アクションゲームとか
ライブラリは貧弱なの？

O'CamlだとOpenGLとか、GTK+2とか、SDLとか使える。

>>145
マジで！？OCamlでゲーム作ってる人いるの?

とりあえずパッと思い出せた分だけ。

ttp://freetennis.sf.net/
ttp://www.rashitoul.net/fr/htm/index.html
ttp://www.cs.ubc.ca/~rbridson/personal/spiff/
ttp://francois.pessaux.neuf.fr/creations.html

>>141
即席レビュー

2冊とも良かったです。以上

OcamlってC++でいうconst修飾子ってないの？

>>148
1人中0人が参考になったと言っています。

>>149
残念ながらない

なんで残念ながらなのかようわからんが、151は釣りか。

ヒント: string は mutable

stringを指す変数自体が非constなわけじゃないべ。

それはへりくつ

www.motiontwin.com
100% ではないと思うが Caml でゲームの開発をしている。

155はCですらポインタが絡むとconstを正しく使えないと見た。

はなから全部MLでアプリ作ろうとは思わんでしょ？
骨組みを手っ取り早く作れるって言語じゃないの？
仕様的に、込み入った処理ができるとは思えない。

それは頭が悪いから。

>>96
「間違ったコードに対してエラーを出すコンパイラは糞だ」とおっしゃりたいのですね？

>>158
込み入った処理ってどんなの？

SML/NJ で引数の型を指定する場合
　　- val hd2 = fn x:int list => hd x;
　　val hd2 = fn : int list -> int
は問題なく動作も予想通りなのですが, 同じものを fun で定義しようとすると
　　- fun hd2 x:int list = hd x;
　　val hd2 = fn : int list list -> int list
list が一段深くなってしまいます.
型の指定を int とだけすると
　　- fun hd2 x:int = hd x;
　　val hd2 = fn : int list -> int
のようになります.
型全体を ( ) で囲んでも
　　- fun hd2 x:(int list) = hd x;
　　val hd2 = fn : int list list -> int list
結果は変わらず, 引数を含めて ( ) で囲むと
　　- fun hd2 (x:int list) = hd x;
　　val hd2 = fn : int list -> int list
ようやく期待通りの結果となります.
　　- fun hd2 x:int = hd x;
　　- fun hd2 x:int list = hd x;
はどのように解釈されているのでしょうか?

hd2 x 全体が int / int listと解釈されてるんでしょうね．

納得しました. ありがとうございました.

>>160
厳密には間違っているけど、動作上意図に完璧に沿う時
Cはコンパイル通してくれるが、MLは駄目だ許さんのいってんばり。
学者のように融通がきかん。

要するに煩く括弧つければいいって事ですか？

なんで自分の頭が悪いんじゃないかと省みることをしない人が増えたんだろう

>>165
動作上意図に沿わない時にも通してくれちゃうのが問題。
あと、Cにも「直感的には大丈夫なのにだめだしされる場合」はあるよ。
同一メモリを互換性のない複数の型でアクセスするのはだめ、とかね。

この関数を呼んでもstringが破壊されることがないっていうのを
コンパイル時チェックで保証できたほうがいいし、
MLの言語設計の他の部分とも考え方が合わないかな？

現状もっともすごいプログラム言語はＭＬだろ？

>なんで自分の頭が悪いんじゃないかと省みることをしない人が増えたんだろう
無駄な勉強やるくらいならHaskellやった方がましだろ。

>>169
つーか、string が mutable なこと自体が間違い。
Xavier 自身も「OCaml を書き直すことがあったら immutable にするだろう」って言ってる。

>>171
そういうやつは Haskell も理解できないと思われ。

ところで、
option と Some の使い方がイマイチわかりませぬ

>>173
値がない状態を None、値がある状態を Some value に統一しとくのさ。

値がない状態を意味するのに 0 とか -1 とか負の数とか "" とか null とか
Nothing とか DBNull とか色々あると面倒でしょ？

サンクスです。じゃ、たとえば

let equal_one x = if x = 1 then (Some("ok")) else None;;

とか定義すると

val equal_one : int -> string option = <fun>

とかなって、上の option の意味するニュアンスは、
「値があるなら戻り値は string 型を内包する Some だお」
「値がないなら一律で None だお」
と言っているわけですね？

>>175
その通りでつ。
option 型にすることで、意味のない値を返さなくてすむのさ。
関数が失敗したら null を返すとかではなくて、None を返せば、いみのない値を間違って
使ってしまう危険性もなくなるわけだな。option 型だと match させないと値を
とりだせないわけだから。

勉強になりますた

エラーチェックが面倒で、いつも valOf を使ってしまう…
よくないのは分ってるんだけどね。

それなら ExtLib 使えよ。
http://ocaml-lib.sourceforge.net/doc/Option.html

1 + 0.1がコンパイルエラーになるなんてこんな糞言語初めてだ

そこで SML ですよ(何

>>180
それ俺も思った
まさに鬼

>>180
1 + "0"
もコンパイルエラーにしないほうがいい？

>>175
例題がいまいちだなー。equal_one だと int -> bool と思えてしまう。

例えば、環境変数HOMEの内容を読み込むとしよう。

let get_home () =
try
Some (Sys.getenv "HOME")
with
Not_found -> None

環境変数は定義されているかどうか不明だから、値がない場合は None, それ
以外は Some になる訳だ。

>>184
確かに漏れのは、よくなかったね
環境変数とかのサンプルの方が使いどころがわかっていい感じでつ
なんだかんだでサンプルコードを見るのが一番近道であると

>> 181
落ち着け。 1 + 0.1 は SML でもエラー。
もちろん 1.0 + 0.1 なら SML は OK。Caml は×。

はぁ。どこの大学の授業で O'Caml/SML 教えているか知らんけど、
(+) についてはもっときちんと解説するべきでは？
初学者が去っていく第一関門に成りかねないだけに TA には
是非頑張ってほしいと思います。

個人的には今の SML 方式が現実的かと思う。
これなら Caml で実装するのも簡単なんだけどな。改造するか。

>>181はOCamlだけ叩いてんじゃなくてML全部叩いてんだろ。

>>187
あ、ごめ。>>180に言ってるのだと勘違いした。
OCamlだけ叩いてると勘違いしたのが>>181か。

公理的集合論の基礎ぐらいはやっておいた方がよい？

さんざん既出だけど、そこで G'Caml ですよ、奥さん。
本当にありがとうございました。

オーバールーｄぃんぐ

Ocamlで作ったプログラムってライセンス的にどう縛られるの？
ライセンス文読んだけどよくわからん。
基本LGPLだけど静的リンクでもライブラリに変更が無ければ縛られない？

簡単に言うと、
配布ライブラリに変更を加えていなければクローズドソース開発可能。
配布ライブラリを改造した場合でも基本的に同様だけど、
ライブラリの改造部分に関してだけは成果をコミュニティーに
バックしてね、ということ。

コンパイラ部分が QPL なのは Caml-Light 時代にパクリ事件があったため。

Ocamlでリストの一部を変えたリストを作ったり間に挿入したりするのってどうやってる？
いったん配列にして破壊的に編集するのがいいのかな。

そもそもそんなデータ構造ははじめからリストとして実装しないだろ？

でもOcamlの配列って拡張不能っぽいじゃん

拡張可能だよ

えっ、できるの？
10年以上 Caml 使ってるけど、、、知らんかった。
どうするの？わくわく。

>>194
>>198
楽しい？

10年以上 Caml 使ってるなら以下略

>>194
Zipper で解決できそうだ。結構便利だぞ。

ただし、解こうとしている問題に対して、本当に「リストの一部を変えたリス
トを作ったり間に挿入したりする」操作がベターなアルゴリズムなのか、再考
してからね。

ocamlfind ocamlc hoge.ml
とかやってもhoge.ml がコンパイルされない・・・なぜ？
エラーが出るとかそういうこともなく、ただコンパイル処理にならない。
これが動かないので ocamlfind 使ったMakefile が失敗します。。。
誰が、同じようなトラブルになった人いませんか？
ちなみに ocamlfind list は動作します。

おおっと
/usr/local/etc/findlib.conf
で、ocamlc="ocamlc.opt" → ocamlc = "ocamlc"
と変更したら上手くいった・・・なんで？

なんか、新しいバージョンのパッケージをインストールした後に
ときたま、ocamlfind list としてもバージョンが変わってないときあるよね？
これってパッケージ作成者の作業抜け？
自分でsite-lib/packagename 内の META ファイル書き換えなきゃいけないの？

Ｏｃａｍｌで拡張可能な配列が実装できないと本気で思ってるの？

METAが書き変わってないのを発見したら、開発者に教えてあげると良い希ガス。
作業抜けだろう。

O'Caml を使って拡張可能な配列が実装できるかどうか、
と、
O'Caml native な配列が拡張可能であるかどうか、
は全く違う。

ちなみに、 Obj.truncate を使えばブロックの短縮は出来る。
詳細は byterun/obj.c を参照。でも、実際に使われているのを
見たことは無い。Planar 専用機能という専らの噂。

>>202
ocamlc.opt を作り忘れてた! なんて事はないですよね?

横内さんの「プログラム意味論」の正誤表ってどこかにないでしょうか？
誤字(誤植？)っぽいのが多くて何を信じたらいいか分かんないよ・・・(´･ω･`)

標準でUnicode対応してほしいなあ。F#つかえばいいんかな。

>>210
F#でもパーサの問題で日本語は表示できんよ。

WDialog 使ってみた人いる？
コレって FastCGI 対応してるんだよね？
本家サイトの説明見る限りじゃかなり期待できそうなんだが

今日使ってみますた
ui のパーサが駄目駄目
凝ったページが書けねえ
や〜めた

WideStudio ってOcaml に対応してたんだね

Zipperおもしろいな。目からうろこが落ちた。

質問させてください。この間、偶然タイプミスから見つけたことなんですが

let a = `a;;

とかすると

val a : [> `a] = `a

とかなりますよね？
これってどういう意味なんですか？

>>216
http://ocaml.jp/archive/document/intro4.html

>>217
有難うございました！

Camomile で、Unicode の文字列を分割した文字列を取る方法が
わかりません

open Camomile
let str = "あいうえお" (* UTF8 *)
let utext = UText.of_string str (* string -> utext *)
let utext_sub = UText.sub utext 0 1 (* utext_sub = "あ"？ *)

ここで、utext_sub を string 型に変換したいんだけど・・・
わかる人いませんか？

ごめん、自己解決しますた。
SubText モジュール使えばいいんだ。

module Sub = SubText.Make(UTF8)
let str = "あいうえお"
let s1 = Sub.refer str 0 1
let _ = print_string (Sub.excerpt s1)

とすると無事に "あ" が出力される
こんなんでいいのかな？

おおっと
自己解決かと思いきや、

let s1 = Sub.refer str 0 2

としても”あ”が出力されてしまふ
これってバグなんだろうか？

ああ、どうも 数字はバイト位置を指定するらしいすわ

let s1 = Sub.refer str 0 4

で”あい”となる見たい

スレ汚しすまんです・・・

下のプログラムを実行して kill -HUP すると uncaught exception が
発生してしまう。
Event モジュールとシグナルって一緒に使うとまずいんですかね？

open Event

let mput ch =
while true do
sync (send ch 1);
Thread.delay 0.1
done

let mget ch =
while true do
sync (receive ch);
Thread.delay 0.1
done

let interrupt n =
Printf.printf "i am %d\n" (Thread.id (Thread.self ()));
flush stdout

let _ =
let _ = Sys.set_signal Sys.sighup (Sys.Signal_handle interrupt) in
let ch = new_channel () in
(* Fire up the compute thread: *)
let t1 = Thread.create mput ch in
let t2 = Thread.create mget ch in
while true do
Thread.delay 1.0
done

>>223
おんなじことやってみたけど、問題なかったよ
sig_test.ml とかを

ocamlc -thread unix.cma threads.cma -o test sig_test.ml

とかコンパイルしてみた。環境は Ocaml 3.09

あ〜ごめん、vmthreads の方をリンクしたら問題なかったけど
threads の方をリンクしたら
Unix.Unix_error(11, "select", "")
とかなったなあ

>>223の自己レス
上のコードの Thread.delay を外したら例外が出なくなったので delay のせ
いかと思いきや、下のコードでも -HUP で例外発生。むー。デーモン君を作り
たかっただけなんだけど、素直に equeue ライブラリ使えってことか？

open Event
let (@@) f x = f x

let wait_accept () =
let socket = Unix.socket Unix.PF_INET Unix.SOCK_STREAM 0 in
let _ =
Unix.bind socket @@ Unix.ADDR_INET (Unix.inet_addr_any, 1025);
Unix.listen socket 10
in
let make_accept socket =
let ac_channel = new_channel () in
let accept_send () = sync @@ send ac_channel @@ Unix.accept socket in
let _ = Thread.create accept_send () in
receive ac_channel
in
sync (make_accept socket)

let interrupt n =
Printf.printf "i am %d\n" (Thread.id (Thread.self ()));
flush stdout

let _ =
let _ = Sys.set_signal Sys.sighup (Sys.Signal_handle interrupt) in
wait_accept ()

さらに事故れす。
socket を nonblock にして返事が戻ってくるまでループさせるようにしたら、
無事シグナルが使えた。

let rec loop () =
try
Unix.accept socket
with
_ -> loop ()
in
sync @@ send ac_channel @@ loop ()

ちょと調べてみると、otherlib/unix/accept.c を見る限りでは、

enter_blocking_section();
retcode = accept(Int_val(sock), &addr.s_gen, &addr_len);
leave_blocking_section();

なので、本来は accept 中はブロックされるみたい。シグナルで無理に起こし
ちゃまずいのかも。
# Cコード呼び出しは全部該当する気がしてきた...--;

>let (@@) f x = f x
コレ、いいね。
漏れも使おう

バイナリファイルを読み書きするときにintが31ビットっていうのがいちいち不便。
わざわざInt32を使うのもなんか納得いかない。

MLton は Integer が 32bit だったような気がするけど。

ml�d

>>229
char 使いなよ。

Ocamlでスレッドってどうやって使うの、いちいち詳しく手順おしえて。

とりあえず手順1としては http://caml.inria.fr/pub/docs/manual-ocaml/manual038.html を熟読することだな。

>>234 Fortranスレッドで聞くと、すごく親切に教えてくれる
　　　Ｃスレッドで聞くと、普通に教えてくれる
　　　ＪＡＶＡスレッドで聞いても結局は教えてくれる。
　　　でＭＬすれっどできくとこれかよｗ

　　　そんなんじゃ、ＭＬユーザー増えないよ。

要は説明できるほど理解してないと

>>229
char でよいとおも

>>233みたいな「教えて君」には使って欲しくないって事だろ（ｗ

無能は重罪だからな（ｗ

>>232
>>237
バイナリファイル上で32ビット整数があってOcamlでInt32で表現して計算をしたい場合
*put_binary_intは使えないから*put_byteを4回繰り返してビット演算でInt32に対応させるしかないじゃない。
なんでこんなことしなきゃならんのと思わないかい。

>>240
MLを使うのが間違い

外部データを読み書きする時は、どうせバイトオーダーに合わせてビット操作が発生するんだから、
バイト単位の読み込みで良いじゃんよ。

正規表現あつかうときなんだけど

let regexp_str = "\[aaa\]"

とかすると、コンパイル時に

Warning : illegal backslash escape in string.

とか出てしまう。
プログラム本体はこれで上手く動いてるからいいっちゃいいんだけど。
この辺の警告はしょうがないんだろうか。

>>243
\が正規表現上のエスケープではなく文字列リテラル表現上の
エスケープと解釈されてるのではないか。
\[aaa\] という正規表現ならば"\\[aaa\\]"と書くべし。

>>244
あわわ
本当だ、ボケまくりでした
�dｸｽです

SML/NJとMLtonでどちらがおすすめですか？

ttp://blogs.msdn.com/dsyme/archive/2006/02/19/534925.aspx
天下のMicrosoftが関わるとこんなすごい物が出来上がるんだな。
研究者がコソコソオナニー開発したところでこのレベルには一生たどり着けないだろｗｗｗ

>>247がMicrosoft Researchのメンバーを見たあと
再び同じ台詞を言うことを期待。

>>247
痛々しいなあ。ｗ

MLton でネイティブスレッドが使えるようになれば、MLton なんだけどなぁ。

>>227
また事故れす。
Unix.set_signal じゃなくて Thread.wait_signal が正解でした。
お騒がせしました。

>>233
OCaml でマルチスレッドなプログラムを作る場合、二通りのスタイルがある。

1) Thread,Mutex,Conditionモジュールを駆使して、従来の pthread ライブラ
リを叩くような感覚で事を進めるスタイル。pthread を使った事がある人
やマルチスレッドプログラミングをかじった事がある人は難なく使える。
ディープな人には物足りない。

2) Thread,Eventモジュールを駆使してお気楽にマルチスレッドを扱える、
concurrent プログラミングと呼ばれるスタイル。concurrent プログラミ
ングに初挑戦の場合、最初は意味が分からない。でも、分かってくれば便
利。基本的に一対多の同期はできないので、やっぱりディープな人には物
足りない。

どちらかというと、2)をお薦め。せっかくOCamlでやるのだから。

例題として、二つの計算を別スレッドで立ち上げて、それらの計算結果を表示
するプログラムを作ってみよう。

open Event

let compute_mul ch = sync (send ch (7 * 8))
let compute_add ch = sync (send ch (7 + 8))

let _ =
let mul_ch = new_channel () in
let add_ch = new_channel () in
ignore (Thread.create compute_mul mul_ch);
ignore (Thread.create compute_add add_ch);
Printf.printf "mul %d\n" (sync (receive mul_ch));
Printf.printf "add %d\n" (sync (receive add_ch))

これを th.ml として保存しコンパイル。

$ocamlc -thread -o test unix.cma threads.cma th.ml
$./test
mul 56
add 15

となるはず。これができれば第一歩ですな。

同じ事だけど、こっちの方がいいかも。スレッドを作って、それへのチャネル
を返すというスタイルが基本。

open Event

let compute_mul () =
let ch = new_channel () in
ignore (Thread.create (fun () -> sync (send ch (7 * 8))) ());
ch

let compute_add () =
let ch = new_channel () in
ignore (Thread.create (fun () -> sync (send ch (7 + 8))) ());
ch

let _ =
let mul_ch = compute_mul () in
let add_ch = compute_add () in
Printf.printf "mul %d\n" (sync (receive mul_ch));
Printf.printf "add %d\n" (sync (receive add_ch))

>>252
横槍ですまんですが、「一対多の同期はできない」とはどういう意味？
Mutex だと、スレッドが一つのリソースをロックしている間に
その他のスレッド全部をブロックできるけど、concurrent を使うと
それができないってこと？

マルチランデブーをサポートしていないということかな?

>>255
send, receive, sync という操作はチャネルを通じて、そのチャネルの両端に
いるスレッド同士の一対一の同期を実現しています。

一方で、一対多の同期(例えば receive 一発で複数の計算の終了を待つ)は
Event モジュールでは扱えません、という意味です。
# もしかして間違ってる？ 識者の方コメントよろしく。

もちろん複数の計算結果を取りまとめるスレッドを作って、そのスレッド経由
で同期を図れば、一対多の同期もすぐにできます。あくまで Event モジュー
ルの話なので。

>receive 一発で複数の計算の終了を待つ
pthread で スレッドハンドルを配列でまとめて join するようなのと
同じ様な操作は Event.sync では実現できない、という
ようなことでしょうか？

>>258
exactly. ちなみに、共有リソースはこんな感じで。

open Event
type 'a mvar = { takeCh : 'a channel; putCh : 'a channel; ackCh : bool channel }
exception Put

let mVar () =
let takeCh = new_channel () and putCh = new_channel () and ackCh = new_channel () in
let rec empty () =
let x = sync (receive putCh) in
sync (send ackCh true);
full x
and full x =
select [
wrap (send takeCh x) empty;
wrap (receive putCh) (fun _ -> sync (send ackCh false); full x)
]
in
ignore(Thread.create empty ());
{ takeCh = takeCh; putCh = putCh; ackCh = ackCh }

let take { takeCh = takeCh } = receive takeCh

let put { putCh = putCh; ackCh = ackCh } x =
sync (send putCh x);
if sync (receive ackCh) then ()
else raise Put

ﾑｽﾞｶｼｽ　(´・ω・｀)

慣れだよ、慣れ

yappari
ﾑｽﾞｶｼｽ　(´・ω・｀)

まじでﾑｽﾞｶｼｽ　(´・ω・｀)

>>259 は難しい
けど、それ以外はそうでもないと思うに一票

>>259は少し先走りすぎたかな。
じゃー、マルチスレッド状態で、複数のスレッドから読み書きできてかつ安全な変数"cell"を定義してみよう。

open Event
type 'a cell = { getCh : 'a channel; putCh : 'a channel }

let get { getCh = getCh } = sync (receive getCh)
let put { putCh = putCh } x = sync (send putCh x)
let cell x =
let getCh = new_channel () in
let putCh = new_channel () in
let rec loop x = select [
wrap (send getCh x) (fun () -> loop x);
wrap (receive putCh) loop
]
in
ignore (Thread.create loop x);
{ getCh = getCh; putCh = putCh }

let _ =
let c = cell 10 in
put c 20;
Printf.printf "v=%d\n" (get c)

>>265
う〜む、select は、リストされたイベントがそれぞれアトミックに
処理されるための処理ですよね？だけど、そこから先がよくわからない
特に以下の部分

let rec loop x = select [
wrap (send getCh x) (fun () -> loop x);
wrap (receive putCh) loop
]

が難しい

event.mli で、wrap はヘッダの説明だと

val wrap : 'a event -> ('a -> 'b) -> 'b event
(** [wrap ev fn] returns the event that performs the same communications
as [ev], then applies the post-processing function [fn]
on the return value. *)

とあるけど、 例えば、 wrap a fn とあった場合は
a というイベントが起きたとき、処理された結果に対して fn を適用する？
みたいな意味なんでしょうか？英語が上手く理解できないかも

select [wrap....] の部分は具体的にはどういうことをしているのでしょうか？

>>266 良い質問です。自然言語で解説してみましょう。

select の部分は、[...] のリストの中に有るイベントの内、最初に発生した
イベントを選んで実行せよ、という意味。アトミックという言葉が適切かどう
か判りませんが、他のイベントは破棄されるという意味で排他的です。

send getCh ... は、getCh というチャネルに x を送信するイベントですが、
受け取る相手が確定するまで待つイベント。

wrap (send getCh...) (fun () ...) は、(send getCh...) イベントが発生し
たらその後に、(fun () -> ...) を実行せよというイベント。

receive putCh は、putCh というチャネルからデータを得るイベント。もちろ
ん putCh にデータが流れてくるまで待ちます。

wrap (receive putCh) loop は、(receive ..) イベントが発生したらその後
に、受け取ったデータを loop に渡して loop を実行せよというイベント。受
け取ったデータはループを回りながら保持されているので、破壊的代入は一切
行われません。

ちなみに、イベントが発生した後に特定の関数を呼び出すのが、wrap。イベン
トが発生する前に特定の関数を呼び出すのが guard です。

>>267
う〜ん・・・
wrap,sellect に関する意味合いは何となくわかりましたが・・・
以下の点がまだよくわからないです

cell を利用する外部のスレッドは、
getCh から受信して、
putCh に送信しますよね？

でも、cell が起動したスレッドでは
getCh に対する「送信」イベントをフックして (fun () -> loop x)
putCh に対する「受信」イベントをフックして loop

送信と受信がcell の内部と外部（この言い方でいいのかわからないですが）
で逆ですよね？これがよくわからないです。

例えば、外部のスレッドが cell から受信するとき、
（すなわち getCh から受信しようとするとき）、
cell 内部ではgetCh に対する送信イベントが起こる？のでしょうか？

また、cell に送信するとき、
（すなわち putCh へそうしんしようとするとき）、
cell 内部では putCh に対する受信イベントが起こる？のでしょうか？

２つのスレッドが相互にチャンネルに対して送受信の要求をしたとき、
もし片方のスレッドが受信を試みたら、もう片方のスレッドがそのチャネルに
対して送信するようなイベントが発生する？のでしょうか？
そういうものなのでしょうか？

ああ、チャネルって、相互のスレッド間の通信のための仕組みだから
片方のスレッドが受信しようとすると
もう片方のスレッドでは送信イベントが起こるってことか
ひょっとして考えて見リャ当たり前なのかな？

>>269
そうです、チャネルの片方で送信すれば、もう片方では受信しなければいけま
せん。

これは、ネットワーク越しの通信でも、サーバがデータを送信すれば、クライ
アントはデータを受信しなくてはいけないのと全く同じです。

>>270
よっしゃ！ようやく理解した！
師匠、ありがとうございますた！

すばらしい。意欲的に理解しようとする人を歓迎します。

では、早速ですが、応用課題ですw 興味のある方はどんどん答えてください。

Q. cell は複数のスレッドから読み書きできる変数として使用できるものでし
た。では cell を改造して、「一度誰かが書き込んだら、二度と書き込めず、
読み込みだけは何度でも出来る変数」を作ってください。

P1(x) := write(x).P2(x)
P2(x) := read(x).P2(x)
P := ΣP1(x)

let cell x =
let getCh = new_channel () in
let putCh = new_channel () in
let rec loop_ex fix x =
select [
wrap (send getCh fix) (fun () -> loop_ex fix x);
wrap (receive putCh) (loop_ex fix)
] in
let rec loop x =
select [
wrap (send getCh x) (fun () -> loop x);
wrap (receive putCh) (fun fix-> loop_ex fix fix)
] in
ignore (Thread.create loop x);
{ getCh = getCh; putCh = putCh }

let _ =
let c = cell 10 in
Printf.printf "v=%d\n" (get c) ;
put c 20;
Printf.printf "v=%d\n" (get c) ;
put c 10;
Printf.printf "v=%d\n" (get c) ;

一応、結果は１０，２０，２０と出る

>>273
よくわからないけれど正解なんだろうね・・・
数学ﾜｶﾝﾈ

273はprocess代数式でしょう。
MLの並行processもこんな風に簡潔に書ければいいね。

誰か >>273 の大雑把な読み方を教えてちょうだいな
ようはどういうことを言っているの？
サラっと数式を書かれると微妙に凹む

へー、プロセス代数なんて物があるのか...

>>247
すばらしい。これも一つの答です。

ただ、put が常に成功するので、本当に書き込めたのかどうか判りづらいのが
難点ですね。2回目以降 put しようとすると例外が発生するなどすると、より
使い易いでしょう。

>>274でした。失礼しました。

Java信者がJavaでハッピーならそれを邪魔する必要がどこにある？
MLor関数型を否定してきても、相手するのは一番後回しでいいんじゃね？

274の人じゃないけど、278の人としては 259の mVar みたいに
・最初に書き込まれるまでは receive しかしない
・書き込まれたら send できるようになる
っていう方式ということ？

259 はさらに、いったん書き込まれたあとでもまた上書きできるようになって
いますね。

>> 280
それがあなた、スレが停滞したときに限って現れるので、
思わず相手をしてしまうのですよ。

>>281
278です。おっしゃる通り。empty状態とput時の例外を採用すると殆どmVarになります。
mVarを一気に理解するのは難しいので、cell -> 272 -> mVar と発展させる予定でした。

mVar について質問させてください

mVar は、利用者が mVar へ書き込んだ後 full 状態に遷移して
利用者が読み込む前に書き込もうとすると Ack false で例外が出るけど
仮に利用者が読み込まないと full 状態にとどまり続けますよね？

つまり、put mVar したあと、誰も take mVar しないと、永遠に put mVar が
失敗しますよね？ 例えば、shareVar を mVar として、

let old = take shareVar in
let _ = put shareVar (old + 100) in
let new = take shareVar

見たいな処理は、無数のスレッドから呼ばれても整合性を保つけれど

let old = take shareVar in
let _ = put shareVar (old + 100)

だと、shareVar はずっと full で書き込み禁止になってしまいませんか？
あるいは、共有リソースは、更新したらその更新した値を参照するのが当たり前と
言うことなのでしょうか？う〜ん、こんがらがってきた・・・

>つまり、put mVar したあと、誰も take mVar しないと、永遠に put mVar が
>失敗しますよね？ 例えば、shareVar を mVar として、
それはその通りです。

おそらく、疑問の出発点は、mVarって何が嬉しいねん? という事でしょう。

mVar は「値を参照・それを元に新しい値の生成・それを書き込む」という一
連の手順を保証するのに適しています。あるスレッドが変数 m に対して

sync $$ mVar.put m $$ calc_new_value $$ sync $$ mVar.take m

したとします。仮に他のスレッドがこの処理の途中で同じような処理をしよう
としても、値が無いので、新しい値が書き込まれるまで待たされます。つまり、
「値を参照・それを元に新しい値の生成・それを書き込む」という一連の手順
は、必ず順番に行われるよう保証されます。

要は mVar は参照したら必ず更新する変数を意図しているのです。ちなみに、
272で示した「一度書き込んだら参照だけ何度も可能で、二度と書き込めない」
変数は iVar と呼ばれ、データの受渡しやStreamの実装など、幅広く使える変
数です。

ごめんなさい、
sync $$ mVar.put m $$ calc_new_value $$ sync $$ mVar.take m
じゃなくて、
mVar.put m @@ calc_new_value @@ sync @@ mVar.take m
でした。ちなみに、@@ は、let (@@) f x = f x です。

あっ、mVar ってモジュール名使えないじゃん。失礼しました。適当に読みか
えてください ToT

SML# alpha release sage

>>285
なるほど、一連の手順がスレッドセーフになることを保証する
変数を抽象化しているわけですね

ところで、mVar、iVar の それぞれ i、m って何の略なんでしょうか？

mutable/immutable

>>290
あ、なるほど、THXです

厨な初心者質問で恐縮です
O'Camlで互いに呼び出し合っている様な大域で束縛された２つの関数を作りたい場合、

let rec f1 x =
　if (x <= 1) then 1
　else x * f2 (x-1)

let rec f2 x =
　if (x <= 1) then 1
　else x * f1 (x-1)

みたいに書くと「束縛されてない"f2"」を呼び出そうとしているので怒られます。
でどうしようかと悩んだのですが、

let rec f0 f1 x =
　if (x <= 1) then 1
　else x * f1 (x-1)

let rec f1 x =
　if (x <= 1) then 1
　else x * f0 f1 (x-1)

let f2 = f0 f1

みたいな書き方しか思い付きませんでした ('A`)
普通はどう書くものなのでしょうか？

let rec f1 x =
　if (x <= 1) then 1
　else x * f2 (x-1)
and f2 x =
　if (x <= 1) then 1
　else x * f1 (x-1)

>293 … orz

"and"の意味を思いっきり誤解しておりますた ('A`)
てっきり「同時に束縛される＝束縛の式記述内でもう一方の束縛は使えない」と思っておりますた
「評価」されなければいい、ということでしょうか？

もう一つ似たような問題に悩んでいまして、互いに参照(？)しあう型定義をしたい時

type type_a = int * type_b
type type_b = int * type_a

とか出来ないので、

type 'a type_ = int * 'a
type type_a = int * type_a type_
type type_b = int * type_a

とか考えたのですが、これももっと良い書き方があるのでしょうか？

バリアント型として定義し、andで繋いで相互再帰にする。

type type_a = ACons of int * type_b
and type_b =BCons of int * type_a ;;

ていうかこの型、終端がないじゃないか！ 無限リスト？

>295
やっぱり綺麗な書き方があるんですね orz
バリアント型をちゃんと理解できてないようなのでもう少し勉強しまつ

ちなみに上のコードは問題箇所だけに単純化して書いたので、
実際に考えていたコードは片方をバリアント型として定義して
終端させる所で終端データを束縛させています

厨な質問に相手をして戴き、ありがとうございました。
おかげでとても勉強になりました m( _ _ )m

>>296
-rectypes オプションつけるという逃げ方もあるよん

これも....〆(･ω･｀ )めもめも

OCaml の object って多相レコードだと思っていいの？

>>299
意味論とか詳しいことは判りませんが、let name p = p#name みたいな事がで
きるという意味では、正に多相レコードと同じですねー。
# ad-hoc とか subtype とかと言えばいいのでしょうか?
# あと、両方 parametric pol. 出来ますねー。

object で言うところの val と method の違いは mutable かどうかに対応す
るのでしょうか?

あと、object では initializer とか inherit とか便利な構文がありますが、
これは多相レコードには無さそう...?

ねー。
か?
ねー。

か?

う...?

なんか久しぶりに 2ch ぽいレスを見た気がする…？

授業で扱ったSMLが楽しかったので関数型言語を勉強したいと思っているのですが、
OCamlとSML、どちらの方が人気があるんでしょうか？
また、よりいろんなことができるのはどちらになるんでしょうか？
このスレではほぼOCamlの話題で埋まってるみたいですけど…

Ocaml の Record 宣言なんだけれども

type atype = { name : string; desc : string }
type btype = { name : string; point : int }

とか宣言して、

let get_name (x : atype) = x.name

とかすると、

This expression has type atype but is here used with type btype

とかでてしまい、atype として使えないのですが、これを
回避する方法ってないのでしょうか？

あ、自己レスだけどヴァリアント型とかいうのを使えばいいのかなぁ

宣言の順序から「name」というフィールド名が btype に対応するようになっ
ているのが原因。そういう宣言のときには atype の name にさわることはで
きない。

実際の利用局面にもよるがバリアントはレコードと違う(双対の関係にある)の
でたぶん関係ない。


多相的なレコードを OCaml でやろうと思ったら、とりあえずオブジェクトを
使えということです。
class atype (n:string) (d:string) = object
method name = n
method desc = d
end
class btype (n:string) (p:int) = object
method name = n
method point = p
end

let get_name (x : atype) = x#name

補足すると、

let get_name x = x#name

とすると、 get_name の型は < name : 'a; .. > -> 'a になる。つまり name
というメソッドのあるオブジェクトならオーケーなので、 atype でも btype
でも get_name に適用できる。

おお！まさにそれで上手く出来そうです。
ありがとうございますた。

前々からできるのか、最近できるようになったのかは知らないけど、
let x = object method name = "taro" end;;
で直接オブジェクトが作れたりする。。
けど、これ camlp4r の改訂版構文(?)だと使えないんだよな。
ガリグさんの polymap みたいに
let x = `{ name = "taro" };;
で上の宣言に変換されるようなマクロを書こうと思ったんだが…。
なんか解決策あったら教えてくれ。

多相レコードといえば、SML# alphaを入れてみた。
今時SML/NJの110.07なんて公式サイトをだいぶ探さないと
見つからないから難儀したぜ。

TextSS　のWindowsXP(Professional)64bit化おながいします

もしくは64bitにネイティブ対応したテキスト置換ソフトありますか？

>>310
SML# を体験してみた感想はいかが？
レコード多相やランク1多相もいいけど、Cとの連携がいけてるらしいけど、ど
んなもんかな。
IEEE 854(マージされた754でもいいけど)とかに対応してると、とっても実用
的って感じ。

>>299
型の観点からは多相レコードと一緒。
大堀先生の多相レコードとまったく同じだと思えばいい。

>>300
細かいことだけど、多相レコードの型つけはsubtypingとは違う。
< name : 'a; .. > -> 'a
は、
∀ρ . < name : 'a; ρ > -> 'a
で、ρが適当に代入される。
多分、意味的にはParametric Polymorphismと一緒。

>>304
オブジェクト使うのも手だけど、OCamlの標準ライブラリを見た感じだと、
レコードのラベルには型名のprefixをつけてるみたいだね。

SML/NJ触った後、どこ行けばいいの？
オキャメル？ハスケル？

SML#

OCamlのプログラムを書いているとき、
Visual Studioのインテリセンスのように、
コード補完や、型名の表示をしてくれるエディタが
激しく欲しいと思うのですが、みなさんはどうでしょうか。

さあビジネスチャンスはそこに広がってるぞ！
何故自分で創らない！？

>>316
つ F#

F#ってもう公開されてるの？

F#、少しだけさわってみたけど、文法がOCamlと少し変わっているし、
.NETのメソッドやなんかはカリー化できない。
結局、やっぱり.NETではC#を使おうと思った。

>.NETのメソッドやなんかはカリー化できない。
ｶﾞｰﾝ

タイプパラメータの + 'a, - 'a の +,-の意味がよくわからないです。
どなたか教えてくださいまし

MLtonってミルティンって読むのか。
今までエムエルトンって言ってたぜぃ。

>>323
まりがとん

ぬるぽん

SML#ってどうなの？
とりあえずおれに
１．ランク1多層性
２．多層型レコード演算

について、従来のMLとの違いがわかるようにおしえてくれ。

ちなみにSMLってオブジェクトはつかえるの？

SMLでグラフィックってかける？

実は、たったの２４時間で、
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
あなたの今後のネット収益を倍増するスキルがあります。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
それを知りたい方は、他にいませんか？

アフィリエイトを使わずにホームページとＥメールだけで3,000万以上稼いだ
インターネット・マーケッターの宮川さんが、

巨大な現金の山を作り出す門外不出の一生涯使えるノウハウを
下記のサイトで公開しています。

その内容をお知りになりたい方は、下記をクリックしてください。

【たったの２４時間で あなたの今後のネット収益を倍増するスキルとは？　】
http://infostore.jp/dp.do?af=moneyclick&ip=successpreneur&pd=01

>>326
従来のMLの多相は、多相の限量子が型式の一番外側にしか来られないが、
これを直和型（バリアント）、直積型（ペア、レコード）、関数型の値域（矢印の右側）に
一段分だけ入れ子になって表れてもいい体系がランク1多相。

ところで、MLには参照型があり、こいつを多相型と一緒にすると色々具合が悪い。
例）
val x = ref (fn x => x);  (* 'a -> 'a 型な関数への参照x *)
x := (fn x => x + 1); (* int -> int 型の関数をxに代入 *)
(!x) "string"; (* 型エラー *)

こうならないように、MLでは多相型になれる式を、定数・変数・関数式（fn x => ...）、および
これらをペアやデータコンストラクタで組み合わせた式に制限している。

しかし、この制限によって、明らかに多相型を与えても問題無いような式も制限されて
しまうことがある。
例）
fun f x y = (x, ref y);  (* 'a -> 'b -> 'a * 'b ref  *)
f 1;  (* 'b -> int * 'b ref になりそうな気がするが (f 1) には多相型がつけられない *)

ランク1多相ならば、 f に∀'a.'a -> (∀'b.'b -> 'a * 'b ref)、(f 1) に∀'a .'a  -> int * 'a ref
みたいな型をつけることができ、この制限を大幅に緩和することができる。

次に多相レコード。

普通のMLのレコードは、#name などとすると、レコードからnameフィールドの値が取り出せるわけだが、
このレコードの型はコンパイル時に完全に決まっていなくてはならず、nameフィールドを持つレコード型なら
何でもOKというものではない。
多相レコードでは、例えば fun name x = #name x みたいな関数を定義すると、{ name=3, ... } だろうが
{ ... , name=1.5, ... } だろうが { ..., name="hoge" }  だろうが、nameフィールドを持つレコード型全てに使える。
しかも、レコードの何番目のフィールドを取り出せばよいかは、コンパイル時における型の単一化プロセスで
静的に決定するので、実行時にサーチするオーバーヘッドもない。

(∀'b ←顔文字

ホウ！
じゃ、
∀'a.'a -> (∀'b.'b -> ∀'c.'a * 'b ref * 'c) みたいなのはランク１じゃなくなるってこと？

MLの王者は何言語？
Haskell

>>333
総括する言語として作られた、という意味に置いては。

fold_left の折り畳みを回数制限つきで実行させる fold_left_count
を実装するとして、みなさんはどうやって実装しますか？

fold_left_count (fun a b->a+b) 0 [1;2;3;4] 3

としたら３回だけ畳み込んで、１＋２＋３を計算してくれる、みたいな
そもそもそんな関数作らずに〜しろ、とかそういうのでもいいです

MLの具体構文を忘れたのでHaskell風に

fold_left_count f a xs n = foldl f a (take n xs)

おれもそう思ったんだが OCaml って take 相当の関数ある？
ExtLib 入れないとない気がする。
自分で定義してもさほど面倒ではないが……。

あと (fun a b -> a + b) は (+) と書く方が普通じゃないかな。

Haskell のことはよくわからないけれど・・・
take っていうのは、呼ばれた回数をどこかで管理しなくちゃいけないよね
なんか、裏で副作用を伴うカウンタを持たせてるって事？

無論、副作用を使っても良いかもしれないが、

let rec take n xs = match n, xs with
| 0, _ | _, [] -> []
| n, _ when n < 0 -> []
| n, x::xs -> x :: take (n-1) xs

とかいう風にやるのが普通だと思う。

ああ、なるほど！
やばい、俺頭固いわ
ありがとう >>339

ExtLibだとtakeは末尾再帰になってるね。
外部関数よんで実現しているが。

Haskellの場合、末尾再帰にしてもそれほどうれしくないし
lazy listとの直観的な対応として>>339みたいにやるのが一番おさまりがいいのだ。

ExtLibのtakeは頭から取っていった要素を中間リストに破壊的appendすることによって
末尾再帰にしている。
Schemeのset-cdr!みたいなのを外部関数使わなきゃ実現できないってのがかっこわるいが。

破壊、かっこ悪い

外から見て関数的なら内側に破壊的操作が含まれていることの何が問題なのか？

今気づいたが、よく見るとこの take というのは、SICP で見た
いわゆるStream というものと同じですね

>>344
ファーストクラスの継続があるとまずいよ。

>> 346
よく分からんけど、マルチスレッドでも問題になる？

>>347
いや、一回しか再開しないなら問題ない。複数回再開する場合
前回の実行でローカルな状態に加えた変更が影響することがある。

(fun a b->a+b) は (+)

では、

(fun x->x)

はなんて書いたらいい？

?
そのままじゃ

・・・あれ？
自分でも何でこんな質問したのか思い出せないｗ
なにを疑問に思ったのだろう？

object is poormans closer!!!!!!!!!!!!

>>352
何回もｺﾋﾟﾍﾟされてはるけど、closer じゃなくて closure じゃないの。

マニュアルにはinfix symbolsは左結合ってかいてあるのに、
# let (@@) f x = f x;;
val ( @@ ) : ('a -> 'b) -> 'a -> 'b = <fun>
# List.iter @@ (fun _ -> ()) @@ [];;
This expression has type unit but is here used with type 'a -> unit
とうように
(List.iter @@ (fun _ -> ()) @@ []
でなくて、
List.iter @@ ( (fun _ -> ()) @@ [])
となってしまうのはどうして？

>354
どこのどのマニュアルの話？
http://caml.inria.fr/pub/docs/manual-ocaml/manual015.html
の表を見ればわかるが、中置記号は先頭あたりの記号の種類で結合方向が決ま
る。 @ から始まる記号は右結合。

> 355
orz そのとおりでした。

OCamlを勉強し始めたところですが、最近ではHaskellが人気のようです。
そこで、OCamlとHaskellとを比較したページとかはありませんか。
自分で調べた限りではこんな感じでした。
OCaml - 非純粋関数型、遅延評価なし、
Haskell - 純粋関数型、遅延評価あり、モナド？
どなたか、より詳しい比較（使い勝手とか速度とかメモリ使用量とかライブラリとか）をしてないでしょうか。

>357
それ、自分も知りたい。
Haskellは純粋関数型だから副作用のある関数が作れないんじゃない？
だとしたらけっこう実用になるプログラムを書くのが難しそう。
どうなの？そこんとこ。

>>357
それって2chだけの話だろ？ww(俺は元OCaml工作員)
前からHaskellの方が人気だよ

OCaml だってやろうと思えば遅延評価はできる。デフォルトがどちらかという
話。 OCaml で遅延評価ばりばりのコードを書くのはちと大変。

また、 Haskell だって副作用のある関数が書ける。しかしふつうの関数とは
違うので、実際のコードでやるのは面倒くさい。

ふつうに書くなら、 OCaml の方が速い。ライブラリは、 Haskell の方が汎用
的なデータ構造ライブラリは揃っている気がするが、一般的によく使うライブ
ラリは OCaml の方が若干、揃っている。メモリ使用量は比べたことないな。

そもそも文字列ですら文字リストなわけで・・その分・・

http://d.hatena.ne.jp/tanakh/20040725#p2
ここによると一文字20バイトだそうだ。

どうもありがとうございます。
>>358さんがかいているように、実用になるプログラムが書きやすいかどうかは非常に興味あります。
関数型言語の本を読むとたいがい数学チックな例題ばかりで、例えばWebアプリのようなものは見受けられません。
数学チックなものはたしかに関数型言語では書きやすいのですが、
ファイルやネットワークのような入出力、あるいはデータベース処理とかいったところが
どうなのかなと思っています。
そこらへんでの、OCamlとHaskellとの比較があればうれしいですねー。

>>360-362
なるほど。メモリ使用量はHaskellのほうが多いみたいですね。
Webアプリだと数値計算はほとんどなくて文字列処理ばかりなのですが、
それだとHaskellの富豪ぶりはちょっと問題ですね。
参考になりました。ありがとうございます。

>>363
っ ttp://www.informatik.uni-freiburg.de/~thiemann/WASH/


関数型言語「懐疑派」は、実用的なサンプルが示されないと
ひとしきり文句言って、示されたら示されたで、「それは他の言語でもできる」だの
「そのシステムを作った人間の能力が高いのあって、関数型言語の能力の高さを
証明するものではない」だの

って、なんでここでHaskellの話になってんだ。

あっ>>364の愚痴の部分は別に>>363さんに言ってるんじゃないからね

っていうか、関数型言語関連のスレ住人ってほとんどかぶってるんじゃないかな。
MLとかHaskellとかLispとかetc..を分ける必要はあるのかな・・

何となくLISPは他とかぶってない気がする

>>366
いちよ、統合スレはあるんだけどね...

関数型言語Part IV
http://pc8.2ch.net/test/read.cgi/tech/1083649982/

以下、順次リストのお尻に処理結果を繋げていく処理ですが、
どちらが速度面、メモリ面で好ましいのですか？
前から疑問に思ってたもので・・・

�@ 「::」で繋いで、最後に逆さまにする
let hoge f list =
let rec iter = function
| h :: tl -> (f h) :: (iter tl)
| [] -> []
in
List.rev (iter list)

�A 「@」で即座に後ろに繋げていく
let hoge f list =
let rec iter = functoin
| h :: tl -> [f h] @ (iter tl)
| [] -> []
in
iter list

>>369
1はO(n)、2はO(n^2)

すいません、どなたか、できればｋｗｓｋ

>>371
実際にどれだけ時間がかかるかは色んな細かい条件に依存するけど、確かな事として、
・1はおおまかに入力の長さに比例する時間がかかる
・2はおおまかに入力の長さの2乗に比例する時間がかかる
よって、入力が十分大きい場合、1の方が速い。

２は、お尻に繋げるときに、毎回連結リストの最後を探しに行くので
n^2 見たいな事でしょうか？こっちはなんとなくわかります。

でも１の、リストの反転って、すばやくできるんでしょうか？

>>373
リストの反転はO(n)で出来る
let reverse ls =
  let rec rev ls = function
  | [] -> ls
  | x::xs -> rev (x::ls) xs
  in rev [] ls 

ありがとうございます！
そうか、リストの反転がＯ（ｎ）ということなんですね
「：：」はＯ（１）なんですね、ただつなげるだけですもんね
すこし恥ずかしい勘違いをしてました。
Ｏ(n) という言葉を最近覚えたことがバレてしまうorz
スレ汚しすみません

>>369
つ List.map
というか(1)のやつ最後に反転させる必要が無いような気が。

>>376
う！！！
その通りですた・・・

今回のは、例えば末尾再帰にして、
結果を引数にストックしていくような処理を書くときに

let rec hoge f ret list =
let rec iter ret = function
| h :: tl -> iter ((f h) :: ret) tl
| [] -> ret in iter [] list

こんなときに、リストのそれぞれに処理した結果を元のリストの順で
並べたいとき、上の例だと ret を反転させないといけないじゃないっすか
でも確かに map というのがそのためにあるんですねorz
いや、知らないって怖いです、本当に・・・

>>362
Haskellって文字列がばかでかいみたいだけど遅延評価があるからなんとかなっているんでしょ?

確かに遅延されてるうちはいいが、ひとたびリストをたぐっていくと
そのそばからキャッシュしていってメモリを食う。
foldｌ系の関数を作って値をまとめてるつもりでも、その演算すら遅延されるから
簡約グラフがリストと同じような形で残り続ける。

>>364
まあ、言語には向き不向きがあって、
関数型言語は実用的なアプリケーションの作成には、不向きってことでいいの？
OCamlがコンパイラ書くのに使う以外みたことなかったりするのも、
それが原因ですか？

たしかに言語自体に向き不向きなアプリケーションがあるけど、
大部分のアプリケーションは、CやJavaで書くのも、関数型言語で書くのも大差ない。
それより、ライブラリや、ネイティブコードを吐けるコンパイラなど、
開発環境が整っていないのが大きいと思う。

>>379
それを防ぐために`seq`があるわけだが

結局、関数型のプログラミングスタイルというのはプログラミングスタイルの一部で
しかなく、関数型で簡単に書けるところは関数型で書き、命令型で簡単に書けるところは
命令型で書くというのがいいんじゃないかなと、最近思う。
言語としては、この両者を自然に行き来できるものが最高だろうと思う。

つまりOCaml最強ということですね？;-)

MLやHaskellやSchemeはその両者間の行き来が十分に自然じゃないってこと？

OcamlはMLだよねえ
Haskellは命令型で自然に書けない
Scheme(Lisp)はCurry化が無い

>>386
>>385は>>383へのレス

>Haskellは命令型で自然に書けない
よくわからん。Haskellではdo記法のおかげで
MLと大差なく自然に命令型のプログラミングができると思うんだが。
>Scheme(Lisp)はCurry化が無い
カリー化と命令型プログラミングにどういう関係がある？

>>387
Haskellは副作用を自由に使えないよね．
両方使ってみた実感としてHaskellよりML(Ocaml)の方が
はるかに命令型プログラミングは楽．
あとSchemeの方は，Curry化がないので関数型プログラミング
しにくいってことね

>>388
なるほど、回答ありがとう。

そんなことどうでもいいから最強言語スレにでもいけや

？

ＷＥＢで拾ったＰＤＦでラムダ計算を勉強しようと思ったのですが、
その中で、タプルを

(e1,e2) = λc.c e1 e2

と表現できて、

match e1 with
(f,s) -> e2

が

e1(λf.λs.e2)

を表しているそうなのですが、なぜこうなるのか、これが何を意味するのかが？？？です。
参考にしたのは、
ttp://www.kb.ecei.tohoku.ac.jp/~sumii/class/keisanki-software-kougaku-2005/lambda.pdf

です。
識者の人 智恵を貸して下さい。

>>392
実際に簡約してみればすぐわかる。

(λc.c e1 e2) (λf.λs.e3) -> (λf.λs.e3) e1 e2

>>393
ありがとうゴザイマス。何となくわかったような気がするんですが
一応、勘違いしていないか確認させてください

x = (e1,e2) として、
match x with (f,s) -> e3

が

(λc.c e1 e2)(λf.λs.e3)
-> (λf.λs.e3) e1 e2
-> e3

ということなんですか？

要するにJAVAにファーストクラスのメソッドなり関数を入れれば
それが最強だということジャン。

え？なんで？

Java からクロージャを外したのは言語デザイン上の選択だから、今さら入らないでしょ。

2つのリストの要素のあらゆる組み合わせを得る関数
(たとえば
func [1;2;3] [1;2;3]
=> [(1,1);(1,2);(1,3);(2,1);(2,2);(2,3);(3,1);(3,2);(3,3)]
のようなの)
を作ったら、どういう名前をつけるのが適当でしょうか?

おれなら、allElemPairList_of_2list
だね。

そゆんじゃなくて、タームがあるといいんですが。
日本語だと総当たりみたいな。
full_combine ぐらいかなあ。

jibunndetukuranaikagirisonnnabakagetakannsuunita-munanntearuwakene-daro,konobokega

>>398
cartesianProduct。

>>398
クラス名・変数名に迷ったら書き込むスレ。Part7
http://pc8.2ch.net/test/read.cgi/tech/1144978008/

>>402 それだと、あまりにアバウト杉

そうか？

がっかい

direct_product

>>398
permutation

さすがにそれは違うだろ。

O'Camlの対話環境で、現在の状態(環境)を保存したり復元したりすることはできるのでしょうか？

スナップショットが持ち運べると便利かなぁと

無いと思います。

そうすか、ちゃんと纏めてないとダメすか

tuareg-run-ocamlのHistoryを纏めて保存する機能とかないのかなぁ…

>410

#!/usr/bin/perl

open OUT, "> temp" or die "Cannot create file";
$| = 1;

while (<STDIN>) {
if (/\s*\#quit\s*;;/) { last; }
print OUT $_;
print;
}

close OUT;

とか適当に入力を記録するスクリプト書けば、入力したものはファイルに残せる。
エラーが起こる入力も含めてだけど。

↑　をパイプでつないで対話環境を実行ね。

$| = 1;

は必要なん？

そんなら script 使えばいいのでは。

tuareg-mode の run-ocaml を使ってるなら、バッファの内容を全選択→コピー
→適当に編集して保存、てのはだめ？　っていうかそれが面倒という話？

>413-414

参考にさせて頂きます m( _ _ )m

>416

おっしゃる通りで、それも検討致しました。
結局は非対話的部分をﾌｧｲﾙに書いて、対話環境で「#use "hoge.ml";;」てな感じで反映させてます。
なんかもっと良い方法がないものかと思いまして質問致した次第です。

ocamlsdlがやっと動いたー
苦労させすぎ

ごめんねー、お父さんさえ元気でいてくれたら、お前にこんな苦労(ry

Debian使えば(ry

だめだー
SDLとOpenGLを同時に使おうとするとビルドできない
それぞれ単体だといけるのに

>>418
関係ないけど、OS何？Windows？
だとしたら、手順をまとめてくれるとうれしいな

環境は、winXP + OCaml-3.09.0-msvc + ocamlsdl-0.7.2 + SDL-1.2.10。

手順はだいたいINSTALL.win32のとおり。
それとは違う、工夫が必要だった点は、

〜ビルド時〜
・makefile.config.msvcの下のほうにある、
　MKCMXA = $(OCAMLOPT) -a -o $(1).cma〜 を
　MKCMXA = $(OCAMLOPT) -a -o $(1).cmxa〜 に変更する。

・makefile.config.msvcの下のほうにある、
　MKCLIB = lib /out:lib$(2).$(A) $(3) を
　MKCLIB = link /lib /out:lib$(2).$(A) $(3) に変更する。
　INSTALL.win32にはlib.batを作れとあるが、代わりにこうする。

（続く）

〜ビルド後〜
・libsdlloaderstub.lib、libsdlmixerstub.lib、libsdlstub.lib、
libsdlttfstub.libをリネームする。
どのように変えるかはコンパイルエラーを参考にすべし。

・DLLの方のSDL.libとocamlsdlのSDL.libがかち合うので、DLLの方の
ライブラリパスを先に書く。

・デフォルトライブラリがかち合うので、
-cclib "/link /NODEFAULTLIB:msvcrt.lib"
を指定する。

これで、ttp://shinh.skr.jp/testsprite/ のOCaml用ソースが
コンパイルできて動いた。

と、ここまではよかったのだが、ocamlglと併用しようとすると
ビルドがうまくいかない。
どうにもならなかったので、Cygwin + MinGW 用のOCamlで挑戦してみたが、
こっちはライブラリのビルドすらうまくいかなかった。

こちらの現状をこんなところ。あともうちょいのところでうまくいってない。

ここに書いてあるOCamlのまともな問題の１００％がJavaで解決できる件について

小回りのきかない、めんどくさい、糞言語　→　Java

食い付くなよ

>>426
MLはバグが出にくいのがとりえだと思ったんだが・・

>> 423
makefile.config.msvc の MKCMXA の所で .cma と typo したまま
リリースしている時点で、 ocamlsdl の作者は windows でのテストは
まじめにやってないんじゃないかと、、、

こういう外部ライブラリインターフェース系はほとんど linux で開発が
行われていて、windows へのポートはあまりサポートされておらず、
サポートされているように見えても、実は地雷原になっているという
一般的印象があります。開発者が windows に興味を持ってない場合
どうしようもないけど。

とりあえず linux で ocamlgl + ocamlsdl をやってみて動いたら
windows へ、というのはどうですか？

ocaml で ifdef みたいなのってどうやるの？

camlp4 で pa_macro 使え

>>431
THX!!
camlp4 ってのはなんだか凄そうですね
pa_ifdef ってのがあるみたいですけど、これ使えばいいのかな
でも何となく使い方はわかった
けど camlp4 の書き方とかは難しそうだな

m4を知らずにぼくらは生まれた

caml 文字列の連結って遅い？コピーとか発生するの？

文字列はmutableなのでコピーは不可欠

じゃあ、"aaa" ^ "bbb" だと、
６文字分の新規領域を作って、そこに６文字コピーするってこと？
でっかい文字列を効率よく連結したいときは、Buffer とか使うの？

連結の数が多いときBufferを使う。
一回の連結の時どちらが早いかは自分で調べてくれ！

>>436
> そこに６文字コピーするってこと？

それは実装による。

ありがとう。
今でっかい文字列を扱う処理を書いていて、色々と切り取った文字列を
リストに貯めておいて最後に連結、みたいな処理書いていたんだけど
これってBufferつかったら速くなりそうだ。

Ocamlで書いたプログラムをJavaのプログラムに組み込むのって
どうやってやればいいのですか？

なんか定番的なOcaml本ってないですか？英語可

>>441
ttp://caml.inria.fr/pub/docs/oreilly-book/
など。

http://caml.inria.fr/pub/docs/oreilly-book/

>>443
>442

ファンクターという概念が未だによく理解できません
数学的にもOcaml 的にも。
ズバっと理解できる単純な説明はありませんか？

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

ところで、pa_extend とかの pa って何の略？ pattern ？

pa は parser。 pr が printer

�dｸｽ

数学的にどうとかは知らんけど、
ファンクターってモジュールを返す引数付きのモジュールでそ。
モジュール関数みたいなもの？
んで、引数にはモジュールもファンクターも取れるので、高階らしい。

そういえば、第一級のモジュールを実装って話はどうなったんだろう。

>>450
なるほど。かなりスッキリしますた。

ファンクターでぐぐったら、こんな感じの説明があった
ttp://www.math.kochi-u.ac.jp/katsumi/kenkyu-ama.html

カテゴリーとして「日本国民」があって、これから別のカテゴリー「日本の人口」
を対応させるために選ぶファンクターが「国勢調査」なのだそうです
なんとなくわかったような

>>452
その説明だと関数とファンクターの差がわからない気がする。
準同型写像になる良い例があるといいのだが。

>>453
準同型写像になる良い例、というのを漏れにもわかる喩え話しでｷﾎﾞﾝﾇ

それと、Ocaml でファンクターっていうときに、
モジュールに与える引数をファンクターっていうのか
あるいはそういう引数を取れるモジュールをファンクターっていうのか
どうにも混乱するのだが実際はどっちなの？

漏れw
ｷﾎﾞﾝﾇw

>>454
後者でしょ。で、前者の引数にファンクターも指定できる。

map

ML初心者です。
SML/NJで遅延評価ってできますか？
Webで読める資料とかあったら教えてください。

>>458
SMLは遅延評価してません

>>459
ttp://wiki.ocaml.jp/index.php?%B4%D8%BF%F4%B7%BF%B8%C0%B8%EC%A4%CE%C8%E6%B3%D3%2F%C3%D9%B1%E4%C9%BE%B2%C1
ここの記述を読んで期待したんですが、無理ですか…
OCamlでも試してみようかな。

ぐぐったらLazySMLとかSMLofNJ.Suspとかいろいろ見付かるんだが、これは違うの？

>>461
少なくともSMLとは違うのものではないでしょうか。

元が SML/NJ でって書いてあるから、良いんじゃないの。

>>461
ググってみました。
全部英語ですね…
頑張って読んでみます。

日本語の資料を期待していたらしい時点で
>>458は相当の素人だと推測できる。

(* Susp -- support for lazy evaluation *)

type 'a susp

val delay : (unit -> 'a) -> 'a susp
val force : 'a susp -> 'a

(*
['a susp] is the type of lazily evaluated expressions with result
type 'a.

[delay (fn () => e)] creates a suspension for the expression e.
The first time the suspension is forced, the expression e will be
evaluated, and the result stored in the suspension. All subsequent
forcing of the suspension will just return this result, so e is
evaluated at most once. If the suspension is never forced, then e
is never evaluated.

[force su] forces the suspension su and returns the result of the
expression e stored in the suspension.
*)

http://www.sato.kuis.kyoto-u.ac.jp/~igarashi/class/isle4/mltext/ocaml.html#htoc63
ここの無限リストについて、
「ヴァリアント型をわざわざ使わずに，要素と関数の組で表現することも原理的に可能である」
ってあるんですけど、実際にヴァリアント型を使わずに書くにはどう書いたらいいんですかね。

>>467
# let rec from n = (n, fun () -> from (n + 1));;
# let head (x, _) = x;;
# let tail (_, f) = f ();;

単にこうゆうことじゃない？

Ocaml 3.09.0ですが、こうなっちゃいます。

# let rec from n = (n, fun () -> from (n + 1));;
Characters 17-44:
let rec from n = (n, fun () -> from (n + 1));;
^^^^^^^^^^^^^^^^^^^^^^^^^^^
This expression has type int * (unit -> int * (unit -> 'a))
but is here used with type int * (unit -> 'a)

>>469
-rectypes オプションで動かしてると大丈夫

ほんとだ。どうもありがとう

＞-rectypes
＞ 型チェックの際、任意の再帰的な型を許します。デフォルトでは、オブジェクト型を経由する再帰による再帰的な型しかサポートされません。

関数型言語を勉強するのは蟻
手続き型言語で十分だと言ってる奴はキリギリス

誤爆

むしろ手続きのほうが蟻な気がす。

関数型言語を勉強する奴は犬
手続き型言語で十分だと言ってる奴は猫

関数型言語を勉強するやつは淫乱
手続き型言語で十分だと言ってるやつは淫売

むしろ手続きのほうが犬な気がす。

>>477
サンダルの愛し方で犬だろう←関数型

# let rec f = 1 :: f;;
とかやると、
val f : int list = [1; 1; 1; 1; 1 ...]
っていう無限リストができるけどこれって何に使えるんでしょうか？

通常の再帰関数だと停止させるための条件を書かないといけないが、
無限リストだと、takeとかnthで簡単に取り出せる
とか言ってみるテスト

でも例えば
let rec f x = 1 :: f (x + 1);;
これが[1; 2; 3; ...]っていう無限リストになるんなら使い道はありそうだけど
Ocamlで普通のリスト（takeとかが使える形の）で無限リストができるって>>479みたいなものだけですよね。

質問の本質的意図を明確に

>>481
少し勘違いしてた。確かに、
> let rec f x = 1 :: f (x + 1);;
このタイプの無限リストは使えない。

でもlazyを使えば、遅延リストとして無限リストが実装できて、
そっちの方が頭の中にあった。

ttp://www.jmuk.org/d/?path=2005/03/24
ここにLazyListというのがあって、それを使えばフィボナッチ数列のコードが
let fib () =
　let rec loop a b =
　　LazyList.lcons a (lazy (loop b (a + b)))
　in
　loop 0 1

let _ =
　print_int (LazyList.nth (fib ()) 25)

というように書ける。

ちなみに、zip_withという関数を自分で書くと、こんな風に書くこともできる。
open LazyList

let rec zip_with f l1 l2 =
　lcons (f (hd l1) (hd l2)) (lazy (zip_with f (tl l1) (tl l2)))

let rec fib () =
　lcons 0 (lazy (lcons 1 (lazy (zip_with ( + ) (fib ()) (tl (fib ()))))))

let _ =
　print_int (LazyList.nth (fib ()) 25)

上記のコードは、このHaskellのコードを直訳したもの。
main = print $ last $ take 25 fib
　where
　　fib = 0 : 1 : zipWith (+) fib (tail fib)

さらに、Camlp4を使って演算子を定義してやると、
open Pcaml

EXTEND
expr: AFTER "+"
[RIGHTA [x = expr; "+:"; xs = expr ->
<:expr< lcons $x$ (lazy $xs$) >> ]];
END

-------------------------------------------------
open LazyList

let rec zip_with f l1 l2 =
　f (hd l1) (hd l2) +: zip_with f (tl l1) (tl l2)

let rec fib () =
　0 +: 1 +: zip_with ( + ) (fib ()) (tl (fib ()))

let _ =
　int_int (LazyList.nth (fib ()) 25)

と書けたりする。

>>482
いやまあ割りと素朴な疑問の類で、
[1; 1; 1; 1; 1 ...]
これが ...] で終わる表示になったり、Stack overflow during evaluationにはならなかったりするのは
なんか OCaml の中でわざわざ特別扱いをしてあげてるんですよね。
そういう設計判断の動機って何なのかな、何かにうまいこと使えるのかな、っていう疑問です。

>486
単にリストが長いときには表示をはっしょってるだけ。
List.length とかを呼ぶと止まらない。

>483-485
見事にスルーされてるな
君はお呼びじゃなかったってことだ（藁

>>488
自演乙

馬鹿丸出しw

>>488
氏ね

ﾜﾗﾀ

ハードル上げすぎてスルーされちゃったわけですか……

>>486
循環を含むようなデータを考えると必要な場合があるということだと思う。
どんなデータかはぱっとは思いつかないけど、Webのリンクを含むようなやつとか、ファイルシステムとか？

関数型言語の世界はLispの世界から多くを引き継いでいるけど、
Lispのprint関数はそういうのに対する配慮が厚い。

Common Lispの場合は、
・*print-circle*がnil以外で、再帰のチェックをして、
#n=, #n#を使って、再帰構造を再構築可能な印字表現を出力する。
;;; 確か共有構造再現の処理もやったはず。
・*print-level*, *print-length*で深さ、長さの上限指定

環境のdump/restoreを昔からやっていたからだと思う。
*print-readably*は、read可能な印字表現の強制を行う。

シリアライゼーション考えると、
まともな言語/ライブラリは当然持っていていい機能だと思う。

>>495
> ;;; 確か共有構造再現の処理もやったはず。

CLtLには、
;;;
For example, the result of

(let ((x (make-symbol "FOO"))) (list x x))

would be printed as

(#:foo #:foo)

if *print-circle* were nil, but as

(#1=#:foo #1#)

if *print-circle* were not nil.
;;;
な例が。

> まともな言語/ライブラリは当然持っていていい機能だと思う。

まともな関数型言語はLispしかないことが証明されたね

>>497
Lispもダメだということが証明されたが

は?

500get ｽﾞｻｰｯ

Lispの話書いてごめん。荒れちゃった…

Lisp最高！

Lip Stick Adventure

もっとOcaml盛り上がろうぜ

ここの連中は声にする度胸の無いガキでFAだから期待すっだけ無駄だぜ。
毎日毎晩、串挿してシコシコキーボード叩いてろって一蹴しちゃえ。

ちなみに俺と話すならスカイプIDは　dj-tama　で検索なりしてくれればOK。
どっかで見覚えあるID？　細かい細かい。知ったこっちゃね。

>> 503
じゃあ O'Caml、せめて OCaml と書いてくれや。

OCamlに足りないものってなんだろうね。

ときめき

モテ要素？

世話焼きの幼馴染

角度とか

ﾌﾞﾗｺﾝで甘ったれの妹

やさしく癒してくれる統合開発環境

厳しく怒ってくれるコンパイラ兄

514

wxCaml開発再開してくれないかなぁ。

camlってフランス人が開発してるでしょ。
だから閉鎖的なんだよね。
開発が遅れるのも当然。。

GCC版のMLコンパイラってありますか？

ML使いのサイトいっぱい教えて

夏ですなあ

MLってなんでオーバーライドできへんの

MLにクラスがないから

ふーん。クラスにしかオーバーライドって無いんだ

夏だな……

camlp4 で
try .. with .. finally
って書ける構文拡張ってある？
あるなら自作のじゃなくてそっちを使うんだけど。

camlp4のチュートリアルってなんであんなに分かりにくいんだろうね

マクロ・プリプロセッサのドキュメントや解説が解りやすかったためしなどない。

>>524
http://martin.jambon.free.fr/p4ck.html
pa_tryfinally

>>524
紹介サンクス。
ただ、それは試したんだけど　 try .. finally しか書けなかった。

紛らわしすぎ。

MS/IBM/Sunなど10社、ITリソース用モデル化言語「SML」草案を公開
http://www.nikkeibp.co.jp/news/it06q3/509767/

>>529
これはひどいな。もうすこし考えて名前付けりゃいーのに。

こっちのSMLもあんまり考えてつけたような名前ではないような。。

>>530
3 文字の achronym なんて数が限られているから仕方が無いんでない。
個人的には、何年か前までは SML といえば Smalltalk Mailing List だったし。

個人的には、何年か前までは SML といえばドリンクのサイズだったし。

個人的には、今 SML といえばエロゲ屋のことだし。

つ http://www.google.com/search?q=SML

>>534
google1位かよ。SEO対策できてるのなｗ

そのエロゲはSMLで作ってるのかな

metacaml

http://itpro.nikkeibp.co.jp/article/COLUMN/20060808/245371/
こんなの始まった。OCamlメジャー化するといいなあ。

smiiさんのブログは結構楽しいけど、今回の記事はなんだか
もやもやした内容だなぁ

楽しみですねぇ

研究の歴史は長いけど一向に実用化する気配が無い
自動的静的メモリ管理（リージョン推論、コンパイル時GC）の話が読みたいなぁ。

>>541
そんなもんあるのか。知らんかったお。

Implementation of the call-by-value lambda-calculus using a stack of regions
A theory of stack allocation in polymorphically typed languages

こーゆーやつ？

今、日本の大学でML系言語教えてるのは東大ぐらい？
東大はSML？OCaml？

>>543
俺は東工大だが、コンパイラの授業でやるよ。

OCamlもhaskelも日本語（というか多国語）扱えないからいまいち遊びと実験の域から先に進めないのはなんとかならんのだろうか。

一文字を一文字として扱える用になれば実用ユーティリティにも使うんだけどなぁ。　（ｼｮﾎﾞｰﾝAA略)

>> 545
是非自分で書いてください。

>>541
リージョン推論とか詳しくないから聞きたいんだけど、
実用的に使うにあたって何か技術的な困難があったりするの？
それとも、単にあまり知られていないだけ？

stringとcharがあってもstringがcharのリストなり配列に還元されない
っていうのはいったいどういうつもりでそうなってるのかな。

>>543
東北大だけど、プログラミング演習Ｂでやった。というか今レポートやってる。
講義の半分はJavaだから、MLは90分*5週だけど。

この科目は今年かららしい。

>545
Camomile は？

>>549
東北大は住井先生が教えておられるんだっけ？
結局、教える人がいるかいないかで、授業で採用されるかどうかが決まるわけか。
東工大はどなたが教えてるのかな？

東工大は、情報科学科の方かな？
情報工学科でやってた憶えはないけど。

東大は理学部の情報科学科でOCamlを教えてるな
工学部のどっかではHaskellをやってたような気がするが詳しく知らない

>>547
動的型や副作用が入ってくると、いきなり解析が難しくなるんですよ。
Cでキャストやポインタ演算を使うと、究極的にはメモリ空間のどこでも
指すことができるわけだし。
それに、手動管理(malloc/free)との混在も話がややこしくなる。
逆に言えば、C以外の、メモリアクセス手段が制限されている言語であれば、
うまく使うことによってGCの仕事を減らすことができる。
Java SE 6 に導入される予定の「エスケープ解析」（関数スコープの外に
出て行かないと解析できたオブジェクトはヒープではなくスタックに置く）は
リージョン推論の亜種だと思う。

str2list, list2str みたいな関数って標準ライブラリにないの？

SMLだとexplode/implodeっていうのがあるけどそれかな。
OCamlの標準ライブラリにexplode/implodeがないのはかなり疑問。

>556
thx. つか早っ。
やはり OCaml にはないのか…。OCaml では文字列のまま処理するのが
一般的なのかな。どうも手続き型っぽい処理になって気持ち悪いんだけど。

つ extlib

変に char list <=> string 変換をバリバリされて遅いプログラムを
書かれる位なら、標準ライブラリからは外す、というデザインだと思われる

名前は判らなくても型は判る関数を探すには、標準ライブラリの .mli を
grep するか ocamlbrowser を使って探すとよい。まあ、この場合ないわけだけど

>485
そのfibは構造を共有していないので O(2^n)になってるよ！
let fib =
ってすると怒られるから、OCamlではそういう再帰構造は書けないのかな

>>559
なるほどね
どうりでメモリを食いまくるわけだ
構造の共有か……
うーむ

>>559
let rec fib () =
　0 +: 1 +: (let fb = fib () in zip_with ( + ) fb (tl fb))
というように変更したら、遅延評価のキャッシュが効いて、速く計算できるようになったよ。
再帰的なデータという意味合いからは外れるけど、確定した値は再計算しないということでは
同じことになっていると思う。

いや、まあそうすれば早くなるんだけど、それでも、
N > 2の時は、N番めの値を求めるには新しい fib () の N - 1番目まで
計算しているから計算量は大体ΣNくらいある。
これはO(n^2)だから、
Haskellで同じように書いた場合はO(n)よりも効率がわるい。

で、OCamlでは
let rec a = a + 1
とか書けないから、OCamlではこの形ではO(n)にできないんじゃね？っていうはなし。

とういわけで、頭のいい人再帰的な定義かつO(n)のfibを書いてくれ!

正：Haskellで同じように書いたO(n)よりも効率がわるい。
文がおかしくなってた。

>560は馬鹿と認定されますたwwww

>>562
詳しい仕組みとかは全然分からないんだけど、
let rec fib = lazy(
　(num_of_string "0") +: (num_of_string "1") +:
　　zip_with ( +/ ) (Lazy.force fib) (tl (Lazy.force fib)))

let _ =
　print_endline (string_of_num (LazyList.nth (Lazy.force fib) 1000))
というように「lazy()」で括ってみて、-rectypesオプションでビルドしたら、なんかうまくいった。
多倍長整数を使って1000番目を計算しても、Haskellと遜色ない速度で答えが出る。

ほんとだ！サンクス!

なんか各ブログのLL Ringのレポートを読むとOCamlは馬らしい。ラクダではなかったのか。

ラクダです。
ラクダマスクのつもりだったのですが、工作精度の悪さが災いして、
馬にしか見えなかったみたい。反省。

やっぱりそうなんだ。じゃあ来年はコブ付きで･･･

筑波でOCamlやってます。ガリグさんって人が来てます。
集中講義で2単位くれるっていうから取ってみたけどついていけませんorz

OCaml で文字列処理するの C 並に面倒くせぇ…。

けっきょく効率的に書こうとすると命令的になるしな。

>>570
講義資料見たけど、確かにあれを2日間で初心者がやるのはちょっときついかも

最初はそう思ったけど最近は「効率的に書こうとするときの素直な手段」が
提供されているというのはいいことだと思えてきた。

「プログラミング言語の進化の歴史は、文字列を簡単かつ効率的に扱えるようにするための試行錯誤の歴史である」

どこで聞いた台詞であったか。

どこ？

惹玖がんばってね。

知り合いの方に

「ocamlcでなくocamloptで使える，dlopenのような動的リンク機構がないか」

と尋ねられたのだけど，私には分かりませんでした．
どなたかご存知の方いらっしゃいません？
自作ソフトにいわゆる「プラグイン」の仕組みを盛り込みたいらすぃ

友達から聞いたんだけど〜(ry
な話はたいてい実は本人の話な件について

>>579
大変申し訳ない。

578じゃないけどな〜

プラグインは何言語で書きたいのさ。

>>578

ttp://caml.inria.fr/pub/ml-archives/caml-list/2005/12/c583b03155e82f2d0f4e7ab031542f17.en.html

でどうかな？ちょっとぐぐったら出てきたんだけど。

いったんCでwrapすれば、OCamlのコードを共有ライブラリにできるけど、
それをOCamlから直接使えるようにサポートする気はない

とXavierが去年の12月に言ってる。

578 の知合いが
する気はない＝する気のある人募集
と読みかえる漢であることを望む

>>583
漢と書いて「おとこ」と読ませたいらしいが、この文字が人に当たるときに
「卑劣漢」「詐欺漢」といったネガティブな熟語ばかりが想起されていやだ

漢はおとこだよ。人に当たるって何?
熱血漢って１０回言ってみ。詐欺漢て何?初めて聞いた。

>>585
もっともポピュラーな例「痴漢」

無頼漢ってのもあるな
>>585
子供じゃしらんかもしれん、最近は言わないからね。

>>587
30歳でも子供でしょうか？

>>588
おっさんｷﾀｰ

まじめな話プログラミング言語より日本語の書物を読んで語彙力つけるべきじゃないかと思います。

>>589
語彙力って何ですか？

その時々の流行の言葉を覚えればいいのでしょうか。

レスって何ですか？

↓何事も無かったかのように ML の話が始まります

SML
Sadistic Mika Land

>>582
> いったんCでwrapすれば、OCamlのコードを共有ライブラリにできるけど、
> それをOCamlから直接使えるようにサポートする気はない
> とXavierが去年の12月に言ってる。

ふむ，なるほど．本人の言葉ですか...
やっぱりnative codeにしてしまうと型が分からなくなってしまうので，それを嫌っているんでしょうね．

なんかTyped Assembly Languageを使ってnative codeを安全に動的ロードしよう... という研究があるけど，
http://citeseer.csail.mit.edu/471673.html
まだ先は長そうだ．

ITProの連載2回目だけど、もうちょっとこうOCaml sugeeee!!って感じの煽りがほしいです。

本人のはてな日記に書くがよろし
レスきっと付くよ

OCamlsugeeeeと思うコードを紹介せよ。
いまいち思いつかんな・・・

新鮮でインパクトのある例がまだあるかなぁ。
素人に直観的にアピールできる関数型言語のsugeeところは
スクリプト言語たちにあらかたパクられちまったし。

では、スクリプト言語ではとうてい達成できないであろう
「速さ」をアピールしてはどうか

>>599
それはね、単にコンパイラの作者が優秀なだけ。。
別にOCamlだから実現できたという訳ではない。

URL失ってしまったがSMLでコンパイラ構築する手順みたいの書いていたサイトがあって
結構感動した覚えがある。

言語の個性とかは置いといて、他のスクリプト言語と違って
native コンパイルができるというのは利点ではないの？

OCamlは実装がsugeeということか。

言語研究者の視点に立つと >>600 見たいな考えになるんだろうな
実用主義者にとってはツールの性質が使用する動機になる

そういえば俺が使い始めた動機のひとつはネイティブコンパイルできることだった。
でもHaskellもコンパイルするとバイナリできるよね？
よくしらないんだけどあれはocamlrunみたいなものに依存してるのかな

GHCだと、HaskellのコードをCのコードにしてから機械語にしてるんじゃなかったっけな。

そしてlibgmp.soとかに依存するぜ

caml は自力でやってるんですか？

ocamloptの場合はそうでしょ。

>>606
中間コード→最適化→中間コード→最適化→機械語

実装が速いというのもこの言語仕様あってのことだよね。
rubyとかセマンティクス上どうしても効率の良い実装は作りづらい。

OCamlって実行時に使う型情報ってどのくらい残ってるんですか？

>>601
SMLでコンパイラ書いてみせるのは割とpopular

つーかそれぐらいしかやる子とないよね

>>613
論文なら結構あるのしってるけど日本語のサイトで自分の論文の種書いたのあんまり見かけないorz

MLコンパイラdがMLコンパイラd'より優れていることを d ≦ d' と書く。
このとき、MLコンパイラの集合( D, ≦ )は、Edinburgh LCF MLを最小元とする完備半順序集合である。
D上の研究 f:D→D は、MLコンパイラdを使用してMLコンパイラd'を作成する。
このとき、d ≦ f(d) でなければならない。
d = f(d) である不動点dが得られたとき、かつそのときに限り、MLの研究は終了する。

>>616
不等号が逆?
それともMLコンパイラを改悪することを研究と呼ぶのか。

>>617
創始者を超えることは出来ません。だから最小元なのです。

つまり自分自身のソースコードしかコンパイルできないMLコンパイラを書けばいいわけだ。
俺にもできそうな気がしてきた。

ml → javascript な言語拡張ってないかな
にしても CDuce はとっつきにくいよね

日本語OCaml本がついに複数出るらしいけど日本にそんなに書き手がいたんだ。

>>621
キャッチコピーはこうだ。

「素人が素人に送るOCaml本の決定版！」

"Practical OCaml"は読んだ?

"Prizmatical OCaml"は読んだ？

お兄ちゃん……おはよう。型環境、できています

明示的に型を書くというのは、保守的なために敗北したかのような、
苦い後悔が残るものだ…。

そして他人のコードを読む時に、その後悔は埋め合わされる。

>>625
英語で書くとマッチョダンディな世界に見えて鬱だぞ（ｗ

Ocamlで書かれたsugeeeソフトウェアをアピールすればOcaml sugeeeと思ってもらえるかもしれないね。
MTASCとかC--とかNekoVMとか。

MTASCはともかく他2つはどうだろう……。

Unison があまりにも知られていないのはちょと悲しい

MATSCはすごよね

凄いのにつづりを覚えてもらえない件について

もういい加減頭文字略語にはうんざりしてんだ。

なんて読んだらいいのか解らないような略語つくんなぼけって言いたいね。

まるで前民主党党首のようですねぇ。

【社会】ICFPの国際プログラミング・コンテストで日本のチーム「kuma-」が2位に
http://news19.2ch.net/test/read.cgi/newsplus/1159369025/

>プログラミング言語としてはRuby,C,C++,D,Java,Perlを使用した。

アレ??

出題者側がちょっと本気を出すと、関数型言語では歯が立たないという現実
どんな問題でも対応しようと思えばできる手続き型言語はすばらしい

OCamlって何て読むの？ おかむる？

http://shinh.skr.jp/yomikata/#OCaml

日本語本まだかな〜。

日本語本って、どこから出るの？
誰が書いてるの？

日本語本には是非
ユニオン型とかを詳しく書いてほしいね

日本語での入門なら、京大の五十嵐先生の講義用テキストがいいよ。

惜しいなぁ・・
俺の先生が書いたテキストを公開してくれればなぁ・・・細かいところまで解説してくれていて良いテキストなのに・
受講生のみなんだよね・・

どこの大学です？
先生の名前臥せなくてもいいのでは？

UPUP!

DOWN DOWN!

>>645
晒したりとかしたらダメなんだよ。
本にする予定みたい。

本にする予定って知っているのに何故「公開してくれればなぁ」と残念がるのか

　　　　　　　　　　　　　　　　　　r=ﾆ二..＿;:::::::::::::::::.:...￣｀:ｉ　冫　　　　　　　 　 ｀` - ､
　　　　　　　　クスクス♪　　　 　 ＼　 　 /::::::::::::::::::::::::::::::.:..∨　　　　　 　 　 　 　 ヽ　 ＼
　　　　　　　　　　r‐ , 　 　 　 　 　 i＼ /::::/.::::::::::;:::::::/|::::::://　　/　 / . 　 ,　/　 　 ｢￣ ﾌ
　　　　　　　　　 /:: /　　　 　 　 　 |:::::|:::::,'.::::/:: //:::ｲ |:::::|{ |　| / //!{　}1ｲ / .　 |　},. イ
　　　　　　 　 ／:／　　 　 　 　 　 .|:::::|i::::i::::::|: //::〃! |::j'1ﾊｉ. |仁i/i从/大iト､}　/ ﾊ　/
.　　　　　　／:／　　 　 　 _　 　 　 |:::::|i:::|::::Ｎ/厶ｲ/ﾉ j/廾}::ﾄ〈.|_j{　　　r=ミV' / /, }/ 　OCamlよろしく〜〜
　　　　 ／:／ 　 　 　 　 ｛:.ヽ.　 　 j　┴く::::l:i《bし{　　　}5T}: | | 　 ,.　　 }しﾘﾟ / /,／
.　　　 /: /　　　　　　　 　 ＼.ヽ／　 　 　 Yi:ﾄ ￣　　 ,. ¨`ﾊハ ﾄ､ ｰ-　　 ,/ / /艸　　　　 ___
　　　/::/　　　　　　　　　 　 ／　　　　　　 |ヽi:ﾄ､　ｔ ァ　ノi/　 ヽ. ヽ- ＜ /ノ ｲ/ .|　 　 　 {　 |
.　　/::/ 　 　 　 　 　 　 　 / 　 　 ヽ　　 　 |:: ゝ／/T ´　 　 　 　 　 　 ___＼//　ji＼　　　|　 |
..　/::/　　　　　　　　　, ィ {.　　　　 ｜　 　 |::{く　/　ｉ　　ｉ:|:. i. 　 i 　 　 |.　＼〉. /ﾘ.　 ｉ.　　|　 |
　 |:::|　　　　　,.　　　´　 |　＼ ＿_　｜　 　 |:.ヽ:＼　!｜ |:|　| ｉ.　|.　! ,　|__,.イ// ﾉ　　|.　　|　 |
　 |:::| 　 　 ／　　　　　　!　.　　,:r''￣|　　　 |::::::i:::::} |ｉ弋ﾅ|ヽl从‐|i-j/　 }イ jﾊ{.　 　 /　　 |　 |
　 ヽ:.ヽ._,.ｲ　　　　　　 　 ＼`r'　　　｜　 　 |从jﾊﾉﾊkげi`　　'ｉげ}j/　　|｜ /　　　/　　　.|　 |
　 　 ヽ/　{　　　　　 　 　 　 ＼ 　 　 |　　　 |　| |　|iゝ￣　 ,　 ￣ /'/ j.｜|./　 　 / 　 　 丿 ,ﾉ
.　 　 /　　＼　　　　　　　　／ ￣￣｢|　　　 |　V!　|! ﾄ､　 r┐　 /'/ /ﾊ,ﾊ|　　　/　　　／ ／
　　　|　 　 　 ｀　ー―一ｧﾍ 　 　 　 l | 　 　 {. 　 Vi'ア /￣〉,ﾊ'´j/j/ﾘ ﾉ/　 　 ∧　 ／ ／
http://caml.inria.fr/

誰？

このスレでよくあらわれるＯｃａｍｌハカー（学生さん？）が書いたほうが
良い本が出来そうな気がするけどな

>>652
それって俺のこと？
だったら俺の先生の方が上だよ

理屈うんぬんすっとばして使うだけの本だったら学生が書いたほうが良さそう

偉〜い先生って、一般的・抽象的に書くのが好きだからどうしても具体性に欠けるんだよねぇ。
一般的に書くのがかっこいいと思ってやがるの。
自分の文書が使い捨てにされるのが我慢ならないんだね。
マジできもいし。

http://www.smlnj.org/
sml/njのサイトが繋がらない。
index以外は404だし…
クラックされたのだろうか

ocamlnet2 って互換性とかどう？equeue とか色々一緒にまとめちゃったんでしょ？
以前のバージョンで書いたソースの手直しとか発生する？

>>655
しかも洋書のパクリみたいな内容

ML系の言語で整数が機械語の一ビットを使ってるって言うのがいまいちわからない
いちいちくわしくおしえてくれ

レジスタに収まるサイズのデータ（整数）とそうでないデータ（メモリブロックへのポインタとして表現されるその他の大きいデータ）を、そのレジスタに収まるサイズ分だけ見て判別できるようにするために1ビットつかって印をつけているということだと思う。
そのビットが0だったらそのまま整数とみなして、そうでなかったらポインタとみなす、みたいな。

単にGC用のビットじゃネーノ

型検査は静的に終わってるんだから動的型情報を持っておく意味ないし

強い型のMLでそれが必要なのか? っていう疑問だと思うけど。

多相関数に対して整数用とポインタ用2つのコード生成すんのマンドクセ、ってこと。
2つ作るだけならいいんだけど、引数の数が増えると指数関数的に増大する。

GCでポインタ辿るときにポインタか整数か見るため?

SML#ではちゃんと32ビットあるらしいけどそこんとこどうやってるんですか。

>>663 なんで整数用とポインタ用2つのコードを生成するひつようがあるの？

MLに限定した話じゃないよな
静的型付き言語をGC付きで実装するときには避けて通れない点だ
データが整数かポインタかどうやって判定する?

α.データだけを見て判定する
たとえば有効なアドレスの可能性があるならポインタと判定し
その可能性がゼロのときに限って整数とみる
ゴミを除ききれないのが欠点だ

β.実行時にも型情報をもたせてGC時にそれを見て判定する

β.1.データに型情報を埋め込む
32bitワードを31bit整数と1bit型情報で分けるのがこの方法
データの数に比例して型情報の合計サイズも増えてしまうのが欠点だな

β.2.型情報をデータと別の領域に持つ
データの数が増えても型情報のサイズは一定
しかし多相型を扱えない. データの型が実行時にならないと
決まらないから型情報をコンパイル時につくれないから.

例えばSun Javaの実装は別領域に配置した型情報への
ポインタをオブジェクトに持たせているからβ.1.とβ.2.
の折衷だな
MLのデータ構造に比べたらJavaのオブジェクトはそれほど頻繁
に生成されるものではないからポインタを持たせるコスト
もacceptableだと判断したんだな
MLの場合膨大な数のデータが生成と消滅を繰り返すから
ワードサイズのポインタを持たせるのは到底受け入れられ
ない. bitだけ持たせることにしたんだな. それしかいらないし.
Javaの場合, 整数かポインタかだけじゃなくてクラスやインタフェイス
の継承関係も実行時に必要だから1bitじゃ足りない

>>667
多相型の関数は必要なだけ作れば?
どういう型のラインナップが必要かは実行しなくてもわかるんだから。

データを生成する関数が多相型であろうとなかろうと
GCつけるならデータの型を実行時に判定しなくちゃならない。
多相型のない言語でもGCを付けるならこの問題は同じ。
多相型があると解法が限定されてしまうが。

>>669
> GCつけるならデータの型を実行時に判定しなくちゃならない
自体は真だけど、それはタグビットを値に持たせることが必須となることの
十分条件ではないね。

タグビット以外だと BIBOP が有名だね。
使えるメモリ量が増えたから BIBOP 使えねという話を読んだ事があるけど、
領域毎に格納するオブジェクトを決めておく方式は良いアイデアだと思う。

C とかで

(a==b)? a : 0

とか書くじゃないですか
こういうのってOcaml にもありますか
毎度 if then else 書くのが疲れるので・・・

ない
やりたきゃ camlp4 使え

はい。

# 1=2 && true || false;;
- : bool = false
# 1=1 && true || false;;
- : bool = true

3項演算子のない言語では割と一般的な慣用句だよん。
なんでもcamlp4使おうとするのは逆に頭固いと思う。

あ、まって。ごめん。

boolだけにしかつかえなーい

いつからBASICスレになったのかと思ったw

http://www.pllab.riec.tohoku.ac.jp/slides/jssstTaikai2006sli.pdf
これおもしろいですね。誤字が多いけど。

SML# に期待

SML!
SML?

SML#　＞＞＞＞　ruby

SML#　＞＞＞＞　D

Dは流行らないと思った。

俺は（以前から） G'Caml に超期待。

SML# と G'Caml の良いとこ取りをできないかな？

SML#　＞＞＞＞ Ocaml

SML#　＞＞＞＞ lisp

GcamlとOcamlっていうのどこがどうちがうの？

ocamlの和書ってどうなったのさ。

ﾜｼｮｰｲ!!

ocamlでリストを受け取りその要素のべき集合を吐き出せって言う課題でたのですが
↓がその答えなんですが、こんな答えパッと出るものなのですか？
何かアルゴリズムの定石みたいのがあるのですか？それともおれが馬鹿なだけ？
一応書けたけのだけれどおれのは物凄い計算量。
初めて勉学で壁にぶちあたってます。。。

let rec add_h a = function
[] -> []
| h::t -> (a::h) :: add_h a t;;

let rec powerset = function
[] -> [[]]
| h::t -> let pt = powerset t in
pt @ add_h h pt;;

ocamlどうこうより再帰的な考え方の問題。慣れればどうってことないよ。
逆に言えば慣れることが大事。

691です
>>692
なるほど。大１でプログラミング能力はJavaをちょっと齧った程度です。
Javaのソートなどは見ていてなるほどなぁ、と思ったのですがOcamlの
それを見て、どこからこんなの思いつくんだ！？って思ってしまいました。
やっぱ慣れなんですかね？
とっつきは記述の仕方など数学に似ている部分があったのでocamlのほうがスラスラ
いったのですが…

定理証明を利用したオブジェクト指向解析とかそのへんって
今どれくらいまで進歩したの？

いま、関数型言語の間では、関数型言語独自のデザインパターン（らしきもの）というのが研究されているよね。
オブジェクト指向離れが進んできてる気がする。

例えばどんなパターンがあるの？

SYBとかかな。

SYBなんかすげーおもしろそうだけど
論文が2005年の数本と6年の1本ぐらいしかないんだけど
どっから勉強すればいいの？今さXPATHとかああゆうちょっと
普通の言語だと処理しにくい構造のやつSYBだと処理しやすい
みたいだから勉強したいのおしえてちょ

scrap your boilerplate？
何これ？

scrap your boilerplate ってデザインパターンだったのか

全然洗練されてないけどね。論文もへたくそだし。

row polymorphism と structual subtyping って、型論理の中身など
知ったこっちゃない俺にとっては同じ抽象化に見えるんだが、どうよ？
<m:int;ρ> だろうが <m:int> <: <m:int;m':string> だろうが、
<m:int>は共通部分ですよって事しか言ってないじゃん。
どっちかに統一できんのか？

100年後に再び生まれてくれば統一されているかもよ。

そのころにはSMLとOcamlも統一されてUnified MLになってるだろうね

VCやgdbみたいな（できればGUIの）デバッガはないの？
コードは書きやすいけど、デバッグがめんどくさい。

100年後にはMLなんて忘れ去られてますよ

もうちっとだけ続くぞい

>>705
ocamldebugというのがありますよ。

ヤダヤダ、そんなコマンドラインツールヤダ　AA略
ウォッチウインドウとかクリックでブレークポイント設定とかしたいの

そんな君にF#。
ただしVS2005Proが必要。

Expでﾀﾞﾒなのは知ってたけどStdじゃだめなの？(´･ω･｀)

ocaml でリストを一様にシャッフルする関数を書きたいんですが，

shuffle_list l = (* 'a list -> 'a list *)
let rec shuffle_list' t =
let insert a l n =
let rec insert' a l n t = match l, n with
_, 0 | [], _ -> List.rev_append t (a::l)
| x::xs, n -> insert' a xs (n-1) (x::t)
in insert' a l n []
in function
[] -> t
| x::xs ->
let n = Random.int ((List.length t) + 1)
in shuffle_list' (insert x t n) xs
in shuffle_list' [] l

これでは効率が悪いような気がします．
他に何かいい書き方があるでしょうか？

こんなのどうだろう。O(n log n)。

let random_split (l, len) =
  let final_xlen = len / 2 in
  let rec loop source slen x xlen y ylen = match source with
      [] -> ((x, xlen), (y, ylen))
    | (s::ss) ->
        if Random.int slen < final_xlen - xlen
          then loop ss (slen-1) (s::x) (xlen+1) y ylen
          else loop ss (slen-1) x xlen (s::y) (ylen+1)
  in loop l len [] 0 [] 0;;

let shuffle_list l =
  let rec shuffle_list' (l, len) = match l with
      [] -> []
    | [x] -> [x]
    | xs ->
        let (a, b) = random_split (l, len)
        in List.rev_append (shuffle_list' a) (shuffle_list' b)
  in shuffle_list' (l, List.length l);;

>>713
なるほどこれだと速いですね．ありがとうございます．
この場合はシャッフルが一様である保証ができるでしょうか？
というのは，リストのどの要素も等確率にリストのある位置に
くるという意味ですが．

>>713 さんとは別人ですが一様性は成立する気がしますね．

loop の処理は source から final_xlen 個の要素を無作為に選択する処理に他ならないので，

>let (a, b) = random_split (l, len)
で l の各要素が a に入るか b に入るかが等確率であると言えるように見えます．

細かいですが，len が奇数の場合には当然等確率にならないので，
厳密には，確率 len / 2 で a に入り，確率 1 - len / 2 で b に入る，
でした．

>>715,716
ご指摘ありがとうございます．
確かにそう考えるとほぼ一様っぽいですね．
面倒なので証明を考えてみていないのですが十分使えるのでOKです．
改めて 713 さんありがとうございました．

肝はn個からk個を選ぶアルゴリズム：
n個から適当な一個に注目し、(k/n)の確率でこれを選ぶ。
さらに残りの(n-1)個から同じアルゴリズムで足りない分を選ぶ。
で、これを使ったとき、考えられるnCk通りが全て等確率で現れることを示せば良い。

nに関する帰納法で示す。n=0のときは自明。
注目された一個が選ばれたとき(確率k/n)、帰納法の仮定から、残りについて(n-1)C(k-1)通りが等確率で現れる。
よって特定の選びかたが現れる確率は、
k/n * (1/(n-1)C(k-1)) = k!(n-k)!/n!
選ばれなかったとき、同様に、
(n-k)/n * (1/(n-1)Ck) = k!(n-k)!/n!
であり等しい。結局全ての選びかたが等確率で現れることがいえた。

713のアルゴリズムは面白いね。
実際には、配列に変換してから、ランダムシャッフルするのが
一番楽だと思うけど。

ところどころの説明で出てくる
単相型とか多相型って言葉の意味がわからないんですが・・・
どういう意味なんですか？

多相的に使えるとか単相的に使えるとかそういう言葉の使い方とかが
なんだかピンと来ません
簡単な例でどういう感じが単相だとか多相だとか教えていただけないでしょうか

こういう感じが「多相的に使える」
# let make_list x = [x];;
val make_list : 'a -> 'a list = <fun>
# make_list 1;;
- : int list = [1]
# make_list true;;
- : bool list = [true]

こういう感じが「単相的」
# let make_list x = [0; x];;
val make_list : int -> int list = <fun>

（緩和された値多相とか、そーゆー難しい話はこの際抜きで）

あ〜なるほど、そういうことだったのか〜
やっと、わかりました。ありがとうございました。

こういうコードを見つけたのですが（escape_charは直前で定義されている）

let quote_string fmt s =
Format.fprintf fmt "\"%a\""
(fun fmt s ->
String.iter (fun c -> Format.fprintf fmt "%s" (escape_char c)) s) s

これって、どうして

let quote_string fmt s =
Format.fprintf fmt "\"%a\""
(String.iter (fun c -> Format.fprintf fmt "%s" (escape_char c)) s))

じゃいけないんでしょうか
なんで間に　(fun fmt s -> ....）が入るのかがよくわからないのです

下の方だと、どう型が合わないじゃん

%aの仕様わかってる？
%aは formatter -> 'a -> unit という関数と 'a の値と二つ必要なんだよ。

# open Format;;
# fprintf std_formatter "%a";;
- : (Format.formatter -> '_a -> unit) -> '_a -> unit = <fun>

参考:ttp://caml.inria.fr/resources/doc/guides/format.html

expression-problemってなんすか？

ocaml用に、埋め込みocamlとかありますか。
rubyでいうところのeRubyみたいなものです。

>>724-725
ありがとうございます
%a について勘違いしてました。ただ型についてはわかりましたが
formatter ってものについてまだよくわかってないみたいす
も一度勉強してきます

728どなたか教えてください

eRubyを知らんのだけどmod_camlかな？
mod_camlも別に使ったこと無いけど

eRubyとmod_camlはぜんぜん違うと思う。

eRuby の実用途で一番近いのは camltemplate なんだけど、
http://saucecode.org/camltemplate/
こちらは OCaml のコードがそのまま埋め込まれるわけではないので少し違うしなぁ

caml のライブラリを動的にリンクする方法ってないの？
Cでso作ってリンクするんじゃなしに

あ、Dynlink なんてモジュールがあったんだ、これ使えばいーのか

あーnativeコードではできないのか、残念・・・

他言語の拡張をOCamlで書いたりしたいよねー

共有メモリにクロージャを置く方法ってありますか

・共有メモリをさわれるAPIがそもそもOCamlの標準にはないのではないか
・クロージャのMarshalも結構制限があるっぽい
なので難しそうな印象

Marshalもfunctional value扱うとwarning出すし、
たしかNetshm というモジュールがなんかのライブラリにあったけど
これもMarshal同様の制限があった気がするな

cmaとかcmxa とかに入っているライブラリのインタフェースを
エクスポートして中身を確認したいんですがどうすればよいのでしょう

camlp4のマニュアルには、拡張構文と通常構文は相互変換可能みたいな事が
書いてあるけど、.ml の相互変換ってできるのでしょうか。
どなたか、やり方知ってたら、教えて下さいませ。

>>737>>739
Marshal.Closures指定すればできね？
同一プログラムファイルでしか共有できないけど。
byte/native問わず3.08からはふつうに使えるはず。
http://caml.inria.fr/pub/docs/manual-ocaml/libref/Marshal.html
http://wiki.ocaml.jp/index.php?ChangesSince3.07
共有メモリを別のプログラムで使う場合はクロージャは諦めてくれ。

>>741
camlp4 pa_o.cmo pr_r.cmo foo.ml
camlp4 pa_r.cmo pr_o.cmo foo.ml
とか？

> 743
おお! そんなやり方が!
一応、マニュアルとかも斜め読みしたんですが分かりませんでした。
マニュアルよく見たら、分かりますかね。それともソースですか?
何はともあれ、ありがとうございました。

Camlp4は苦しみぬいて分かった後にマニュアルをよーく見ると確かに分かったのと同じことが書いてある。

>>744
ttp://caml.inria.fr/pub/docs/tutorial-camlp4/tutorial008.html#toc55
manualは分かりづらい。tutorial推奨。
>>745
禿同。

FreeBSD6.2R/i386 で ocaml 実行して

% ocaml
Objective Caml version 3.09.3

# #thread;;
/usr/local/lib/ocaml/threads: added to search path
/usr/local/lib/ocaml/unix.cma: loaded
/usr/local/lib/ocaml/threads/threads.cma: loaded
# let t = Thread.create (fun () -> while true do Thread.delay 1.0 done) ();;
val t : Thread.t = <abstr>
# Thread.kill t;;
Exception: Invalid_argument "Thread.kill: not implemented".

てなるんですが Thread.kill って実装されてないんでしょうか？

いや、実装されている。

それじゃどうして Thread.kill が使えないのでしょうか？
あるいは thread を kill する別のやりかたはあるのでしょうか？

メール欄見ろよ。

それからソースを見れば、
(* Thread.kill is currently not implemented due to problems with
cleanup handlers on several platforms *)
とあるのがわかる。

あと vmthread なら kill は実装されてるだろ。

横槍だけど、、、
vmthread って light weight なスレッドだとか聞いたけど
じゃあ、ふつーの native thread って何であるの？
外部のCのライブラリとかと共存するため？

mt がらみの処理がcaml で閉じてる場合、vmthread 使ったほうが
高速なんだよね？

>>751
native threadだと実CPUの数でパフォーマンスがあがるから。

vmthread だと、実CPUの数でパフォーマンスがあがらないの？

たっぷる……なんか違和感がw
それなりに使ってる人たちもいるんだろうけど、
どの界隈に多いんだろうか。

native thread はOSが管理する→CPUの数も考慮に入れて動く？
vmthread は ocaml 上で動く　→ ？？？

>>754
俺も思ったw
それはそうと本出るらしいね
http://d.hatena.ne.jp/sumii/20070214/p2

スレッドを沢山はしらせるなら立ち上げのコストが高い分
vmthread の方がいいよ

あーコストが高いのはねいてぃぶスレッドね

マニュアルのthreadsによると、
http://caml.inria.fr/pub/docs/manual-ocaml/manual038.html
Native/vmthread関係なく複数CPUの恩恵を受けることはないと書いてある。

たしか、IO等の重い処理(正確にはleave_blocking_section()を呼ぶ処理)に対しては、実行中に他のスレッドを実行しうる。
それ以外については複数CPUで走ることはないはず。
ちょっと論点は違うけどこの辺が参考になるのではないかな。
http://alan.petitepomme.net/cwn/2006.05.16.html#5

知らなかったorz

>>756
スレの上の方で予言してた人のはこれですかね
でもエントリの内容だけだと内容の想像が付かない

お茶の水女子大ではOCamlを教えているんですね。

パターンマッチ＋再帰な関数を書くときに
　let hoge x = let rec loop = ... in loop
と必要なだけ引数を取ったらクロージャを作るのと
　let rec hoge x = ... else hoge x y
と変化しない引数も持って回るのとで、速度の差はあるのでしょうか？

>>761
女が使うような女々しい言語なんかつかえるか！！！

>>763
それじゃ女の子とどうやって話するんだ

一つ、戸外で女と言葉を交わしてはなりませぬ。

男女同衾を許さず

http://www.saiensu.co.jp/?page=book_details&post_id=7751
出版社のページに目次あったよー

これは日本語で読める初めてのOCamlの本ということになるのかな。

>>762
本家のページに「前者のように書きたがる人が多いけど
後者の方が速いから改めよ」みたいなことが書いてあった気がする

すいません。以下のような２つのコード

#!/usr/bin/env ocaml
print_string "hello\n";;

#!/usr/local/bin/ocaml
print_string "hello\n";;

というのを$ocaml test.mlという風に実行すると両方とも同じ結果になるんですが、
実行権をあたえて、./test.mlという風に実行するとなぜか後者だけprint_stringが見つかりません
見たいな事を言われてしまうんですが、なにか解決する方法はありませんか。

すいません、愚かでした。
#!/usr/local/bin/ocamlrun /usr/local/bin/ocaml
print_string "hello\n";;

で、よかったんですね・・・、

これでさくらレンタルでもocaml CGIが走る！ψ（｀皿´）ψｳｼｬｰ

キミはshebang行についてまず勉強しなさい。

#!から始まる先頭行の行末までをコマンドとみなして、あたかもそのコマンド
に引数を与えて実行するという機能を、UNIX系のOSでは持つ。
で、そのコマンドがそのパスに存在しないと file not found 系のエラーになる。

ということで間違いなく ocaml が /usr/local/bin にないだけだから、
which ocaml してその結果で置き換えなさい。
env コマンドが何をするものか、なぜそれだと上手く行くように見えるのか、
というのは自分で調べること。

ｶﾞｸｶﾞｸｶﾞｸｶﾞｸ(((( ；ﾟДﾟ)))ｶﾞｸｶﾞｸﾌﾞﾙﾌﾞﾙ　

書いてある内容は基本的なことっぽいけど俺としてはこういう学術的な棚に入りそうな
本じゃなしに、例えばC++とかJavaとかの棚に入るような雰囲気の本をそろそろ出すべきだと思う
この感じだと、せっかくの入門書なのに古臭いLispの本が並ぶ棚の側に置かれそうな感じだ

>>769
http://caml.inria.fr/pub/old_caml_site/ocaml/speed.html
これですね。後者のほうにしときます。ありがとうございました。

>>772
いや違うと思うぞ。
うまくいかないのはocamlコマンドが#!で始まるスクリプトだからかな。
http://ocaml.jp/archive/ocaml-manual-3.06-ja/manual023.html

まあ1冊目の本が出るところでそろそろもないだろう

>>772>>776
shebang行に#!<dir>/bim/ocaml
と入れても実行できない理由は、
ocamlというファイル自体がocamlrun上で走る
バイトコードだからかなと思ったんですが、違いますかね？
実際そのように考えて、>>771のように
#!<dir>/bin/ocamlrun <dir>/bin/ocaml
としたら、うまく動いてるんですが・・・

ttp://www002.upp.so-net.ne.jp/mamewo/ml.html

bimじゃなくてbin・・

しょっぱ

http://ocaml.pbwiki.com/Ocamlscript
これでも導入しとけよ。

>>778
そうだと思う。ocamlの先頭部分をダンプすると
#!/foo/bar/ocamlrun
とか付いているし。

もう一個の実行の仕方として
#! /bin/sh
# (*
exec ocaml "$0" "$@"
*) directory "."
というのがある。
面倒なので俺も>>781使うのを推奨。

本日サイエンス社のOcaml本買ってきました、ハードカバーなので列車内じゃ読みにくいですね(片開きみたいな持ち方ができないんで）
結構行間が空いてるのでもう一回り小さい装丁でもよかったんじゃなかろうかと思わんでもない、
内容をぱっと見してるかぎりじゃプログラム初学者から関数型を食わず嫌いしてた古参のプログラマも読める内容になってます。

toplevel で実行すると

# [1;2;3];;
- : int list = [1; 2; 3]

とかpretty-printしてくれるけど、これと同じことする関数ってない？

tuple -> list
list -> tuple

の相互変換をする標準関数はないの？

>>784
Toploop.print_value
ただし使い方が難しいかも

>>785
たぶんない。型がつけられないと思われる。
Obj.magic的なことをすれば何とかなるかもしれんが。

let list_of_tuple v = Array.to_list (Obj.magic v)
let tuple_of_list lst = Obj.magic (Array.of_list lst)
ちゃんと動くかどうかは…知らん。

なにその何も考えてないコード

OCaml3.10って何が変わったん？

例外に対してコールスタックが見れるようになった
nativeコードでも見れる

SML#0.2キター

Windowsバイナリ！！！
http://www.pllab.riec.tohoku.ac.jp/smlsharp/ja/?Download

SML#0.2使ってみた。
ウィンドウズでさくっと使えるので楽しげ。

SML# 0.20 (2007-03-30 10:47:08 JST)
# val x = 1;
val x = 1 : int
#

さぁ、何作って遊ぼうかなー。

やっぱりまずはレコード多相？

# fun get_name n : string = #name n;
val get_name = fn : ['a#{name:string} .'a -> string]

おー、forallになってるお。

# get_name { name = "smlsharp", version = 0.2 };
val it = "smlsharp" : string

グレイト。まぁ、前からできるんだろうけどさ。初体験なわけよ、俺的には。
っていうか、レコードって型宣言しなくても使えるんだ。

レコード型宣言しなくてもフィールド参照が使える（型推論できる）、ってのが
多相レコードのキモだ。
他のレコード（オブジェクト）型がある言語では「そのフィールドを持つレコード（オブジェクト）型の
宣言がないよ」って言われる。

OK. じゃー次は噂のランク１多相だ。

#fun pair x y = (x, y);
val pair = fn : ['a .'a -> ['b .'b -> 'a * 'b]]
# pair 1;
val it = fn : ['a .'a -> int * 'a]

うん、多相になっている。OCamlなら、

# let pair x y = x, y;;
val pair : 'a -> 'b -> 'a * 'b = <fun>
# pair 1;;
- : '_a -> int * '_a = <fun>

と単相になってしまう。
ちなみに私はSML#の関係者でもなんでもないので、
広告のための自作自演ではない。あしからず。
ホントに単なる趣味です。

追加するとSML#だと、これが無理っぽい。

# fun fst (x, y) = x;
val fst = fn : ['a,'b.'b * 'a -> 'b]
# fst ([], 1);
stdIn:7.1-7.11 Warning:
dummy type variable(s) X0 are introduced due to value restriction
val it = [] : X0 list

残念。単相になってしまう。

そういえば、SML#では32bit intは32bit intとしてそのまま使えるんだったな。
どれどれ。

# fun power (x, 0) = 1
> | power (x, n) = x * power (x, n - 1);
val power = fn : int * int -> int
# power(2, 31) - 1;
val it = 2147483647 : int

うむ、確かに。正負あわせて32bitって訳だ。

MLのJoel Reymontという人の投稿っぷりはすさまじいな

>>798
そいつは基地外。HaskellとかErlangのコミュでもフレーム撒き散らして迷惑かけてる。

ＳＭＬ＃ ってﾄﾞﾄﾈﾄなのかとｵﾓﾃﾀ。危なくｽﾙｰする所だった。

.net方面には SML.net と F# がある。
http://www.cl.cam.ac.uk/research/tsg/SMLNET/
http://research.microsoft.com/fsharp/fsharp.aspx

オレも誤解してた時期があったけど。でもSML#の方が .net より先なんで仕方ない。

せっかく新しい処理系作るならマルチスレッド対応にして欲しいなあ。
マルチコアプロセッサを積んだマシンが殆どな時代だし。

ttp://www.cbook24.com/bm_detail.asp?sku=9784839923112
既出?

鳥本ってあんまり良い印象無いんだけど、今度はどうなんだろう？

HaskellとCommonLispはいまいちだった感じだよね

辻内が退院
http://www.sanspo.com/baseball/top/bt200705/bt2007050201.html

SML#からFUSEが使えた。
MLでファイルシステムを書けるなんて、鼻血が出そうだ。

Scheme/Common Lispではなく、SML/OCamlを選んだ理由を教えてください。

・型付きだから
・速いから

・アルジェブライックデータタイプがあるから

・フランス贔屓だから

パターンマッチがあるから。

>>808
えーっと、この変数に入ってるのはリストのリストのリストのリストの。。。。。キッーーーーー(ｲﾗｲﾗ

>>813
おまえはオレかw

>>813
ﾜﾛﾀ

『Scheme/Common Lisp』と『SML/OCaml』の一番の違いは『動的型付け』か『静的型付け』かという点です。

動的型付きと型なしの違いを教えてください

『型付け』とはつまり型エラーがあるということだよ。
『動的型付け』がScheme/Common Lispの言語仕様に入ってるの？

はい、入っています。

OCamlは型推論を持つ静的型付け言語です。

『形なし』の言語ってどんなの？

scheme

Perl とかか

>>817
静的型付け (=変数に型がある)
- 強い型付け(即エラー), 弱い型付け(一部自動キャスト), 型推論(ひもづけるリテラル等から判断) 等で更に細分化できる

動的型付け (=値に型がある)

型なし
- BCPL、アセンブラ等

『型なし』とは、すべての値に対してすべての操作が可能であること。
たとえば1という値に対して加算という操作ができるのであれば"a"という値に対しても加算という操作ができる。

らむだ計算について

OCamlがCommon Lispよりも優れている所って何だろう？

馬鹿速い

速いのはOCamlが静的型付け言語だからですね

SBCLは結構速いみたいだけど

速いLisp処理系は、オプションの型アドバイスや最適化によって
実行時型検査を省略する。
つまり、型推論と同じようなことをしている。

SBCL は「Common Lisp として」は結構速いというだけ
Common Lisp だって静的型付けは言語でサポートされているし、
型推論をする事も可能だけど、OCaml の方が全然速い

俺が実測した限りでは、sbclはOCamlと同じぐらい速かったよ。
型指定を山ほど書くはめになるけど。

majisuka?
実測したのはどんな処理ですか?
数値演算系かな。

OCamlの利点は速さ？
そりゃ速いのは助かるけど、Webアプリや業務ロジックを実装する上では
CommonLispだろーがOCamlだろーが、速さに関して特に不都合に感じない。

それよりも静的検査の強力さがOCamlの一番の特徴じゃないの？

OCamlいいよ、適度に副作用認めてるし。

あとは、遅延評価をデフォにしてほしい

こいつ Lisp スレでもキチガイじみた質問してるじゃん。
どっちも気になるなら両方つかえよ。あんま相手しないほうがいいんじゃね。

sbclは開発速度も最近かなりのものがあるから、早く速くなっていってる
ように思う。

デビアンのべんちのサイトでも確かに結果がでてる。１年前の順位とちがう。

国内で一桁しか使ってそうに無いcleanって速いみたいだね。日本のサイト
でがんばってる二人凄いと思う。出版の規格が浮かび上がればいいね。その
前にあらーんのように、ITmediaなどで取り上げてもらって、世論誘導を願
えば売れるかも。昨年はすける、今年あらーん、来年くりーんか。三拍子だ。
おきゃむるブレイクも有り得るんか。

アーランは平行並列分散処理が得意な関数型言語として時代の要請と
シンクロしている事が人気に繋がっている訳だけど、クリーンはそういうのが
無いんだよね。元々コンカレントを意識していた筈なのに…

つーか、まともにネイティブスレッド使えるまともな関数型言語の処理系って
少ないよね

歯ブラシがこんなにエロかったなんて・・・
http://thumb.uploda.org/file/uporg808735.jpg

ネイティブスレッドを関数的にどう定義してあるの？＜Erlang

IOモナドつかったらhaskellでもできるんじゃね？＜ネイティブスレッド

SML 系は全滅だね

traditional functional languageだもん

でも開発が2005年で止まってるよ、Clean。

cleanはもう過去の遺物でしょ。
開発を始めたのは　一時の気の迷い　か　魔が差した　って感じ？

これからはHaskellの時代です。
OCaml厨の皆さん、お疲れ様でした。ｗ

あ〜、俺今Haskellで開発してるんだが、これは案外不便な代物だよ。
言語仕様的に、使いにくい。
OCamlの方が副作用がある分使いやすかった。

やっぱOCamlっすよね！？
そうすっよね！？
なんちゅうか、道筋が一本しかない感じがＣと違うっつぅか、
なんちゅうぁ、そこがいいんすよね。
不器用なのか糞真面目なのか、複数名で開発する場合の
保守のし易さつぅか、どう考えてもOCamlでしょ？
って感じですよねぇ。

でもフランス人だしねぇ　アメリカ人なら最高なんだが・・・

俺が入れ込む言語は来ないというジンクスがあるのでOCamlは来ないと思う

OCaml は見た目が汚いのが嫌;;

Ocaml 好きだったけど >>950 みたいなのが使うのかと思うと嫌になってきた…

>>950の汚い使い方に期待がかかる

つかMLもう来ないのかよ(´・ω・`)

MSがF#（OCaml.NET）を開発中です。
でもC#の中に型推論を組み込むとかいってるし、
F#のほうは途中でぽしゃるような気がします。

「MSが」でなく「MS Researchに勤める研究者が」だよ
その事実を踏まえれば途中でぽしゃるという表現がそもそもおかしい
Visual Studioに同梱されることを目指して作ってる訳ではなかろう

>>857
一連の流れからVSシリーズに載ることなくと言う期待への裏切りがポシャることを指している事は明らかなんだからそこまで厳密に指摘するのは酷だろう。

>>858
とりあえず落ち着けw

Eclipseに載せる方が現実的だろ・・・実用的かどうかはさておいて

OCamlにもSchemeのiotaみたいのがあったらなー

http://ocaml-lib.sourceforge.net/doc/ExtList.List.html
これの List.init を使えばいいんじゃね

List.tabulate使えばいいんじゃね？って思ったおいらはSML遣い。

>>861
そのくらいなら、自分で作ってmy utilitiesとしてつかえばいいじゃない。
ocamlでは作成が難しいのか？

OCaml3.10でたよー

うっかりなんも考えずにインスコして、依存する全ライブラリを再ビルドする羽目になった
メジャーバージョンアップということ忘れてた

* クラス内のインスタンス変数は"virtual"で宣言させられて、サブクラスに
インプリメントさせられる。その文法は "val virtual v:t"

* 事前的にバイトコードコンパイルプログラムの為だけに可能なつかまえへん例外の
バックトレースのスタックのプリントはネイティブコードにもサポートさせました。
(32/64bitのIntel/AMD & PPC)

* 新ポート：Mac OS X , PPC 74bit, PSDKツールチェインを使っとるMS Windows
64bit (x64)、VS2005 ツールチェインを使っとる MS Windows 32bit

* Camlp4プレプロセッサは部分的に再装備されて、新しいcamlp4、文法拡張の為のよ
りモジュラーなAPIに提供してる。(サードパーティの文法拡張を利用してるユーザー
はこれらの拡張が新しいAPIにポートされるまで0caml 3.09に留まる事を望むかもし
れへん。）

* 新しい試みのツール、"ocamlbuild" : OCamlアプリやライブラリを自動的に作るコン
パイルマネージャ。ドラフト文章を見ろや！ゴラッ

だそうです。

>>867
一見機械翻訳のように見えて、実は妙に味のある訳文乙。

SML#をMLtonでビルドしたら、動き始めがすごく早くなった
もう、NJ版は使う気になれないわ

入門OCamlってもう出てるんですか？

入門OCamlの感想を聞かせてもらおうか。
web情報と比べて、書籍として買うだけの価値があるかどうか。

あそこの入門××ってシリーズはどうもいまいちなんだよな。
ocamlはどうだろね。

ファンクタの説明が適当でﾜﾛﾀ

まず、著者がろくなやつじゃねーぞ
大学生が書いてんのか、このシリーズ

住井さんの評価はこんな感じ

「目次からもわかりますが、基本と実用のバランスが取れていて、
すごく良い感じです。」
ttp://d.hatena.ne.jp/sumii/20070523/p2

てゆうか目次しかみてないんじゃ

洋書だけど、F#の本が今年2冊出る。

ttp://www.amazon.com/Foundations-F-Robert-Pickering/dp/1590597575/
ttp://www.amazon.com/Expert-F-Don-Syme/dp/1590598504/

酒の肴にどうぞ
http://blog.livedoor.jp/dankogai/archives/50838208.html

OCaml版もHaskell版も「っぽく」見えないのって俺だけか。

俺も見えない。

プログラミングの基礎 ... 基本をしっかり！？
入門Ocaml ... 実践的！？

かなり色分けがはっきりしているね。
Ocaml用に発売された最近の２冊は

>>874
ろくでないかどうかしらないけど、立ち読みで確認したら、Ocaml開発
関係者のアドバイスも得てるみたいだね。名古屋でOcamlがはやってる
のはこの人の努力の結果なのだろうかな？？？

確かに、874のように経歴などでしか判断出来ないとどうしても、信頼
出来ないと思われがちだし、そんな人の方が多いし、初心者でいい本か
どうかなんてその辺からしか判断出来ないもんな。率直に言って、監修
になんでその人の名前を使わせてもらわなかったんだろうと思ったです。

入門シリーズはほかにもあるけどOcamlが一番良く出来てるんじゃないかとも思った。
その辺は弾さんと意見は同じ。

OCamlって正格でしょ？
言っちゃ悪いけど、言語の性格としては古いんじゃない？

で？

haskell使えと言いたいんだろう

正格かどうかにこだわるのはイバラの道だよなあ
雑食が一番。

もってけ！ 884の座布団

OCamlは記号の使い方がどうもキモくていかんな…
HaskellやSMLは気にならないんだが

Haskellは日本語扱えません　ゆにこーどだとおｋだけど。

>>890
使えるようになったの？

おいらがさわったときは漢字1文字がリストの3サイズにされてたりしたんだけど。
バージョンいくつからいけるようになったん？

Hugsだったら大分前からほどほどには使えてる。

GHCは6.6からUnicodeなソースコードを読み込むようになった。
だけど、IOライブラリが対応しきれて無くて、
Unicodeな文字列を表示しようとしても、各文字の1バイト分ずつしか表示されない。

>>889
俺もそう思う。でも OCaml が一番処理系の使い勝手が良さそうなんだよね。
Moscow ML って確か Caml の VM からの派生だったと思うけど、OCaml
処理系から派生した SML 処理系があったら良いな。

C#が型推論を取り入れるらしいね
そうなったらOCamlとJAVAは駆逐されるね

もう入ってる

ラムダ関数も書けるなんて

(int n) => n > 0;

レコードも書けちゃうなんて

var x = new { FamilyName = "糸色", FirstName="望"};
Console.Write("{0}\n", x.FamilyName, x.FirstName);

>>896
型宣言とごっちゃに書かなくちゃいけないなんてきもすぎ

このスレのレベルが急速に低下してるな……

>>899
高度なレスをお願いします

>>898
n => n + 1

書かなくても問題無い

ML のスレなんだから、せめて Nemerle くらいネタにしてくれよ。C# じゃなく。

Nemerle って、なんか日本だとマイナーだからなぁ……
まだＭ＄謹製の F# のほうがネタにしやすい

>>900 関わっちゃだめ!! 899 は色んなスレを同じ内容で荒している。

そんなドマイナー言語は腐るほどあるからいちいち相手にしてらんない。
C#のようなメジャー言語がMLに歩み寄っていることの方がニュースバリューがある。

>>905
別にマイナー/メジャーは関係ない。
有用と思われる特徴がある言語でどういう事ができるのか検証したりするとおもしろいよ。

C++,C#,Dが型推論の導入を検討している
そしてOCamlはその役目を終えるだった
ありがとうOCaml
そしてさようなら

その中には有望な言語が一つもないじゃん…
OCaml は無くなっても良いけど、きちんとした代わりが欲しいよ

>>908
君のいう有望な言語を教えてほしいｗ

>>909
無いから困ってるんだけどね。

有望でないのは、プログラミングスタイルが確立されていないから。
JavaやC++ではオブジェクト指向やらUMLやらいろんな研究がされてきたけど、
関数型ではそういう積み重ねがまだまだ少ない。
これからに期待だね。

まぁ少なくとも >>909 本人は役目とかいうレベルじゃないけどな。今も不要だし将来も真っくら。
一生非生産的な言語比較でもしてれば。別にありがくもないし、さようなら。消えて。

なんで俺が叩かれてんだよｗ

>>907=909 だと思われたんじゃないの

どっちもうっとおしい

４月から社会人になった。
田舎町の、４０人程度の小さな会社。
２０代前半の女は私だけで(そもそも女が私含め３人しかいない)最初はみんな優しかったけど、
日が経つにつれ私が仕事ができなくてどんくさいヲタ系喪女だとわかるとみんな掌を返すように冷たくなり
職場でも孤立して寂しい思いをしていた。

ある日、私が一人でバス停までトボトボ帰り道を歩いていると、同じ職場の３歳年上の技術官の人が声をかけてきた
背が高くて細身。少し頼りない感じの人だけど男と２人きりで話した事がない私は顔を真っ赤にして震えry

彼｢○○(私)さん。今、帰り？｣
私｢は、ははははｈい、、い、今ｋえる途中です！！！！！｣
彼｢仕事は慣れた？｣
私｢いいいいいいいいいいいえ、と、、、とんでもないです！！｣

そんな感じで数日間オドオドしながら彼と一緒に帰った。さりげなくメアドも聞かれた・・・
ある日、

彼｢○○さんって漫画とか好きだったりする？｣
私｢(興奮して)ｄふゅぎうｊｐｋ＠ｐだだだだ大好きです！！！！｣
彼｢マジ？オタクだったりする？これから一緒に食事いかない？もっと話そうよ！｣

それから彼のアパートまでいき、車に乗せてもらってヲタトークで盛り上がりながらお食事
家に帰ったら｢今日は楽しかったですねーオフの日にまた何処か遊びに行きません？(^0^)｣のメールが


やばい！！２０で処女、友達いない、デブス、キモオタの四重苦なのにここ１週間に若い男と初めてメールの交換して、車にのっけてもらって
さらにオフの日に遊ぶ約束までしちゃったよ
今ならしねる。きみのためなら死ねる
あああああああ妄想が止まらない

関数型言語ってナンなの？

世界

ナンではない。あれはパサパサしてて好かん。

やっと "Foundations of F#" という本が届いたのだが、
どのあたりを特に勉強すればよいのだろうか。

>>917
ナンというよりも、床の間に飾られてるうちにカチカチに干からびた正月の鏡餅。

>>921
砕いてから油で揚げたら旨いんだぞ

Dynamic loading of OCaml code in native code programs, through the Dynlink module.

ttp://alain.frisch.fr/natdynlink.html

来ましたね

質問

type-preservingて日本語でどう訳せばいい？

日本語でおk

>>924
型保存?

>>926
質問に質問で返すのはやめてください

罵倒で返そうが質問で返そうが自由じゃね？

もちろん自由です。
だから「お願い」しています。

>>923
OCamlで書いたプラグインを受け付けるようなプログラム書けるようになるのかな？

byte コード版は前からあった
オマケでnative の toplevel も入ってるらしいね

それと、dynlinkモジュールってライブラリファイルにリンクできないんだけど
なんでかな
実行ファイルにはリンクできるんだけど

fold_left と fold_right で初期値とリストの適用順が逆なのは何か意味があるの？

そのまんまやん。

fold_leftとfold_rightの意味は分かった上での疑問ですな？

List.fold_left f a [b1; ...; bn] is f (... (f (f a b1) b2) ...) bn
hold_leftは、初期値とリストの先頭要素がfの呼び出し引数になる。
だから、aとb1をくっつける順番に引数が並ぶ。

List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...))
hold_rightは、リストの最後の要素と初期値がfの呼び出し引数になる。
だから、anとbをくっつける順番に引数が並ぶ。

...まぁ単なる私の想像だけど。

ありがとう
手書きで一個一個ノートに書いて展開してみたら良くわかりました

超どうでもいいけど、今日foldとholdを間違える人を見たのは>>934で2人目だ。

SML# 0.3 とメイリングリストががキタ

ttp://www.pllab.riec.tohoku.ac.jp/smlsharp/ja/?Download
ttp://www.pllab.riec.tohoku.ac.jp/smlsharp/ja/?Contact

関数型言語の勉強中です。
Ocaml でリストのシャッフルがしたい(要素をランダムに入れ替えたい)のですが、どんな書き方があるでしょうか？

とりあえず Perl での Schwartz 変換風に書いてみたのが↓ですが、こんな書き方もある、とかありましたらお願いします。
let shuffle lst =
  List.map (fun (_, x) -> x)
    (List.sort (fun (x, _) (y, _) -> compare x y)
      (List.map (fun x -> ((Random.float 1.0), x)) lst));;

シャッフル　シャッフル

>938
>712-717

型とか丁寧に作ったりしてる？
ひとりで書くときはいいけど、そうじゃないときは
string ２つ３つ受け取るような関数ばんばん書いたらまずいよね

俺は、学業として始めてML言語に出会った。
それも仕方がなくである。
参考書を渡されて読んでみたが、
「なにこれ？玩具みたいな言語だな。へんてこな仕様だし。」
って思ってた。全然、必然性を感じなかったしやる気も出なかった。
でも、課題があるので仕方なくやっていた。
周りはやる気があって課題をこなしていくのに俺はまったくやる気がなかった。
だけど約１年後、
急に目覚めたのである。
うわ・・・なにこれ。パターンマッチとかポリモフィズムとか・・・特に型推論。
コンパイルが通ればほぼ動くではないか、手続き型で良く見る「セグメンテーションフォール」
が出ない・・・。
しかも何よりもうれしいのが、処理を見て関数が何をしているかではなく、
関数そのものが処理である、という事実に喜びがこみ上げてきた。
今では、現場でML言語は使われるはずもなく、JavaやＣ++で仕事してるが、
この時の経験は活かされてる実感がある。
世の中では必要にでも迫られなければ、ML言語などというマイナー言語を
体験する人の数も少ないのではないか。
そんな中、仕方なくから始まったものの、この言語に出会えた事を非常にうれしく思う。

ありが十々。

×必然性
○必要性

×セグメンテーションフォール
○セグメンテーションフォールト

学生のLispかぶれと良く言いましてな。
お仕事で揉まれるうちに、彼らが忌み嫌う副作用のほうに
計算の本質があることが分かってくるものじゃ

>>944
計算の本質は副作用じゃなくて、副作用は我々とのインターフェースにすぎないよ。

その我々とのインターフェイスが重要という話じゃないの。

F#ってどうなん？
某コロシアム？でやたら使ってる人いるけどなんか微妙な気がするんだよね。

>>946
それは実用プログラムを作りたい人の話じゃないの？
計算可能性とか研究してるからそういうのにあんまり興味ない。

俺は実用プログラムを作りたい人だから、我々とのインターフェイスに興味がある。
それが本質かどうかは知らんけどね。

そこで宣言的記述ですよ＞我々とのインターフェイス

>>947
.NETライブラリをばりばり使って書くと独自性がかすんで微妙に見えるかもしれないけど
言語自体はかなり野心的だと思うよ。

微妙とか言わないで・・・。orz

>>951
今expert F#のドラフト読んでるけど確かに野心的。
でも配列系のデータ構造が
List,LazyList,Array,Seq,(IEnumerable?)...
と大量にあるのは頂けない。

えー
マイナー言語処理系で配列表現が1つだけとかだったら
不安でしかたないと思うけど。何が頂けないの？
あと、特に読んでないけど何が野心的なの？

入門OCaml買ったよー
色々なテクニックを知ることがでけてよかった
スレのないようにかぶるトピックもあったから
筆者はこのスレに出没してるのかな？
とりあえずいい本だった、感謝。

>>953
>マイナー言語処理系で配列表現が1つだけとかだったら
不安でしかたないと思うけど。何が頂けないの？

そういわれればそうかもしれない。でも、なんか使いづらいんだよ。

List,LazyListはいいとしてArrayとSeqは正直違いがわからない。
知っていたら教えてください。（マニュアル嫁になるのはわかるが。）

>あと、特に読んでないけど何が野心的なの？

そうだなぁ。印象でそう感じた、じゃ答えになってないな。
OCamlの使いづらい点を改善してもっと使いやすくしてやろう、
という感じを受ける。
e.g. intもfloatで演算子(+とか)を統一,いちいち分けなくて良い。
リストじゃないけど内包表記が使える。Active pattern。

答えになっているだろうか？まだ抽象的？

あとMatrixで線型代数が使えるのが良い。

>954
浅井本もいいぞ。両方おすすめ

matlabチック

SML#あげ

ODT (ocaml + eclipse)
http://ocamldt.free.fr/spip.php?article3
試した人いる？

その手の「実用的」な話しは気取ってるんだかどうだか知らないが
スルーされるんだよ、間違いない。

誰も実用していなんじゃないの

ひねくれてるねえ。。コード補完やオブジェクトブラウザ，GUIエディタを備えたIDEって興奮しません？

emacsに慣れちゃったからなぁ

>960
使ってみたが、Macでは動かず。こっちの方が断然良い：

OcaIDE
ttp://ocaml.eclipse.ortsa.com:8480/ocaide/screenshots.html

構文エラーが下線で即座に指摘されるし、型情報をポップアップで表示してくれるし、コード補完も効くし、モジュールを修正すると勝手にインタフェースも修正してくれるし、トップレベルやocamlbrowserもついてくる。
JDTとなんら遜色はない。
不満をいえばocamlbuildやcamlp4へのオプションを与えたり、findlibを使ったパッケージのリンクとかそういうのがないとプロジェクトを共有する時などのポータビリティに欠ける。

つーかこの程度で実用的とかほざく奴ってどんな原始人だ？

>>963
>コード補完やオブジェクトブラウザ，GUIエディタを備えたIDEって興奮しません？

元Windowsプログラマーとしてはそれはあたりまえだったから興奮しない

元 UNIX プログラマーとしてはそんな飾りには何の実利も無いから興奮しない

Windowsプログラマは、水とIDEがタダだと思っている

>>968
確かにｗ

UNIXプログラマは、ミネラルウォーターと、IDEは不要と来ている

IDEあるとやぱり効率違うよ
おっちょこちょいの自分には。
コード補完、文法ミスを判定してくれるだけでも開発効率×２だよ。

俺は人並みの注意力があるからIDEは要らないや

>>970
emacsでいいんじゃない

つまりOCaml使いはそういう人たちの集まりという事でFA?

>>960を使ってみた。
http://uproda11.2ch-library.com/src/1119129.jpg

Ocamlのバイトコードインタプリタ実行の設定箇所はまだ空白になってた。

けっこういいかもっておもったり。

コード補完とか記述ミス判定はもちろん、
アウトラインがあるのはけっこういいかも。
MLってletでネストしまくって訳わからなくなるときあるけど、
そういう時にね。

取り合えずキーボードだけですべての操作ができるようにしてくれ

>>974
日本語つかえないの？

>>977
どこらへんが？

>>978
>>977はコメントが文字化けしてる点を指摘してるんじゃない？
EUCだったとか

OCaml　にもLispのマクロに相当するものあるの?

ﾗｿﾁﾓﾘｾｳ

ラは要らない

Lisp のマクロには相当しないと思う

C#つかいでF#に興味を持ってFoundation Of F#とりあえず買って読んでみてるがいまいち関数型の利点がピンと来ん････

>>984
どう書く？orgのお題から適当に見繕ってチャレンジしてみるとかどうよ？
ttp://ja.doukaku.org/challenge/

C#とOCamlの既存解答を見比べることもできるし
なんか参考になるんじゃないかね？

>>984
F#のおいしいところはC# 3.0に取り入れられるから
将来的にはC#一本でも問題ないかと。

C# 2.0にも一部取り入れられていて、
たとえば無名delegateでブロック渡し（クロージャ）をしたり、
継続渡しなんかを意識的に使うと便利な面がある。
ttp://d.hatena.ne.jp/yaneurao/20070207