【.NET】F#について語れ【OCAML】

MSResearchから出てきた.NETで使える関数型言語のひとつF#
OCAMLの流れを汲むこの言語、いろいろと面白そうなことができそう。
まだまだ英語の情報しかないこの言語について、幅広く語れ。

http://research.microsoft.com/fsharp/fsharp.aspx

J#の間違いじゃね？

F# のスレっていつの間にかに落ちてたのか
需要無いんかね

おおお！！ついにきた！

レスの数わずか９で終わったスレ：

＞Windows Live プログラミング

5 ：デフォルトの名無しさん：2007/05/23(水) 03:51:43
くだらねえ。なんでタダでMSの奴隷にならなあかんの。

7 ：デフォルトの名無しさん：2007/06/15(金) 08:37:17
漏れのW-zero3に
LIVEのサービスにシンクロするのを入れたけど
接続しっぱなし、常に電源オンで
頭にきて速攻消した。
OFFICEは付き合いで買ってみたけど
VSはもう川根。

8 ：デフォルトの名無しさん：2007/06/15(金) 23:14:07
>>5
Webサービスの類は自前でサーバを作らない限りどこかの会社の奴隷じゃよ

9 ：デフォルトの名無しさん：2007/06/16(土) 13:29:16
だからLAMPで組むところが多い

ここは6で終わりか

7まではいく

昔あったF#スレは190レス位で落ちた。
他の関数言語スレも過疎ってるし、単独スレはきついだろうな。

せめて、F#〜J#について語れ、とセットにしてはどうだろう？

　 　　　　 |
　 　＼　　__　　／
　 　＿　（ｍ）　＿ﾋﾟｺｰﾝ
　 　　　　|ミ|
　 　／ 　.｀´　 ＼
　　　 　∧＿∧ 　／￣￣￣￣￣￣￣￣￣
　　　　（・∀・∩＜ C丼以外の#言語を語れ
　　　　（つ　　丿 ＼＿＿＿＿＿＿＿＿＿
　　　　⊂＿ ノ
　　　　 　（＿）

>>9
G# H# I# ってどんな言語？

＞ H#

目立言語

んー？こんな言語できてんだ。
そのうちMSはA＃からZ＃まで26種類の駄言語を作りかねんな

工エｴェｪ（´д｀）ｪェｴエ工工

先にF++を作れよ。

ところでやっぱりﾄﾞﾄﾈﾄ専用言語？

>13
昔、そういう1文字言語のリストをどっかで見た覚えが・・・

OCamlって具体的にどういう分野が得意なの？なんかおもしろいネタある？

F#ってなんだ？
誰か三行で説明してくれ

前スレ
http://pc8.2ch.net/test/read.cgi/tech/1054523453/

メインフレーム用 JCL# とかどうよ？

F＃で仕事ある？
ttp://pc11.2ch.net/test/read.cgi/tech/1111656698/l50

新スレ記念にState Monadを作ってみましたよ。(　ﾟдﾟ)ﾉ

#light

type State<'s, 'a> = ST of ('s -> ('a * 's))
　with
　　static member Run (ST x) = x
　　static member Get () = ST <| fun s -> (s, s)
　　static member Put s = ST <| fun _ -> ((), s)
　　static member Eval x = State.Run x >> fst
　　static member Exec x = State.Run x >> snd

type StateBuilder () =
　member b.Return a = ST <| fun s -> (a, s)
　member b.Bind (ST x, f) = ST <| fun s -> let (a, s') = x s in State.Run (f a) s'
　member b.Let (x, f) = f x

let state = StateBuilder ()

let _ =
　state
　　{ let x = 100
　　　let! s = State.Get ()
　　　do! State.Put (x + s)
　　　return () }
　|> State.Exec <| 1000
　|> (print_any >> print_newline)


(実行結果)
1100

http://ja.doukaku.org/28/
これどうやればいいのかわからない。誰かヒント下さい。
リフレクションつーことは
http://research.microsoft.com/fsharp/manual/fslib/Microsoft.FSharp.Reflection.html
これを使うんだろうけど・・・正直さっぱりわからん。

ていうか、俺能力無さ杉。

>>22
おお！！使う機会あったら使わせてもらいます。

コールスタック見れば楽勝でしょ

>>24
うーん。そういうのあんましよくわからないんだわ。
でもがんばってみる。ありがとう！

C#のをもろパクってこういうのやってみているんだけど常に
_main()が帰ってくる。
bar(), baz()っていう関数名を返すにはどうすればいいんでしょうか。

#light
open System.Diagnostics

let foo() =
　　let stck = new StackTrace()
　　let frme = stck.GetFrame 1
　　let mthd = frme.GetMethod()
　　mthd.Name

let bar() = foo()
let baz() = foo()

スタックフレームの浅いのはインデックスの大きいところに入ってるでしょ

>>27
インデックスってどのインデックス？(GetMethod ?のところ?)
というか、やっぱりStackTraceよくわからない。

F#ってmixinできんの？

F#のFってFortranのF？

function

fuck you

fuck me

>>30
違います。弄って見れば分るけどFortranとは別物

Formula

MS による壮大な fiction

当たり前といったら当たり前だけど、guardがきちんと動いた。

#light

open Seq

type SeqBuilder () =
　member b.Return a = singleton a
　member b.Bind (m, k) = map_concat k m
　member b.Let (x, f) = f x

let seq = SeqBuilder ()

let guard = function
　| true -> singleton ()
　| _ -> empty

let _ =
　seq { let! x = {1..10}　 (* from *)
　　　　do! guard (x > 5)　(* where *)
　　　　return (x * x) }　 (* select *)
　|> iter (string_of_int >> print_endline)

(実行結果)
36
49
64
81
100

>>36
完全に記法の問題だけど、seqの後の{ }がやっぱキモい

このスレはのびない。

夢にF#が出てきてびびった

F#チラッといじてるが、これかなりいいんじゃね？
でかいアプリ作ったときの安定性がどうだか気になるけれど、使いこなせばC#よりはるかにGenericプログラミングできて生産性があがりそう。
VSでの使いかってもまぁまぁだし。

よく知らないんですが、
40の意見って何てアストロターフィング？

関数型言語が理解できないのなら黙っとけ

.NETのgenericsって高階型が使えないのが痛い。

IOモナドどうやって作ろう？

>>44
ttp://haskell.g.hatena.ne.jp/nobsun/20060907/monadicIO
ttp://haskell.g.hatena.ne.jp/nobsun/20060908/monadicIO

実は>>22のState Monadほとんどそのままだったりする。

>>45
実装じゃなくて「入出力する」ということはどういう感じにしたら
モナドになるんだ？って話。

>>実は>>22のState Monadほとんどそのままだったりする。

実は別にState Monad使わなくても作れたりするらしい。
もともと抽象的な実装方法というものがあってそれを満たすものがあれば
なんでもいい。(一番自然なのはStateMonad使う方法になるんだろうけど)

よく読んだら意味わかんないこと言ってるな。
つまりその実装で一体何を作ったのか？ってこと
（副作用出ないが云々は抜きで）

Foundation of F#って良い感じ？
買ってみようかどうか迷ってるのだが。

>>48　良いと思うよ

F#と本家Ocamlってやっぱ違う？？
ttp://oandrieu.nerim.net/ocaml/
ここにあるものってF#で使えますかね？？特にGsl。

岡村

OCamler

見事に過疎ったな。

(´∀｀∩)↑age↑

⊃・ ・〃 ｜age｜

Windows を使っている層と OCaml を使っている層は相容れない感じがするからねえ…

F#perになろうとおもってるんだが、いまやってるC#の仕事が落ち着かん(´；ω；｀)…

ていうか、OCamlって実はユーザ少ないのか？
Scheme >>> OCaml > Haskell
ぐらいかと思っていたけど
実は
Scheme >>> Haskell >> Ocaml
なんじゃまいか

もしそうなら現在においては
OCaml >>>>>> F#
なのでOCamlユーザの絶対数が少ないのならF#使いの数は・・・。

nagoyaでやれ

>>58
Schemeをネタに優越感に浸ってる香具師はよく見かけるが
そういう香具師が仕事で使ってるのはJavaだったりするし
小物ツールはRubyで書いてたりするのがほとんどな希ガス

Matrix,LinearAlgebraライブラリに固有値計算の関数ってある？
探しても無いからこれはMatlabあたりと連携させる必要があるのかなぁ。

あげ

LINQをTECPreviewじゃない正式版として使えるのはいつごろでしょうか?

>>64
FLinqサンプルが、May 2006 CTPじゃなくて.NET 3.5 Beta2(以降)に対応しないかってこと？
まあ、FLinqはあくまで標準ライブラリじゃなくてサンプルだから、対応の優先度は低いと思う･･･。

>>65　いや、ベータじゃないバージョンでリリースされてるのかということ。
自己責任だとしても製品に使っていいものかどうか。

>>66
LINQ自体(.NET 3.5)はまだベータで、RTMは年末頃だけどそういう話？

>>67　そういう話。さんくす。

全部lazyにしとけば遅延評価として正常に動作するもんどすか?
それともHaskelとかと比べて注意しないといけないとこあり?

age

普段 Visual C++ で業務アプリ書いている俺が
酔狂で関数言語（関数型言語？）をいじってみようと思うんだけど、
ocaml と haskell とどちらがお勧め？
手続きがたべったりの俺には無理？

だから、ドトネッツはクラスベースだって。

F# 入れてみた。おもしれぇ。
Visual Haskell も入れてみたけど、とっつきにくかった。
http://www.haskell.org/visualhaskell/
そういやなんでも IL 上でつくられてね？
IronPython とか IronRuby とか。

J#は？

JAVAとC#どちらが優れているか教えてください Part2
ttp://pc11.2ch.net/test/read.cgi/prog/1189919634/196

いまのオープンソースの流れから考えてもC#は数年後には今のJ#と同じ道を辿る。

利潤追求の激しい企業が本来ならば仲間にしなければならない開発者までも食い物に
していることも分からず、M$マンセーしている奴は頭を齧られ過ぎて考えることも出来ない
くらいに脳みそがなくなっているんだろ。可哀想だよ。

>>71
はじめはOCamlで、慣れてきたらHaskellもやってみるのがよろしいかと。

OCamlだけだと遅延評価とか関数合成あたりが学びづらいし、
Haskellだけだと再帰とかモジュールシステムあたりが学びづらい。

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿__
　　　　　　　　 (^o^)ﾉ ｵﾜﾀ　　　三┌(^o^)┘ｵﾜﾀ　　　　　　　　　 ／|
　　　　　　　　 ﾉ( ﾍﾍ　　　　　　　三　┘>　 　　　三 ┌(^o^)┘ｵﾜﾀ |　ミ
　　　(^o^)ﾉ ｵﾜﾀ　　　　　　　　三　┌(^o^)┘ｵﾜﾀ　　　 ┘>／　　　|　　 ミ ＼( ^o^)／ ｵﾜﾀ
　　　ﾉ( ﾍﾍ　　　　(^o^)ﾉ ｵﾜﾀ　 三　　┘>　┌(^o^)┘ｵﾜﾀ　　　 ／　　　　ﾐ 　|＿/
　　　　　　　　　　ﾉ( ﾍﾍ　　　　　　　　　　　三　 ┘> 　／　　　／ |　　　　　 　ﾉ ﾉ
￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣|　　　／ 　 |　　ミ
　　　　　　　　　　　　　　　　　 　 　 　 　 　 　 　 　 　 |　 ／　　 　|　 ヽ(^o^ )ﾉ ｵﾜﾀｰ　　　　　　ミ ＼( ^o^)／ ｵﾜﾀ
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿|／ 　 　　　|　 ＼(＼ﾉ　　　　　　　　 　　　　ﾐ　|＿/
　　　　　　　　　　　　　　　　　　　　　　 　 　　　　　|　　　　　　　　|　　　　　　　　　ミ　　　　　　　　　 ﾉ ﾉ
　　　　　　　　　　　　　　　　　　　　　　 　 　　　　　|　　　　　　　　|　　　　　　　　ミ ＼( ^o^)／ ｵﾜﾀ
　　＿＿＿＿＿＿ 　　　＿＿＿＿＿＿　　　　　　|　　　　　　　　|　　　　　　　　　　 　|＿/
　　||// 　 　 　 　.||　　　||// 　　　　　　||　　　　　│　　　　　　　 |　　　　　　　　　　 　ﾉ ﾉ
　　||/ 　　　　　　.||　　　||/ 　 　 　 　 　||　　　　　│　　　　　　　 |
　　||　　　　　　 　||　　　||._____________　...||　　　　　│　　　　　　　 |　　　　　　　　　　　　　　ミ
　　||　　　　　　　 ||　　　|||　 (^o^)　 |　 ||　　　　　│　　　　　　　 |　　　　　　　　　　　　　　　ﾐ＼(^o^)／ ｵﾜﾀ
　　￣￣￣￣￣￣　　　 ￣￣￣￣￣￣　　　　　　|　　　　　　　　|　　　　　　　　　　　　　　　 　　┘|

Adobe『AIR』は、「MSによるオフィスアプリ支配」を崩すか
ttp://wiredvision.jp/news/200709/2007090520.html

ttp://journal.mycom.co.jp/articles/2007/10/01/moesuku/menu.html

J#って何のためにあるの？
ttp://pc11.2ch.net/test/read.cgi/tech/1179314479/l50

>>75
C# はどうなるかわかんないけど、
C++/CLI の出来はいいと思うよ。
Managed C++ でいろいろと改良点が指摘されて
それが十分に生かされていると思う。

基地外にマジレス不要

うほ。
System.Windows.Forms とか見えてる・・・
もしかして俺が C# で書いたフォームを
Haskell から呼び出したりできるのか？？

Haskell じゃなかった、 F# だた。
両方並行していじってると頭がおかしくなるみたい。

出来るお(´・ω・｀)

F#速いお
OCamlよりも速いお
立ち上がってからの話だけど・・・
ちょっと言ってみたかっただけだお

Python並みにコードが短く、C#のように実行が速い
ttp://www.strangelights.com/blog/archive/2007/06/17/1588.aspx

C#って速いか？
C#って速いか？
C#って速いか？
C#って速いか？
C#って速いか？

遅いのはGDI+

初回起動時のコンパイルもかな

>>88
速いと思うよ。 >>90 が言うように初回起動時に
JITコンパイラのようなものが働いているみたいで、
確かにデバッグ・実行繰り返しているときに
いらいらすることがある。デバッグコードだから
かもしれないけど。

あと、実際に多用するかどうかはともかくとして、
C#だとどうしても速く書けない部分があっても
DLLの呼び出しが簡単なので、Cやアセンブラで
書いたコードを呼び出せるし。Javaのネイティブ
メソッドよりも簡単に。

>>91
interopでのDLLやCOMの呼び出しは確かに簡単だが、マーシャリングの
コストが高いので細切れにCの小さなコードを呼ぶような使い方はすべきでない。

そういうことがしたいなら、むしろC++/CLIを使うべきだろう。

>>92
C#のP/InvokeとC++/CLIの暗黙のP/Invokeのマーシャリングにかかるコストは実は差がない。
違いはC++/CLIではデフォルトでSupressUnmanagedCodeSecurityAttributeが付加され、
C#は付かないということ。
C#のP/Invokeに[SupressUnmanagedCodeSecurity]をつけると途端に速くなるから試してみるといい。

UTF-8 で書いておけば日本語もおｋなんだね。

>>93
それってセキュリティ的にどうなの？

>>95 セキュリティって文字列に反応しているようだけど、
この設定はセキュリティ関連のチェックを事前にできるように
するかどうかというだけの設定じゃなかったっけ？

ドトネトなプログラムは実行時にたとえば「ディスクへの書き込み
はしちゃだめだからね」なんていうセキュリティ上の制約を
つけて実行することができるようだけど、プログラムが全体として
その制約を満たしているかどうかを実行開始前にチェックできるように
するか、実行時に「おいおい、書いちゃダメだってば」って
例外を出すようにするかって違いじゃないの？

F#の話から外れて申し訳ないが。

ほっしゅほっしゅ

入れてみたよ〜。なんだか面白そうだ。

>>97
ttp://blogs.msdn.com/dsyme/archive/2007/10/17/s-somasegar-on-taking-f-forward.aspx
うは、Luke HobanがF#チームに異動か。

まあOrcasでの仕事もほぼ終わったところだろうし、いいタイミングなのかも。

ごめん、>>97は関係ない。

ttp://blogs.msdn.com/somasegar/archive/2007/10/17/f-a-functional-programming-language.aspx

これって、F#を製品化するって話なの？
表現が微妙でそう読み取れないんだけど、反響を見るとそういう扱いになってる･･･。(´･ω･`)

Iron ほげほげといい、F# といい、
Visual Studio で何でもありという感じだなぁ。
その一方で、 Visual Studio 2008 Beta 2 見ると
J# がなくなっている・・・
俺としては継続してほしかった。
さらにライセンス的に無理なんだろうけど
JDK 1.6 にも対応してほしかった。
いまは JDK 1.1.4 相当だから。
スレちがいでごめん。

wikipedia の F# のページ http://ja.wikipedia.org/wiki/F_Sharp
には F# は科学計算用途に適した言語であるといえる。
F# は、低級だが高速な数値計算言語 （Fortran など） と、
高級だが低速な言語 （Mathematica など） の両方の特徴をもつ。

って書いてあるんですけど、 F# によって matlab や R 言語で処理するような
事柄にむいていますか？向いているなら今から習得して修論に使おうと思って
いるんですけど...

後、同ページ http://ja.wikipedia.org/wiki/F_Sharp
には、 F# は異なる言語に容易にアクセスすることができ、
LAPACK や FFTW などといったライブラリの利用が容易である。

と書いてありますが、これは、 C 言語など低級の言語のみならず、 matlab や
mathematica や R 言語などにもアクセスする事は可能なんでしょうか？

言語による

Cにはアクセスできるよ。
ほかのはCからいけるならとりあえずラッパコード書けばいけんじゃね？

matlab や R はインターフェイスがネイティブの C だよね？
なので C++/CLI でラッピングすればドトネトの世界から
アクセスできる。当然 F# からもアクセスできる。
でもあんまり F# 使う意味ないんじゃね？

俺にとっての F# を使う意義と言えば、
Visual Studio の中で仕事しているふりをしながら
現実逃避できるというところだろうか。

>>105>>106
確かに、そうなると F# 使う意味なくなりますね...
それはそうと、 >>102 の

F# は科学計算用途に適した言語であるといえる。
F# は、低級だが高速な数値計算言語 （Fortran など） と、
高級だが低速な言語 （Mathematica など） の両方の特徴をもつ。

っていう記述は本当なのですか？もし本当なら、院生にとっては
夢のような言語のような気がするんですけど...

>>107
F#というよりベースになってるOCamlの特徴かな。
それなりの訓練は必要だが関数型言語はある種の科学技術計算に向いてる。
ただ、これを高級と呼ぶかどうかは知らんし、手続き型がいい場合もある。
関数型言語の多くは遅延評価で弱い型付けであるが、
OCamlは正確（遅延評価でないという意味）で、推論でしっかり型付けされるため、
コンパイルが可能でパフォーマンスがいい。
問題はまだ新しい言語でライブラリが充実してないところ。

>>107
どっかのページに大学院生でOCaml使っていて、こんなに（・∀・）ｲｲ!!言語なのになんでマイナーなんだろうとかいう記述があったぞ
>>108
F#なら.NETのライブラリが使えるお

正格だよね

>>108
> OCamlは正確（遅延評価でないという意味）
正格だボケ

ボケはお前だ

VC# expressしか持ってないんですが
この場合VS上でのF#プログラミングって使えるんですかね

Expressは駄目。たしか、IronPythonのも駄目だった。
いまお金かけないとすると、VS2008のbetaですかね。

2008 Beta2 Standardがおすすめ

F#はじめました。クロージャもどきを作ってみましたが、
let rec makeclr v n = 
    let pr n = printf "closure %d\n" n in
      if n < 1 then v else (fun () -> pr(n)) :: (makeclr v (n - 1))
let makecl = makeclr [] ;;
let v = makecl 10 in
  List.iter (fun x -> x()) v ;;

リストの後方に追加するスマートな方法があったら教えてください。
逆にしたら怒られた。
(makeclr v (n - 1)) :: (fun () -> pr(n)) 

>>116
3行目で if n < 1 then rev v が定石かと思われ。

(makeclr v (n - 1)) @ [fun () -> pr n] は効率の面でおすすめできない。(´･ω･`)

>>117
ありがとう。最後にまとめて反転させたほうが早いわけですね。
末尾再帰になってなかったのでそうしたら反転の必要もなくなりました。
最初はforやwhileを使ってたのですがなんだかうまくないようです。
あまりforやwhileは使わないのでしょうか。配列専用の機能のように思えました。

let rec makeclr v n = 
      if n < 1 then v else makeclr ((fun () -> printf "closure %d\n" n) :: v) (n - 1)
let makecl = makeclr [] ;;
let v = makecl 10 in List.iter (fun x -> x()) v ;;

>>118
ループとしてのfor, whileはほとんど使いません。(つーか、構文忘れてるし･･･。)
ただし、内包表記のforはよく使います。

let makeclr n =
　[ for i in [1..n] ->
　　　fun () -> printf "closure %d\n" i ]

でもまあ、最初のうちは再帰で解決する習慣を身につけるべきかと。(´･ω･`)

F#のメリットってなんですか？
C#より優れてるところ、劣ってるところはなんですか？
F#にできてC#にできないことってありますか？

>>119
こういうforの使い方があるのか。おいしくいただきまます。

あかん・・・手続き型べったりの俺には
簡単なコードで頭の体操するのが精いっぱい。

しかし使い慣れた Visual Studio で動くので
なんとなく使えてる気になるけど。
やっぱり理論的な基礎をしっかりとやってない
専門学校上がりのコーダーには扱えないのかね。

Emacs における Emacs Lisp のように、
既存のネイティブ or ドトネトなプログラムの
マクロ言語としておもしろい？とかオモタけど、
妄想だけにしときます。

>>118を1行で。

[1..10] |> List.map (fun n () -> printf "closure %d\n" n) |> List.iter ((|>) ())

暗号にしかみえんがみなさんはこういうのにメリット感じるの？

Microsoft、関数型言語F#をVisual Studioに統合へ――開発者からはおおむね好意的な反応
http://opentechpress.jp/developer/07/10/24/0310251.shtml

手を広げすぎ

let flip f a b = f b a
let delay f = fun () -> f

let _ = [1..10] |> List.map (printf "closure %d\n" |> (delay >> flip)) |> List.iter ((|>) ())

right to leftの方が読みやすいかな。

let _ =
　List.iter ((|>) ()) << List.map (flip << delay <| printf "closure %d\n") <| [1..10]

型推論ってなんですか？

型を推論してくれるんです。

やけに賑やかDaNa

OCaml は整数型と実数型で足し算の演算子すら違って面倒だという話を聞いたことがありますが，本当ですか？
F#もそうなってるんですか？

整数の演算子 :
+ - * /

実数の演算子 :
+. -. *. /.

めんどくさ

>>132

> 1 + 0.1;;

  1 + 0.1;;
  ----^^^^

stdin(7,4): error: FS0001: This expression has type
        float
but is here used with type
        int
stopped due to error

> 1.0 + 0.1;;
val it : float = 1.1

> 1.0 +. 0.1;;

  1.0 +. 0.1;;
  ----^^^

stdin(9,4): warning: FS0062: This construct is for compatibility with OCaml. Use
 the overloaded infix operator '+' instead. Disable this warning using --no-warn
 62 or #nowarn "62"
val it : float = 1.1

>>132
F#では演算子は共通になった。
.NETのサポートするデータ型を全部サポートしなきゃいけないのでこうなったものと思われる。
ただし暗黙の型変換はないので整数＋実数の計算は変換が必要になる。

> 3.2 + float 2;;
val it : float = 5.2

F#ってVS2008についてくんの？

OCamlってフランス製だっけ？

そうざます

おフランスｗｗｗ

140が見えない

なんで？

F# 1.9.3.4が出ますた。(　ﾟдﾟ)ﾉ

Asyncの実装がまた微妙に変わってますがな･･･。(´･ω･`)

おぉ〜

この言語は普及するのかな

ありゃ、ライブラリのマニュアル、バージョン古いままだ･･･。(´･ω･`)

普及するわけないだろｗｗｗｗｗｗｗｗｗｗｗ

並列計算の需要がものすごく増えてきてるから普及するんじゃないかねぇ

Async型って、Haskellで

　type Async a = Cont () (Either a Exception)

って脳内変換すれば、unit, bindの実装の意味が理解できることに最近気がついた。

で、ごく一部の方々がActionを使った継続をやけに議論してた意味もようやくわかった。(つД｀)

Eitherじゃぜんぜんダメだった･･･。orz
エラー系の継続を最初からずっと保持してなきゃならんので、結局

　type Async a = (a -> (), Exception -> ()) -> ()

こうするしかないですわ。(´･ω･`)

でも、Asyncってモナド則を満たしてるんかいなという新たな疑問も･･･。

あ、型コンになってなかった。(´･ω･`)

　data Async a = Async ((a -> (), Exception -> ()) -> ())

Asyncを単純化するとこんな感じなのかな？（ ´・ω・）


#light

type Async<'a> = Async of (('a -> unit) * (exn -> unit) -> unit)
　with
　　static member Run (Async x) = x

let unit a = Async (fun (cont, _) -> cont a)

let bind m k =
　Async (fun (cont, econt) ->
　　let cnext = fun a -> try Async.Run (k a) (cont, econt) with exn -> econt exn
　　Async.Run m (cnext, econt))


で、実際にはここでのunit→resultPrim, bind→bindAsyncPrim相当でしかなくて、
これにキャンセルサポート(AsyncGroup)を追加してはじめてresultAsync, bindAsync相当になる、と。

モナドの定義自体にはスレッド云々は関係なくて、モナドを起動する側(Run, Spawn)の方で
スレッドに結びつけてる、と。

これをC#で表現するのはめんどいのう。(´･ω･`)

関数型言語は図で説明できますか？
フローチャートのように。
それが出来ないと、企業で使うのは難しいと思う。

フローチャート(笑)

次の質問をどうぞ

質問が正確じゃないな。

　　「Javaはむずかしすぎて使えません！」とギャグでなく主張する
　　ド低脳にとっては関数型言語のほうが簡単なのですか？
　　そうでないと、ドカタが使うのは難しいと思う。

こうだろ。

おもしろくないよ

あ、>>151間違えとる。(´･ω･`)

Async.Runは Async<'a> -> 'a にしないとダメなのか･･･。
>>151の実装は flip asyncApp 相当に過ぎないか。

うーん、やっぱりキャンセルサポートなしでAsync.Runまで作っても複雑になるなあ･･･。

#light

type Async<'a> = Async of (('a -> unit) * (exn -> unit) -> unit)

let app (Async x) = x

let unit a = Async (fun (cont, _) -> cont a)

let bind m k =
　Async (fun (cont, econt) ->
　　let c = fun a -> try app (k a) (cont, econt) with exn -> econt exn
　　app m (c, econt))

let catch p =
　Async (fun (cont, _) ->
　　app p (cont << Choice2_1, cont << Choice2_2))

let start p = app p ((fun () -> ()), (fun exn -> raise exn))

type Async<'a> with
　static member Run p =
　　let res = ref None　// val res : Choice<'a, exn> option ref
　　let cont = fun r -> res := Some r; unit ()
　　start (bind (catch p) cont)
　　match Option.get !res with
　　| Choice2_1 a -> a
　　| Choice2_2 exn -> raise exn

これでAsync.Spawn, Async.Parallelまで挑戦するのは無理ぽ。(´･ω･`)

1.9.3.6リリース

>153-154
図星だったようだね。

？

政治的な理由で図が必要なら、Executable UMLでも
使ってれば？
あと>>155が答え。

CPSだとアピールするよう、>>158のstartをプチ改良。ｗ

let id x = x

let start p = app p (id, (fun exn -> raise exn))

これはすばらしすぎるｗｗｗ
ttp://channel9.msdn.com/Showpost.aspx?postid=358968

コメント欄もなかなか熱い。（；＾ω＾）

もうちょっとHaskellよりなOCamlがいいと思う

OCamlは副作用に対して寛大で、保守性や開発効率を保ったまま言語仕様を定めるのが忙しくて
165の様な要望に対しては手一杯

F#のオブジェクト機能をちょっとまじめに使ってみますた。(　ﾟдﾟ)
ttp://cid-c42499cb3a347006.skydrive.live.com/self.aspx/Public/DLRSample.fs

日本語の解説はないの？
htmlは読みにくいからpdfのドキュメントはないの？

両方ともにすばらしい。(´ー｀)

(.ppt注意)
ttp://qcon.infoq.com/sanfrancisco/file?path=/QConSF2007/slides/public/ErikMeijer_LINQIntro.ppt
ttp://qcon.infoq.com/sanfrancisco/file?path=/QConSF2007/slides/public/ErikMeijer_Confessions.ppt

モナドの観点では、LINQの標準クエリ演算子で最重要なのは実は SelectMany なのね。


>>168
日本語の解説は見たことないです。
英語のなら最近すごくいい入門記事が出ましたが･･･。

ttp://tomasp.net/articles/fsharp-i-introduction/article.pdf

>>169
モンドリアン風なのが気に入ったｗ

F#がC#より優れている点ってあるの？
すべてにおいてC#が優っているように思えるのだが。

んじゃC#使えばいいじゃにあか

そうだけど何かメリットがあるならF#を使ってみようかと思って。
無いなら使わないけど。

F#とC#は使い所が違うんじゃないかな

(::)が関数として使えないんだけどそういうもん？

F#の機能とかっていずれC#も取り込みそうな気がする。C#って何気に巨大言語だよね。

へじたんの夢の固まりだからな

C#でできることすべてはF#でできない。
F#でできることすべてはC#でできる。

逆だろ

逆じゃない。

C#、F#でできることの集合をそのままC#、F#と書く
１行目から C# ∩ F# ＝ φ
２行目から F# ⊆ C#

∴F# ＝ φ

アッー

aho

（C#でできることすべて）はF#でできない。
ではなく
C#でできることにはF#でできないことがある。
という意味なのか

仕様書でこういうどちらとも取れる言葉遣いをしていたら揉め事の種になるな

F#使ったことないけど、
C#では

var f = i=>i

で型推論が働かず、コンパイルが通らない。
F#ではできる！(=F#でしかできない事)

という認識で良いでしょうか？

開発はなに使ってますか?VS2008?

気がつけば、F# 1.9.3.7にマイナーアップデート。
ttp://research.microsoft.com/research/downloads/Details/e8478d6b-49c0-4750-80eb-0e424d1631a3/Details.aspx

そして待望のこれ。F#との相性よろし。(´ー｀)
ttp://www.microsoft.com/downloads/details.aspx?FamilyID=e848dc1d-5be3-4941-8705-024bc7f180ba&DisplayLang=en

改めてこちらにも注目。
ttp://research.microsoft.com/research/downloads/Details/f9d6994e-45f6-49b8-b3c9-2a44bb2a4c50/Details.aspx

C#で航海関数(なぜか変換できない)かけるのかとこ一時間

ﾊｧ?

System.Linq.ParallelEnumerable
System.Linq.Parallel.Enumerable

まぎらわしい･･･。(´･ω･`)
前者はIParallelEnumerable用、後者はIEnumerable用。

ParallelEnumerableに、ForAllなんていうAction系の拡張メソッドが。
オリジナルのEnumerableにもこれ付けてほしかったのに。(つД｀)

Parallel.Aggregateはどこへ行った？と思ったら、

　Parallel.For<TLocal>
　Parallel.ForEach<TSource, TLocal>

がその代わりらしい。でも、使い方がちょっとわかりにくい･･･。(´･ω･`)

>>191のForAllは、inverted enumerationというやつだった。
ForEachのつもりで使うと、順番がバラバラで困ったことになる。

MSDN Magazineできちんと解説してた内容をすっかり忘れてた･･･。orz
ttp://msdn.microsoft.com/msdnmag/issues/07/10/PLINQ/default.aspx

http://research.microsoft.com/research/downloads/Details/e8478d6b-49c0-4750-80eb-0e424d1631a3/Details.aspx
http://www.microsoft.com/downloads/details.aspx?FamilyID=e848dc1d-5be3-4941-8705-024bc7f180ba&DisplayLang=en
http://research.microsoft.com/research/downloads/Details/f9d6994e-45f6-49b8-b3c9-2a44bb2a4c50/Details.aspx

SEQUENTIAL_THRESHOLDがからむと、チューニング(値決め)がむずかしそうですのう。(´･ω･`)

TPLむずかし杉ワロタｗ

#r "System.Core.dll";
#r "System.Threading.dll";

#light

open System
open System.Linq
open System.Threading
open Int32

let _ =
　let sum = ref (to_int64 0)
　do Parallel.For(0, 1000000,
　　　　　　　　　new Func<_>(fun _ -> !sum),
　　　　　　　　　new Action<_,ParallelState<_>>(fun i st ->
　　　　　　　　　　st.ThreadLocalState <- st.ThreadLocalState + (to_int64 (i + 1))),
　　　　　　　　　new Action<_>(fun localSum -> Interlocked.Add (sum, localSum) |> ignore))
　Console.WriteLine("TPL　 : {0}", !sum)

let _ =
　let seq = ParallelEnumerable.Range(1, 1000000)
　ParallelEnumerable.Aggregate(seq, to_int64 0, new Func<_,_,_>(fun sum i -> sum + (to_int64 i)))
　|> fun sum -> Console.WriteLine("PLinq : {0}", sum)

dual coreでのパフォーマンスアップは1.5〜1.6倍といったところでしょうか。
quadで動かしてみたいのう。(´･ω･`)

F#じゃないけど、こんなのを取りまとめ中。
ttp://cid-c42499cb3a347006.skydrive.live.com/self.aspx/Public/LinqUtils.cs

C#も十分関数的ですのう。(´･ω･`)

なんかむずむずする関数名だな。

>>198
・Unitは確かにムズムズするな。unit 型と混乱しそう。
・IsEmptyの実装は Enumerable.Count<T>使うより
　Enumerable.Any<T>使った方が良いんでは？
　Count使うと無限リストで死ねる。
　てかAnyがあるからIsEmpty要らん気もするけど。個人的には。

C#もラムダ式で再帰を書く方法の改善と末尾再帰の最適化をやってくれるようになったら
関数型っぽく遊べるようになるんだがな。

その辺は棲み分けでしょ
.net frameworkって糊を上手く使う所ってことで

>>200
コメント感謝です。

> ・Unitは確かにムズムズするな。unit 型と混乱しそう。

前は「Lift」って名前にしてたんですが、そっちの方がわかりやすいでしょうか？

> ・IsEmptyの実装は Enumerable.Count<T>使うより
> 　Enumerable.Any<T>使った方が良いんでは？

Anyの使い方を知らなかっただけでつ。（´・ω:;.:...
勉強になりますのう。

>>203
個人的にはLiftで良いと思う。
ただ、.NET全般として見たときには
Nullableのところで"Lift"を使っちゃってて面倒鴨。

ttp://msdn2.microsoft.com/en-us/library/system.linq.expressions.unaryexpression.islifted(VS.90).aspx

monadがあればこの辺のメタな名前の衝突は回避できるというか統合できるのかのぅ。

>>204
修正しますた。ついでに使用例も。(　ﾟдﾟ)ﾉ
ttp://cid-c42499cb3a347006.skydrive.live.com/self.aspx/Public/LinqUtilsDemo.cs

> monadがあればこの辺のメタな名前の衝突は回避できるというか統合できるのかのぅ。

monoid派が「Unit, Bindにすべし！」と言い出す悪寒･･･。

うーん、結局のところ

　かなり必要 → ZipWith
　できれば必要 → Lift (T -> IEnumerable<T> のインターフェイスで)

ぐらいで、他は別にイラネって感じかもしれん･･･。(´･ω･`)

Cycleは漏れ的にはお気に入りだけど、実際には使わんよなあ･･･。(;´Д`)

OCamlは糞言語だな。F#は大丈夫なんだろうな。

TPLは、TaskManagerPolicyを変えて、ParallelよりもConcurrentライブラリとして使えば便利かもしれん。
でもそれって何てjava.util.concurrent？(´･ω･`)

Lisp系に比べるとML系って泥臭いというか、洗練されていない感じがする。頭悪そうな感じ。

でも得てしてそういう言語の方が広まったりしない？

MLは普及してないだろ。

まさに目くそ鼻くそ

MS は # シリーズが Z までいったら，
次は $ シリーズを展開してくれると期待している．

M$

>>210
CL, Scheme, SML, OCaml なんかを比べているのであれば、
どれも大差無い様に見えるけど。歴史的に一番泥臭いのは
CL だろうけど…

Scalaの言語仕様もよくできてますなあ。
F#よりもHaskellに近い希ガス。
もしかしたら、C# 4.0のヒントもこの中にあるのかもしれん。(´･ω･`)

気になる開発プロダクツ
第7回 Scala 2.6.0-final
http://gihyo.jp/dev/serial/01/awdp/0007

初めて名前聞いた．

ところでみんな将来的には業務に使おうと思ってF#とか
関数型言語をいじってるの？

Scala、Rubyみたいな言語だなｗ

一部で話題になってる論文。
ttp://www.cs.kuleuven.be/~adriaan/?q=genericshk

これをJVM上の言語で実現したのはすごいなあ。

一方、.NETの方では･･･。(´･ω･`)
ttp://www.haskell.org/pipermail/glasgow-haskell-users/2005-January/007603.html

いちおう動いたけど、なんか間違えてるような･･･(´･ω･`)？

trait Monad[M[_]] {
　def returnM[T](x: T): M[T]
　def bindM[T, U](m: M[T], f: T => M[U]): M[U]
}

abstract class Maybe[T]
case class Just[T](x: T) extends Maybe[T]
case class None[T] extends Maybe[T]

object Test {
　implicit object MaybeMonad extends Monad[Maybe] {
　　def returnM[T](x: T) = Just(x)
　　def bindM[T, U](m: Maybe[T], f: T => Maybe[U]): Maybe[U] = m match {
　　　case Just(x) => f(x)
　　　case _ => None()
　　}
　}
　def test[T, U](a: Maybe[T], f: T => U)(implicit m: Monad[Maybe]) {
　　m.bindM(a, (b: T) => m.returnM(f(b))) match {
　　　case Just(x) => println(x)
　　　case _ => println("None")
　　}
　}
　def main(args: Array[String]) {
　　test(Just(100), (x: Int) => x + x)　// 200
　　test(None(), (x: Int) => x + x)　// None
　}
}

testの第1引数にMaybeを使ってしまうと、Monadで汎化した意味がないような･･･。

しかも、JustとNone。名前の由来が微妙に混ざってる･･･。orz

あ、こうすればいいのか。(ﾟ∀ﾟ)

　def test[M[_], T, U](a: M[T], f: T => U)(implicit m: Monad[M]) {
　　m.bindM(a, (b: T) => m.returnM(f(b)))
　}

関数を { 〜 } で囲むと戻り値はUnitになっちゃうのか･･･。なるほど。(；`・ω・）

修正版でつ。

trait Monad[M[_]] {
　def returnM[T](x: T): M[T]
　def bindM[T, U](m: M[T], f: T => M[U]): M[U]
}

abstract class Maybe[T]
case class Just[T](x: T) extends Maybe[T]
case class Nothing[T] extends Maybe[T]

object Test {
　implicit object MaybeMonad extends Monad[Maybe] {
　　def returnM[T](x: T) = Just(x)
　　def bindM[T, U](m: Maybe[T], f: T => Maybe[U]) = m match {
　　　case Just(x) => f(x)
　　　case _ => Nothing[U]()
　　}
　}

　def test[M[_], T, U](x: M[T], f: T => U)(implicit m: Monad[M]) =
　　m.bindM(x, (y: T) => m.returnM(f(y)))

　def main(args: Array[String]) {
　　def p[T](m: Maybe[T]) = m match {
　　　case Just(x) => println(x)
　　　case _ => println("Nothing")
　　}
　　p(test[Maybe,Int,Int](Just(100), (x: Int) => x + x))
　　p(test[Maybe,Int,Int](Nothing(), (x: Int) => x + x))
　}
}

前、海外でF#使える人の求人あったけどどんなものなのかね?
日本でもかまわんけれど、実際のシステムで使われてるかなど教えてエロイ人

>>226
実際は雑用とかだろ

このスレ一人しかいないのか知らんけど、過疎ってるからってさすがにつっこむべきかと・・・・
そのコードF#ですか？

>>226
基本的には.netアプリだけど、ASP.NETでスクリプト的に使うんだろうな〜
まあIronPythonもそうだがちゃんとしたフォームデザイナがないとGUIアプリは作りづらいし
当然C#とかVBを置き換わるものではない
ってか常識で考えろ

>>228
常識が何をさしてるのか知らんが、別に既存の業務土方アプリ作るのにF#使うことは無いでしょう。
まぁF#のほうが生産性高いとは思うけれど、メンテや技術者の人数から見ても選択されることはないかと。
それよりも自分が見たのは、何かの科学計算に向けての実験的なアプリの作成などに絡む部門だったような。Lispとかの経験でも可とかいってたから何か面白そうなにおいがした。

Scalaをいろいろと触ってみましたけど、オブジェクトの発想が強すぎて
関数型としては扱いづらいですね･･･。(´･ω･`)

F#の比較対象としては不向きかも。

fsi --quiet --exec hoge.fs

hoge.fsを実行してそのまま終了。
今までこのオプションを知らんかった･･･。orz

そうなると、DLRの使い道が一気に減ってしまうがな。(´･ω･`)

F# 1.9.3.14あげ

ttp://www.iunknown.com/2008/02/langnet-wrap-up.html

IronRubyの中の人による、Lang.NETのまとめ

へじたんのお言葉
I think that the taxonomies of programming languages are breaking down. I think that languages are fast becoming amalgam. ... I think that in 10 years, there won't be any way to categorize languages as dynamic, static, procedural, object, and so on.

だそうで。

F#の学習はいい先行投資かもしれないねぇ。まぁ楽しいからやってるんですし、皆さんそうなんでしょうけど。

どうせ次のＣ＃までまた2年ぐらいあるんだろうしなぁ･･･
Ｆ＃製品に使うことにするﾉｼ

OCamlとか知らんでいきなり#lightでやるの危険だな
letに宣言と式があるなんて知らんかったし、do,doneとかもかなり混乱する
Web上だとそういう初歩の情報ないし。
OCaml入門は読むべしだ。互換性とか適当だけど。
Expert F#は割とわかりやすかった

ひゃー

Ｆ＃の日本語本うｐ

F#でMapReduceもどきを作ってみますた。(「もどき」なのは、sequentialにしか動かないから。ｗ)
C# LINQに比べると、やっぱり圧倒的に記述しやすいわ。

#light

open System
open Seq

let ap_snd f (a, b) = (a, f b)

// MapReduce

let map_reduce m r =
　map_concat m
　>> groupBy fst
　>> orderBy fst
　>> map (ap_snd (map snd) >> r)

// word count demo

let mapper (_, v : string) =
　v.Split [| ' '; ','; '.'; '!' |]
　|> filter (not << String.IsNullOrEmpty)
　|> map (fun s -> (s.ToLower(), 1))

let reducer = ap_snd (fold1 (+))

let data =
　[ "This is a pen.";
　　"Hello, World!";
　　"All your base are belong to us.";
　　"My name is nanashi." ]

let _ =
　mapi (fun i s -> (i, s)) data
　|> map_reduce mapper reducer
　|> iter (fun (k, v) -> Console.WriteLine("{0}\t{1}", k, v))

C#版も置いておきまつ。クエリーの部分だけはきれいなんですが･･･。(´･ω･`)

using System;
using System.Collections.Generic;
using System.Linq;

// MapReduce

public interface IMapper<K1, V1, K2, V2> {

　　IEnumerable<KeyValuePair<K2, V2>> Map(KeyValuePair<K1, V1> p);
}

public interface IReducer<K2, V2, K3, V3> {

　　KeyValuePair<K3, V3> Reduce(KeyValuePair<K2, IEnumerable<V2>> p);
}

public class MapReduceJob<K1, V1, K2, V2, K3, V3> {

　　Func<KeyValuePair<K1, V1>, IEnumerable<KeyValuePair<K2, V2>>> mapper;
　　Func<KeyValuePair<K2, IEnumerable<V2>>, KeyValuePair<K3, V3>> reducer;

　　public MapReduceJob(IMapper<K1, V1, K2, V2> mapper, IReducer<K2, V2, K3, V3> reducer) {
　　　　this.mapper = mapper.Map;
　　　　this.reducer = reducer.Reduce;
　　}

あれ？数分間書き込めなかった･･･。(´･ω･`)

　　public IEnumerable<KeyValuePair<K3, V3>> Execute(IEnumerable<KeyValuePair<K1, V1>> data) {
　　　　return from d in data
　　　　　　　 from p in mapper(d)
　　　　　　　 group p.Value by p.Key into g
　　　　　　　 orderby g.Key
　　　　　　　 select reducer(new KeyValuePair<K2, IEnumerable<V2>>(g.Key, g));
　　}
}

// word count

class WCMapper : IMapper<int, string, string, int> {

　　public IEnumerable<KeyValuePair<string, int>> Map(KeyValuePair<int, string> p) {
　　　　return from s in p.Value.Split(' ', ',', '.', '!')
　　　　　　　 where !String.IsNullOrEmpty(s)
　　　　　　　 select new KeyValuePair<string, int>(s.ToLower(), 1);
　　}
}

class WCReducer : IReducer<string, int, string, int> {

　　public KeyValuePair<string, int> Reduce(KeyValuePair<string, IEnumerable<int>> p) {
　　　　return new KeyValuePair<string, int>(p.Key, p.Value.Sum());
　　}
}

static class Test {

　　static string[] data = {
　　　　"This is a pen.",
　　　　"Hello, World!",
　　　　"All your base are belong to us.",
　　　　"My name is nanashi."
　　};

　　static void Main() {
　　　　var d = data.Select((s, i) => new KeyValuePair<int, string>(i, s));

　　　　var job = new MapReduceJob<int, string, string, int, string, int>(new WCMapper(), new WCReducer());

　　　　foreach (var p in job.Execute(d)) {
　　　　　　Console.WriteLine("{0}\t{1}", p.Key, p.Value);
　　　　}
　　}
}

Map/Reduce = Select/Aggregate だと今まで勘違いしてたけど、

　Map -> SelectじゃなくてSelectMany(generator的な操作)
　Reduce -> 確かにAggregateの操作だけど、厳密にはSelectの中で(selectorとして)実行されるAggregate

だったのね。実際に書いてみないとなかなか気づけんわ。(´･ω･`)

ついでにネタ振り。

末尾再帰のスタイルはどちらがお好み？

#light

// val sum : int list -> int

let sum1 l =
　let rec sum' l v =
　　match l with
　　| [] -> v
　　| h::t -> sum' t (v + h)
　sum' l 0

let sum2 =
　let rec sum' v = function
　　| [] -> v
　　| h::t -> sum' (v + h) t
　sum' 0

要は、sum' の引数の順番の問題なのですが･･･。

僕は末尾再帰用の追加の引数は最後に置くなぁ
もともと引数は「入力、出力」の順で書いてたので。
末尾再帰は局所定義にすることがほとんどで
部分適用をしないから、それでもいいかなと。

おお、即日レスがつくとは･･･。(つД｀)

>>245
> もともと引数は「入力、出力」の順で書いてたので。

確かにそうですね･･･。

sum2の方は一見ムダがないですけど、意味的にはちょっと無理やりなのかもしれませんね･･･。(´･ω･`)

F#がNTPに対応すれば問題なし。

Haskellにも移植してみますた。

import Data.Char
import Data.List hiding (groupBy)

-- MapReduce

mapReduce :: (Ord k) => (a -> [(k, v)]) -> ((k, [v]) -> b) -> [a] -> [b]
mapReduce m r = map r . orderBy fst . groupBy fst snd . concatMap m

-- word count

mapper :: (Int, String) -> [(String, Int)]
mapper (_, v) = map (\s -> (map toLower s, 1)) . filter (not . null) $ split " ,.!?" v

reducer :: (String, [Int]) -> (String, Int)
reducer (k, v) = (k, sum v)

-- test

data_ = [ "What is this?",
　　　　　"This is a pen.",
　　　　　"Hello, World!",
　　　　　"All your base are belong to us" ]

main = mapM_ p $ mapReduce mapper reducer $ zip (iterate (+1) 0) data_
　　　　 where
　　　　　 p (k, v) = putStrLn $ show k ++ "\t" ++ show v

-- utils

orderBy :: (Ord k) => (a -> k) -> [a] -> [a]
orderBy fk = sortBy (\x y -> fk x `compare` fk y)

groupBy :: (Eq k) => (a -> k) -> (a -> v) -> [a] -> [(k, [v])]
groupBy _　_　[] = []
groupBy fk fv l　= let key = fk $ head l in
　　　　　　　　　 let (g, rest) = partition (\x -> fk x == key) l in
　　　　　　　　　 (key, map fv g) : groupBy fk fv rest

split :: [Char] -> String -> [String]
split sep s = case break (\c -> any (==c) sep) s of
　　　　　　　　(v, [])　-> [v]
　　　　　　　　(v, h:t) -> v : split sep t

こうやって見ると、F#は.NETの資産を使える分、すごく楽だなあ･･･。(´･ω･`)

こだわる人はこだわる修正でつ。(´･ω･`)

mapper :: (Int, String) -> [(String, Int)]
mapper = map (\s -> (map toLower s, 1)) . filter (not . null) . split " ,.!?" . snd

やはは

>>247
NTP対応って何よ？
これか
>米国国家毒性プログラム（べいこくこっかどくせいプログラム、英： National Toxicology Program 、略称： NTP )
とはアメリカ保健社会福祉省が実施している化学物質の毒性研究をまとめ、発がん性物質の分類、試験を行う計画である。

面白いと思って書き込んでるのがすごいよな

named template(?) parameter

むしろ名古屋トヨペット

時間同期のプロトコルにきまっとるだろう

自分のプログラムの中にF#のインタープリタを組み込みたいんですが可能ですか？
今のプログラムはC#で書いていて、その挙動の一部をカスタマイズできるように
したいのですが、せっかく覚え始めたF#で書ければいいなぁと思っています。

キーワードはCodeDOM。
あとは自分で調べろ>>258

Visual Studio持ってないとF#って使えないの？
一応インストールはできたんだけど、コマンド打ってくだけ。

VSShellがあれば使える。
あと、SharpDevelop 3.0で使えるようになる予定。Beta1で載った。

VSShellをDLしようと思って、Visual Studio 2008 SDK 1.0をDLしたんだけど
Visual Studioがインストールされてないとだめみたいだ。VSShell単体って
どこにあるの？てか、あるの？

あったわ。

ハローワールドできたわ。
で、いい本ないの？

http://www.amazon.com/Foundations-F-Experts-Voice-Net/dp/1590597575/ref=pd_bbs_sr_2?ie=UTF8&s=books&qid=1206698720&sr=1-2

Foundations of F#

ネイティブが分かりにくいと酷評してるんだが、読んだ人どう？

全部読んでないが、Expert　F#のほうが分かりやすい。
内容も別にExpert向けというわけでもないし。高度な話題も載ってるが。

>>266
そうなんだ。
星の数のとおりか。
でも高いな。。

すみません、WinAPI呼び出しわかる方いますか？やりたいこと→PeekMessage呼び出し

[<DllImport("user32.dll", EntryPoint="PeekMessage" ,SetLastError=true,CallingConvention=CallingConvention.StdCall)>]
let PeekMessage( (lpMsg : ref MSG),(hwnd : Int32),(wMsgFilterMin : Int32),(wMsgFilterMax : Int32),(wRemoveMsg : PeekMsgOption)):bool = failwith "extern";;

エラーメッセージ
　The type 'MSG' is not defined.
　The type 'PeekMsgOption' is not defined.

MSG構造体については
自分の環境(Win2k,VS2005,.Net framework 2.0.50727.42)ではwindowsbase.dllがないようなので
これはXPかVistaを使えってことでしょうかね,..
　http://msdn2.microsoft.com/ja-jp/library/system.windows.interop.msg.aspx
また、PeekMsgOptionはオンラインのMSDNではほとんど情報がないようです
そもそも、VS2005のF#プロジェクトでは「参照の追加」はできないのでしょうか？

↓XPと.net framework3.0入れたらコンパイル通ったので、何かの参考までに。

open System.Runtime.InteropServices;;
open System.Windows.Interop;;
[<System.Flags>]
type PeekMsgOption =
| PM_NOREMOVE = 0
| PM_REMOVE = 1;;
[<DllImport("user32.dll", EntryPoint="PeekMessage" ,SetLastError=true,CallingConvention=CallingConvention.StdCall)>]
let PeekMessage( (lpMsg : (ref <System.Windows.Interop.MSG>)),(hwnd : Int32),(wMsgFilterMin : Int32),(wMsgFilterMax : Int32),(wRemoveMsg : PeekMsgOption)):bool = failwith "extern";;

そりゃそうだ。
System.Windows以下（Forms除く）は.NET Framework 3.0からのWPF。

そこのURLの先にもはっきりとこうかいてあるはずだ。
バージョン情報
.NET Framework
サポート対象 : 3.5、3.0 SP1、3.0

System.Windows.Forms.Messageなら2.0でも使える。

PeekMsgOptionについてさっぱり見つからないのは、
単にその2つの定数を宣言するためだけに即興で作ったからではないか？
もともとはただの符号無整数型だし。
http://msdn2.microsoft.com/en-us/library/ms644943(VS.85).aspx

MSGとかの構造体を自力で実装しなくていいってことか？
まじ.netとかそうなってるの？
そもそも実行できたのかあやしいんだが

さらに追記
(lpMsg : (ref <System.Windows.Interop.MSG>)の箇所は
(lpMsg :System.Windows.Interop.MSG)にしないと実行時にマーシャリング系のエラーが出る。
しかしどちらにせよ、デバッグモードで動かすと構造体のサイズ違うっていわれるから
自分でMSG構造体定義した。


..けれど結局、やりたかったことは、Win32API使わなくてもできたよotz

1.9.4.15 リリース

>>171
OCaml, Haskell, Lispなどの関数型言語はラムダ計算という理論が骨組みにあって、
特別な構文を使わずに、柔軟なプログラミングをすることができる。
関数を抽象化するためのdelegateや、多相型を表現するためのgenericsなども、
特別な構文無しにプログラムできる。

しかも、キャストや、nullを使う言語よりも、実行時の安全性が高い。

関数型言語を知っている学生は、プログラミングの質に対する意識が非常に高いのが多い。
OCamlができる優秀な学生を雇って、F#のプロジェクトをやれば、いいんじゃね。

FizzBuzz 2.0 ですね。わかります。

>>274
学生　プｯ

こんにちは。
Ｆ＃の開発環境って何があるんでしょうか？
・VS.NET拡張
・エディタとコンパイラ
以外にはありませんか？

つ　インタプリタ(fsi.exe)

Expert F#のPDFを買ったお

Expertというわりにぜんぜん入門から対応しているから、いいね。
しかし、600ページ以上あって読み応えありすぎだｗ

>>278
good! 補間や履歴も聞いていいですな。

しかしC-Aで行頭、C-Eで行末移動がほしかったな

ebook版ってあったのか。英語はわかりやすくてよいよね
ただ、分厚いから俺は辞書的に使ってる

>>280
つ　fsi用のEmacsモード作ろうぜってスレッド。俺は試したことないけども参考までに
ttp://cs.hubfs.net/forums/thread/4004.aspx

>>277
ttp://www.infoq.com/jp/news/2008/03/sharpdev-3-beta

F#のライセンスについて、市販製品に使うときの注意事項を3行でplz

知
ら
ん

fslexってまだ日本語対応してないのな・・
ttp://www.strangelights.com/fsharp/wiki/default.aspx/FSharpWiki/fslex.html

　{ open Microsoft.FSharp.Text.Printf;; }
　rule strtest = parse
　　| _ { printf "%c" (Lexing.lexeme_char lexbuf 0); strtest lexbuf }
　　| eof { raise End_of_file }
　{
　　//こっから実行コード
　　let test s = strtest (Lexing.from_string s);;
　　try test "aiueo" with _ -> printf "\n--end--\n";;
　　try test "あいうえお" with _ -> printf "\n--end--\n";;
　　printf "あいうえお";;
　}
実行結果
　aiueo
　--end--
　?????
　--end--
　あいうえお

ふとおもったんだがLispの.NETなやつってある？

>>286
List of CLI Languages - Wikipedia, the free encyclopedia
http://en.wikipedia.org/wiki/List_of_CLI_Languages

IronLisp, L#, DotLisp

NemerleもLispを参考にしてるらしいな

英語のwikiは凄いな
P#とかA#とかあるｗ

これみてP#やってみたくなったｗ

ううむ，原理的には JVM でもいろいろできるんだろうけど，
MSIL （っていうのか？）上での方がバリエーションが多いなぁ．
これって一応MS的にはドッキリ大成功みたいな感じなのかね？

>>290
MSは.NET 1.0のSDKにLISPのコンパイラを付けてたくらいだから
最初から狙って取りに行ってたんだと思うよ。

MSはCOMでも多言語に凝っていたな。

>>245
そもそもこの例ではfold_leftを使って、
let sum = fold_left (+) 0
のようにできるのでは。（やぼですかそうですか）

末尾再帰のスタイルとしてはsum2の方がよい気がします。
＞もともと引数は「入力、出力」の順で書いてたので。
関数型言語では、部分適用などができるから、この考え方はやめた方が。

列挙型の扱いってよくわからないんですが誰か助けてください
今Visioのオートメーションのプログラム作ってて、以下の定数と
http://msdn.microsoft.com/ja-jp/library/cc376719.aspx
以下のオブジェクトのTypeの値を比較する文が書きたいが
http://msdn.microsoft.com/ja-jp/library/cc377211.aspx
型があわないと文句言われます

今の俺の認識
deprecated1：Idiomを使う
deprecated2：Enum.combineを使う
今後：|||や&&&などのBitwise andやorを使う。最新版にコンパイラ変えたら、これつかえと警告でた

以下思いつく限り試してみたもの。全滅
if (obj.Type　= Visio.VisShapeTypes.visTypeGuide) then ...
if ((obj.Type &&& Visio.VisShapeTypes.visTypeGuide) <> 0) then ...
if (obj.Type　= (Visio.VisShapeTypes.visTypeGuide : int16)) then ...
if (obj.Type　= (Visio.VisShapeTypes.visTypeGuide :> int16)) then ...
if (obj.Type = (Visio.VisShapeTypes.visTypeGuide :?> int16)) then ...
if ((obj.Type:>int) = (Visio.VisShapeTypes.visTypeGuide :> int)) then ...
msg (Microsoft.FSharp.Compatibility.OCaml.Obj.magic (s.Type.ToString())); (*　これは数値5 *)
msg (Microsoft.FSharp.Compatibility.OCaml.Obj.magic (Visio.VisShapeTypes.visTypeGuide.ToString())); (* これは文字列が出る *)
(obj.magic ごにゃごにゃ).ToString()はエラーになります

OCamler な俺には 294 ってキモすぎてしょうがないんだが。
F# プログラムってこうなの？

パターンマッチングつかえってことかい？

いや、Obj.magic とか、キモい

名前空間深すぎて読み辛すぎるな

Ocamlerってなんて読むの？おかむらー？

MinCamler?
SML#ist?

>>299
オブジェクティブラクダ

OCaml 使いは 岡村 なのか・・・

だからOでオブジェクティブなんだよｗ

Camlはフランス語でラクダ（キャメル）の意。

オブジェクティブキャメラー。

ラクダー

>Camlはフランス語でラクダ（キャメル）の意。
大嘘こいてんじゃねーよ

C: Categorical
A: Abstract
M: Machine
L: Language

>>305
低脳ｗ

camlなんてフランス語ないよね
仮に camelのつもりだとしてもない

>>308
camlはフランス語にあるよｗ

つまらん

>>309
ない

>>311
学習用の辞書に載ってないからってｗ

CAML　＝　Cargo Aircraft Minelayer

そいうや随分前にも全角ｗで書き込む阿呆がいたな
日本もそういう季節になったの？

フォントをメイリオにしてから全角、半角の区別がつかない

それだけＭＳゴシックが不メイリオだったってことか。

これってバグかな？マニュアルでは見つからない場合Not_found例外とあるが
IndexOutOfBounds例外が出る
初心者なので判断がつかず・・

let msg s = System.Windows.Forms.MessageBox.Show s |> ignore in
try
let h = List.find ((<)100) [1..10] in
printf "%A\r\n" h
with e -> msg (e.ToString());;

F#のことは知らんOCamlの人だけど、printfでこけてんじゃないの？

んー、以下のコードでも試してみたけど、やはりIndexOutOfBounds例外でます
ライブラリよりは俺のコードがバグってると思うんで
どっかしょぼい所でミスってるんじゃないかと思うが・・
let msg s = System.Windows.Forms.MessageBox.Show s |> ignore in
try
List.find ((<)100) [1..10] |> ignore
with e -> msg (e.ToString());;

手元のF# Version 1.9.4.17だと、>>317で
Not_found(System.Collections.Generic.KeyNotFoundException)例外が出るので
コードに問題はないはず

この例外は、.NET Framework version 2.0で追加されたものなので、
Microsoft .NET Framework Version 2.0 Redistributable Package
を入れれば直るんじゃない?

検証ありがとうございます。
私の環境の問題のようですね

F#のバージョンも1.9．3.14と少し古いので
あわせてバージョンアップしてみますわ

ちょｗｗまずはバージョン確認せいやｗ

>>317
Detailed Release Notes for F# 1.9.4
ttp://blogs.msdn.com/dsyme/archive/2008/05/02/full-release-notes-for-f-1-9-4.aspx

> Not_found now maps to KeyNotFoundException not IndexOutOfRangeException.

F#はLinux上でも動きますか？
コンパイルだけでもしたいのですが。。。

>>324
zipを展開すると install-mono.sh が入っているからこれで動くんじゃないのかね。

InfoQ: F#の土台を越えて - 非同期ワークフロー
http://www.infoq.com/jp/articles/pickering-fsharp-async

ttp://blogs.msdn.com/dsyme/archive/2008/07/14/1-9-4-19-release.aspx
1.9.4.19 release

Microsoft F#, September 2008 Community Technology Preview
ttp://www.microsoft.com/downloads/details.aspx?FamilyID=61ad6924-93ad-48dc-8c67-60f7e7803d3c&DisplayLang=en

言語仕様からライブラリ構成まで、だいぶ変わったな

非同期ワークフローとか、ParallelExtention,Scopeとかがどうかぶってどう統合されるのかがよくわからん(´・ω・｀)

知ってる言葉を並べてるだけだろ

>>330
ぷっ
理解できないからって・・・ｗ

>>330
ぷっ
理解できないからって・・・ｗ

>>330
理解できないからぶってぶって・・・ｗ

>>333
は？

>>333
は？

>>333
は？

俺もぶってほしい（*´∀｀*）

Detailed Release Notes for the F# September 2008 CTP release
http://blogs.msdn.com/dsyme/archive/2008/08/29/detailed-release-notes-for-the-f-september-2008-ctp-release.aspx

Microsoft F#, September 2008 Community Technology Preview
http://www.microsoft.com/downloads/details.aspx?familyid=61ad6924-93ad-48dc-8c67-60f7e7803d3c&displaylang=en&tm
F# 1.9.6.2

ブログネタとかでもだんだん見るようになってきたけど、
OCaml派生として使ってるやつばっかりだな
OCaml知らない俺から見るとなんかぜんぜんF#っぽくないし、
そっち系は面白くならないと思うが。
.NETライブラリ使ってるやつとかあんまいないのかね

>>339
windows上の設置が簡単なocamlって扱いだからでないか？
人に渡すにしてもランタイムいらんし。

CTPになって2008しかインストール出来なくなったのはいいけど、
前からあったサンプルプログラムがコンパイルできないよ。

CTP用のサンプルはDirectX関係がコンパイル出来ないし、
スレッド周りとか勉強したいんだけどなぁ。

.netライブラリなんて他と同じように使えばいいだろ

こうですか？わかりません
をVB.NET風に書こうと思ったけどめんどくさかったのでやめた

#useってデバッグ用途とかでかなり便利だったのにな。
#loadじゃ関数とかアクセスできないし、
再起動してfsi --useも起動の時間がかかりすぎて代わりにならない。
復活してくれんかな。

.Net使ってるとWin32APIが使いたい場面が多々出てくるが
細かいところでわからんことが多い
C#⇔F#コード対応表みたいなのがほしいわ
フック書きてぇ

F#で学ぶ関数型プログラミング入門
「関数型プログラミングの主な概念とF#での利用例」

http://codezine.jp/article/detail/3041

>>345
P/Invoke宣言だけはC#で書いてしまえばいいんでない？

↓こんなのがC#側で定義出来るってこと？
[<DllImport("user32.dll",EntryPoint="SetWindowsHookEx",SetLastError=true)>] let ...

(たぶんdelegateキーワード使う)HOOKPROCの型がわからないので
実際そこでも詰まってるんだが、それがわかったとしても
SetHookの返り値をIntPtr.Zeroとどうやって比較するのかとか
わからない箇所あって、若干諦めてる

ところでF#にはいわゆるbreakやcontinueはないんですかね
for文の中でreturnするケースは手続き型の既存資産には多いと思うが
F#に移植しようと思ったら再帰等でロジックを考え直す必要があるとすると
作業コストが高い
break,last,return,continueなんかで言語仕様検索しても
それらしいのは見つからんね

自己レス。残念だけどなさそうだわ
ttp://cs.hubfs.net/forums/thread/7118.aspx

>>348
移植コストを下げることに意味はない
カエレ

アローつくれば、順次処理、条件分岐、繰り返しができるお

>>350　なぜ

逆に、何でソースコードレベルで移植しようとか思うんだ？
対象環境に言語処理系が無いとかなら分かるけど、.NETだぞ？
普通、DLL作ってFFI経由で呼び出しするだろ。

なんだか、同じ言語で書くことにこだわりすぎてる気がするけど。

>>345 そんな単純な置き換えができるのはVB⇔C#とかだけだろ
F#は関数型言語で全然違うから、考えを変える必要があるかもしれない

むしろC#とF#のコードの一対一対応表がつくれるくらい似てる言語なら、F#いらねーだろ。

そんなたいそうな理由があるわけじゃなくて、
単に楽したいと思ったんだが、気に障ったならすまない

>>355
関数型言語によるプログラミングスタイルの一種に
breakやcontinueを使わずに制御構造をくっつけていくという一派がある。
それを調べてみると面白いと思うよ。

listモナドとかmaybeモナドとか>>351の言ってるarrowとか。
ttp://d.hatena.ne.jp/r-west/20070720/1184946510

慣れるとむしろbreakやcontinueイラネになる。

もしかして、今の新しいバージョンのF#って2008製品版もってないと
入れられなくないですか・・・？('A`)

>>356
ほー、参考になる

前のバージョンなら Express でも入れられたの？
プラグインとか機能追加系は製品版じゃなきゃ基本無理。

よく調べもせず臆面なくそんなレスを…

そのための２ｃｈ

356見て、出来たらF#でarrowを表現してみたいと思ったがさっぱりだ
関数a->bを渡すとarr a bが出来て、
arr a bの型に対する操作が色々あるんだろうと思うんだが
arr a bの型に当たる物はf#ではどう表現すれば良いのか
'a 'b tみたいに複数のジェネリックな型を持つことになる？

もしかしてHaskellのほうが抽象度が高いことができる？

>>358
2008はもってないんだよね・・・うpでとするいい機会だ

>>361
higher kind genericsというやつで、F#の型システムでは再現は無理ぽ。(´･ω･`)
F#もどきで書くと、こんな感じのものが必要。

Arrow<'arr<'a, 'b>>

なるほど、非常に参考になった。
Haskellは進んでるな

>>357, >>358, >>362
Visual Studio 2008 Shell (integrated mode) Service Pack 1
http://www.microsoft.com/downloads/details.aspx?FamilyID=2e9a8c35-eb3d-43eb-9122-a5ec195cd7bb&DisplayLang=ja

>>365
Thanx。shell runtime入れりゃよかったのね

手続き型べったりの人間には　(|>)　を多用すると評価順序がわからなくなって混乱するんだぜ

>>123とか

let _ = List.iter ((|>) ()) (List.map ((delay >> flip) (printf "closure %d\n" )) [1..10])

とかけば　(unit -> unit) unit が10回ってわかるんだが…

これでいいんじゃね？
Seq.iter (fun n -> printf "closure %d\n" n) [1..10]

素人です。Expert　F#読んでてわからないことがあったので質問

type Attempt<'a> = unit -> 'a option
let runAttempt (a:Attempt<'a>) = () |> a

type AttemptBuilder() =
　 member b.Return(x) = fun () -> Some x
　 member b.Bind(p, rest) = match runAttempt p with None -> (fun () -> None) | Some x -> rest x
　 member b.Let(p, rest) = rest p

let attempt = new AttemptBuilder()
let failIfBig n = attempt { if n>1000 then return! (fun () -> None) else return n }

とあったとき、これ↓を de-sugar しろって問題なんだけど、
let sumIfBothSmall (i1, i2) =
　 attempt { let sum = ref 0
　　 let! n1 = failIfBig i1
　　 do sum := sum.Value+n1
　　 let! n2 = failIfBig i2
　　 do sum := sum.Value+n2
　　 return sum.Value }

これ↓であってるかな？
let sumIfBothSmall2 (i1, i2) =
　　 attempt.Let(ref 0, (fun sum ->
　　　 attempt.Bind(failIfBig i1, (fun n1 ->
　　　　 attempt.Bind(attempt.Return(sum := sum.Value+n1), (fun () ->
　　　　　 attempt.Bind(failIfBig i2, (fun n2 ->
　　　　　　 attempt.Bind(attempt.Return(sum := sum.Value+n2), (fun () ->
　　　　　　　 attempt.Return sum.Value))))))))))

見づらくて申し訳ない…

こうじゃない？
let sumIfBothSmall2 (i1, i2) =
　　attempt.Let(ref 0, (fun sum ->
　　　attempt.Bind(failIfBig i1, (fun n1 ->
　　　　attempt.Let(sum := sum.Value+n1, (fun () ->
　　　　　attempt.Bind(failIfBig i2, (fun n2 ->
　　　　　　attempt.Let(sum := sum.Value+n2, (fun () ->
　　　　　　　attempt.Return(sum.Value)))))))))))

ここ見る限り
http://blogs.msdn.com/dsyme/archive/2007/09/22/some-details-on-f-computation-expressions-aka-monadic-or-workflow-syntax.aspx

あーunit -> 'a option のコンテナってことか
ようやく理解できたような
ありがとう

C++のvectorみたいなコンテナってある？
Microsoft.FSharp.Collections.ResizeArrayがそうかと思ったら、
Note: an abbreviation for List<'a>て書いてあたよ

ResizeArray でいいんじゃないのん？
Microsoft.FSharp.Collections.List<'a> と System.Collections.Generic.List<'a> は別物

ttp://research.microsoft.com/fsharp/manual/FSharp.Core/Microsoft.FSharp.Collections.html

ああ、Listって名前だから勘違いしたけどインデックスアクセスはO(1)なんだな

System.Windows.Forms.dllを参照したいんですが、.NETのVersion3.5には見つかりませんでした。
フォームを表示するアプリケーションを作る場合、現状では.NET Version2のSystem.Windows.Forms.dll
を参照するしかないんでしょうか？

自己解決しました。

アセンブリ System.Windows.Forms
.NET Framework 3.5, .NET Framework 3.0, .NET Framework 2.0 のメンバ
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\System.Windows.Forms.dll

と書いてあったので、今の設定で良さそうです。

今、日本がピンチです。
http://messages.yahoo.co.jp/bbs?.mm=GN&action=5&board=552022058&tid=cf9qa4nhbfffca5ga5b&sid=552022058&mid=83344
http://sora1975.blog88.fc2.com/blog-entry-144.html
リンク先を見て危機を感じるなら、コピペを貼ってください。

Foundation of F#の92ページのサンプルってビルド失敗しないか？
IEnumerable.iterで怒られる。iterなんてねーよって。

Seqにしたら動いた。。

F#の時代がｸﾙ━━━━━━(ﾟ∀ﾟ)━━━━━━ !!

正式発表：Visual Studio 2010がF#でシップ予定 - InfoQ
http://www.infoq.com/jp/news/2008/12/FSharp-Release

WindowsではC++は消え行く運命か？

何でそう思ったのか知らんけど、当面は残るから心配する必要は無い。
まぁでも、Windows向けに開発するなら.NETにも触れといた方がいいとは思う。

>>380
機能プログラミングって･･･ｗ

F#はOCamlのコード書くために使うわ

>J#と全く同様の方法で、
ざわ…　ざわ…

>>384
let 〜 andができないのこまらね？

今後MFC使う場面ってあるの？

質問です。
ExpertF#に以下のクラス定義があります。

type Vector2D(dx: float, dy: float) =
let len = sqrt(dx * dx + dy * dy)
member v.DX = dx
member v.DY = dy
member v.Length = len
member v.Scale(k) = Vector2D(k*dx, k*dy)
member v.ShiftX(x) = Vector2D(dx=x+dx, dy=dy) (* �@ *)
member v.ShiftY(y) = Vector2D(dx=dx, dy=y+dy) (* �A *)

�@と�Aのところで引数を指定するのにdx=x+dxのようにしてい
ますが普通にx+dxではいけないのでしょうか？こちらでも
同じように動作しました。dx=x+dxの方法には他に意味が
あるのでしょうか？

名前指定してるから引数の順番入れ替えても許されるとかそういう利便性の話では

>>389
レスどうもです。
やってみました。確かにそういう利便性がありました。
ありがとうございました。

>>380
VSでは単独での使用が想定されてないとか
アプリケーションのコアを構築するためとか
どういう意味なのかね。想定場面がよくわからん
だいたいC#VBからF#の関数呼ぶのも一苦労なんだけど。
VSなしじゃ使い物にならなくなるってことかな
CLR上のLL的ポジションでいて欲しかったんだけどなあ

>>391
F# にはデザイナ ツールが含まれない。
つまり、WinForm やら ASP.NET Page やらをポトペタで開発できない。
ついでにいえば型付きデータ セットも、やるならコードごりごり書くしかない。
やるならやればいいけど。やりたい？それ？やりたくないよね？
じゃそういう部分は C#/VB.NET に任せて、他のコアな部分を F# で書くといいよ。
の意。

>>386
ふつうに書けるけど。なんか別の意味か？

let rec even n =
    if n = 0 then true else odd (n - 1)
and odd n =
    if n = 0 then false else even (n - 1)

>>392
ペタペタできないのか
じゃあ覚える意味あんまりないか

あー。
念のため言っとくと「F# にはデザイナ ツールが含まれない」てのは VS2010 での話ね。
その次の VS とか、あるいは SP とかで、いずれは提供されるようになるものと思われ。
まあ、だとしても何年後だよって話だが。

その次の VS とか、あるいは SP とかで、F#がなくなる可能性・・・

.net自体物凄い歴史浅いのに、普遍化しとるねぇ

>>393
ごめんこれ釣りなのかどうかわからなくなってきたｗ

F#って型推論のせいでVSのインテリセンスの恩恵とかほとんどなさそうだな

>>392
ごめんこれ釣りなのかどうかわからなくなってきたｗ

>>392
普通にかけないんだけどなにが普通なんだ？
let x = 2 and y = 1;;

どういう仕様なんだと思ったけどandの前に改行がいるんだな

天才ども教えてくれ

let f a b c =
match a, b, c with
| Some a, Some b, Some c -> Some (a, b, c)
| _ -> None

と定義して、以下を実行すると value restriction と言われて結果が None に
ならない。

f (Some 3) None (Some 1.5)

分かる人いる？

そもそもvalue restrictionとは何なのか。

>>401
天才じゃないが答えてみる

関数 f の型は
    val f : 'a option -> 'b option -> 'c option -> ('a * 'b * 'c) option
になるわけだけど
    f (Some 3) None (Some 1.5)
という式を評価しても 'b の型は最後まで確定しないわな
それはよろしくない（→というのが超大雑把な value restriction の説明）
つまり 'b の型を明らかにすれば error を消せる
簡単には適当な型注釈をつけてやれば OK で
    f (Some 3) (None : int) (Some 1.5)
とか、あるいは
    (f (Some 3) None (Some 1.5) : (int * int * float) option)
とかすればよい
しかし通常は文脈から 'b が具体的な型に決まることが多い
    if true then f (Some 3) None (Some 1.5) else f None (Some 1) None
だもんで型注釈に頼るような場面は少ないように思われる

>>402
なるほど。理解できた。
(None : int)は(None : int option)の誤記だと
思うけど後者でうまくいった。全体に型注釈
をつけても良いんだね。thx。

age

もうだめぽ

とりあえず、Ocamlの開発環境について教えてください。
ライブラリの管理などを含めてノウハウを教えてください。
エディタはこれを使えとか、コンパイルするときはこうしろとか、成果物を配布するときはこうしろとか、
そういう諸々のプログラミング周辺の雑務について知りたいです。

関数型が難しいとかわからんとか言ってるヤツってなんなの？
けっこう他の言語はバリバリ使いこなしてるヤツに限ってそういうこと言う
なんかコードも書いてないのにわかんね言ってるように見えるんだけど

Web でかるーく拾いあさった断片的な知識並べてわかんない言われてもねえ

ほなたとえば OOP べんきょーするときもそんなやり方でやったんかと
『やさしい Java』読んだだけで Java できますゆー人間信用すんのかと
実践皆無の人間が OOP 知ってますゆーのを見てなんとも思わんのかと

もうね、自分の知らん新しいテクノロジ排除したいだけのオッサンちゃうんかと

プログラマ名乗るんならまずやってみろよと
知りたいのなら知る努力をしてみせろよと
その上でどこがどーゆー風にわからんのか言えと

難易度はともかく関数型は実用性が低いから困るんだよ

F# イラネ C# でイイじゃんゆうヤツには
精々逃げ切れるようにがんばれよと言っておきたい

>>408
言いたいことはわからないでもない
でも F# に限っていうなら使い分ければいいんでないの？
関数型と命令型と OOP と

アルゴリズムらしいアルゴリズムを自分で考えて（選択して）実装することなく、
APIを順に呼んでエラーチェックだけするようなプログラムばっか
書いている（書かされている）人には、勉強しようというモチベーションなど
湧かんだろうなー。

やぁ、関数型言語っぽいノリになってきましたね

>>411
職業プログラマの多くがそれに該当するのではないかと想像するが
それが仕事なんだから許してやってくれ
職業プログラマの世界では、そもそも「車輪の再生産」は悪とされている
自分でコードを書かなければ工数が減るしバグをつくりこむ機会もなくなるからな

うちのところはよく使うものも全然共通化してくれないんだけど・・・

世の中の「プログラマ」と名乗る人の結構な割合は関数型言語はおろか、
自力でtreeのトラバース程度もやる必要に迫られたことも無く、
2分探査のコードを書けと言われてバグ無く書けないこと位、みんな判ってるさ。
そして、F#を勉強する俺出世確実、とか思ってるやつもきっといない。

自分でアルゴリズムを考えるのが楽しいんだよ。それはもちろん。
でも他人がもう作っちゃったプログラムを同じように作ったってしょうがないだろ。
その労力を新しいものを作る事に傾けたほうが効率的だし、
自分が作るということは作ったものに責任を取るということなんだから、
そんな余計な事まで首突っ込んで余計な責任を取ることも無いだろ。

コレクションになんか突っ込んダリするだけですめばいいが、そこに永続化とか色んなフィーチャーを盛り込もうとすれば何処かの段階で全てを自分で作った方がきれいにまとまる段階が来ると思うがどうよ。

もちろん既存のオープンソースなどを使った方がいいのもわかるが、その仕様を自分の要望に合わせる時に無理があることも多いから。

自分で作るのも追っついてるうちはいいが本当に全てを作るわけにもいかずどこまで突き詰め、どこで妥協するのか考える毎日だが。

そうなんだよなー
出来合いの API とかじゃ "想定された使い方" しかできん罠
なんかインジェクションしたいってなったらもう自分で組むっきゃないわけで

そんなときにクラスじゃ粒度がデカすぎるって場合も多いんだよね
はばからずに高階のノリでイケるってホント楽（柔軟）でいい

>>413
> 職業プログラマの世界では、そもそも「車輪の再生産」は悪とされている
むしろどんどん再生産して儲けてくださいそれが職業プログラマの本分です

再生産で儲けるのは三流
俺　一流だから　そんなこと　しない

>>420
「再生産」で儲けることのなにが三流なのか、答えてもらおうじゃないかｗ

儲けて旨い飯が食えりゃどっちでもいいじゃないか。

一流は金に困ってなんかいないから、儲けることなんか二の次に考えて新しいことを追い続けられる。

何で一流の奴がこんなとこで一流だの三流だのしょうもない議論やってんだよｗ
俺にできないような、新しい事を追い続けてくれよｗｗ

続きはマ板で

>>419は皮肉

×車輪の再生産
○車輪の再発明

糞スレ

関数を表す型を定義して、定数関数を定義しようとしたのですが
型からは関数とわかっていても、関数のようには呼び出せませんでした。

以下のようなことを実現するのは難しいのでしょうか？

type FUNC<'arg1,'result> = F of ('arg1 -> 'result);;
F ((+)1);; //使用例1
F (+);; //使用例2
//ここでエラー
let apply1 (f:FUNC<int,int>) = f 1;;

//apply1 ((+)1)、などとしたい

欲を言えば、FUNC型からarg1やresultの型を取り出すような
プログラムも書きたい・・

型と関数を混同してるような
というか、なんかいろいろ勘違いしてそうに見える

> apply1 ((+)1)、などとしたい
で、一体なにをしたいの？その式を評価して得るものはなに？
まずはその式の「型」を教えてくれないとなんともアドバイスできない

いちおーエスパーしとくとこんなんか？

let apply1 f x = f x
let f = apply1 ((+) 1)
f 2 // val it : int = 3

もしなにか Union Types を使わにゃならんような
理由があるんだったなら教えてほしい

ご回答ありがとうございます。
おっしゃるとおり、自分でもたぶん型と関数の違いがあまりわかってないと思います＾＾；

上の質問をした経緯です
最終的にやりたいことは、let recを用いずにYコンビネータを書きたい
しかし、F#では、次のような呼び出しは型情報が∞ループして決定できない
　let fact self n = if n=1 then 1 else n * ((self self) (n-1)) in fact fact 10;;
そこで、まずは、再帰的なデータ型を定義して用い、上記のような呼び出しを通るようにしたい
(再帰的に'aを'a->'bに置き換えるような型)

しかし、再帰的なデータ型とか、あまりプログラミング経験がないので
型情報を扱うプログラムからまず取り組むことにしたが、つまづいた、とう状況です

上のプログラムですが、次のようにするとコンパイルは通ります。
let apply1 f:FUNC<int,int> = f 1;;
val apply1 : (int -> FUNC<int,int>) -> FUNC<int,int>
しかし、自分が求めた型は
val apply1 : FUNC<int,int> -> int
なのですが、なぜこうなるのかはさっぱりわかってません

MLでYコンビネータを書く話なら、↓の最後にコードが載ってる
私には内容がさっぱり理解できないので、参考になるかどうかは分からんが

ttp://www.kurims.kyoto-u.ac.jp/~hassei/selfref2006.pdf

>>427 は、↓にすればコンパイルが通るぞ

let apply1 = function (F f) -> f 1;;

あっと、別にfunction使う必要はなかった

let apply1 (F f) = f 1;;

>>430,431
ありがとう。とても参考になりました。
let recは言語組み込みのYコンビネータみたいなもんらしいですね
無事できあがったYコンビネータ
type X = Psi_inv of (X -> (int -> int));;
let psi (Psi_inv f) = f;;
let Y g =
let h y = g(fun x -> (((psi y) y) x)) in
h(Psi_inv(h));;
(Y (fun f x -> if x=0 then 1 else x * f(x - 1))) 10;;
しかし、単純にF#に翻訳しただけなので
理解したとは言い難い・・

この流れなら書ける

type fix<'a, 'b> =
    Fix of (fix<'a, 'b> -> ('a -> 'b))
let y f =
    (fun (Fix g as h) x -> f (g h) x) (Fix (fun (Fix g as h) x -> f (g h) x))

y (fun f x -> if x = 1 then 1 else x * f (x-1)) 5
// val it : int = 120

[1..10] |> List.map (y (fun f x -> if x <= 2 then 1 else f (x-1) + f (x-2)))
// val it : int list = [1; 1; 2; 3; 5; 8; 13; 21; 34; 55]

同じ結論にたどり着いた
type Rec<'a,'b> = R of (Rec<'a,'b> -> ('a -> 'b));;
//version1
let y f =
let ymaker (R proc) = f(fun arg -> (proc (R proc)) arg) in
ymaker (R ymaker);;
//version1 extract
let y f =
(fun (R proc) -> f(fun arg -> (proc (R proc)) arg))
(R
(fun (R proc) -> f(fun arg -> (proc (R proc)) arg))
);;
//version 2
let R_inv (R f) = f;;
let y f =
let ymaker proc = f(fun arg -> (((R_inv proc) proc) arg)) in
ymaker (R ymaker);;
//version 2 extract
let y f =
(fun proc -> f(fun arg -> (((R_inv proc) proc) arg)))
(R
(fun proc -> f(fun arg -> (((R_inv proc) proc) arg)))
);;

Programming F#: Rough Cuts Version

By Chris Smith
Rough Cuts Release: February 2009
Print Book Release: October 2009
Pages: 504

俺、この本が出たらF#はじめるんだ・・・

のーみそが関数型に染まってくると
「左辺値」「右辺値」という言葉に
妙な違和感を覚えだす

そもそもそんな観念がないというか
あえて言うなら左辺に値などない

てなことを妄想してみたけどどうよ？

>>437
概念じゃねーの？

>>434-435
lazyに考えれば、もっとシンプルに書けるんじゃね(´･ω･`)？

let rec fix (f : Lazy<_>) = f.Force() (lazy fix f)

let fact = fix <| lazy fun f x -> if x = 0 then 1 else x * f.Force() (x - 1)

do fact 5 |> printfn "%d"

>>437
「let x = 1」
これは等式とは思わない方が自然じゃないだろうか。
もともとは数学の論文とかでよく出てくる
「Let x := 1.(xを1と置く。)」とかいう表記を構文にしただけなんじゃないかと想像する。
等式じゃないなら、左辺、右辺とかいう観念はない。

おまえら頭いい　サイコーだ

>>439
>>429 をよく見ろ
> 最終的にやりたいことは、let recを用いずにYコンビネータを書きたい

ついでに、let rec 使用可なら lazy を使う必要すらない

let rec fix f x = f (fix f) x
let fact = fix <| fun f x -> if x = 0 then 1 else x * f (x - 1)

>>443
> let rec fix f x = f (fix f) x

あー、そっか。x つければ落ちないんだ。(´･ω･`)

let rec fix f = f (fix f)

と書いて、StackOverflowになってたのでlazyにしてた。

x はラムダ的に冗長に見えるけど、型推論の重要な手がかりになってるということか。

> let rec fix f = f (fix f);;

val fix : ('a -> 'a) -> 'a

> let rec fix f x = f (fix f) x;;

val fix : (('a -> 'b) -> 'a -> 'b) -> 'a -> 'b

そのあたりのことってProgramming in OCamlに書いてある
正格評価がどうのこうので。
試してないが、確かこれでもいけたはず
let rec y f = f (fun x -> y f x);;
fun arg -> (proc (R proc)) argの箇所を
(proc (R proc))としないのも同じ理由だと思う

とりあえずfunで包めばOK,みたいな

結局、再帰型を使うようにしたら、結論はほとんど同じだった。(´･ω･`)

type Fix<'a, 'b> = Fix of (Fix<'a, 'b> -> 'a -> 'b)

let run_fix (Fix f) = f

let ycomb f =
　let g proc = f (fun arg -> run_fix proc proc arg) in
　g (Fix g)

let fact = ycomb <| fun f n -> if n = 0 then 1 else n * f (n - 1)

>>438
正直、「観念」と「概念」の違いがわからんで調べてきた
どちらも「モノコトに対する意識・考え」だが…

* 観念
英語でいう idea の意味に近い
オレオレ解釈的（主観的）
故に観念は多様である

* 概念
英語でいう concept の意味に近い
ふつうはみんなそう解釈するよねー的（客観的）
故に概念は一様である

という違いがあるようだ。

左辺値、右辺値という考え方は、一般に共通の理解を得ている
もの（通念）であり、それらは「概念」と呼ぶのが相応しい
ということかな？

>>448
まあニュアンスが伝わればいいんじゃね？

>>445
冗長なんじゃなくて、正格評価の世界では意味が全く別のものになる。

let rec fix = fun f -> f (fix f)

let rec fix = fun f -> fun x -> f (fix f) x

後者では x が遅延の役割をしてくれる。

Haskellのような遅延評価の世界では、確かに冗長なだけ。

f そのものを遅延化してしまう(>>439)のと、
引数 x を追加して遅延の役割をしてもらう(>>443)のと、

どちらがコードの見た目的にやさしいかは明らか。ｗ

f (fix f) と fun x -> f (fix f) x って同義じゃないの？

んー、マジで分からん

let rec fix f = f (fix f) だと、f が渡された途端、

f (fix f)
↓
f (f (fix f))
↓
f (f (f (fix f)))
↓
f (f (f (f (fix f))))
↓
f (f (f (f (f (fix f)))))
↓
あぼーん

関数を返そうとはするが、fix を展開しようとして無限ループ。

let rec fix f = fun x -> f (fix f) x だと、f が渡されても、

fun x -> f (fix f) x

x が渡されるまで fix は展開されない。

ちょっと言葉足らずなので修正。

× 関数を返そうとはするが、fix を展開しようとして無限ループ。
○ 関数を返そうとはするが、先に fix を展開してしまい無限ループ。

× x が渡されるまで fix は展開されない。
○ 先に関数を返し、x が渡されるまで fix は展開されない。

関数は first-class object ではあっても
関数 = 値 ではない、と

――ここで正格評価において

let rec fix f = f (fix f) なる定義で fix g を評価しようとしたら？
必死こいて値を算出しようとしてしまうんだな
で、その結果、>>453 が示すように無限ループに陥る

let rec fix f x = f (fix f) x なる定義で fix g  を評価しようとしたら？
これは部分適用だから関数オブジェクトの生成を行うのだな
で、後々、(fix g) y とされたときに値の算出が始まる

高尚な議論の最中で流れぶった切ってゴメン

入れ子になった型宣言（ネストされた type）って無理？

type a () =
  type b = {x : int; y : int;}
  ...

とかすると、２つ目の type で
Unexpected keyword 'type' in type definition
と怒られる

>>456
できなさげ

確かに C# ではインナー クラスできるけど
Java と違ってそんなに多用されるもんでもないような

てか例示のコードならタプルでいいんじゃ？

ありがと、やっぱ出来なさそうですね。

まぁ、確かにタプルでも機能するんですが、
各要素へのアクセスが面倒なんで
レコードの方が扱いやすいなぁと。

.NET 言語なんで C# 基準で考えてしまいがちだが
F# は OCaml ベースなんだぜ？
internal すらぬるい、どうしても外部から隠蔽したいというなら
シグネチャ（.fsi）ファイルを書けばいいじゃないか

と、眠たいので調べもせずにいってみるテスト

>>259
公開するものだけをシグネチャ ファイルにしたら上手くいった。
なるほど、fsi はこうやって使うのか。
改めて読み直してみたら本には書かれていたけど、
いままで自分には無関係だと思って無視してた。
もうちょっと調べてみる。

じつは OCaml は見たことも触ったこともないんだけど、
やっぱ一通り触れてみた方がいいのかな・・・

>>259
言い忘れてた
ありがと

seq<int> 型に拡張メソッドを加えたいです。

パラメータを int 型に制約しなければ例えば次のように出来ました。
type System.Collections.Generic.IEnumerable with
  member this.H = Seq.hd this

これを seq<int> 型の時のみ拡張することは出来ないのでしょうか。

これってVisual Studioから使えるの？

つかえるよ。
男は度胸。ものは試し。
まずはインストールしてミソ。

2008のProでしか駄目でした的な感じなのだが・・・orz
2008 Pro安く売ってないのかね

エディション比較ちゃんと見れと
http://www.microsoft.com/japan/msdn/vstudio/products/vs08/compare.aspx

相変わらず Visual Studio 2008 Shell は知られてないなと
http://msdn.microsoft.com/ja-jp/vsx2008/products/bb933751.aspx

アドインなんだから devenv.exe のあるなしで判断できるだろうと

使ってる人もっとなんか書いてくれ
Scala がどうとか言ってる同僚を黙らせたい


…俺？ 日本語の本が出てからやるわｗ

F# のことを勉強しようかと思ったが、至るところ null があるって聞いた時点で、萎えた。

何を言ってるんだ?おまえは?

>>467
どうとか言ってる内容にもよるわけだが、黙らせる方法ってのは。
関数型サイコーとでも言っているのかい？その同僚は。

nullがあるって変な表現だよね。

>>466
kwsk

2008 StdあればF#の拡張機能は組み込めるってこと？
あと、VS2008 の Shell 版なら本体買う必要なすってことなのかな？

ごめん、検索したら一杯情報出てきた。
大体あってた。

いげ太のブログ: Microsoft Visual Studio 2008 Shell (integrated mode) で F# 無償開発環境
http://igeta.cocolog-nifty.com/blog/2008/04/vsshell.html

> Microsoft Visual Studio 2008 Shell (integrated mode) を導入すれば、
> 無償の F# 開発環境が手に入る。噛み砕いて言えば、C# も VB.NET も C++/CLI も、
> 何の言語もバンドルされていない Visual Studio 2008 が、タダで手に入るってことだ。

> そして、VSShell がインストールされた状態で、F# をインストールすればよい。
> そうすれば VSShell に F# が組み込まれるのだ。

Visual Studio で F#の開発を行う - ピコピコの日記
http://d.hatena.ne.jp/net-k/20080911/1221099444

> F#はVisual Studio 2008 もしくは、Visual Studio 2008 Shellから利用することができる。
> Visual Studio 2008 を持っていないので、無償で公開されているVisual Studio 2008 Shellをダウンロードした。
> ちなみに、Visual Studio 2008 Shell とは、C++やC#などの開発環境が何も入っていない状態のVisual Studio 2008で、
> Visual Studio向けの開発環境をSDKを使って組み込むことができる。


Visual Studio Shellダウンロードしてくるわ。
ありがとう。

>>468　はこれか。
http://d.hatena.ne.jp/camlspotter/

いろいろ挑発的なことが書いてあるな

下がりすぎだろ

FParsecの話なんかやってくれないかなあ

こやつめｗ

Lang.NET開催中でつよ。(´･ω･`)

ttp://www.langnetsymposium.com/2009/speakers.aspx

CCIがいつの間にかCodePlexに逝ってたんだ。知らんかった。(´･ω･`)

Common Compiler Infrastructure - Metadata
ttp://ccimetadata.codeplex.com/

Common Compiler Infrastructure: Code and ASTcomponents
ttp://cciast.codeplex.com/

Common Compiler Infrastructure: Sample applications
ttp://ccisamples.codeplex.com/

Reactive Framework解禁でつね。(´･ω･`)

Democratizing The Cloud Using the LiveLabs Reactive Framework
ttp://en.oreilly.com/oscon2009/public/schedule/detail/9093

>479
なにこれ？
やさしい人（かしこい人）おしえてくれろ。

>>481
MS Researchで昔から使われてる、.NETでのコンパイラ実装のための共通基盤です。
少なくとも2002年には存在してます。
ttp://www.inf.ethz.ch/personal/zueff/Presentations/dotNET%20ONE%202002.pdf

今ごろソース公開をはじめたということは、「Compiler as a Service」に向けての一歩ということじゃろか(´･ω･`)？

んで、ccisamplesを見てのとおり、Small BasicがCCI上で書かれてるみたいね。

へー。面白いね。
jay for C#とかと違って共通的なライブラリにするってわけだよね？

FxCopのカスタムルール書いてアセンブリを分析してた人には、部分的にお馴染みかも。
http://japan.internet.com/developer/20061025/26.html

にわかに盛り上がってると思ったら、F#の話題じゃなく、ドトネト全般の話題だったか。

M言語の話題はどうよ？ > Lang.NET 2009

ビデオがもううｐされてますがな。(´･ω･`)
ttp://www.langnetsymposium.com/2009/talks.aspx

EnumerableとObservableが双対になるということは、Reactive LINQは
comonadicなアプローチになるということじゃろか(´･ω･`)？

comonadとFRPの関係に言及してる人なんて、世界で数えるほどしか見つかりませんが･･･。

SelectとWhereまではなんとなく動いた。


interface IObservable<T> {

　　IDisposable Regsiter(IObserver<T> o);
}

interface IObserver<T> {

　　void OnUpdate(T value);
}


class Observable<T> : IObservable<T> {

　　IList<IObserver<T>> observers = new List<IObserver<T>>();

　　public IDisposable Regsiter(IObserver<T> o) {
　　　　observers.Add(o);
　　　　return new Disposer(() => { observers.Remove(o); });
　　}

　　public void FireUpdate(T value) {
　　　　foreach (var o in observers) {
　　　　　　o.OnUpdate(value);
　　　　}
　　}
}

class Disposer : IDisposable {

　　Action dispose;

　　public Disposer(Action dispose) {
　　　　this.dispose = dispose;
　　}

　　public void Dispose() {
　　　　dispose();
　　}
}

class Observer<T> : IObserver<T> {

　　Action<T> update;

　　public Observer(Action<T> update) {
　　　　this.update = update;
　　}

　　public void OnUpdate(T value) {
　　　　update(value);
　　}
}

static class Linq {

　　public static IObservable<U> Select<T, U>(this IObservable<T> obs, Func<T, U> func) {
　　　　var ret = new Observable<U>();
　　　　obs.Regsiter(new Observer<T>(t => { ret.FireUpdate(func(t)); }));
　　　　return ret;
　　}

　　public static IObservable<T> Where<T>(this IObservable<T> obs, Func<T, bool> pred) {
　　　　var ret = new Observable<T>();
　　　　obs.Regsiter(new Observer<T>(t => { if (pred(t)) ret.FireUpdate(t); }));
　　　　return ret;
　　}
}


class ObservableCollection<T> : Observable<T> {

　　IList<T> list = new List<T>();

　　public void Add(T value) {
　　　　list.Add(value);
　　　　FireUpdate(value);
　　}
}

static class Test {

　　static void Main() {
　　　　var list = new ObservableCollection<int>();
　　　　//list.Regsiter(new Observer<int>(n => { Console.WriteLine(n); }));

　　　　var obs =
　　　　　　from n in list
　　　　　　where n > 2
　　　　　　select n + " が追加されますた";

　　　　using (obs.Regsiter(new Observer<string>(s => { Console.WriteLine(s); }))) {
　　　　　　list.Add(1);
　　　　　　list.Add(2);
　　　　　　list.Add(3);
　　　　　　list.Add(4);
　　　　　　list.Add(5);
　　　　}
　　　　list.Add(6);
　　　　list.Add(7);
　　　　list.Add(8);

　　　　Console.ReadLine();
　　}
}

// 実行結果
3 が追加されますた
4 が追加されますた
5 が追加されますた

??
上のコードは何となくC#に見えるのですが･･･
まあ、F#まだ良く知らない私が言っても説得力無いですね＾＾；

ええと、質問です。
F#がVS2010に正式採用されるそうですが、そうなったらF#入門書がそれなりに出ると思いますでしょうか?
さらには関数型言語のシェア(?)が今よりもっと広がると思いますでしょうか?
（つまり、他の関数型言語の入門書も増えますか?w)←実はこっちが私の願望

あ、他の関数型言語の開発も活発化するというのも私の願望にあったりします＾＾；

おれにもF#には見えないな

>> 490
別擦れたてろ。

別ｽﾚ立てるまでもないだろ。
http://pc12.2ch.net/test/read.cgi/tech/1202568694/

>>494
私も期待してます。
「F# for Scientists」の様な面白い本が
日本でも生まれるといいな。

> 「F# for Scientists」の様な面白い本
どんな内容なの？

>>500
「Expert F#」と重なる部分も一部あるけど、
ライブラリの使い方や .NET 系としての使い方というよりも
関数型言語としての使い方の解説が多い。
たとえば、memorize を関数型で実現するテクニックはなるほどと思った。

最適化についても、高位のアルゴリズム的なものや、
もっと低位の最適化も一章まるまる割いて解説されてる。
（といっても、わずか24ページだけど）

Managed DirectX (Direct3D) の扱い方も載ってた。
しかも、クラスを作ってメソッドを作ってという
C# などの一般的な作りじゃなくて、
高階関数を連ねていく関数型言語っぽい作り。
シーングラフはバリアント型によるツリー構造のいい実例になってる。

ただ、CTP がリリースされる前に執筆した本なので、
今は推奨されていない古い書き方が一部ちらほらある。
（コンパイラが指摘してくれるから、簡単に直せるが）
同じ理由で Units of Measure などの新機能も扱っていない。

また、CTP 以前の文法も全てを網羅しているわけではなく、
例えばアクティブ パターンなどは扱っていない。

それでも、「Foundations of F#」の後に読むには
なかなかいい本になってる。

すいません、名前の 10 は無関係です。

前に同じ板の 「課題」 にレスしてたので・・・

せっかく>>10を参照したついでに、おまいら的にL#とかってアリなの？
http://www.lsharp.org/

またLispもどきかよ、くらいの印象しかない

Lisp の構文で .NET ライブラリが扱える
という以上の何ができるのか、紹介されたページからは分からん。

> 501
詳細どうもです。DirectX にまで触れてるんですね。
2 冊目以降に読む本、みたいなイメージでしょうか。

国内では入門本すらまだの段階ですし
コイツと同じような内容のものとなると
…さていつ出るやらですなあ。

lsharpでマクロとか使えるなら考えてみてもいい

F# の標準ライブラリにある printf 系の関数みたいに
可変長引数のまねごとをしてみたいんだけど、
どういう仕組みになってるのかよく分からないです。

単純に次のようにはできないですよね。
let f n =
  if n = 0 then (fun () -> ())
  else (fun a -> printfn "%d" a)

F# のソースから printf => fprintf => ... => gprintf
と追ってみたけどよく分からないです。

単純な１引数と２引数を選択出来るようなサンプルを
誰か作ってくれませんか。

> formats.mli
>
> /// Parse "printf-style" format specifiers at compile time, producing
> /// a list of items that specify the types of the things that follow.

ParseFormatString で grep するとしあわせになれるかも。

>>509
ありがと。

grep してみたが、まだ幸せにはなれない。
ちょっと解析してみます。

海外では徐々に F# 関連の本が出始めてますね。
これなんか面白そうです。

Real World Functional Programming: With Examples in F# and C#
http://www.amazon.co.jp/dp/1933988924/

著者のブログ
http://tomasp.net/blog/functional-programming-book.aspx

７月発売なんで、まだまだ先だけど

>>511
早読みバージョン読んでるけど、関数型初めての自分には色々関数型での開発の利点とかを細かく説明してくれてるのでよいわぁ

こっちの本はリファレンス的に利用できそう

The Definitive Guide to F#
http://www.apress.com/book/view/9781430224310

501 ですが、すいません、
アクティブパターンは扱ってました。

ただし、他のトピックほど詳しくはないです。
半ページほどの紹介と、XML の解析を例にした
１ページ強ほどの実例だけです。

私自身、未だに使い方がよく分かりません。

他に、こんな事に役立つよとかいう例はないですかね。
「いげ太のブログ」をみても、使い所が想像できなくて。
http://igeta.cocolog-nifty.com/blog/2008/04/actpattern2.html#more

あれ？
let multiply n1 n2=n1*n2
printf ("%f")( multiply 1.0 2.0)
printf ("%d")( multiply 3 4)
でなんで3行目にfloat is not compatible...とかいわれるの？

>>515
ヒント：

２、３行目をコメントアウトして１行目の multiply 関数の型をみてみる
次に３行目だけをコメントアウトして multiply 関数の型をみてみる
最後に全てのコメントを外し、２行目と３行目を入れ替えて multiply 関数の型をみてみる

>>516
2，3行目を逆にすると後の行がエラーになるのはわかります。
F#の型推論の場合、2行目で型が決定されてしまった時点でほかのものはそれに従わないといけないと言うこと?
これがC#のgenericsだったら（まぁそもそも＊とかで書けませんが)2行目も3行目も各々の型に展開されてコンパイルされると思うんですが。
あぁかいてておもったがa'とかつかえばよいということ？

ジェネリックと同じ問題があって演算子があると ’a のままで使えない。
もともとのOCamｌでは演算子も別だしね。 *. とか。

いっそ演算子を外出しにするとか
let compute f n1 n2 = f n1 n2
printfn "%f" (compute ( * ) 1.0 2.0)
printfn "%d" (compute ( * ) 3 4)
;;

inlineをつけるとエラーにならない。

let inline multiply n1 n2=n1*n2
printfn ("%f")( multiply 1.0 2.0)
printfn ("%d")( multiply 3 4)
;;


（実行結果）
val inline multiply :
^a -> ^b -> ^c when ( ^a or ^b) : (static member ( * ) : ^a * ^b -> ^c)


2.000000

12

なる。
演算子の問題あるから、例に書いたのはそのまま通らないとして、
inlineをつけないと最初の奴を書いた時点でそのコンパイルスコープ?でコンパイルされる時の型が一意に決まってしまうため後の行のものはエラーになる。
inline付ければ各々に対して展開されるため大丈夫。
a'とかつかえば、どの型でも通るようになる。
ということでおけー？

これはキモい。

わからんならかかんでヨロし

>>520面白いな
static head-type type variableっていうのか　^ω^

おもしれー、これってF#固有？OCamlにもあるの？

ocamkでの通ったな

F#のリソース管理ってどうしてますか？

>>525 G'Camlだったらこんなことが出来るっぽいね
let plus = generic (+) | (+.)
F#版もstaticなメンバ関数が定義されていなければならないのは同じだから
これと同じ機能っぽい気がする

自己解決しました
useがusingと似たような機能を持っているようです

今月ベータ１が公開される予定だってさ。

http://fsharpnews.blogspot.com/
[Monday, 4 May 2009] Re: Microsoft canning F#

The next release, beta 1, is due out this month
and a beta 2 is scheduled for release before the full 2010 release next year.

むーん。今作ってるシステムの一部F#で実装しようと思ってたんだがどうすべかな･･･

>>531
OOPを駆使しなければなんとかなるんじゃね
クラスまわりは構文かわりそう…

>>531
まあ、一部ならいいんじゃね？
言語混在できるのが.NET Frameworkの強みだし。

>532
構文の変更とかはいいんだけど、作り込んでったあとにあるときだけ挙動がおかしいとかわけわからんバグが出るのが怖いです･･･
>533
ごもっともだす。どうせC#と混在になるのは目に見えてるからなぁ

ベータ１が今月内に出るんなら、
何が修正されたのか、機能はどうか、
情報が出てきても良い頃なんだが・・・
まだどこにも無いな

VS2010ベータのF#は.NET4.0しか対応してないみたいだ

PowerPack もなしですなー

May 2009 CTPだと.NET2.0やMonoもOKみたい

むぅ
fold_left -> fold
fold_right -> foldBack
ここに来てスタイル変えるか…

OCamlの小文字アンダースコア区切りはすっきりして好きだったんだがなぁ

だよなあ
まあ アンダースコア区切り→キャメル はわからんでもない
しかし right を back はないわー

fold_right を foldBack と呼ぶような言語は聞いたことないんだが
どこ由来なのかねえ？

変えるなら.NETと同じパスカルケースがよかったな…

>>539
マジ？そりゃないわ。
畳み込みって、右からとか左からっていうのが一般的な用語
だと思う。

+のオーバーロードとパイプ演算子|>のさわやかな風を残しつつF#終了
あれ多相ヴァリアントは？

さてOCamlに戻るか

fold イイ！ foldBack ダメ！ みたいに覚えてもらいたいんだろうけど、、、

できれば「.NET Frameworkが使えるOCaml」として作ってほしいなぁ
そういうリクエストしてみるかな
どうせβ2まであと1年あるし

VisualOcaml作ってくれればいいよ

>>545
実はあるんだが.NET1.1向け
Haskellもそうだな

.NET1.1の時に.NET向け関数型言語コンパイラが多数存在したのは
C#やF#に取り込むために関数型言語の実装を研究した残骸なのかもな


OCamlはライブラリ不足な上にLinux以外のOSで動かないライブラリもいくつかあるし(win以外も含め)
不満は色々あるが今更OCamlには戻れん…

>>541
キャメル→関数
パスカル→メソッド
てことではないかと

>>540
いいじゃん。
そもそも左から右が正で右から左が逆っていう考え方はヨーロッパ的で日本とは逆なんだから、
右とか左とかいうのが消えたのは喜ばしい。データには右左関係ないからな。

データには正逆関係もないと思う。
古くからある抽象概念の名前を、突然、別の抽象的な言葉に置き換えるのなら、
もっと強い根拠がほしいと思う。もしあったら教えてください。

F#初心者だが、配列だろうがリストだろうがとりあえずデータの前後はあるんでは?
初心者からするとそれほど違和感ない。

OCamlとF#ってどのぐらい違うのよ。
.NET対応になってるのは別としてOCamlにあったナイスな機能がF#ではなくなってるとかあったら教えてたもれ

>>552
OCamlのみ
　多相ヴァリアント、ファンクタ、注釈ありで型がつく箇所では省略しても必ず型推論できる性質
　Camlp4/5、ビルド関係のツール(F#はしょぼい)

オブジェクト指向部分は根本的に違う(nominal/structural)

・・・
そのへんがあるとどんなにナイスか3行で頼む･･･

>>549
「fold_left or fold_right」より「fold or foldBack」の方が、
なんとなーく、ふつうは fold 使えよ的雰囲気をかもせるような
気はするんだよね

array はいざしらず、seq や list では処理効率が違ってくるから、
それをやんわりと臭わせるのは好ましいことなんだとは思う

まあやっぱりただ、他言語では left か right かで統一されているものを
わざわざ無視してまで改良すべきものなのかなー？という感は拭えない
>>550 も言うように、伝統を変えるにはもっと強い根拠がほしいなあ

「これだから MS は！」なんて、関数型畑の人たちになじられやしないかという

いっそのことaggregateとaggregateBackにすればまだよかったのに
長ったらしいが

>>380

どうせ次にはJ#のポジションになってるんでしょw

J# は言語やIDEの良し悪しの問題じゃなくて、
SUNともめたせいだからなぁ。

その点、F# はMSリサーチ製なんで大丈夫。

Cωとかあったねー

Cωの機能は C# に引き継がれてるから問題ない

F# と J# を比較するのってアホ丸出しだぜ？

>>561
自分で自分の事をアホ呼ばわりしてるようにしか見えんのだが

　　　　　　　　　　　　　 ∧∧
　　　　　　　　　　　　 ／ 共＼
　　　　　∧∧　　　　（　 ｀ハ´）　　　∧∧
　　　　／留学＼　　（ ~__))__~）　 ／留学＼　ｶﾀｶﾀ
　　　　 （｀ハ´　）　ｶﾀｶﾀ　　　|　　.（｀ハ´　）
　　 ＿|￣￣||＿）　　|　　　　.j.＿|￣￣||＿）
　／旦|――||/／ ／|　　　..／旦|――||/／ ／|
　|￣￣￣￣￣￣|　｜　　　|￣￣￣￣￣￣|　｜

中国の検閲システム金盾は2ch.netへのアクセスを遮断している
http://www.greatfirewallofchina.org/test/index.php?id=18911
にもかかわらず…

２ちゃんねるのアクセス状況（08年3月時点)
http://alexa.com/data/details/traffic_details/2ch.net
1. 日本 874/1000
2. 中国 　57/1000　　＜＜ネット規制のある国でアメリカの５倍以上？
3. 米国 　10/1000
24. 韓国 　1/1000
中国から金盾を介さないで2chにアクセスしている輩は何者か？

なんでJ#の話題になってんの？全然違うだろ。

理由を書かず他人を罵倒する奴は大抵自分も判ってない。

そりゃ疑問文だしなｗ

まあなんだ、F#について語ろうよ

Custom Numeric Literalがどうしてもできんのだが
アレどうやったら定義できるの？わかる人いる？

Custom Numeric Types ですね（Custom Numeric Literal とも言うのかな）。

私も NumericLiteralI が定義されたソースコード
（C:\Program Files\FSharp-1.9.6.16\source\fsharp\FSharp.Core\math\z.fs）
を見て試してみましたが、上手くいきませんでした。

とりあえずモジュールの記述をそのまま自分の *.fs にコピーしてきたのですが、
（BigInt とかの型問題はもちろん解決させた上で）
そのリテラルを使うと "This is not a valid numeric literal." と怒られますね。

1.9.6.16だと
#loadした先のファイルに#loadや#rがあったらエラーになる
#if INTERACTIVE,#endfしてもダメ。

1.9.6.2は平気
なんでー

一応エラー文面はっとく
hoge.fs(4,1): error FS0076: This directive may only be used in F# script file
s (extensions .fsx or .fsscript). Either remove the directive, move this code to
a script file or delimit the directive with '#if INTERACTIVE'/'#endif'.

追記
hoge.fsがhoge.fsx
ロード先ファイルが.fsx/.fs

等の組み合わせもいろいろためしたけど同じエラーが出る

>>567 >>568

> only the suffixes in the set "INZQRG" are supported
http://cs.hubfs.net/forums/thread/10939.aspx

もうね、そうならそうと Release Note に書いといてくれと

>>571
おぉ、できた。

苦労してできた後で思ったんだが、
これって何に使うんだろ・・・
いまいち分からん

正式リリース後の入門書にはたいてい紹介されるであろう
Custom Numeric Types による有理数表現を一部実装してみたが、
面倒な割には余り恩恵が得られなさそうだ。

>> 573
まあ関数なりで代用は利くけどね
無駄なカッコが省けるし、コード読みやすくなって割とイイと思う
面倒っちゃ面倒だけど取り立てて言うほどのものでもなくないかい？

面倒というのを取り立てて言うほどのものでもないけど、
そもそも Custom Numeric Types 自体が取り立てて言うほどのものでもないような

そういう細やかな機能のアレコレの積み重ねこそ
F# を F# たらしめている、と思うんだけれども

言語機能としてあるのにユーザ定義はできない
みたいなことがないように言語が設計されている
てのはよろこぶべきことなんじゃないかと

>>576
そうですよね、すいません、別に悪く言うつもりは無かったんです。
他にどういうシチュエーションで使うと便利なんだろなぁという程度の気持ちでした。
（printfn なんかで使われてる可変数引数も
簡単にユーザー定義できるようになるといいなぁ・・・）

それはそうと、VS でのプロジェクト作成時に
オプション設定を無視して勝手に保存されるのは、
正式リリースではちゃんと直してくれるんだろうか。

保守

以下のコードでF#からWPF呼んでみてるんだけど、
裏でコマンドプロンプトが立ち上がるのがうっとうしくてしょうがないんだ
どうしたら消せるのん？

let CreateWindow : string -> Window =
　　fun path ->
　　　　use reader = XmlReader.Create(path)
　　　　XamlReader.Load(reader) :?> Window

// Main
[<STAThread>]
do

　　let w = CreateWindow "Window1.xaml"

　　let app = new Application()

　　app.Run(w) |> ignore

プロジェクトのプロパティで、
Application -> Output type を
Windows Application に変えれば消えるんじゃない?

サクッと消えました。ありがとう！

F#の使いどころって並列処理なのは理解できるんだが、
効果的に使える分野がわからない。
大量データで大量に処理する用途って動画とかそっち方面？

普通のプログラムもF#で書けばよくね？
一度慣れるとC#とか万度くさくて。

ピンポイントで使おうみたいな意見をよくみるが
それはアプリの当該機能部分のみにF#使おうとしてるのか
そういう機能を持ったアプリ全体をF#で書こうとしてるのか。

どっちなんだろか。

>>582
別に高速計算のためだけに並列処理があるわけじゃないぞ。
GUIのインターフェース部分とメイン処理部分のスレッドを分けて、GUIの反応が悪くならないようにしたり、
ネットワークプログラムならそれぞれのセッション毎にスレッドを分けたり、
オブジェクトみたいな乗りで複数のプロセス同士をメッセージ通信でやりとりしたり（アクターモデル？プロセス代数？パイカルキュラス？）、
並列/並行プログラミングはプログラミングパラダイムだと考えた方がいい。

オブジェクト指向に取って代わって関数型言語による並行プログラミングが台頭してくる可能性がある

つうか関数型言語はなんでいちいち対話型インターフェースがついてくるんだ
あんなんいらないと思うんだけど

>>587
便利じゃん。
いちいちコンパイルしてテストなんてやらずに、対話的にいろいろ式を変化させて試せる。
軽量プログラミング言語とはそういうもんだ。

インタープリタでも動作し、コンパイルも可能というのは良い路線だと思う。
MSは次期オフィスにVBAの代わりにF#でも載せればいのに。。
VBAはあまりにも古臭い。

実はExcelとは親和性が高いかもね。
逆に手続き型のほうが相補的で良いのかも知れないが。

http://codezine.jp/article/detail/4254
金融か。やっぱブラック＝ショールズ公式適用できない問題に使われるのか。
金融に使われるためには、幾何ブラウン運動のシミュレーションできる
ライブラリがないと難しいかも。

現在、F#を使う理由が見当たらないのだが、
C#を使わずにF#を使う利点ってどんなものがある？
関数型言語は慣れると工数を削れると言われているけど、
現状のF#ではC#よりも手軽に・・・とはいかないよね？
VS2010でGUIにて開発ができるようになると変わるのかな・・・

>>592
一般的なプログラミング言語よりも数式の方を見慣れてる人向けだろうなぁ。

関数型（変数はimmutableで、関数のチェインでプログラム作る）ってのは
確かに並列処理には向いてるんだけども・・・

今、「関数型」って言われてるような言語はちょっと既存の流行りのプログラミング言語と
パラダイムが違いすぎて、そのままだと流行りようがないと思う。
なんか、C#っぽい文法、C#に近い文法で書いてるつもりが、
いつの間にかimmutableな変数使わされてて、
いつの間にか関数型なコード書いてるっていうような、
開発者に関数型を意識させない関数型言語みたいなのができないことにはなぁ。

>>593
確かに関数型言語は理数系向きといわれてるね。

変数がimmutableということは、一つの関数は小さく作らざるを得ないだろうし、
となると、再利用の効率も上がるだろうし、
少しでも文法に慣れると可読性も高くなるだろうから、
将来的にはそれが利点になるのかな…。

しかし、これもVB6→VB.NET or C#のときも、
オブジェクト指向ということばと共に、同じことを言ってたような気がするな…。

まあ、とりあえず暫くはぬるーく付き合いを続けてみます。

>>594
C#だって、C++系統の文法（見た目だけでも）かなり借用して、
そっちからの移行をかなり強く意識したわけで。
今となっては失敗だったと思う文法もあるけど、当時としてはやむなかったと思うし。
0, 1 で変わるようなパラダイム変化は大衆向けにはできない。

どっかのタイミングで、C#の成果とF#の成果が自然と融合して次の世代が生まれるかもしれないし、
F#に触れること自体は損にはならないと思うけど。

俺的にはF#(・∀・)ｲｲ!!とおもってたんだが
本場のオカムラ-によると型推論がなってないとか多態バリアントねーじゃんとかだめ出しされてる･･･(´；ω；｀)ｳｯ…

そういや、VF#ってOCamlの構文もサポートされるのはなんでだろう。
VF#インスコすると.mlファイルもなんかアイコンが変えられるし
OCamlの開発環境として使えるんだろうか。
OCamlの遺産を使いまわすつって需要があると思えんし。

Standard ML昔いじってから10年以上ブランクあるが、
ひさしぶりに関数型言語触ってみるかな。

金融関係の人に興味持ってもらえるもの作りたい。
http://derivative.fixstars.com/hpc.html
これ読む限りだと、確率過程（いわゆる確率微分方程式の領域）を
めちゃくちゃいっぱい高速で作り出せれば興味もってもらえそう。
F#って乱数計算速い？もしくは、並列計算で速くできるもの？
乱数関係さっぱりわからんのよ。

訂正：乱数関係”も”

関数型は特定用途を除き流行らない感じがする。

んーずっとC#ばっかやってたけどF#は.NETつかえつつオブジェクト指向と関数型織り交ぜられて簡潔に書けるのでかなり使えそうな予感。

>>601
「特定用途」が何か一言も書けないような人は触ったことないだろうし
今後も使わないだろうから、無理して来なくていいよ。

でほるとが定数って頭おかしいだろ

定数？

定数じゃないよ、制約された値なんだよ

実際、C# とかで書いててもそんなに変数を mutable に使ってなかったりはするんだけど。
mutable に使うのはメンバー変数かループで反復に使うものくらい。
それ以外のローカル変数は immutable でもまず困らない。

まあでも、デフォルトが immutable なのはやっぱちょっと使いづらい。

デフォルトimmutableなほうが気にすることが減って楽だと思うけどねー

>>608
役に立たないとは言わないけど、そんなにメリット大きい？
その代償として OOP 的なメンバー変数使えなかったり、
ループ全部再帰で書かなきゃ行けなくなるってデメリット以上に。

並列化しやすいとかいうのは、
要はスレッド間で状態を共有できなくすればいいだけの話なんで、
immutable はやり過ぎ。

変数は全部スレッドローカル、スレッド間で参照渡すの禁止、
スレッド間通信は Actor （MS 的に言うと Agent）ベースのメッセージ交換でやる
ってのだけで行けるはず。

>609
多分、関数型チックに書くのになれてくと自然とそういう風に書かなくなると思われ。

>>610
そっちに慣れた結果得られるものは何？

immutable強制だとさすがにやりすぎだと思うけど、
両方使い分けができてデフォルトがimmutableな分には別に問題ないと思う。

>>611
関数型でやりたくないならなぜF#を使うのか知りたい

>611
(簡潔に書けること+状態無し)による高生産性が主なメリットじゃね。

ところで

hoge.Connect()なんてるそっどがあって
例外が返ってこなくなるまでリトライし続けるのはどう書けばいいの？

>>614
それ、ほんと簡潔で生産性高い？

関数型プログラミングだからと言って、むやみやたらとループを再帰で書くことはないと思うけど
一般的にはそういうイメージなのかなあ。
自分はforeachとかfold/Aggregateのようなものをよく使う印象。

関数型言語の入門としては、手続き脳を関数脳にするためにという意図か、
必ずやるプロセスなんだよね。ループ的な処理を再帰で書かせるのは。

一旦慣れてしまうと、mapとかの高階関数を使うようになって、自分で
高階関数を書いたり直接再帰を書いたりはしなくなるわけだけど。

関数型な考え方は手続き型に応用できる場面が多い
まあ完全に関数型に移行するのは難しいけど、C#だって最近は関数型的になってるし

VS2010のF＃とOct2009CTPのF#ってバージョン違いますか？
2010はドットネット4.0上でCTPは2.0上？

>> 620
You'll also see 1.9.7.4 reported as the F# compiler version number
for VS2010, and 1.9.7.8 for the compiler in the CTP ZIP and MSI.
These compilers are the same apart from some very minor differences
such as this.

ttp://blogs.msdn.com/dsyme/archive/2009/10/21/some-smaller-features-in-the-latest-release-of-f.aspx

F#の数値単位変換みたいな機能いいね。
あれ、通貨レートとかうまい具合利用できたりするの？

ああああああああいいいいいいい

市場価格と連動するないのｗ？（冗談）

さすがに今の市場価格とリアルに連動はネットワークとか
いろいろ絡んでくるからFX専門会社とかに任せないと無理として、
計算で便利ったら通貨だよね。

VSとは独立してコマンドラインで使いたかったのは俺だけ？

うん

path通せばコマンドラインでも使えるよ

Ocamlからそのまんまなんだろうけど、
コメントが (* *)　なのは何とかして欲しい。

いつからかは知らないが(*) は演算子で解釈してくれてるよ

コメントなんかすぐ慣れるだろ

普段は困らないが、インタープリタのfsiで使ってるときだね。

> List.fold_left (* ) 1 [1..10]
- ;;
- ;;
- ;;
-
-

何を入力しても反応がなくなってあせるぜ。

>>629
> コメントが (* *)　なのは何とかして欲しい。
たしかに慣れるまでキモいけど、入れ子に出来るのは最強だろ。
(*
　let hogehoge = ...
　(*
　let foobar = ...
　*)
　...
*)

(*_*)　(*ﾜ*)　(*v*)　(*o*)

F#って2010ExpessEditionで使えないんだろ？

C#ほど普及しないで廃れそうな気がするな
言語自体は面白そうだけど

そんなガチで普及させる気もともとないだろ。
.NET 使えばいろんな言語の相互運用できるよっていうポーズと、
リサーチの連中が作ったやつがなんか話題呼んでるみたいだし正式搭載するか
って程度のものかと。

クラウドクラウド言ってるし関数型の方が基幹システムなんか作るなら
良さそうな感じするけどな

関数型言語はクラウドと相性よさそうだもんな。

普通の企業はGoogleとかMSの検索エンジンを作りたいわけでもないので、
目に見えてメリットがあるような要素がないと飛びつかないだろうね

C#との相互運用の方法を分かりやすくマニュアルにすれば、
使う人は使うようになると思うな。
C#からF#を呼び出す使い方が重要になる。

これからメイン開発言語を徐々にF#に移行していく予定。

>>635
VS SDKでの対応は続くでしょ？

.NET の思想からすると、メインに C#、部分的に F# 使うとかがいい気がするよなぁ。
>>639 の言うとおり、C# からの呼び出し方をもっとアピールした方が。

F#のスケールの扱いはどうよ？
それ次第では、C#の一部をF#におきかえられるんだけど。

ここで言うスケールって何？

F#ってOCamlのライブラリは使えるの？

--mlcompatibilityを付けて、
互換ライブラリ（FSharp.PowerPack.dll）をロードすれば使える。

>>646
exeを配布する場合はそのdllも添付しないといけないの？

F#の追加ランタイムが.NETとは別に必要なので、
それと一緒に配布されている。

>>644
マルチンコアでのスケール

ほりゃ、とっくに独自のパラレルライブラリを実装している。
標準のスレッドプールを使った簡易版みたいなので、
.NET4.0からは標準のパラレルAPIを使うようになるんじゃないかなぁ。

#light
open System.Threading
let tid = fun () -> Thread.CurrentThread.ManagedThreadId
let sleep = fun (t:int) -> System.Threading.Thread.Sleep t
let x1() = [|1..100|] |> Array.map(fun x -> sleep(100); [|x ; tid()|])
let x2 = [|1..100|] |> Array.map(fun x -> async { sleep(100); return [|x ; tid()|] } ) |> Async.Parallel
let _ = printfn "%A" (x1()); printfn "%A" (Async.RunSynchronously x2)

19.6系から1.9.7系に変えたらメソッド名の変更が多すぎてワロタ。
VS2010が出るのにこんなに変えて大丈夫なのか・・・

マルチコアもいいけどさErlangのようにマルチマシンで動くようにしてくれよ
Axumがどのくらい実用的に動くか分からないし

そのむかしJ#というのがありまして…

何その黒歴史？

とりあえず日本語テキストどっかから出ないとやる気起きないよう

>>654
OCamlの日本語テキスト読んどけば？

>>651
COM+

button.Click.Add( fun args -> MessageBox.Show("Hello World") )
ボタンにイベントを追加しようとしているのですが、
戻り値がDialogResultでUnitではないと怒られます。
戻り値はいらないのですがどのように書けばいいでしょうか。

>>657
MessageBox.Show("Hello World") |> ignore

>>658
それスマートですね。ありがとう。
こんなことをやってました・・
button.Click.Add( fun args -> let dm = MessageBox.Show("Hello World") in () ) 

あけましてあげ

F#なにげに面白いですね。
オブジェクト指向言語から入った人てきには、
こんなに簡素すぎてアレ大丈夫かしらって思ったりするんだが。。

残念なことに良い本がないからなのか、イマイチ中途半端な知識で止まってるのが残念

OCamlのテキストすらまともなのないからな
MSにしては珍しく時代を先取りした感じがする

近々出るProgramming F# (The Definitive Guide)が翻訳されればいいんだけどね。

洋書ってほとんど翻訳されないよな。。
需要が少ないからなんだろうけど。

技術評論社の「プログラミングOCaml」買ってきたぜ

もうc#はいらないな。

CrythのほうのProgramming F# 買った。これ良書だわ。

f#って何に使うの？

C#だとウンコ漏れる場所をF#でふさぐんだよ

このスルーのされ方はJ#以来だな。

F# in Action
http://www.manning.com/laucher/

#お前ら
#lightは
#onで使ってんの？

使ってる。

アップデートのたびに動作が変わるのでちゃんと確かめたことはないのだが、
こういう認識で良いのだっけ？
.fs がデフォルトで #light "on"
.ml がデフォルトで #light "off"
#lightのみは #light "on" に同じ。

げ

F#に興味あったけど
VisualStudio2010が重いせいで
興味なくなったわ

重いから興味ないとか笑止、所詮その程度の興味

なんであんな重いんだろうな
Pen4　2.6GHz　1GBぐらいだと電源ファン唸りっぱなし
Q9400　4GBでも起動すんのに数秒かかる
あんな糞重いGUI誰も望んでないとおもうんだ

F#はVS2008用のがある。STD以上が必要だが、
コマンドラインだけでいいならVS2008なしでも導入可能だよ。

さわって満足するだけのような用途じゃないので
コマンドラインは無理っす

Alt+Enterでコンソール実行って便利すぎるもんな

F#の生産性はC#と比べてどうなの？
C#より優位性ある？

.NETなんだから適材適所で使い分ければよろし

その適所がイマイチ見えないんだよな。

見えない物を�_に使う必要はない
使いこなせるかどうかは使う人間次第

そんな風に突き放されると勉強してみようかなという気も起きなくなる

>>679
IDEのサポートといってもほとんど何も無かったと思うけど。
どんな用途なんだか。

勉強もしてないのに適所なんて見えるかよ

何に使えるのかもわからん物を勉強するのは趣味人だけだろ

適材を完全に理解して始めて適所が解るんだよ
かっこつけないで最初から「F#のメリットって何？」って聞けばいいじゃん

特定の実装パターンやアルゴリズムのみ、みたいな局所的な利用であれば
メリットも解るんだけども、モジュールを丸々F#で書いてもいいと思える
ほど生産性の高い言語には見えないんだよな。

そもそも関数型言語のコードって、書く分にはいいけど読みにくくない？

VS2010にF#のるから、そろそろまともな解説書が出て欲しいな。
そしたら本気出す

>>690
F# は見ただけでまだタッチしてないが、他の関数型言語でなら、
一つ一つの関数の定義に用いるコードが自然と短くなって、
むしろ見通しがいい。

ただ、ひとつの関数に複数の機能やフロー全体を気軽に盛り込もうとすると、
たいていは酷く読みにくくなる。
これは手続き型言語でも言えるが、関数型は比較してその傾向が高い。

>>690
その超局所的な利用が F# の意義だと思うよ。
F# 単体で使われることはないと思う。

別に、C# を置き換えるための言語じゃないから、
C# よりも生産性高くなくても別にいい。

関数型はステートを持たない事だから。
入力->出力になるから、いくらでも分解して並列処理できるってメリットあるわけだ。
でも、その性質を効果的に利用できる分野ってなんだろうか。

>>693
だとすると、C#と混在で使えるようにならないと実用は苦しいな。
言語の境界＝モジュールの境界な現状では超局所的利用そのものが難しい。

まあ、いいんじゃないかな。
もともと Research の言語だし。
2010 でも Visual F# 単体リリースないし。
その程度の位置づけ。

つうか、C#でできることはほとんどよりエレガントに短くかけるだろ(´・ω・｀)

短けりゃいいってもんじゃないし。

C#とF#をひとつのファイルにかければいいのに

確かに。短い記述は必ずしも読みやすい記述とイコールじゃないよね。
書いたときはスッキリして美しいと思ったコードが後で見たら？？？って事あるよな。
これは関数型言語だけの話じゃないけど。

なんちゅうか、関数型の方が書き手を選ぶというか、よりセンスを問われる感じがする。
書き慣れてない人にに使わせると大火傷しそう。

F#で作ったライブラリをC#から呼び出せばいいじゃん

>701
それだとモジュール丸々F#で書く事になるだろ。
C#よりF#が適している状況はもっと限られていて、プログラムモジュールよりも
コンテキストが狭いんじゃないか、という話をしてる。

>>702
なんでモジュール丸ごと書いちゃダメなわけ？
その理由を先に行って貰わないと

>>702
狭くないよ

C# + WPF で GUI 作って、バックでの計算は F# でってのは違和感なくできる。

C#よりF#が適してない状況って何よ？F#なら関数型でもオブジェクト指向でもかけるやん。
周りの開発者のレベルが低くて関数型とかを使いこなせんとかは除く。

生産性とか言ってる時点でよく解ってないんだろ

・Cよりちょっと遅いぐらいのスピードで走る
・.NETのライブラリを使える
・他の言語から呼び出せる
・コンパイルしなくてもスクリプトで使える

もう俺なんかこれだけでｳﾎｯって感じだ

>>707
まだ最適化があまり発達してないから、実際には C# よりもスピード遅いな。
コンパイルされたコードを見ると、関数型の特徴を実現するために
余計なクラスが大量に作られていたりする。

まぁそれで問題になるようなものには、そもそも .NET は使わんが。

F#使ってオブジェクト指向で書こうって発想が既に意味不明。
「書けます」ってのはわかるけど、オブジェクト指向中心で書くなら
明らかにC#のほうがスッキリ記述できるわけで。
手段と目的がひっくり返ってね？

ちょっと前にも書いてる人いたけど、関数型の設計/記述の方が
スマートに書ける状況って特定のパターンにハマった時だけでしょ。
だったらそこだけに適用しようとするのは道理だと思うんだけど。

VS2008用 ver.1.9.9.9
Microsoft F#, February 2010 Community Technology Preview
http://www.microsoft.com/downloads/details.aspx?FamilyID=ba52e650-4e77-4b0b-b987-9f9ecd3bab3b&displaylang=en

VS2010向けRC ver.2.0.0.0
Microsoft Visual Studio 2010 F# Runtime 2.0 RC
http://www.microsoft.com/downloads/details.aspx?FamilyID=8ff66036-37e2-4ae4-9651-3317c028c6ec&displaylang=en

F#仕事に使いたいって言っても
1秒で却下されるだろうな

>>710
VS2010向けのはruntimeだけでコンパイラもInteractiveも入ってなかった。
こっちからVSごとダウンロードをしてくれ。
http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx

>>704
UIの裏で動いてるのが本当に計算的な処理だけならF#もよさそうだけど
IOやら状態管理やらがあるのが普通なわけで。
そういうのはF#ですっきり書ける気がせんのだよなあ。

MSDNにもドキュメントがあがってました。翻訳はまだまだですが一応読めます。
ttp://msdn.microsoft.com/ja-jp/library/dd233154(VS.100).aspx

ビジュアルF番号ってなんだよ〜

C# から F#　の呼び出しは、これまでモジュールやネームスペースの扱いが、
ころころ変わってたのであんまり話題にできなかった。

だからさーオブジェクト指向はデータ構造やその処理についての区分け、カプセルか、ポリモーフィズムについて利点があって、関数型はイミュータブル、処理の合成、簡潔な記述、容易な平行性の適用などに利点があって両者は混在可能。
そして、F#の強みはそれらの容易な統合を.NET上でできるところ。

ttp://stackoverflow.com/questions/478531/call-f-code-from-c/478557
汚ねえ……
同じ.NET言語なのにまるでffiだな
こんなに汚くて面倒なのでは、単純で疎な結合で済む程度の相互運用以外は
非現実的なのでは

C系は相変わらず汚ねえなぁ・・・

F#のListやMapを直接C#から扱うとそうなるな。
スマートにやりたいなら IEnumerable<T> を seq<T>にマップするのがよい。
F#2.0(CLR4.0対応版)からTupleがSystem.Tuple(mscorlib)を使うようになったので、
互換も取りやすくなった。

これだとC#側にFSharp.Coreへ直接の依存がない。
-- fs
namespace Local.FSharp
  module XpaiLib =
    let private xpai ar ad = 
        let pi = System.Math.PI
        ar |> Seq.map (( * ) pi) |> Seq.map(( + ) ad)
    let Xpai (ar:seq<float>) (ad:int) :seq<float> =
        xpai ar (float ad)
-- cs
   foreach (var v in Local.FSharp.XpaiLib.Xpai(new []{10.5, 8.9, 1.1, 3.4, 1.9, 100.0 }, 1000))
     Console.WriteLine(v);

>>719
ありがとう、それならマシだね
F#側のカリー化された関数を、C#側で普通の関数のように呼べるのか

関数型に対応するにしても、なんでOCamlなんて残念な言語を採用しちゃったんだろうな。

あーあ、がっかり。

中途半端なIronなんちゃらじゃなくて、Scheme#とHaskell#をMSが作ってくれないかな。。

SchemeだとS式の不評さと継続の扱いが、
Haskellだと遅延評価の最適化に問題がある。

現時点で、ベンダが自分の所の言語のひとつとして採用する分には、
OCamlは割と妥当な選択だと思うけどね。納得できる。

十年先は、また違う展開になってるだろうけど。

OCamlが残念とか・・・

オッカムル最強伝説(´・ω・｀)

Schemeみたいながっかり言語より
OCamlの方がいいだろ

OCamlの残念ポイント

「let rec」

コンパイラが出来ることを人にやらせる。
これによってバグを抑制出来るのならばよいが、単に冗長なだけ。

こういう無駄をみると、他にもたくさん言語仕様の中に無駄が潜んでいるだろうなと思っちゃう。
あーあ、残念。

下みたいにrecの有無で結果が変わる場合もある。
束縛の再定義が嫌な人もいるだろうけど、個人的には便利。

let square n =
    let f x = x + 1
    let f = function 1 -> 1 | x -> x * f (x - 1)
    f n

let factorial n =
    let f x = x + 1
    let rec f = function 1 -> 1 | x -> x * f (x - 1)
    f n

printfn "5^2 = %d, 5! = %d" (square 5) (factorial 5)

多かれ少なかれ、現在存在するどの言語にも、
その手の妥協はあると思うけどね。
大事なのは利点と欠点のバランスじゃない？

recの有無で結果が変わるなんて、明らかにバグの温床だよな。

>>726
それを言われると let, let*, letrec, letrec* なんてある Scheme の立場が……
まあ実際はあればあったで使い分けるんだけど

rec って、その関数は再帰的に評価しますよっていう、
プログラマに注意を促す印だろ。

>727
これどんなふうに結果変わるのさ？
recは型推論のためにあると聞いたが…

recはリカーシヴの意、定義自身が定義内から可視になる。

入門書、入門に適したweb
おしえてくだされ

いや、わざわざrecを明示的に指定させる理由って何さ

Haskellみたいにletrecの意味のlet一本槍でいいだろってこと？

https://twitter.com/camlspotter/status/9163127215

再帰する関数とそうでない関数を区別したいと当時考えたからでしょ
一方でHaskellは無限ストリームを使う点からしても再帰とそうでないものを区別する文化じゃないし
そもそも >>726 が言う言語仕様の無駄って何だ。let recが無駄ならletも無駄だわなJK.
ML系以外には殆どないんだもの。

そんなどうでもいい差異よりも気になるのは例えば
・明らかに推論できる型も推論できないその辺の言語たちのことか
・外から呼べるようにするためにはpublicとかstaticとかfinalとか常に書かなきゃならんとか
・templateとかいうキーワードがないと多相関数も書けんとか
・オブジェクトがないと手続き抽象すらできないとか
・無駄にカッコが多いとか
ぱっと見でも他の言語でそういう話はいくらでも出てくるのに、
OCamlにケチつけるところがrecってあたりがしょぼい。
mli/signature書くのは面倒とか、functorってややこしい割に使えねえとか、
年々研究者が作ったわけのわからん機能がなされるとか、そういう話ならまだわからんでもないが。

Twitterでぼそぼそ愚痴をこぼすよりましだが、できれば２〜３行でたのむ。

まあそういわずもっと煽っておくれよ

中、読んでないけど let rec について Newsgroup でも話題になってたみたいね。

The need to specify 'rec' in a recursive function defintion
http://groups.google.com/group/fa.caml/browse_thread/thread/0d579e64dd00daff?pli=1

初めのほうだけ読んだが、構文的に見たら再帰だとわかるのだとしても
recはλ理論でいうYコンビネータを呼び出しているという意味付けがある
っていうのがocaml界での認識ってことらしい

>>739
どうみてもTwitterのほうがましだろｗｗｗｗ
文句あるなら恥ずかしがらずにRTしろｗｗｗｗｗ

>>734
web記事かなり増えてきたけどメモ書きレベルのゴミばっかりだな
ぶっちゃけOCaml互換・非互換から.netまで自由自在となると相当大変だが。
市販本3冊くらいあるけどドンシメの名前がある奴で問題ない
付属ドキュメントは見難いがMSDNが微妙に充実してるな

>>744
充実には程遠いってのならわかるが、ゴミとは手厳しいね。
なぜにゴミと言い切る？ゴミでないためにはなにが必要？

英語なら前からごみじゃない記事も出てるだろ。
要はそれを読めないお前がゴミだってことだ.

F#の本がでるようです。どうなんだろ。
http://www.amazon.co.jp/dp/4777515001/

すでに出てるだろ。
ちなみにカス本だった。

現状だとOCamlの日本語テキスト買うのが吉かと

F#はどういうプログラムに向いていますか？

.Netで関数プログラミングをやりたい人向け

>>747
それカス本すぎる。
まぁしかし、技術本の半分以上はカスだよな。
この世界で良い本はそんなにないんだよな・・・

洋書だがProgramming F#はかなりの良書。

尼で「Ｆ＃」で検索すると、　「洋販ラダーシリーズ」　なる高校レベルの
英語で、日本のあれこれを紹介しているシリーズが多数ヒットする

なにこれｗｗｗ

検索しにくい

ふつう F# だろ、Ｆ＃で検索する状況が思い当たらない

二年くらい前にExpert F#とFoundation of F#買ったけど積読したままHaskelllに浮気してしまった

.NETように主にコード書いてるからなぁ・・・
ナイスなHaskell.NETキボン。

lispをだいたい勉強終わったぐらいなんですが,
OCamlの入門としてお勧めな本はどれなのでしょうか

>>726
ああ、これ自分もしょぼいと思ったよ。理論・理屈は置いて

>>759

普通に

『プログラミング in OCaml』
五十嵐 淳 (著)

じゃない？

それとスレこっちじゃね↓

関数型言語ML (SML, OCaml, etc.), Part 6
http://pc12.2ch.net/test/read.cgi/tech/1245017721/

まぁ、オレはLispの後、OCamlを中途で投げてHaskellに行ったけど・・・

>>761
ちなみにOCamlはどこで嫌になったの？

>>762

OCamlの本（>>761ではなく『プログラミングの基礎』の方）を読んでたときに
中々頭入らなくて、そんな時にHaskellの本読んだらスーッと入ってきたの
で、そこからHaskellに乗り換えちゃった

だから言語が合わなかったのか書籍が合わなかったのかちょっと分からん

>>1
F#自体に圧倒的なメリットがなければ、無料の開発環境がないんじゃ誰も使わないだろ。

MSはF#をどうしたいんだろうな。Visual F# Express 出せよ。

Visual F# Expressを出されても他言語と連携できないならあんまりいらない

連携以前に、まず単体で使ってみたいだろ。

しかし、単体では実用性に乏しいのが事実。

F#（というか関数型言語全般）は書くときは書き易いが、読みにくいな。
コードの意図を読み解くのに時間がかかるというか。
これは慣れで解決するものだろうか。

使ってみなければ、自分の用途で実用に乏しいかどうかを判断できないだろ

単体で使うならスクリプト書くくらいがいいとこか

スクリプト書くくらいならIDEなんかいらん、コンソールで十分

コンソールでスクリプト書くって、edlinとか使うの？

Programming F#の和訳でるってほんと？

ホント

VS2010でF#入ったんですけど、これ何ですか？

MS版OCaml

MSは次から次へと。。。ちゃんと面倒見る気あんのかね

だめだと思ったら切り捨てるだけじゃん
いつものこと

Trust me.

高校生にうそつき呼ばわりされる鳩山乙

>>764
Visual Studio Shell + F#

>>771-772
ほんとに出るんだ（978-4-87311-466-8）

8月発売か
もう原書持ってるから買わんけど

F#にはポインタありますか？

>>771
ttp://www.oreilly.co.jp/catalog/soon.html

>>781
http://msdn.microsoft.com/ja-jp/library/ee340434.aspx

>>782
サルまばたきしやがる

何を今さら

同じプロジェクト内でC#とF#、混在してかけるようにして欲しいなぁ・・・ソースファイルは分けていいから.(´・ω・｀)

粗粒へしょんには複数のプロジェクトが入る

んなこと知っとるわ

C++/CLRの代わりに使うものっていう位置付でいいの？

全然違う

仕事でバリバリ使うとよろしい

inlineで関数定義すると算術演算もあらかたGenericにできるのな。これ2.0から？

今月、プログラミングＦ＃（日本語訳）が出版されるからうれしい。

すれたてたものだが、3年かけてやっと793か・・・(；´Д｀)
言語としてとてもナイスだと思うんだが実践で使われるのはまだ少ないのかのぅ・・・
仕事場で鋭意普及中。

コンピュータ言語ヲタが喜ぶ機能が揃ってても、普通のプログラマには
何がうれしいのかさっぱりなんだと思うよ。

こういう事を実現するのに他の言語だとこうだけど、F# ならこんな風にプログラムできる、
などと比較して利点を示さないと新言語の魅力はなかなか伝わらないね。
F# に限らんけど。

普通のプログラマはRubyでも拒絶反応起こすからな

2007年ならネーミングはF#7にしておくべきだったな

>>793
明日発売のようですね。
http://www.amazon.co.jp/dp/4873114667
>プログラミングF#
>出版社: オライリージャパン (2010/8/26)
>発売日： 2010/8/26

どーいう人にメリットあんの？F#は

遊びたい人

マルチコアが普通になってきたから、
並列化にすることの恩賜が増えているのは事実。

将来コア数がどれぐらいになるかわからんけど、
今の型落ちＰＣですら４コアあるからね。

より宣言チックにかけるのは万人にとってメリットあると思うけど実際にそれを生かせる人はどんぐらい入んのかね・・・
うちの会社だと2割居るかどうかかな・・・

MSってだけで虫唾が走る

>>804
> MSってだけで虫唾が走る

それは MS の商売気質に対してだろ
Microsoft Research は MS の商売関係なく、
F# を始め広範囲にかなり面白いことを色々やってるぞ

Haskell に多大な貢献をしたのも MSR の人だし

そもそもなんでMSに虫唾が走る人がF#のスレにきてるん

知らなかったから

唾を吐くため

emacsのタグジャンプの変な環境でlisp使うより
VisualStudioの抱負なデバック環境で使える言語は魅力

悔しいが同意だ
Eclipse + Scalaには期待してる

プログラミングF#
これの感想はないのか？

英語版しかよんでないけど、非常にコンパクトに網羅してあって良書と思われ

C# と F# ってどう違うの？
似たようなもん？

.NET Framework 上で動作するが、言語仕様としては全く違う
C# と VB.NET の違い以上に違うし、VB.NET と C++/CLI 以上に違う

要するに、MS が作った他の .NET 系言語とは似たところがほとんど無い

J# ｗ

フレームワークといいながら関数型言語ないから糞って言われないために
作ってやったぜって感じがしなくもない

>>805
Microsoft Researchの技術者あれはどうやって飯食ってんだ？Microsoft に雇われてるんだよね？
研究部門なのか？

まあ多分Microsoft Researchに限る話じゃないんだろうが、Microsoft的には

だから研究してんだろ。お前は研究がどういうものかわかってるのか？

お遊びw

>>817
MS は世界で一番研究予算使ってる IT 企業。
もちろんそもそも金持ってるってのもあるけど、研究予算比率むちゃくちゃ高い。

そもそも研究部門持ってるIT企業ってどのくらいあるの？

IT企業かどうかは別としてNECは研究所廃止したなあ

亡国だしなー

実のところ市場独占率高いほど研究費用投じてイノベーション起こそうとするっていうしね。
独占率低いと、業界他社との戦いでいっぱいいっぱい、
独占率高いと、今の業界に的ないから、技術革新で状況ひっくり返されるの畏れて自分で革新する。
NEC も、国内 PC 市場独占でやってた頃は研究に投資してたけど、今はもう・・・

F#で引数にアクセス制御が書けるのですが、何のための仕組みなのでしょう？

let private f (private x : int) (private y : int) : int = x + y

ニュージーランドがピンチだにゅ

>NEC も、国内 PC 市場独占でやってた頃は研究に投資してたけど、今はもう・・・

なんかイノベーションってあったっけ？

出来なかったからDOS/V機に・・・

AGDCとかEEGCとか当時としてはよくできたグラフィックチップだった

SHとかPowerVRとか

国内でチマチマやっててもなぁ

SHは日立だろ。

今じゃ同じ会社だが（NECエレとルネサスは合併しました）。

NECと日立を、富士通と東芝を、
ってくっつけていかないと
世界で戦えずに国内でつぶしあうだけになっちゃうから
さっさとなんとかしてほいい

BukkakeとかKaraoke、Karoushiが海外に普及して喜んでいる奴らもいる一方、
ガラパゴス用語だと言って恥だという奴らもでてくる

>ガラパゴス用語だと言って恥だという奴らもでてくる
誰が言ってんだよｗ

>>833
日本はソフトウエアに関しては、
ハードウエアのオマケっていう意識が、特に経営層に強いから
たぶん無理じゃないかな。

SH開発ストーリ
http://resource.renesas.com/lib/jpn/superh/theme/01.html

つくづくF#に興味ないんだなおまえらｗ

いやーF#、スクリプト、インタラクティブ、コンパイルを絡めてライブラリ豊富な型付き言語でゴニョゴニョ出来るってのは便利だわ(´・ω・｀)

>>820
WindowsとOfficeで稼いだ金使って研究しまくりだろ
死ぬまでに次の一発を当てないと死ぬｗ

後のIBM出会った

あれだけの大企業になると"死ねなくなる"からなぁ
仮に今後20年ぐらい全てのWindowsとOfficeが失敗し続けたら、不採算部門を切り捨ててIBMみたいになるんじゃね。

でも、今の MS 支えてるのってひそかに .NET よ。
あの基盤でかい。
デスクトップからクラウドへのシフト起きても開発者の負担少なくまるまる移行できてしまうとか。

Google　青年
Microsoft　中年
IBM　老人

x でも、今の MS 支えてるのってひそかに .NET よ。
o でも、これからの MS 支えてるのってひそかに .NET かもしれないよ。

MSの開発基盤から離れられない会社ってのは多いかもね。
NTではじめの頃から見てみれば上はクラウドから下はWP7までよう揃えたと思うよ。

昔、Windows の人気を支えてたのはドライバー回りでハードウェア依存軽減していろんなメーカーのハードでアプリ動くようにしたこと。
今はっていうと、.NET で、3 screens and a cloud で似たようなコードが動くこと。
どっちも、開発者を楽にしてくれてる。

MS嫌いな人ってどの辺が嫌いなの

全盛期の読売巨人が嫌いだった人は、たとえ落ち目になっても嫌いなまま。

>>848
unix由来のツールが動かしにくい点じゃないかな
今は仮想マシンの普及で動作テストにはたいして問題ないけど

単に反体制なだけの奴も多いだろ。

ばるまーちゃんのつい最近までのことばを考えちゃうと、MSまんせーはできない

無条件にマンセーしてると思ってるのってアンチMSだけだろ。
マ板ならまだしも、ム板なんだから技術面で批判すればいいのに

forkが無いOSなんて

fork がないと GnuWin32 で tar がまともに使えない
でもあんまり困んない

tar32.dll

F#からCのDLLってどう使うの？

F#でもP/Invoke使うことに変わりない。構文はこんな感じ
http://stackoverflow.com/questions/1689460/f-syntax-for-p-invoke-signature-using-marshalas

thx!!

>>853
体制マンセーなだけの人もいるようですね

ユーザ数が圧倒的に多いんだからそういう人も居るさ

win33%linux33%mac33%ぐらいにうまくシェア分散しないものか

規模効果考えると最悪のパターンだと思うけどなぁ、均等シェア。

90% 9% 0.9%くらいでいい。

>>854
NtCreateProcessを使えば、たぶんforkできる。
そもそもPosixサブシステムならforkもある。

一応ある、という程度の話だけど。

カレー化っていまいちわかんないんだよね。

おいおい　カリー化だろ

どっちもCurryだけどな

マイクロソフトに電話で、F#を開発に使えるか
検討しているのですが、と聞いたことがある。
F# を知らない部署を５件くらいたらい回しに
されたあげく−＞最初にもどるだったので
諦めたわ

さすがMSKK

>>869
そんな問い合わせするんだ！！
「ああ、そうですか？」ぐらいしか言えなくね？ｗ

マイクロソフトに、とだけじゃ幅が広すぎる。
一体何処に電話したんだろ。
何処に電話したとしても、質問内容のほうが酷い。

たらい回しにされたのはF#を知らないって理由じゃないんだろうな・・・

いつ電話したのか知らんが、今なら触ってみればわかるだろ。

今度C#でプロジェクト立ち上げるんですけど成功すると思いますか？


俺が電話番でもたらい回しにするわwww

そこはたらいまわしじゃダメだろ。
やんわりと「おかしい人避け」しないと。

>>869
どの国のMicrosoftに問い合わせたの？

韓国だろ

問い合わせるなら台湾だろ。F#にも萌えるマスコットがいるかもしれないし。

米Microsoft、関数型言語「F#」をオープンソースに
・Microsoft Research Shared Source Licence Agreement　→　Apache License 2.0
http://sourceforge.jp/magazine/10/11/08/0247250

F# PowerPackもApache License 2.0になった。

うーむ。
ここ数日のMSの動きが読めん・・・。

もうF#いらね　ってことだろ

>>869
今こそもう一度問い合わせるべきだなw

次はWindowsのオープンソース化がくる。

まずはExcelをオープンソース化してください

OOoのソース並みに要らないな

F#のオープンソース化は別に驚くような事じゃないだろ？

一押しアイドルが急に脱いだら驚くだろ。

リサーチのMSR-SSLAから適当なOSSライセンスになるのってそんなに珍しいの？

もともとDon Symeはオープンソースにしたいって言ってたし、特に驚くことでも無い気はするけど、
そこらへんの事情とか最近のマイクロソフトの動きとか知らない人には奇妙にうつるんじゃね

>>886
||＞＞ Libre Office PART1 ＜＜＜||
http://hibari.2ch.net/test/read.cgi/software/1288792911/

世界の官公庁で、
msoffice -> オープンドキュメント
みたいに、
java -> オープンVM環境
という流れがあると、思っているのだろうか。

かつてLAN設備をtcp/ipのかわりにOSIにしてしまった某役所ですね

Mono Picking Up F# Support For Linux, Mac OS X, Etc
http://www.phoronix.com/scan.php?page=news_item&px=ODc3OQ
>In this blog post by Miguel he shares that F# support will now be distributed by Mono for Linux and Mac OS X.
>There will also likely be F# support for Google's Android and the Nintendo Wii too,
>which are other platforms supported by Mono, and that there may possibly be F# support for
>other Mono platform targets like the Apple iPhone and Sony PlayStation 3.

>>893
標準規格に合わせただけ

Andoroid上のMonoって、iPhoneみたいにARMプロセッサ向けにAOTしたプログラムが動くんだろうか。
それとも、MonoのVMがARMのネイティブコードとして動いてんだろうか。

F#というのは1960〜1970年代に科学技術計算に多用された（もちろん今でもよく使われている）
Fortranなる言語に似せて作られたプログラミング言語の名前で、
それで作られたプログラムはMicrosoft .Net Framework上で実行する事ができる。

　ところで、Microsoft .Net Frameworkというものは、C#、VB.NET、F#で書くプログラム中から
同じライブラリーを呼び出す事もできるし、C#で書いてコンパイルしたライブラリーをVB.NETから呼び出す事もできる。
今ではほとんどやらないが.Net Frameworkのバージョンが若い頃はライブラリーロジックはC#で、
それを呼び出して操作する画面はVB.NETで、なんて事もやられていた。
　F#がメニーコアでのプログラミングに向いているのかどうかは私は知らないが、
単純な並列計算を力技で解かせる事が得意なのであれば、計算ロジックをF#で書いて、
それを呼び出すインターフェース（画面だね）をC#やVB.NETで書くというのはアリ、だと思う。

　関数型言語というのは、全てのプロシージャー（手続きを一まとめにしたもの）が「値を返す」言語の事を言う。中学校で習ったよね。
　y=f(x)
　例えば、f(x)=x^2+5だとすると、C言語では以下のようになる。
　double f(double x) {
　　return x^2+5;
　}
　これは極端な例だけど、これを
　double x, y;
　for(x = -1.0; x < 5.0; x += 0.01) {
　　y=f(x);
　}
　などとして（後は画面描画機能を加えれば）画面上に二次関数を表示したりできるね。
まぁ、関数型言語なんて言葉は既に意味の無いものになっているのであまり気にしなくても良いだろう。
　わざわざ「関数型言語」なんて言葉があるのは、その当時はプロシージャーが値を返さない言語も多かったという昔話でしかない。
（その当時の）BASIC 言語とか。GOSUB（サブにイけ）とかどんだけウホッ良いサブ(ルーチン)かっていう話ですよホント。
「（F#プログラミングを）やらないか」とか言われたらもうそこであなたもF#プログラマーなわけです。
ただ、F#が流行りそうか、と言われたら・・・・ボクには何とも言えない。

F#って何？？ | OKWave
http://okwave.jp/qa/q6283983.html

どこから突っ込んだらいいのやら。

(スコア:5, すばらしい洞察)

ベストアンサーも困ったものだな。

F# の F は、FunctionalのFで、他からの移植でなくて.NetFrameworkから生まれた言語の中では、
初めて関数型言語の性質を持つという特徴を持っています。ただ、関数型だけではなくマルチ指向
なので、ご注意ください。

>>897
これはひどい

使ったことがないので、「F#って一体どんな言語ですか？」という問いには申し訳ありませんが正面から答えることができません。
しかし、ANo.1の人は何か他のものと勘違いしていないでしょうか。
・F#はFortranには全く似ていません。言語系統的にはML→Caml→OCamlの流れをくんでいます。
・関数型言語というのは、コンピュータ科学的にはλ計算の概念を基礎とし、関数をファーストクラスのオブジェクトとして扱える言語
というのが広い意味での定義です。値を返さないプロシージャ(手続き)に対して値を返すものを関数と呼んだのとは意味合いが異なります。

C言語プログラマーには馴染みのない型推論とか遅延評価とかの興味深い機能がありますが、
それらが実用上どれくらい役に立つかは何とも言えません。

投稿日時 - 2010-11-03 22:12:48

ANo.2 がベストアンサーかな

いやいやいや・・・関数型言語が「昔話」なんてのは・・・・
F#ってのはMSが最近出した「関数型言語」であってなんで「昔話」の種類の言語が出てくるのでしょうかね．
それとFortranがF#のもとだというソースがどこなのかも知りたいです．
F#はOCamelがベースになっているってのはMSのサイトにもあるんですが．
実際の関数型言語は実はぜんぜん過去のものではないわけでLispやHaskellも盛んだし，
関数型言語をいじると「再帰」が身につくほかかなりスマートなコードが書けるようになります．
F#に限らず，関数型言語の特徴はなんといっても「副作用」の取り扱いと
「関数そのものをデータとして扱う」という考え方で関数に関数を与えちゃうんです．
「副作用」の代表格は「IO」ですけど，面倒なので割愛．ほかにも
F#は「型推論」とか「静的で強い型付け」なんていう特徴もあるようで正統的な関数型言語みたいですね．
＃ほかにも「代入が存在しない」なんていう特徴もあることもがある

関数を値として扱うなんてのは，Cなんかだと「関数ポインタ」，
Perlなんかだと「無名関数」なんてので実現するけど関数型言語は関数そのものをそのまま代入できるわけ

たとえば f(x)=x+1 と定義して map(f, [1,2,3,4]) なんてすると [2,3,4,5] というリストが戻ってくるなんてことができる
第一引数が「関数」にできたりする．foldというタイプの関数が定義しやすいのも特徴かな

どうしてこういう言語を考えるのかという問題は「副作用」の影響が大きいのかな
関数型言語ってのは「同じものを与えれば同じものがもどってくる」（大雑把に言えば「副作用がない」ってこと）
ってのがベースにあって，こういう風になっていると違う環境で計算しても同じものが戻ってくるわけで
そうであれば「後で合体させる」ときに便利なのは分かるでしょう？

あとは関数を連結しやすいのです．いわゆるパイプです．
投稿日時 - 2010-11-03 21:53:31

どの回答にしてももっとすっきりした文章で書けるだろうに、
どうしてこんなに読みにくいのだろう？

質問も回答も自演くさいな

int f(int x){ return x+1; }
int[] map(Action<int> func,params int[] prms){
return (from i in prms select func(i)).ToArray();
}
var rslt = map(f,1,2,3,4,5);

こっちのが見やすくないか…

んあ？C#がいいってこと？

Win以外でも使えるMonoの開発環境にF#のフラグインが登場してる。

http://blogs.msdn.com/b/dsyme/archive/2010/12/22/monodevelop-plugin-for-f-now-available.aspx

なにこれひっど〜い

F#を勉強したいと思っていますが、[実践F#]と[プログラミングF#]のどちらを買おうか迷っています。
C#経験者がF#をみにつけるためにはどちらの本が最適でしょうか。

実践Ｆ＃なんて出版されるのか。買ってみよ。
プログラミングＦ＃は良書ですよ。他はダメダメ

Expert F# 2.0 (Apress) というF#作者の本があるが、まだ翻訳されていない。

Programming F#は良書。
Real World Functinal Programmingも良書。

>>911 >>912 >>913 ありがとうございます。
確かにプログラミングF#は良さそうですが、
私は関数型とか全然分からなくて少し不安です。
目次を見る限り実践F#は関数型初心者にも理解しやすいような
気がしていますが、どなたかお読みになったかたいるでしょうか。

twitterのTLみると類推や例が豊富みたいだからいいんじゃないかな。

F#が利点がしっくりこない理由
・F#でないと！という利点が見えない
・文法が推測しずらい＝書きにくい

そこは、テンプレ通りの釣りで「実は F# がしっくりこないんです」だろ。

それは元ネタがうちの大学のOBだからあんまり使いたくない

F#で書くほうが色々と楽なんだが、インテリセンスがC#のほうがいいのでC#で試し書きすること多し(´・ω・｀)
2012ではもう少し賢くしてくれよパトラッシュ(´・ω・｀)

型推論が強力だったりの都合で無理、
という場所だけじゃなく普通にここは出て然るべきだろ、
というところでも結構IntelliSense動かなかったりするからねえ。

今みたいに言語ごとに個別にVS対応してるうちは、F# みたいな（C# VBと比べて）相対的に利用人口少ない言語はどうしても後回しになるのもやむを得ない。
今MSが取り組んでるらしいCompiler as a Serviceが完成して、IDE対応がある程度共通化できるようにならないと厳しいと思う。

F#でないと手間のかかること、っていうのがないんだよなー

F#でかいてみたが、ついC#っぽく書いてしまいます。。。

なれればF#のほうがはるかに早く実装することが出来るぞ(´・ω・｀)

F#のお試しサービス
http://tryfs.net/

F#じゃないと困るということがない、ってのは、
関数型言語全部にいえるんだよな
結局LLみたいなお手軽言語でもないから中途半端だと

>>926の心理をプロファイリングしてみた

　ちょっと背伸びしてF#を触ってみたが、自分には理解不能だ
　でもそれを認めるのは嫌だから、F#が中途半端なせいだということにしておく

単なる「酸っぱい葡萄」ですた(END

昼間っから乙

実際になにか作ろうとすると、言語仕様よりライブラリのほうが影響大きいしね
研究目的とかゼロから全部自作する場合はそうでもないんだろうけど

VM上のミュータブルな共通ライブラリーが使えて、
静的な関数型言語の利点もかなり享受できるのが、F#やscala

LLみたいにREPLもあるよ

いまそこにあるnull

C# 4だと面倒だけど、F#なら便利、ってパターンある？
なんか、C#が関数型の特長取り込んで、ほとんどできちゃうような印象があるんだけど。

C#に無くて便利なのは、型クラスとパターンマッチングかね
あとは、ML系の(scalaなどより)強力な型推論

>933
・パターンマッチング
・ObjectExpression
･AyncWorkflow
・ComutationExpression
・UnitOfMajor
・まともなクロージャー
・TailRecurtion含んだ再帰
・REPL
・discriminated union
・型推論含めていろいろ簡単にかける仕組み

おー、ありがとう。分からない用語もあるのでちょっと勉強してみます。

間違えた、"型クラス"じゃなくて"バリアント(判別共用体)"だった、、、
http://msdn.microsoft.com/ja-jp/library/dd233226.aspx#Y508
scalaのcase classのつもりで、なにを取り違えたのか型クラスと書いてしまった、、、

>>929
はじめから.netを意識してるし
グルー言語として結構優れてるんだけど
そこが>>935みたいにまったく注目されないんだよなｗ
.netを利用したお手軽アプリならC#とかLL+OSのapiより簡単に書けるわけだし。
まあguiはC#でやりたいけど・・・ｗ

.netが必要となる段階ですでにお手軽でなくなってる

だよな

何を持ってお手軽かって話だろ。

数�b隣のコンビニへ行くのに乗用車乗りたくはないだろ

その例えで行くと、数メートルとなりのコンビニまで動く歩道があるといったほうがいいだろう。
設置するのにコストがかかるが、あるなら使うわ。

他人に配布して使ってもらいたいときに
動く歩道の建設普及促進になるのが良いと考えるか
無駄なコストだと考えるかだろ

動く歩道は乗ったらすげーらくちんって聞くけど
乗るまでが何かめんどくさそうだから普通の道で行くわ
ってなりそうだな

配布するのが大変って言ってる人は、ただでもわざわざ道路作んのかよってことだし
大変じゃないって人は、言えば作ってくれるんだからそれを使えばいいじゃんってことで平行線だな。

.NET3.5以前は入れたくないが
.NET4なら入れても良いと思う

歩く歩道はニュータウンには標準で付いてくるので、そろそろみなさんニュータウンに移ってください

わかりました
すぐに引っ越すので、前の住居の数メートル隣のコンビニをニュータウンの引越し先に設置しておいてください
ユーザーからのお願いです

>>925
なんだこれすげぇ。

ume

950でしばらくしたら落ちるんだっけ？
980だっけ？

>952
985辺りまで安全。立てるのは995前後でおｋ。
早く立てすぎると埋めるのがかなり面倒だから。

自分の周りでは結構F#話題に出るんだが、巷では全くはやってないのかね?

980で落ちる

Don SymeのExpert F#や、Dean SmithのProgramming F#もあるけど、
Tomas PetricekのReal World Fanctional Programmingは、良さそうだね。
https://twitter.com/murrayondotnet/status/56012406744289280

Robert PickeringのBeginning F#ってどうなんだろう。
どうでもいいが、発行年が2007と2009に集中してるな。

>956
Real World Functional Programmingは良書(｀・ω・´)ｼｬｷｰﾝ
他のに比べて関数プログラミングって何ぞやってところに多くを割いている。

>>954
個人的に趣味の範囲で、まだ興味持ってるけど
趣味ですら、ちょっと本格的なアプリつくろうって気にはなんないね・・・
メーリングリストとかFShubもコミュも死んでんじゃん？