Haskell Antenna

HaskellでABC454を解く

2026-04-19T21:08:38+09:00

HaskellでABC453を解く

2026-04-12T14:24:41+09:00

Haskellのモナドを何が何でも理解する（Pythonでもわかる）

2026-04-11T15:30:34+09:00

Haskell の数値計算ライブラリで logSumExp の実装を読む

2026-04-08T22:40:09+09:00

AIはアウトプットだけじゃない。学習ツールとして使ってみた。

2026-03-22T09:11:25+00:00

日々、AIの進化が目覚ましく、実務で使わない日はないほどになってきました。アウトプットへのハードルは劇的に下がった一方、私自身はインプット目的でAIを活用することも多くあります。壁打ち相手として使ったり、技術的にわからない箇所を深掘りしたり……。そこで今回は、AIを用いたインプットがどれほど学習に効果的かを検証すべく、Haskellを題材にミニマムなCLIアプリケーションを作ってみます。目的 AIを用いたインプットが学習に有効かどうかを、実際に手を動かして実感する。やることミニマムなCLI Todoアプリケーションの作成今回の目的はインプットが行えるかを検証したいので...

[windows] Windows11セットアップ・設定項目のメモ

2026-03-19T11:33:37.642+09:00

スタートメニュー・タスクバーの設定個人用設定＞タスクバータスクバー項目検索：「非表示」タスクビュー：オフウィジェット：オフタスクバーの動作タスクバーの配置：　左揃えタスクバーをすべてのディスプレイに表示する：　アンチェック（拡張ディスプレイ接続状態で設定）タスクバーのボタンをまとめラベルを非表示にする：　常時タスクバーのボタンをまとめほかのタスクバーでラベルを非表示にする：常時タスクバーボタンを表示する：　タスクバーに入りきらない場合スタートメニューにコントロールパネルを表示する「Windows 10」のコントロールパネルを表示する方法についてスタートメニューにピン止めするアプリ：（下記以外は「スタートからピン留めをはずす」）WindowsシステムツールコントロールパネルWindowsアクセサリペイントパワーポイントエクセルAcrobat

証明: Applicative の合成は Applicative

2026-03-18T15:00:11+00:00

初投稿です. Data.Functor.Compose には次のような説明があります. The composition of applicative functors is always applicative, but the composition of monads is not always a monad. Applicative が合成について閉じているという性質によって, Applicative では汎用的な合成型が書けます. それがこの Data.Functor.Compose です. Defined in Data.Functor.Compose newtype...

MySQL 8.4対応のシンプルなHA管理ツールをHaskellで自作した話

2026-03-18T11:03:38+00:00

要約 MySQL 8.4対応のシンプルなHA管理ツールPureMyHAをHaskellで作成しOSSとして公開しました。 MySQL 8.4の非同期レプリケーション/準同期レプリケーション環境にて自動フェイルオーバーや手動スイッチオーバーが可能となります。 https://github.com/ikaro1192/PureMyHA 本ツールの作成にはClaude Codeを利用しました。本記事ではそちらの体験やHaskellを採用した理由などについて説明しています。はじめに：なぜ今、HA管理ツールを自作したのか現代のデータベース運用において、Amazon Aurora等のマ...

Haskellのfoldl、foldl'、foldrを比較してみた

2026-03-16T03:36:51+00:00

これは何? (この記事はクロス投稿です) Haskellの畳み込み関数の3つの使い分けについて解説する。この記事を読み、以下がわかるようになれば幸いである。 foldlは巨大サンクを作るため使うべきでない foldl'は厳密な左畳み込みであるため、パフォーマンスが良くなる foldrは演算子が正格でないなら遅延評価の強みが活かせる foldlは巨大なサンクを作ってしまう。最後の要素以外のすべてを結合した結果を、最後の要素と再帰的に結合する方法[1]をfoldl(末尾再帰)と呼ぶ。 foldlを利用してリストの合計を求める例を使ってfoldlの弱点を説明する。 gh...

PythonのrequestsっぽいHTTPクライアントをHaskellで作った

2026-03-14T11:23:59+00:00

Haskellを学ぶときの悩み Haskellを勉強し始めたころ、ずっと困っていたことがあった。「これ、どこで使うの?」という感覚が抜けなくて、なかなか前に進めなかった。ある時、こんな仕事が入ってきた。HTTP APIからデータを取得して、ちょっと加工して、別のエンドポイントにPOSTする、というやつ。よくある感じの作業だ。いつもならPythonとrequestsライブラリで片付けるところ。URLを叩いてJSONを受け取って、変換して送る、それだけのことが数行で書ける。でもふと思った。これ、Haskellでやってみるのにちょうどいい題材じゃないか。既存のライブラリを探してみ...

（仮）絶対できるHaskell 抄「圏論とファンクター」

2026-03-06T09:23:40+00:00

絶対できるHaskell抄僕は、しばらく前から「（仮）絶対できるHaskell」という本をZennで書いているのですが、なかなか完成しません。「Haskell初心者本」という目線で執筆しだしたのですが、執筆するために色々調べたり、考えたり、例示プログラムを書いているうちに、書き始めた頃よりも僕自身もHaskellの理解が進み、以前の説明の書き方に不満を覚え、書き直し、、、ということの繰り返しが起こっています。最近は、「ファンクター」まわりの自習をしながら文章を書いてたのですが、このあたりの初学者目線の解説がほとんどみられないので、とりあえず、たたき台的なものですが、公開してみた...

【TypeScriptよりいいもの】未だ応用されきっていない、型システム本来の力の簡単紹介【読み物】

2026-03-02T11:07:01+00:00

これはなに？型システム（静的型付けのシステム [1]）のオタクによる、ものすごく簡単な説明。型システムには多くの機能が存在するため、必ずしも単純な強弱で語れないものの、基本的に上から下に行くほど、型システムがリッチになっていくことを意図している。 C・C++ intやcharなどの値が区別できるが、いつの間にかそれぞれが紛れ込んでいたりする。これは型チェックエラーにならない: #include <iostream> int main() { int age = 25; char grade = 'A'; // intとcharには暗黙変換がある...

[cygwin] cygwinセットアップ・環境構築手順メモ

2026-03-02T10:25:15.592+09:00

主に自分向けの防備録です。windows10上で確認。インストーラーはここからDLする。 <<設定>> ssh-agentの重複起動を防ぐユーザーのアカウント名、ホームディレクトリの変更 /etc/passwdを編集する（最新バージョンでは自動生成されない？） Cygwinを移動したら/etc/passwdの再生成を巨大ドメインに参加している PC での /etc/passwd, /etc/group ファイルのつくりかた ssh-agentのために秘密鍵セットアップ ~/.ssh/ ※group/otherの権限を削除する必要がある % chmod 700 ~/.ssh less, lv, manコマンド終了時に画面をクリアしない [linux][cygwin] less, manの終了直前の画面を

HaskellのFunctorが圏論の関手であるというのはどういうこと？

2026-02-22T14:20:14+00:00

最近圏論面白いと思っていて、人と話したり Gemini などに聞いたりしながら学んでいるので、その備忘録です。一応 ChatGPT 及び Gemini に読んでもらっているのですが、浅学の身による理解なので間違ってるかもしれません。気になりましたらコメントお願いします。また、この記事は Haskell をある程度触ったことがあることと高階関数とは何かを理解していることを前提として書いています。数学は前提としていないつもりですが分かりづらかったらすみません。 fmap Haskellには fmap と呼ばれる関数がある。以下のように定義されている。 class Functor f ...

含意(→)の用例：マンガ「数字であそぼ。」の論理パズルを解く

2026-02-21T07:04:46+00:00

背景プログラマの飲み会で「含意っていう便利な論理記号があってぇ~」と宣ってみたは良いものの、全然うまく説明できなかったので書きました。含意(→)とは and(&&)やor(||)やnot(!,~)はプログラマであれば良く使う論理記号かと思います。これらは古典論理と言われる分野の記号であり、その仲間がimply(→):含意です。含意は以下のような関係があります。 A → B = (not A) or B 日本語で言うと”Aならば必ずBである。Aでない場合Bがどうなっても知るか！”です。必要条件や十分条件の勉強をされた方はその話です(個人的には嫌いな体系。話を...

BuriKaigi 2026 で Lean によるコンパイラの証明について話してきました

2026-01-16T00:37:18+09:00

こんにちは、チェシャ猫です。先日開催された BuriKaigi 2026 で、定理証明支援系 Lean を用いたコンパイラの証明について登壇してきました。公募 CFP 枠です。 fortee.jp 講演概要近年、生成 AI を利用したシステム開発はもはや特殊な選択肢ではなく、一般のプログラマでも十分に活用しうる水準の技術となりました。一方、生成 AI が高速かつ大量に、しかしハルシネーションを含んだ出力を行うことにより、その正しさを改めて確認する側の人間の負担感も様々な場所で聞かれ、AI Slop などと呼ばれています。ちなみに Slop とは「泥水」のことで、低品質な出力を例えた表現です…

HaskellでGTK 4 tutorialを進めている

2026-01-08T23:31:00+09:00

GTK 4 tutorial という GTK についての充実したチュートリアルがある。(英語だが日本の方が作っているみたいだ。) toshiocp.github.io 何か GUI アプリケーションを作ってみたい気分だったので、冬休み自由研究としてこちらのサンプルコードを Haskell で書いてみるということをしていた。 Haskell で GTK アプリが書けるのかというと、haskell-gi という GTK のバインディングがある。これは単純に GTK の C API をラップするだけでなく、モダンな Haskell の開発体験ができるようによく考えられて作られているようだ。 gith…

シェルで関数型プログラミング

2026-01-08T15:44:25+00:00

以前、AWKを超えて：HaskellをUnixパイプラインに持ち込むという記事を書きました。Haskell でパイプライン処理を書く話です。ただ、そもそものアイデアはこの記事の内容でした。ログを grep や awk で漁っていると、「これ、filter して map して fold してるだけだな」と気づいたのが始まりです。シェルでの関数型プログラミングの基本は、改行区切りのテキストをリストとして捉えることです。 a b c これを ["a", "b", "c"] と見なせば、あとは map, filter, fold を適用するだけです。構造化ログや専用ツールがある時代ですが、...

関数型プログラミングの疑問「副作用を起こさないプログラムなんてありえない」

2025-12-29T01:01:01+00:00

関数型プログラミングについて全く知らなかった過去の自分の疑問に答えます。関数型言語のプロからすると笑っちゃうような疑問だとは思いますが、なかなか初学者には答えにたどり着けませんでした。「Haskellはいいぞ」と言われても分からなかったあの頃 10年以上前の話だと思うんですが、プログラマーの師匠みたいな人に「Haskellいいぞ。主要言語にする必要はないけど、考え方は取り入れた方が良い」と言われて勉強しようとしたことはありました。ただ、当時は入門書もそこまで多くなく、ネット記事も充実していなかったので、初学者の自分は良さがわからずに断念しました。で、その時に文法の難しさとか以...

GHCへの私の貢献2025

2025-12-28T12:53:38+00:00

私はここ数年、Haskellの主要な処理系であるGHCに趣味で貢献しています。この記事では、今年（2025年）行なった貢献を紹介します。バグ報告のみ（修正は他の人）のものも含みますが、その場合はその旨を書いています。去 […]

各言語特有っぽい構文: Haskell

2025-12-23T16:58:30+00:00

この記事はプログラミング言語の特有構文 Advent Calendar 2025 14 日目の記事です。個人的な好みを交えて紹介します。二分探索のサンプルコード言語の特徴をあえて使い実装している。 -- Haskell - ガード + パターンマッチ + モナド import Data.Maybe (fromMaybe) binarySearch :: Ord a => [a] -> a -> Maybe Int binarySearch arr target = go 0 (length arr - 1) where go left right ...

HaskellとWin32 APIでウィンドウを表示する

2025-12-23T15:00:04+00:00

これは「Haskell Advent Calendar 2025」24日目の記事です。 GHCのSystem.Win32モジュールを使うことでHaskellからWin32 APIを呼び出すことができます。このSystem.Win32モジュールを使って、簡単なウィンドウ表示を試します。単純なウィンドウ表示までの手順の全体像 HaskellでSystem.Win32を使ったウィンドウ表示を試す前に、単純なウィンドウ表示のプログラムをCで書いた場合の処理の流れをおさらいしておきます。処理の流れは以下のようになります。 #include <windows.h> int WIN...

なぜ3次元回転はいろいろなのか：完全ガイドと実装tips

2025-12-23T11:12:51+00:00

概要 3次元回転はいろいろなやり方がある。回転行列に始まり、ロドリゲスの回転公式やらクォータニオンやら。なぜかくもややこしいのだろうか。この記事では3次元回転のややこしさに迫り、いろいろな手法を見通しよく統一的に導入する。アウトラインの描出を旨とし個別の概念の包括的な定義や説明、導出はしない。また各々の換算公式を逐一計算することはしないが、グレブナー基底を用いた導出方法や実用上の注意点、とくに角速度ベクトルとの関係についてはコメントする。最後にこうした同一概念の異なる表現をうまく扱う方法をJulia, Python, Haskellで紹介する。またアニメーションの作成方法についても添...

高階作用にも対応しconduitも使えるエフェクトシステムであるYafteeの紹介

2025-12-22T08:46:34+00:00

Haskell advent calendar 2025の23日目の記事です。はじめに今年は高階作用にも対応しconduitも使えるエフェクトシステムであるYafteeを紹介します。例題のコードはここエフェクトシステムとは端的に言うといろいろなモナドの機能を、ひとつのモナドのなかで使うやりかた。たとえば状態モナドと例外モナドの機能を両方使いたいとか。そのようなやりかたとしては古典的にはモナド変換子が使われていた。モナド変換子という仕組みではモナドの機能を積み重ねていく。使うモナドの機能が増えてくると層が多くなり見通しが悪くなる。lift . lift $ lift do...

HaskellでAtCoderやってたけどやっと茶色コーダーになれたので振り返り

2025-12-21T08:49:10+00:00

この記事はHaskell Advent Calender 2025の記事になります。なんの記事？今年もAtCoderでHaskell頑張ったので1年間振り返りの記事です。 2025年の成果 2年近くかかってやっと茶色になりました！とても長かった… なんとか成長できたのでよかったことにします👍 やってきたこと今年やってきたことを振りかってみます AtCoder C埋めまずは脱灰のために300以降のC埋めをしました。一部を除いてほとんど全て解いています。 https://kenkoooo.com/atcoder/#/table/flowert NoviSteps...

FunctorチュートリアルとBiinvariant Opticsへの展望

2025-12-17T11:24:45+00:00

はじめに/ロードマップ関数型言語の一部にはモナドっていう、難しくて、人々が苦しんでて、わかった暁にはかならずチュートリアルを書きたくなるものがあるらしいですね。この記事はモナドチュートリアルではありません。個人的には難しいのってモナド自体というよりむしろ、仰々しい名前のついたフワッとした抽象、特に高階型まわりのあれやこれや、というジャンルだと思っています。その代表例で、まだシンプルなやつであるFunctorというのがあります。前半は、ゆっくりとFunctorのチュートリアルを行います。だんだんギアをあげて隣接する概念に手を伸ばし、今アツい概念であるProfunctor O...

ダンジョン生成に一様分布を求めるのは間違っているだろうか

2025-12-16T23:29:21+00:00

これは FOLIO Advent Calendar 2025 17日目の記事です。誰でも一度は魔王になって、勇者のくせになまいきだと、侵入者を撃退するためのダンジョン作りに興じたことがあるでしょう。ダンジョン（長いので以降は迷路と呼ぶ）は古くからある定番コンテンツなだけあって、自動的な生成アルゴリズムにも棒倒し法や穴掘り法など様々なものがあります。しかしアルゴリズムによっては長い直線だらけの通路ができてしまったり、反対に行き止まりが多くなってしまったりと生成される迷路に偏りが生じることも知られています。そこで本稿ではちょっと視点を加えて、特定のパターンに偏りがない完全に公平な迷路生成...

TypeScript使いがHaskellに入門して、プログラミングパラダイムの「解像度」が上がった話

2025-12-15T04:53:44+00:00

こんにちは、ココナラで Web エンジニアをしている慕狼ゆに (しのがみゆに) (@yuni_shinogami) です。こちらは株式会社ココナラ Advent Calendar 2025 15 日目の記事です。普段は業務で TypeScript を書いていますが、今回は技術的な How-to ではなく、「あえて Haskell に入門してみた」という個人の学習記録を書きたいと思います。「なぜ今さら Haskell？」と思われるかもしれませんが、普段 TypeScript を書いている人間が、Haskell を学習することで、どのように普段使っている言語（JavaScript/T...

クロックパズルを単因子論で解く

2025-12-11T22:47:16+00:00

これは「Haskell Advent Calendar 2025」12日目の記事です。タイトルにクロックパズルと銘打ちましたが、このパズルの本当の名前を私は知りません（知ってたら教えて下さい）。パズルというのは例えば、以下のように左、中央、右にそれぞれ3時間と4時間と5時間を計る時計があり、時計の針は 1,2,3 を指しているとします。それぞれの押しボタンを押すと時計の針は以下のように動きます。押しボタン a を押すと、左の時計の針が2時間進み、中央の時計の針が1時間進む押しボタン b を押すと、中央の時計の針が2時間進み、右の時計の針が3時間進む押しボタン c を押すと...

簡単なHaskellのみでServant並に高機能なライブラリーを作ろうとした振り返り

2025-12-07T00:00:00Z

この記事はHaskell Advent Calendar 2025の7日目の記事です。

本日は、「Haskell製ウェブアプリケーションフレームワークを作る配信」で配信していた、Haskell製ウェブアプリケーションフレームワークを作るプロジェクトについて振り返ります。Servantのような型安全なAPI定義を、（Servantのような）高度な型レベルプログラミングも、（Yesodのような）TemplateHaskellもなしに可能にするライブラリーを目指していましたが、開発を途中で止めることにしました。その振り返り — とりわけ、そのゴールに基づいて実装するのが困難だと分かった機能などを中心にまとめます。

Contents

Link to
here動機

そもそも、Haskellには既にServantやYesod、Scottyといった人気のフレームワークがあるにもかかわらず、なぜ新しいフレームワークを作ろうと思ったのでしょうか。第1に、かつて私が「Haskellの歩き方」という記事の「Webアプリケーション」の節で述べた、次の問題を解決したかったから、という理由があります:

ただしServant, Yesod, 共通した困った特徴があります。それぞれがHaskellの高度な機能を利用した独特なDSLを提供しているため、仕組みがわかりづらい、という点です。 Servantは、「型レベルプログラミング」と呼ばれる、GHCの言語拡張を使った仕組みを駆使して、型宣言だけでREST APIの仕様を記述できるようにしています。 YesodもGHCの言語拡張をたくさん使っているのに加え、特に変わった特徴として、TemplateHaskellやQuasiQuoteという仕組みを利用して、独自のDSLを提供しています。それぞれ、見慣れたHaskellと多かれ少なかれ異なる構文で書かなければいけない部分があるのです。つまり、これらのうちどちらかを使う以上、どちらかの魔法を覚えなければならないのです。

この「どちらかの魔法を覚えなければならない」という問題は、初心者がHaskellでウェブアプリケーションを作る上で大きな壁になりえます。入門書に書いてあるHaskellの機能だけでは、ServantやYesodなどのフレームワークで書くコードを理解できず、サンプルコードから雰囲気で書かなければならないのです。これが、新しいフレームワークを作ろうとした一番の動機です。

その他、このフレームワークを開発し始めるより更に前から開発・執筆している、「失敗しながら学ぶHaskell入門」をウェブアプリケーションとして公開する際のフレームワークとしても使おうという考えもありました。「失敗しながら学ぶHaskell入門」はタイトルの通りHaskell入門者のためのコンテンツです。そのため、Haskellを学習したばかりの人でも簡単に修正できるフレームワークにしたかったのです。

Link to
hereできたもの

ソースコードはこちら👇️にあります。名前は仮に「wai-sample」としました。

igrep/wai-sample: Prototype of a new web application framework based on WAI.

YouTubeで配信する前から行っていた（私の前職である）IIJの社内勉強会中の開発と、全128回のYouTubeでのライブコーディングを経て（一部配信終了後に手を入れたこともありましたが）、次のような構文でウェブアプリケーションを記述できるようにしました:

{-# LANGUAGE DataKinds         #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeApplications  #-}

import WaiSample

sampleRoutes :: [Handler]
sampleRoutes =
  [ -- ... 中略 ...

    -- (1) 最も単純な例
  , get @(PlainText, T.Text) "aboutUs" (path "about/us") (\_ -> return "About IIJ")

    -- (2) ステータスコードを指定した例
  , get @(WithStatus Status503 PlainText, T.Text) "maintenance" (path "maintenance")
      (\_ -> return "Sorry, we are under maintenance")

  -- ... 中略 ...

    -- (3) パスをパースして含まれる整数を取得する例
  , get @(PlainText, T.Text)
      "customerTransaction"
      ( (,) <$> (path "customer/" *> decimalPiece)
            <*> (path "/transaction/" *> paramPiece)
        )
      (\(cId, transactionName) ->
        return $ "Customer " <> T.pack (show cId) <> " Transaction " <> transactionName
        )

  -- ... 中略 ...
  ]

※完全なサンプルコードはWaiSample/Sample.hsをご覧ください。上記はその一部に説明用のコメントを加えています。

上記のサンプルコードにおけるsampleRoutesが、Web APIの仕様を定めている部分です:

sampleRoutes :: [Handler]

Handlerという型のリストで、それぞれのHandlerには、Web APIのエンドポイントを表すのに必要な情報が全て含まれています。wai-sampleでは、このHandlerのリストを解釈してWAIベースのサーバーアプリケーションを実行したり、Template Haskellを通じてクライアントコードを生成したり、はたまたサーバーアプリケーションのドキュメントを生成したりすることができるようになっています。

Link to
here(1) 最も単純な例

get @(PlainText, T.Text) "aboutUs" (path "about/us") (\_ -> return "About IIJ")

先程のサンプルコードから抜粋した最も単純な例↑では、get関数を使ってエンドポイントを定義しています。get関数は名前のとおりHTTPのGETメソッドに対応するエンドポイントを定義します。TypeApplications言語拡張を使って指定している(PlainText, T.Text)という型が、このエンドポイントが返すレスポンスの型を表しています。ここでは、getに渡す最後の引数に当たる関数（Responderと呼びます。後述します）がレスポンスボディーとして返す型をお馴染みのText型として指定しつつ、サーバーやクライアントが処理する際はMIMEタイプをtext/plainとして扱うように指定しています。

get関数の（値の）第1引数では、エンドポイントの名前を指定しています。この名前は、後述するクライアントコードを生成する機能において、関数名の一部として使われます。

get関数の第2引数は、エンドポイントのパスの仕様を表すRoute型の値です。この例では、path関数を使って"about/us"という単純な文字列を指定しています。結果、このエンドポイントのパスは/about/usとなります¹）。

get関数の最後の引数が、このエンドポイントがHTTPリクエストを受け取った際に実行する関数、Responderです。ここでは、単純にレスポンスボディーとして文字列を返すだけの関数を指定しています。

Link to
here(2) ステータスコードを指定した例

get @(WithStatus Status503 PlainText, T.Text) "maintenance" (path "maintenance")
  (\_ -> return "Sorry, we are under maintenance")

デフォルトでは、get関数で定義したエンドポイントはやっぱりステータスコード200（OK）を返します。この挙動を変えるには、先程指定したレスポンスの型のうち、MIMEタイプを指定していた箇所をWithStatus型でラップしましょう。型引数で指定しているタプルの1つ目の要素は、このようにHTTPのレスポンスに関する仕様をHaskellの型で指定するパラメーターとなっています。

この例では、Status503という型を指定しているため、HTTPステータスコード503（Service Unavailable）を返すエンドポイントを定義しています。

Link to
here(3) パスの中に含まれる整数を処理する例

よくあるWebアプリケーションフレームワークでは、パスの一部に含まれる整数など、文字列型以外の値を取得するための仕組みが用意されています。

Haskellにおいて、文字列から特定の型の値を取り出す…といえばそう、パーサーコンビネーターですね。wai-sampleでは、サーバーが受け取ったパスをパーサーコンビネーターでパースするようになっています。従って下記の例では、/customer/123/transaction/abcというパスを受け取った場合、123と"abc"をタプルに詰め込んでResponderに渡すパスのパーサーを定義しています:

get @(PlainText, T.Text)
  "customerTransaction"
  ( (,) <$> (path "customer/" *> decimalPiece)
        <*> (path "/transaction/" *> paramPiece)
    )
  (\(cId, transactionName) ->
    return $ "Customer " <> T.pack (show cId) <> " Transaction " <> transactionName
    )

実際のところここまでの話はRoute型の値をサーバーアプリケーションが解釈した場合の挙動です。Route型はパスの仕様を定義するApplicativeな内部DSLとなっています。これによって、サーバーアプリケーションだけでなくクライアントのコード生成機能やドキュメントの生成など、様々な応用ができるようになっています。詳しくは後述しますが、例えばクライアントのコード生成機能がRoute型の値を解釈すると、decimalPieceやparamPieceなどの値は生成した関数の引数を1つずつ追加します。

Link to
hereContent-Typeを複数指定する

Ruby on Railsのrespond_toメソッドなどで実現できるように、1つのエンドポイントで1つの種類のレスポンスボディーを、複数のContent-Typeで返す、といった機能は昨今のWebアプリケーションフレームワークではごく一般的な機能でしょう。wai-sampleの場合、例えば次のようにして、Customerという型の値をJSONやapplication/x-www-form-urlencodedな文字列として返すエンドポイントを定義できます:

sampleRoutes =
  [ -- ... 中略 ...
  , get @(ContentTypes '[Json, FormUrlEncoded], Customer)
  -- ... 中略 ...
  ]

これまでの例ではgetの型引数においてMIMEタイプを表す箇所に1つの型のみ（PlainText型）を指定していましたが、ここでは代わりにContentTypesという型を使用しています。ContentTypes型コンストラクターに、MIMEタイプを表す型の型レベルリストを渡せば、レスポンスボディーを表す1つの型に対して、複数のMIMEタイプを指定できるようになります。

なお、JsonやFormUrlEncodedと一緒に指定したCustomer型は、当然ToJSON・FromJSONやToForm・FromFormといった型クラスのインスタンスである必要があります²。レスポンスボディーとして指定した型が、同時に指定したMIMEタイプに対応する形式に変換できることを、保証できるようになっているのです。

Link to
hereサーバーアプリケーションとしての使い方

ここまでで定義したHandler型の値、すなわちWeb APIのエンドポイントの仕様に基づいてサーバーアプリケーションを実行するには、次のように書きます:

import Network.Wai              (Application)
import Network.Wai.Handler.Warp (runEnv)

import WaiSample.Sample         (sampleRoutes)
import WaiSample.Server         (handles)


sampleApp :: Application
sampleApp = handles sampleRoutes


runSampleApp :: IO ()
runSampleApp = runEnv 8020 sampleApp

ℹ️こちらにあるコードと同じ内容です。

get関数などで作ったHandler型のリストをhandles関数に渡すと、WAIのApplication型の値が出来上がります。Application型はWAIにおけるサーバーアプリケーションを表す型で、ServantやYesodなど他の多くのHaskell製フレームワークでも、最終的にこのApplication型の値を作るよう設計されています。上記の例はApplication型の値をWarpというウェブサーバーで動かす場合のコードです。Application型の値をWarpのrunEnv関数に渡すことで、指定したポート番号でアプリケーションを起動できます。

ここで起動したサーバーアプリケーションが、実際にエンドポイントへのリクエストを受け取った際実行する関数は、get関数などの最後の引数にあたる関数です。その関数はSimpleResponderという型シノニム³が設定されており、次のような定義となっています:

type SimpleResponder p resObj = p -> IO resObj

ℹ️こちらより

型パラメーターpは、エンドポイントのパスに含まれるパラメーターを表す型です。これまでの例でget関数に渡した(path "about/us")や((,) <$> (path "customer/" *> decimalPiece) <*> (path "/transaction/" *> paramPiece))という式で作られる、Route型の値を解釈した結果の型pです。

そしてresObjは、エンドポイントが返すレスポンスボディーの型です。これまでの例でいうと、get関数の型引数で指定した(PlainText, T.Text)におけるT.Text型、(ContentTypes '[Json, FormUrlEncoded], Customer)におけるCustomer型が該当します。

runSampleAppは各Handler型の値を解釈し、サーバーアプリケーションとして実行します。エンドポイントのパスの仕様（(path "about/us")など）をパーサーコンビネーターとして解釈し⁴、パースが成功したHandlerが持つSimpleResponder（p -> IO resObj）を呼び出します。そしてSimpleResponderが返したresObjを、クライアントが要求したMIMEタイプに応じたレスポンスボディーに変換し、クライアントに返す、という流れで動くようになっています。

Link to
hereTemplate Haskellによる、クライアントの生成

サーバーアプリケーションの定義だけであれば、Haskell以外のものも含め、従来の多くのウェブアプリケーションフレームワークでも可能でしょう。しかしServantを始め、昨今におけるREST APIの開発を想定したWebアプリケーションフレームワークは、クライアントコードを生成する機能まで備えていることが多いです。wai-sampleはそうしたフレームワークを目指しているため、当然クライアントコードの生成もできるようになっています:

{-# LANGUAGE DataKinds        #-}
{-# LANGUAGE TemplateHaskell  #-}
{-# LANGUAGE TypeApplications #-}

import WaiSample.Client
import WaiSample.Sample


$(declareClient "sample" sampleRoutes)

ℹ️こちらからほぼそのままコピペしたコードです。

上記の通り、クライアントコードの生成はTemplateHaskellを使って行います。「簡単なHaskellのみで作る」という目標からは早くも外れてしまいますが、生成されるコードが十分に予測しやすいものであろうことや、考え得る限り何らかの形で「難しいHaskell」を使わなければ実装できないだろうという推察から、TemplateHaskellを使うことにしました。

declareClientという関数に、生成する関数の名前の接頭辞（prefix）とこれまで定義したHandler型のリスト（sampleRoutes）を渡すと、次のような型の関数の定義を生成します⁵:

sampleAboutUs :: Backend -> IO Text
sampleMaintenance :: Backend -> IO Text
sampleCustomerTransaction :: Backend -> Integer -> Text -> IO Text

生成された関数は、get関数などの第1引数として渡した関数の名前に、declareClientの第1引数として渡した接頭辞が付いた名前で定義されます。

生成された関数の第1引数、Backend型は、クライアントがサーバーアプリケーションに実際にHTTPリクエストを送るための関数です。次のように定義されています:

import qualified Data.ByteString.Lazy.Char8 as BL
import qualified Network.HTTP.Client        as HC

type Backend = Method -> Url -> RequestHeaders -> IO (HC.Response BL.ByteString)

このバックエンドを、例えばhttp-clientパッケージの関数を使って実装することで、生成された関数がサーバーアプリケーションにリクエストを送ることができます。以下は実際にhttp-clientパッケージを使って実装したバックエンドの例です:

import qualified Network.HTTP.Client        as HC
import qualified Data.ByteString.UTF8       as BS

httpClientBackend :: String -> Manager -> Backend
httpClientBackend rootUrl manager method pathPieces rawReqHds = do
  req0 <- parseUrlThrow . BS.toString $ method <> B.pack " " <> BS.fromString rootUrl <> pathPieces
  let req = req0 { HC.requestHeaders = rawReqHds }
  httpLbs (setRequestIgnoreStatus req) manager

ℹ️こちらからほぼそのままコピペしたコードです。

Backend型以外の引数は、パスパラメーターを始めとする、HTTPリクエストを組み立てるのに必要な情報です。get関数などでHandler型の値を定義する際に指定したdecimalPieceやparamPieceをdeclareClient関数が回収して、生成した関数の引数に追加します。実際に生成した関数が受け取った引数は、もちろんパスの一部として当てはめるのに用います。

生成した関数の戻り値は、サーバーからのレスポンスを表す型です。get関数の型引数として渡した(PlainText, T.Text)や(ContentTypes '[Json, FormUrlEncoded], Customer)などにおけるT.TextやCustomerがそれに当たります。クライアントの関数はサーバーからのレスポンスを、MIMEタイプを表す型などに従って、この型に変換してから返すよう実装されているのです。

Link to
hereドキュメントの生成

ServantではOpenAPIに則ったドキュメントを生成するパッケージがあるように、Haskellの構文で定義したREST APIの仕様から、APIのドキュメントを生成する機能があると便利でしょう。wai-sampleでも、Handler型のリストからAPIのドキュメントを生成する機能を実装しました — 残念ながら完成度が低く、とても実用に耐えるものではありませんが。

ともあれ、試しに使ってみましょう。これまで例として紹介したsampleRoutesの各HandlerにshowHandlerSpecという関数を適用すると、次のように各エンドポイントへのパスやリクエスト・レスポンスの情報を取得することが出来ます:

> mapM_ (TIO.putStrLn . showHandlerSpec) sampleRoutes
index "GET" /
  Request:
    Query Params: (none)
    Headers: (none)
  Response: (PlainText,Text)

maintenance "GET" /maintenance
  Request:
    Query Params: (none)
    Headers: (none)
  Response: ((WithStatus Status503 PlainText),Text)

aboutUs "GET" /about/us
  Request:
    Query Params: (none)
    Headers: (none)
  Response: (PlainText,Text)

-- ... 中略 ...

customerTransaction "GET" /customer/:param/transaction/:param
  Request:
    Query Params: (none)
    Headers: (none)
  Response: (PlainText,Text)

createProduct "POST" /products
  Request:
    Query Params: (none)
    Headers: (none)
  Response: (PlainText,Text)

-- ... 以下略 ...

…が、前述の通りあまりに完成度が低いので、詳しくは解説しません。実際に上記のコード実行すると、Responseの型などがとても人間に読めるような出力になっていないことが分かります。今どきのWeb APIフレームワークであればOpenAPIに則ったドキュメントを生成する機能が欲しいでしょうが、それもありません。この方向で拡張すれば実装できるとは思いますが、次の節で述べるとおり開発を止めることにしたので、ここまでとしておきます。

Link to
here何故開発を止めるのか

開発をやめる最も大きな理由は、冒頭でも触れたとおり、当初考えていたゴールを達成するのが難しいと判断したからです⁶。wai-sampleのゴールは、「Servantのような型安全なAPI定義を、（Servantのような）高度な型レベルプログラミングも、（Yesodのような）TemplateHaskellもなしに可能にするライブラリー」にすることでした。ところが、後述の通りいくつかの機能においてそれが無理ではないか（少なくとも難しい）ということが発覚したのです。

Link to
here想定通りにできなかったもの: レスポンスに複数のパターンがあるとき

「できたもの」の節では割愛しましたが、wai-sampleでは、サーバーが返すレスポンスに複数のケースがあるエンドポイント — 例えば、一方ではステータスコード200 OKと共に取得できたリソースの情報を返しつつ、一方では403 Forbiddenと共にエラーメッセージを返す — の実装もサポートしています。例えば次のように書けば、/customer/:id.txtというパスで複数の種類のレスポンスを返すエンドポイントを定義することが出来ます:

get @(Sum '[(PlainText, T.Text), Response (WithStatus Status503 PlainText) T.Text])
      "customerIdTxt"
      -- /customer/:id.txt
      (path "customer/" *> decimalPiece <* path ".txt")
      (\i ->
        if i == 503
          then return . sumLift $ Response @(WithStatus Status503 PlainText) ("error" :: T.Text)
          else return . sumLift $ "Customer " <> T.pack (show i))

ℹ️こちらからほぼそのままコピペしたコードです。

get関数の型引数に、随分仰々しい型が現れました。Sumという型は、名前のとおり和型を作ります。型レベルリストの要素としてContent-Typeやステータスコードを表す型と、実際のレスポンスボディーの型を組み合わせたタプル（あるいは後述するResponse型）を渡すことで、複数のケースを持つレスポンスの型を定義しています。上記の例におけるSum '[(PlainText, T.Text), Response (WithStatus Status503 PlainText) T.Text]は、次の2つのケースを持つレスポンスの型を表しています:

ステータスコードが（デフォルトの）200 OKで、Content-Typeがtext/plain、レスポンスボディーを表す型がText型
ステータスコードが503 Service Unavailableで、Content-Typeがtext/plain、レスポンスボディーを表す型がText型

以上のように書くことで実装できるようにはしたのですが、これによって当初の目的である「高度な型レベルプログラミングなしに実装する」という目標から外れてしまいました。型レベルリストは「高度な型レベルプログラミング」に該当すると言って差し支えないでしょう。

なぜこのようなAPIになったのかというと、Web APIに対する「入力」に当たる、パスのパース（や、今回は実装しませんでしたがリクエストボディーなどの処理も）などと、Web APIからの「出力」に当たるレスポンスの処理では、実行時に使える情報が大きく異なっていたからです。「入力」は値レベルでも（高度な型レベルプログラミングなしで）Free Applicativeを応用したDSLを使えば⁷、サーバーアプリケーション・クライアントコード・ドキュメント、いずれにも実行時に解釈できるフレームワークにできた一方、レスポンスボディーなど「出力」の型は値レベルのDSLを書いても、サーバーアプリケーションを実行しない限りそれに整合しているかどうかが分からない、という原理的な問題が判明したからです。

例えば、レスポンスボディーの仕様を次のような内部DSLで定義できるようにしたとします:

get [(plainText, text), ((withStatus status503 plainText), text)]
    -- ...

型レベルプログラミングバージョンでは型引数に渡していた情報を、ほぼそのまま値レベルに落とし込んだものです。しかしこのように書いたとしても、サーバーアプリケーションを起動して、実際にクライアントからリクエストを受け取り、それに対してgetに渡した関数（Responder）がレスポンスの元となる値を返すまで、レスポンスボディーの型が正しいかどうか、検証できないのです。「レスポンスの元となる値」の型はライブラリーのユーザー自身がResponderで返す値の型ですし、実行時以前にコンパイル時に保証できていて欲しいものです。これが、値レベルのDSLを採用した場合の限界です。

それから、型レベルリストを使ったこと以外においても、複雑で分かりづらい要因があります。先程から少し触れているとおり、Content-Typeやステータスコードとレスポンスボディーの型を組み合わせを表すのに、タプル以外にもResponseという型を用いています。Response型とタプル型はいずれもResponseSpec（下記に転載）という型クラスのインスタンスとなることで、「Content-Typeやステータスコード」を表す型（ResponseType）とResponderがレスポンスボディーとして返す型（ResponseObject）を宣言することが出来ます:

class ResponseSpec resSpec where
  type ResponseType resSpec
  type ResponseObject resSpec

instance ResponseSpec (resTyp, resObj) where
  type ResponseType (resTyp, resObj) = resTyp
  type ResponseObject (resTyp, resObj) = resObj

instance ResponseSpec (Response resTyp resObj) where
  type ResponseType (Response resTyp resObj) = resTyp
  type ResponseObject (Response resTyp resObj) = Response resTyp resObj

ResponseSpec (resTyp, resObj)とResponseSpec (Response resTyp resObj)の2つのインスタンスの違い、分かるでしょうか？まるで間違い探しですよね…😥。タプル型もResponse型もgetなどに渡す型レベルリストでの役割はほぼ同じで、最初はタプルだけをとることにしていたのですが、やむを得ない理由があってResponseを別途設けることにしました⁸。こうした分かりづらい部分が出来てしまったのも、失敗の1つです。

Link to
hereパスのパーサー: 実は`<$>`がすでに危ない

パスのパーサーを値レベルの、Applicativeな内部DSLとして実装した結果、Servantと比べて型安全性を損なってしまうという問題があることも、作ってから気付きました。例えば、次のように<$>に渡す関数としてコンストラクターでない、普通の関数を渡した場合です:

path "integers/" *> (show <$> decimalPiece)

decimalPieceはRoute Integerという型で、それにshow <$>を適用した結果はRoute Stringとなります。Route Stringは、パスの一部として文字列を受け取ることを表す型ですから、上記の式はintegers/<任意の文字列>というパスを表すことになります。ところが！実際にサーバーアプリケーションがパスをパースするのに使っているのはdecimalPieceなので、整数でなければなりません。このように<$>を使うだけで、Route Stringという型が表すパスのパーサーと、実際にパースできるパスの仕様が食い違ってしまうことがあります。Applicative（厳密に言えばFunctorの機能ですが）を使ったDSLである以上、こうしたことが防げないのです。

まあ、実は同じ問題が同じようにApplicativeベースの内部DSLを使った他のライブラリーにもあるでしょうから、敢えて気にしない、という手もあるのかも知れませんが。ちなみに、似たような問題を解決するためrelational-recordというパッケージではFunctorやApplicativeは使わず、product-isomorphicというパッケージで、言わば「コンストラクターだけが適用できるFunctor・Applicative」とも言うべき専用の型クラスを作ることで解決していました。wai-sampleもこれを使えないかと企みましたが、どうもうまく適用できなかったため諦めました。

Link to
here実装し切れなかったもの

ウェブアプリケーションフレームワークとして実装すべき機能のうち、実装し切れなかったものは当然たくさんあります。例えば以下のような機能でしょう:

HTTPリクエストに関わるもの:
- リクエストヘッダーの処理
- クエリーパラメーターの処理
- （この辺りは、リクエストボディーの処理と似たような要領で実装できるはず）
HTTPレスポンスに関わるもの:
- 動的なHTMLの配信
- ファイルシステムにあるファイルの配信
- （REST APIに特化したフレームワークであればこれらは不要でしょうが、拡張として簡単に追加できるようにはしたいですね）
両方に関わるもの:
- Cookieの読み書き
ドキュメント生成に関わるもの:
- OpenAPIに準拠したドキュメント生成
などなど！

Link to
here類似のライブラリー・解決策

手が遅いもので、私が最初にwai-sampleのリポジトリーに対して行った最初のコミットから、既に約5年の歳月が過ぎました⁹。当時は私の前職、IIJにおける社内勉強会のネタとして始めたのが懐かしいです。私が知る限り、当時はwai-sampleのように「値レベルのプログラミングで」「Servantのように1つの定義からクライアントやドキュメントの生成も出来る」ことを目指したライブラリーはなかったように思います。しかし実際のところ、執筆時点で次のライブラリーが類似の機能を実装しているようです。これらのライブラリーがいつ開発を始めたのかは分かりませんが、やはり私がwai-sampleを作り始めた時点で同じような問題意識を持った人はいたのでしょう。

Link to
hereOkapi

OkapiにあるEndpointという機能は「An Endpoint is an executable specification representing a single Operation that can be taken against your API.」と謳っているとおり、APIの仕様を表現する内部DSLを提供します。しかもこれから紹介するとおり、wai-sampleより幾分洗練されているように見えます。

Okapiでは下記のEndpointという型 — wai-sampleでいうHandlerに相当するようです — に、「Script」と呼ばれる値レベルDSLを設定して使うようです:

data Endpoint p q h b r = Endpoint
  { method :: StdMethod
  , path :: Path.Script p
  , query :: Query.Script q
  , body :: Body.Script b
  , headers :: Headers.Script h
  , responder :: Responder.Script r
  }

詳細はもちろん公式ドキュメントにも書かれていますが、読んでわかる範囲でこちらでも解説しましょう。Endpoint型の各フィールドは、HTTPリクエスト・レスポンスに関わる各要素の仕様を表しています。methodフィールドを除くすべてのフィールドは、それぞれのフィールドのために作られたScriptという型のApplicative¹⁰なDSLを使って仕様を表現します。Path.Script pはパスの仕様、Query.Script qはクエリーパラメーターの仕様、Body.Script bはリクエストボディーの仕様、Headers.Script hはリクエストヘッダーの仕様、Responder.Script rはレスポンスの仕様、といったところです。

各Script型のうち、特筆すべきはResponder.Scriptでしょう。Responder.Scriptでは、レスポンスの種類毎にレスポンスボディーの型やステータスコード、レスポンスヘッダーの型を、case analysisを表す型として定義できるようになっています。そして、Handler型はEndpoint型が各種Scriptを使って設定した値を使って、実際にResponse型の値を組み立てます:

（⚠️以下のコードは、Okapiのドキュメントにあったサンプルコードを元に、私が推測してコメントを追加したものです。間違っていたらごめんなさい hask(_ _)eller）

-- | Responseにヘッダーを設定する関数群
data SecretHeaders = SecretHeaders
  { firstSecret :: Int -> Response -> Response
  , secondSecret :: Int -> Response -> Response
  }

-- | Responseにヘッダーとボディーを設定する関数群
--   レスポンスの種類毎にフィールドラベルを1つ備えた、case analysisを表す型
data MyResponders = MyResponders
  { allGood :: (SecretHeaders %1 -> Response -> Response) -> Text -> Response
  , notGood :: (() %1 -> Response -> Response) -> Text -> Response
  }

-- | `Responder.Script`として定義する、レスポンスの仕様
myResponderScript = do
  -- allGood の場合はレスポンスボディーは`Text`型で、ステータスコードは200。
  -- レスポンスヘッダーとしては、`IntSecret`と`X-Another-Secret`という
  -- `Int`型の2つのヘッダーを追加する。
  allGood <- Responder.json @Text status200 do
    addSecret <- AddHeader.using @Int "IntSecret"
    addAnotherSecret <- AddHeader.using @Int "X-Another-Secret"
    pure SecretHeaders {..}

  -- notGood の場合はレスポンスボディーは`Text`型で、ステータスコードは501。
  -- レスポンスヘッダーはなし。
  notGood <- Responder.json @Text status501 $ pure ()
  pure MyResponders {..}

-- | Responder.Scriptで定義したcase analysisを表す型、`MyResponders`を使って、
--   レスポンスを組み立てる関数。
--   `someNumber`が100未満なら`allGood`を、そうでなければ`notGood`を使う。
--   この関数が利用していない引数は、`Endpoint`型の他のフィールドに対応するもの。
myHandler someNumber _ _ _ _ (MyResponders allGood notGood) = do
  if someNumber < 100
    then return $ allGood
      (\(SecretHeaders firstSecret secondSecret) response -> secondSecret 0 $ firstSecret 7 response)
      "All Good!"
    else return $ notGood
      (\() response -> response)
      "Not Good!"

wai-sampleがうまく実装できなかった、レスポンスに複数のパターンがある場合の処理を、case analysisを表す型で実装しているのが興味深いですね。前述した「原理的な問題」に対する解決策なのでしょう。

Link to
hereIHP

IHP (Integrated Haskell Platform)は、Haskellで書かれたフルスタックなWebアプリケーションフレームワークです。wai-sampleのような、与えられたパスに基づいて対応する関数を呼び出す機能（ルーティング機能）はもちろんのこと、PostgreSQLと接続するORMやメールの送信、バックグラウンド処理に加えてGUIから管理する機能など、様々な機能を備えています。Architectureを読むと察せられるとおり、古き良きRuby on Railsのようなスタイルのフレームワークのようです。

そんなIHPのルーティング機能、とりわけREST APIの慣習では表現しきれず、カスタマイズしたパスを定義する際の機能は、まさにパスのパーサーコンビネーターを書くことで実装できるようになっています。以下はドキュメントにあった例をそのまま貼り付けています:

-- /posts/an-example-blog-post というような記事の名前(slug)や
-- /posts/f85dc0bc-fc11-4341-a4e3-e047074a7982 というような記事のIDから
-- 記事を表示するアクションを呼び出すルーティング

-- パスにあるパラメーターを表す型
data PostsController
    = ShowPostAction { postId :: !(Maybe (Id Post)), slug :: !(Maybe Text) }


-- CanRoute 型クラスのインスタンスで、
-- パスのパーサーコンビネーターを定義する
instance CanRoute PostsController where
    parseRoute' = do
        string "/posts/"
        let postById = do id <- parseId; endOfInput; pure ShowPostAction { postId = Just id, slug = Nothing }
        let postBySlug = do slug <- remainingText; pure ShowPostAction { postId = Nothing, slug = Just slug }
        postById <|> postBySlug


-- HasPath 型クラスのインスタンスで、
-- パスに含めるパラメーターからパスを生成する関数を定義する
instance HasPath PostsController where
    pathTo ShowPostAction { postId = Just id, slug = Nothing } = "/posts/" <> tshow id
    pathTo ShowPostAction { postId = Nothing, slug = Just slug } = "/posts/" <> slug


action ShowPostAction { postId, slug } = do
    post <- case slug of
            Just slug -> query @Post |> filterWhere (#slug, slug) |> fetchOne
            Nothing   -> fetchOne postId
    -- ...

wai-sampleやOkapiのようにパスの定義を1箇所で済ませられるわけではない（CanRouteとHasPathの2つの型クラスのインスタンスを定義する必要がある）ようですが、パーサーコンビネーターを使って自由にパスを定義できるところは似ていますね。

Link to
here終わりに

wai-sampleは、HaskellでWeb APIを実装するためのフレームワークとして、ServantやYesodのような既存のフレームワークとは異なるアプローチを試みました。残念ながら目標の達成が技術的に困難であることが分かり、開発を止めることにしましたが、HaskellでWeb APIを実装するため新しいアプローチとして、何かしら参考になれば幸いです。

先頭のスラッシュにご注意ください。wai-sampleがRoute型の値を処理する際は、先頭のスラッシュは付けない前提としています。↩︎
諸般の事情で、wai-sampleではhttp-api-dataパッケージをフォークして使っています。そのため、ToForm型クラスなどの仕様がHackageにあるものと異なっています。最終的にwai-sampleを公開する際、フォークしたhttp-api-dataを新しいパッケージとして同時に公開する予定でした。↩︎
名前から察せられるとおりSimpleじゃない普通のResponder型もありますが、ここでは割愛します。Responder型はクエリーパラメーターやリクエストヘッダーなど、パスに含めるパラメーター以外の情報を受け取るためのものです。SimpleResponder型のすぐ近くで定義されているので、興味があったらご覧ください。↩︎
パーサーコンビネーター以外のアプローチ、例えば基数木を使ってより多くのエンドポイントを高速に処理できるようにするのも可能でしょう。↩︎
ghcコマンドの-ddump-splicesオプションを使って、declareClient関数が生成したコードを貼り付けました。みなさんの手元で試す場合はstack build --ghc-options=-ddump-splicesなどと実行するのが簡単でしょう。↩︎
もう1つは、大変申し訳ないですが、私自身のHaskellに対する情熱が落ち込んでしまった、という理由もあります😞。↩︎
今回は詳細を省きましたがFree Applicativeを使ったDSLの実装は、WaiSample.Typesモジュールをご覧ください。↩︎
詳しい理由は面倒なので解説しません！これまでに出てきたコードだけで推測できるはずですし考えてみてください！↩︎
実装に対する最後の修正からも既に1年以上が過ぎました。記録を作るのも遅い…😥↩︎
個人的には、なぜAlternativeにしなかったのかが気になります。Body.optionalやHeaders.optionalなどは文字通りAlternativeのoptionalで実現できそうに見えるからです。↩︎

飛行機の中で Haskell プロジェクトをビルドする

2025-09-11T09:34:22+09:00

いや別に飛行機の中でビルドするのが主題なわけではないのですが、オフラインモードのことを機内モードと言いますからね。最近の飛行機は Wi-Fi の提供があったりするらしいですが。さて、あなたの Haskell プロジェクトをオフラインモードでビルドすることができますか？まあ、今時オフライン環境も珍しいですし「そんな必要あるのか？」という感覚もあるかもしれません。Nix ではビルド再現性のためにオフライン環境でビルドできることが求められます1。 Nix で Haskell プロジェクトをビルドするには Input Output（iohk.io）の作成した haskell.nix が使用されるの…

Shake のキャッシュが効いてなかった

2025-09-03T00:37:06+09:00

下記の記事を覚えていましょうか？ kakkun61.hatenablog.com Shake を使って静的ウェブサイト生成するようにしたことを書いた記事です。ただ、どうも生成が遅いんです。しょっちゅうは更新しないので「まあいいか」と放置していたのですが、最近手を付けることがあったので改善してみました。 fsatrace はどう追跡してくれるのか前方型1の Shake アクションの場合、「fsatrace で変更を追跡する」というようなことがリファレンスに書いてあり、「よく分からんけどそうなんか」ぐらいに思って使っていました。 hackage.haskell.org 実は fsatrace …

「関数の副作用の有無」よりも大事なもの

2025-06-21T07:39:41+00:00

プログラミングをやっていると、「関数に副作用がある」とか「副作用がない」あるいは「純粋である」という話をちょいちょい耳にする。そして、「外界の状態を読み取るけど変更はしない関数」、例えばのような関数に副作用があるか？み […]

関数型まつり 2025 で AWS と定理証明について話してきました

2025-06-17T22:51:30+09:00

こんにちは、チェシャ猫です。先日開催された関数型まつりで、AWS によって開発されたポリシー言語 Cedar と、その開発に使用された定理証明支援系 Lean について登壇してきました。公募 CFP 枠です。 fortee.jp （TODO: 録画が公開されたら貼る）前回登壇との関係 Cedar については、チェシャ猫自身が少し前、PHPerKaigi 2025 でも登壇しています。前回と今回では、扱っている題材は同じですが、想定しているターゲットや興味の方向性が少し異なります。今回の登壇では Lean が保証している意味論的な定理や開発フローなど「Cedar がどのように設計・開発され…

GHCデバッグ日誌 CI編

2025-05-29T13:05:14+00:00

私はHaskell処理系であるGHCに趣味で貢献しています。詳しいことは過去の記事を見てください：今回は、GHCのCIの問題を追求した話をします。前に「GHCデバッグ日誌」という記事を書いたので、今回は「CI編」としま […]

PHPerKaigi 2025 で AWS のポリシー言語 Cedar について話してきました

2025-05-11T23:33:55+09:00

こんにちは、チェシャ猫です。先日開催された PHPerKaigi 2025 で、AWS によって開発されたポリシー言語 Cedar およびそのマネージドサービス版である Amazon Verified Permissions について登壇してきました。公募 CFP 枠です。 fortee.jp www.youtube.com 学習リソースもし、今回のトークを聞いて Cedar や Verified Permissions に興味を持った方がいたら、まずは公式で提供されているワークショップを触ってみることをお勧めします。ワークショップは以下の二種類があります。 Cedar policy la…

GHCのSIMDサポートの進捗：整数ベクトルの演算

2025-04-02T13:14:37+00:00

ブログ等にちょいちょい書いていますが、私はこの数ヶ月ほどGHCのSIMDサポートの改善を進めています。この3ヶ月間はx86 NCGで整数のSIMD演算を使えるようにするパッチを書いており、数日前にマージされました。一つ […]

never型があると便利か（言語処理系実装者の観点から）

2025-03-18T11:02:42+00:00

TypeScriptをはじめとするいくつかのプログラミング言語には、never型という型がある。この型は典型的には「制御を返さない関数」の返り値として使われる： never型は型システム的には「値を持たない型」「任意の型 […]

Haskellで雑にA/Bテストの検定

2025-01-11T21:35:14+09:00

年に一度くらいは Haskell で A/B テストの検定をしたくなるでしょう。普段は R とか Python とか表計算ソフトで済ますにしても人生時にはそのようなゆとりも必要です。 Haskell環境の準備 Haskellスクリプティング A/Bテストの設定 Haskellでカイ二乗検定補足: chi2testの自由度引数の意味参考文献 Haskell環境の準備 PC が吹っ飛んだので Haskell 環境がありません。まず Haskell 環境から準備します。 ……とは言っても GHCup を入れて質問にポチポチ回答するだけで GHC や Cabal や Stack や Haskell…

GHCへの私の貢献2024

2024-12-24T01:34:44+00:00

この記事はHaskell Advent Calendar 2024の24日目の記事です。私はここ数年、Haskellの主要な処理系であるGHCに趣味で貢献しています。この記事では、今年（2024年）行なった貢献を紹介し […]

コンパイル時定数しか受け付けない引数

2024-12-15T09:18:12+00:00

普通のプログラミング言語の普通の関数は、実行時に決まる値を受け取ることができます。これに対して、「コンパイル時に決まる値しか受け付けない引数」を表現できると便利な場面があるのではないかと思うことが最近ありました。動機 […]

YAPC::Hakodate 2024 で様相論理について話してきました

2024-10-09T00:18:34+09:00

こんにちは、チェシャ猫です。先日開催された YAPC::Hakodate 2024 で、様相論理について登壇してきました。公募 CFP 枠です。 fortee.jp しばらく後に録画アーカイブも公開される予定です。質問への回答当日は、ありがたいことに会場で何名かの方が質問を出してくれました。回答をまとめておきます。 EG φ の検査アルゴリズムにおいて、φ が真になるような強連結成分が複数見つかった場合はどうするのか？ EG φ が真になるのは「その状態から始まって φ を満たし続ける無限パスが存在するとき」なので、そのようなパスが複数見つかっても真偽に影響はありません。もし実装するの…

[ThinkPad] タッチパッド（trackpoint）の中央ボタンをマウスの中ボタンにアサインする方法

2024-07-21T22:34:54.908+09:00

ThinkPadでタッチパッド（trackpoint）の中央ボタンをマウスの中ボタンにアサインする方法です。忘れそうなのでメモ。「設定」→「マウス」を開き「ELAN TrackPoint for ThinkTrackPoint」の「TrackPoint settings」を開く。開いた「ELAN TrackPoint for ThinkTrackPoint」の「中央ボタン」のリストボックすのデフォルトが「スクロール」になっている。これを「中ボタン」に変更すると、中ボタンクリック挙動になる。※ 公式ページ（リンク）では、「その他のマウスオプション」で表示されるダイアログに「ThankPad」タブが表示される、とあるが、2024.07.19現在、Windows10 22H2では表示されないので注意が必要。

#技術書典 16 で Go を使って #自作モデル検査器をつくる本を頒布します

2024-05-25T20:43:50+09:00

こんにちは、チェシャ猫です。今回、技術書典 16 にて、新刊『モデル検査器をつくる〜Goで実装して学ぶ形式手法〜』を頒布します。 techbookfest.org どんな本？ただツールを使うだけの形式手法から、君の手でつくる形式手法へ。Go 言語でモデル検査器を実装しながら学ぼう！書名の通り、Go でモデル検査器を実装する本です。Pramo 言語と名づけた本書オリジナルのモデリング言語を定義し、その可視化器と検査器を作成します。 Pramo 言語は、ある種のマルチスレッドをサポートするプログラミング言語であり、Go の埋め込み DSL として記述されます。例えば有名な「食事する哲学者」は…

技術書典16に、Haskellでの型レベルプログラミングの本を出します

2024-05-16T10:13:30+00:00

今度の5月26日（日）に池袋でオフライン開催される技術書典16に、サークル「だめぽラボ」で新刊「Haskellでの型レベルプログラミング」を出します。既刊も在庫があるものは頒布します。技術書典16の基本的な情報は以下の […]

Haskell で Open Telemetry を利用してオブザーバビリティーを向上させよう

2023-12-25T17:35:26+09:00

Open Telemetry って何？この記事では Open Telemetry のトレースの機能を使います。トレースを使うと、サーバーを越境してコールグラフとその実行時間などを取得することができます。下の画像は Jaeger のスクリーンショットです。Jaeger は Open Telemetry の規格にのっとったコレクター実装のひとつです。この例では HTTP サーバーと HTTP クライアントでトレースを取得しています。まずサーバーが /1 のパスでリクエストを受けつけたことが分かります。このリクエストに対してレスポンスを返すまでに 845μs かかっていますね。このトレースにおけ…

GHCへの私の貢献2023

2023-12-05T22:00:00+00:00

この記事は Haskell Advent Calendar 2023 の6日目の記事です。私はここ数年、HaskellコンパイラーであるGHCに貢献しています。この記事では、今年（2023年）に私が行った貢献を紹介しま […]

[ATOK] 候補ウィンドウがカーソル位置ではなく、画面中央に固定表示されるようになってしまった

2023-12-05T12:07:55.681+09:00

[ATOK] 候補ウィンドウがカーソル位置ではなく、画面中央に固定表示されるようになってしまったWindows10上で、特に設定を変更したつもりはないのだが、変換候補ウィンドウ、及び、推測候補ウィンドウが画面中央に固定表示される状態になった。JUST SYSTEMSのサポートページに以下のページがあり、ウィンドウをドラッグ＆ドロップすることで位置を変更できることが分かったが、肝心の「左上のピン」が表示されておらず、カーソル位置表示に戻すことができない。 [サポートFAQ] 候補ウィンドウの表示位置を変更するATOKプロパティ設定の中を確認しても、表示・非表示の切り替えはあるが、表示位置の切り替えが見つからない･･･（FAQは2007年記載なので、古いバージョンの挙動っぽい）。困っていた中、ふと候補ウィンドウ右下の画面の「候補メニュー」の存在に気がつき、表示してみると「表示位置

[windows] Windows10セットアップ・設定項目のメモ

2023-10-02T19:40:04.272+09:00

Windows10セットアップ時の設定項目、インストールアプリの備忘録。スタートメニュー・タスクバーの設定タスクバーの設定小さいタスクバーボタンを使う：オン [スタート]ボタンを右クリックするかWindowsキー＋Xキーを押したときに表示されるメニューで、コマンドプロンプトをWindows PowerShellに置き換える：オフタスクバーボタンを結合する「タスクバーに入りきらない場合」を選択タスクバーをすべてのディスプレイに表示する：オフシステムアイコンのオン／オフの切り替え入力インジケーター：オフ Quick Launcherを表示するクイック起動を復活する Windows 10 タスクバーにクイック起動を表示するスタートメニューにコントロールパネルを表示する「Windows 10」のコントロールパネルを表示する

Haskell/GHCのSIMDについて考える

2023-08-17T13:35:53+00:00

最近のコンピューターの性能を活用するには、何らかの並列化が必須です。具体的にはSIMDの活用やマルチコア（それとGPU）です。プログラミング言語でこれらを利用できれば「C言語よりも速い」を名乗れます。この記事では並列化技 […]

Developers Summit 2023 Summer でサーバーレスについて話してきました

2023-07-27T19:56:34+09:00

こんにちは、チェシャ猫です。先日開催された Developers Summit 2023 Summer で、サーバーレスコンピューティングの形式化について登壇してきました。公募 CFP 枠です。 event.shoeisha.jp 内容は Jangda et al. (2019) による論文 "Formal Foundations of Serverless Computing" を軸にしています。この論文はサーバーレスコンピューティングに対して操作的意味論の定式化を行うものであり、プログラミングの国際学会 OOPSLA '19 の Distinguished Paper を受賞しています。…

意地でも関心を分離する

2023-07-18T13:49:10+09:00

マイクロサービスアーキテクチャにおいて、ある構造化されたデータを、構造を維持したまま別のコンポーネントでも使いたくなる誘惑が存在する。例えば、ドメインロジックを扱うコンポーネントに「ユーザーの種別（ゲスト、メンバー、管理者）」という概念があり、API トークンの認可情報に含めたいとして、APIトークンを管理するコンポーネントはその概念に関与すべきだろうか。 // 関与しない定義 IssueToken(userType: string, expiresAt: Date): Token // 関与する定義 enum UserType { Guest, Member, Admin, } Issue…

リリースされていない変更が溜まるのを防ぐGitHub Action「tocenbough」

2023-06-08T17:57:48+09:00

チームでソフトウェア開発をするとき、一度のリリースに含まれる変更が多すぎることにより、動作検証に時間がかかったり、問題が発生した時の原因特定が難しくなることがある。これを防ぐため、tocenboughというGitHub Actionを作った。読み方はもちろん「とおせんぼう」だ。 github.com 内容は至ってシンプルで、前回のlatest releaseからのマージコミットの数を計算し、その数が閾値を上回ったら落ちるというだけのスクリプトである。かなり単純なので、動作を把握するにはソースを見てもらったほうが早いかもしれない。 # GitHubから最新のリリースのタグを取得する。これがプルリ…

ローカルk8sの上に色んなサービスを立てて壊す

2023-05-11T00:02:26+09:00

ローカルに立ち上げた Kubernetes Dashboard モダンなサービス開発はとにかく入用のミドルウェアが多い。ちょっとしたものを作るだけで RDB と NoSQL とインメモリキャッシュと監視ダッシュボードが必要になってしまう。遠い記憶に RDB とキーバリューストアとキャッシュと検索とジョブキューをすべて MySQL にやらせていた牧歌的な時代もあったような気がするがもうそんな時代ではないのだった。実際にサービスをデプロイする段ではなくローカルで開発するときにもそういったミドルウェアがないと開発自体が進まない。かと言って素の OS の上にミドルウェアを入れまくると設定ファイルディ…

2022 年、アウトプットの思い出

2023-01-01T00:03:17+09:00

こんにちは、チェシャ猫です。2022 年中は大変お世話になりました。本記事では自分自身への備忘も兼ねて、本年度の対外的な発表についてまとめておこうと思います。 2019 年のスライド一挙公開、あるいは 2020 年の方針 - チェシャ猫の消滅定理 2021 年のアウトプットを全部一気に思い出す - チェシャ猫の消滅定理 2022 年の活動実績 2022 年の登壇は 3 件でした。うち（先着や抽選ではなく）CFP に応募して採択されたものは 2 件です。以前は頻繁に登壇していた LT の回数を今年はかなり控えていたこともあり、件数としては少ない水準となりました。賢く「振り分ける」ための Top…

きりたんぽ鍋を作る

2022-12-01T22:48:37+09:00

きりたんぽ鍋を作ります。きりたんぽ鍋の具材具材きりたんぽさいとうの比内地鶏スープ鶏肉ネギゴボウマイタケ糸コンニャクセリ手順鶏肉を手頃な大きさに切る。鍋に水1200mlを張って火にかけ、鶏肉を水から煮始める。ゴボウをささがきにしてボウルの水につける。ゴボウをボウルから出して鍋に入れる。比内地鶏スープを入れる。沸騰したら糸コンニャクとマイタケを入れる。 20分ほど煮たらネギを入れる。ネギに火が通ったあたりできりたんぽを入れる。きりたんぽを煮る時間は好みで調節する(1～5分くらい?)。最後にセリを投入する。湯気を通す程度でいい。完成。鶏肉とゴボウは水から …

Elm 用の Octicons パッケージを作る

2022-12-01T00:00:00Z

CloudNative Days Tokyo 2022 に「謎は全て解けた！安楽椅子探偵に捧げる AWS ネットワーク分析入門」というタイトルで登壇してきました

2022-11-23T20:58:55+09:00

こんにちは、チェシャ猫です。先日開催された CloudNative Days Tokyo 2022 で、SMT ソルバを用いた AWS のネットワーク検査機能、VPC Rechability Analyzer と VPC Network Access Analyzer について話してきました。公募 CFP 枠です。イベントサイトにて録画も視聴可能です。 event.cloudnativedays.jp 今回の登壇は「事前録画を提出」「当日リモートで登壇」「現地で登壇」のいずれの方式が選択可能だったのですが、自分は現地で登壇しました。現地参加者全員が一つの部屋に集まる Keynote では…

AWS Dev Day 2022 Japan に「サーバーレスは操作的意味論の夢を見るか？」というタイトルで登壇してきました

2022-11-10T18:55:12+09:00

こんにちは、チェシャ猫です。先日開催された AWS Dev Day 2022 Japan で、サーバーレスコンピューティングの形式化について発表してきました。公募 CFP 枠です。 www.youtube.com github.com ちなみに会場は観葉植物が生い茂る Amazon 品川オフィスで、講演者向けには個室の楽屋が用意されており（滞在時間は講演直前の 15 分程度ですが）、全体的にとてもゴージャスな感じでした。配信設備も本格的でしたが、話す側としては照明が眩しくてやりづらかったです。講演概要 AWS Lambda を初めとするサーバーレスコンピューティング基盤には、複数の関数が…

wd コマンドをリリースした

2022-10-19T02:56:15+09:00

wd コマンドって？これがしたかった。 hoge path/to/dir foo bar って実行したら、ワーキングディレクトリーが path/to/dir で foo bar コマンドを実行してくれるような hoge コマンドない？— かずき (@kakkun61) 2022年8月11日 $ wd ディレクトリーコマンドオプションとすると「ディレクトリー」をワーキングディレクトリーにして「コマンド」を「オプション」付きで実行する。 pushd でもできるけど popd と合わせるとタイプ数が多かった。インストール GitHub のリリースページに Windows・Linux・mac…

一般社団法人としてのHaskell-jp Admins解散のお知らせ

2022-09-18T00:00:00Z

誠に残念ながら、一般社団法人としての日本Haskellユーザーグループ管理委員会（通称Haskell-jp Admins）は、去る2022年4月16日を以て解散しました。先日、解散後に必要な処理のほぼすべてが完了しましたので、遅くなってしまいましたが、改めてこちらで報告致します。

Contents

Link to
here背景

解散の背景を一言で申しますと、「お金がかかりすぎる上に、士気も下がってしまったから」です。設立前に調査した際、法人住民税のルールを誤解してしまったことで想定より費用がかさんだことや、当初活動の一環として掲げていた大規模なオフラインイベントが、現状のコロナ禍において難しく、その上、代表を含む社員自身の開催するモチベーションが下がってしまっていることを鑑みて、先般行われた第1期の社員総会で解散する事を合意しました。

Link to
here今後の活動

「一般社団法人」という法人格を失ってしまったので、法律上必要な場面において「日本Haskellユーザーグループ管理委員会」という名前を使用することはできなくなってしまいました。それでもできる範囲内で、任意団体として今までどおりの活動を継続したいと思います。

具体的には、

プログラミング言語Haskellに関するイベントの企画・開催・運営
- 任意団体として適宜実施します
haskell.jp ドメインの維持・管理
- ひとまず、代表であった山本悠滋が個人として引き継ぐことにします
Haskell-jpのSlack Workspaceを始めとする、交流や情報共有を行う場の提供・管理・運営
- こちらは引き続き行います

Link to
here今後の連絡先

こちらは設立時の記事から特に変更はありません。該当するセクションをご覧ください。

Windows で Haskell SDL2

2022-08-12T23:57:51+09:00

Hackage にある SDL2 ライブラリーを Windows で利用する方法のメモ。 hackage.haskell.org Haskell-jp の Slack の質問をきっかけに手元で試したことを思い出しながら書いている。 sdl2.cabal に下記の記述があるので C ライブラリーを事前にインストールする必要がある。 pkgconfig-depends: sdl2 >= 2.0.6 今回は stack に附属する MSYS2 を利用する。 stack exec -- pacman -S mingw64/mingw-w64-x86_64-SDL2 でインストールできるはずだが、MSY…

SendGridのEvent WebHookを検証する

2022-06-24T18:44:35+09:00

メール配信プラットフォームであるSendGridは、メールの到達状況などを、呼び出し元のアプリケーションにWebHookで伝えることができる。 sendgrid.kke.co.jp アプリケーションがSendGridからリクエストを受け取るには、当然インターネットからアクセスできるようにする必要があるが、何の考えもなしに開放してはセキュリティ的に不安だ。しかしご安心を、SendGridにはWebHookにデジタル署名をつける機能がある。本稿ではその使い方を紹介する。まず、Mail Settingsから、Signed Event Webhook Requestsという項目に入る。画面のボタンを…

重ね着したバービー人形 in Haskell

2022-05-26T14:08:06+09:00

うやむやで終わる記事なので事前にご了承ください。前回のあらすじ（前回などないので探さなくていいです。）高カインドデータ型（Higher-kinded Datatypes; HKD）というものがあります。 fumieval.hatenablog.com qiita.com 簡単に説明すると下記のようなデータ型 D があるとき data D = D { a :: A , b :: B } D の代わりに H のようなデータ型を作ると便利という発想です。 data H f = H { a :: f A , b :: f B } H Identity だと D と同じ意味になりますし、H May…

依存関係と階層構造の軛

2022-05-09T11:37:15+09:00

21世紀現在のプログラミング言語において、モジュールという機能はほぼ必要不可欠である。ソースコードを分割し、明示的な依存関係を指定する仕組みであるモジュールは、以下のような様々な恩恵をもたらす。インクリメンタルビルド: モジュールごとにコンパイル結果を保存し、変更されていない部分を再コンパイルするのを防ぐ。内部の隠蔽: 実装の詳細を隠蔽し、モジュール外から触れないようにする。プログラムの見通しをよくしたり、不正な操作をする機会を減らす。アーキテクチャの整理: モジュールは他のモジュールを参照できるが、原則として相互参照はしない。依存の向きを定めることで、適切な抽象化と、それに基づいた実…

NixによるHaskell開発環境の構築

2022-04-13T01:41:07+09:00

Nix package manager によって Haskell のスクリプティングおよびパッケージ開発の環境構築をしていく。こいついつも環境構築してんなここで触れられないこと Nix スクリプティングちゃんとした開発 haskell-language-server の導入パッケージの設定高度な依存関係オーバーライドトラブルシューティング nix-shell の立ち上がりが遅い cabal run で cabal 自体の出力を無視したい Mac で nix-env -i が失敗する Mac で channel が消滅するこいついつも環境構築してんな環境構築以外はブログに書くよう…

株式会社HERPに転職しました

2022-04-07T18:18:38+09:00

GitHubのプロフィールを見た人などはもしかしたら気づいているかもしれないが、Tsuru Capital LLCを退職し、2022年2月16日よりHERPの正社員となった。HERPは、大まかに言えば採用活動を管理するプラットフォームを提供している。きっかけ Tsuru CapitalはKospi(韓国株のインデックス)のデリバティブを半自動取引する企業で、Haskellを使っているというのが最大の特徴として知られる謎多き会社だ。2015年に入社し、2022年まで6年以上働いた。流石に同じ職場にずっといると経験が偏ってしまうし、感覚としても飽きがきたので転職を考えた。また、ある時期からRu…

Haskell Servant + WebSocket で非同期ジョブを作る

2022-03-05T00:00:00Z

GitHub の URL を自動で OGP 画像に置き換える

2022-01-12T00:00:00Z

2021 年のアウトプットを全部一気に思い出す

2021-12-31T21:24:10+09:00

こんにちは、チェシャ猫です。2021 年中は大変お世話になりました。今年もいくつか外部で発表を行いましたが、その中には登壇報告の形でこのブログに載せていなかったり、スライドとして公開していないものがあります。自分自身の記録も兼ねて、本記事では 2021 年のアウトプットを一覧としてアーカイブしておきたいと思います。 2021 年の活動実績 2021 年の登壇は 9 件でした。うち（先着や抽選ではなく）CFP に応募して採択されたものは 5 件です。傾向として以前よりも LT の割合が少なくなり、比較的長尺の登壇がメインになりました。 CockroachDB から覗く型式手法の世界【CFP …

文字列型を抽象化するのにはmono-traversableパッケージがいいかも

2021-12-25T00:00:00Z

この記事はHaskell Advent Calendar 2021の25日目の記事です。

Haskellのよく言われる問題点の一つとして、文字列型が下記のようによく使われるものだけで5種類もある、という点があります:

String
StrictなText
LazyなText
StrictなByteString
LazyなByteString

（上記の頻繁に使われるもの以外にも、もっとあります）

それぞれ確かに使いどころが違うので、アプリケーションで使用する場合は場面に応じて使い分ければいいのですが、文字列を使ったライブラリーを開発する場合はなかなか悩ましいものがあります。内部で依存しているライブラリーが使用しているものがあれば、それをそのまま使うのが簡単で確実ですが、そうでない場合も多いでしょう。そこで本稿では文字列型を抽象化して扱いたい場合の手段として、mono-traversalbeパッケージを検討したいと思います。

Contents

Link to
heremono-traversableパッケージの紹介

mono-traversableパッケージは、名前のとおりMonoTraversableやMonoFoldable、MonoFunctorといったおなじみの型クラスの名前にMonoという接頭辞を付けた型クラスによって、多様なコンテナ型を抽象化してくれます。これらの型クラスはすべて、ByteStringやTextのような、「要素として持てる値の型が1種類だけ」の型も対象にしているのが特徴です。Type Familyを応用し、次のように型毎に要素の型を固定することで、そうした特徴を実現しています:

type family Element mono

type instance Element ByteString = Word8
type instance Element Text = Char
type instance Element [a] = a

-- ...

class MonoFunctor mono where
  -- ...
  omap :: (Element mono -> Element mono) -> mono -> mono

instance MonoFunctor ByteString where
  omap = ByteString.map

instance MonoFunctor Text where
  omap = Text.map

instance MonoFunctor [a] where
  omap = map

※mono-traversableパッケージのソースから引用して少し改変しました。

さらに、これまで紹介したMonoTraversableやMonoFoldable、MonoFunctorに加えて、SemiSequenceやIsSequenceという型クラスで分解や構築に関わる操作（例えばconsやbreak）などの他、（今回は取り上げませんが）SetContainerなどの型クラスでMapやSet、IntMapなどの型まで抽象化してくれます。

そこで次の節では、このmono-traversableパッケージにおける型クラスを中心に、Data.TextモジュールやData.ByteStringモジュールにおける各関数が、どの型クラスに対するどの関数に対応するのか、まとめた表を作ってみました。

Link to
heremono-traversableパッケージにおける型クラスのメソッドと、各種文字列型向け関数の対応表

ℹ️調査したmono-traversableパッケージのバージョンは1.0.15.3です
ℹ️原則として関数の名前しか見ていないので、実際には異なる用途かも知れません
ℹ️mono-traversableパッケージにある型クラスの他、baseパッケージにあるMonoid、Semigroupなどのメソッドも調査対象に含めました
ℹ️Stringについてはbaseパッケージにある関数のみを対象にしていますが、Data.Listモジュールのドキュメントと自分の記憶を頼りに埋めているので間違いがあるかも知れません
ℹ️Text・ByteStringについてはStrictなバージョンのドキュメントのみ参照しています。Lazyな方になかったらごめんなさい！
ℹ️Textual型クラスについては、ByteStringがインスタンスになっていないのでご注意ください
ℹ️以下のような関数は除外しました:
- IOが絡むもの
- プリミティブな処理で使うもの

`Text`	`ByteString`	`String` (`[Char]`)	型クラス / 関数
`all`	`all`	`all`	`MonoFoldable` / `oall`
`any`	`any`	`any`	`MonoFoldable` / `oany`
`append`	`append`	`++`	`Semigroup` / `<>`
N/A	`breakByte`	N/A	N/A
N/A	`breakEnd`	N/A	N/A
`breakOnAll`	N/A	N/A	N/A
`breakOnEnd`	N/A	N/A	N/A
`breakOn`	`breakSubstring`	N/A	N/A
`break`	`break`	`break`	`IsSequence` / `break`
`center`	N/A	N/A	N/A
`chunksOf`	N/A	N/A	N/A
`commonPrefixes`	N/A	N/A	N/A
`compareLength`	N/A	N/A	N/A
`concatMap`	N/A	`concatMap`	`MonoFoldable` / `ofoldMap`
`concat`	`concat`	`concat`	`MonoFoldable` / `ofold`
`cons`	`cons`	N/A	`SemiSequence` / `cons`
`copy`	`copy`	N/A	N/A
`count`	`count`	N/A	N/A
`dropAround`	N/A	N/A	N/A
`dropEnd`	N/A	N/A	`IsSequence` / `dropEnd`
`dropWhileEnd`	`dropWhileEnd`	`dropWhileEnd`	N/A
`dropWhile`	`dropWhile`	`dropWhile`	`IsSequence` / `dropWhile`
`drop`	`drop`	`drop`	`IsSequence` / `drop`
N/A	`elemIndexEnd`	N/A	N/A
N/A	`elemIndex`	`elemIndex`	N/A
N/A	`elemIndices`	`elemIndices`	N/A
N/A	`elem`	`elem`	`MonoFoldable` / `oelem`
`empty`	`empty`	`""`	`Monoid` / `mempty`
`filter`	`filter`	`filter`	`IsSequence` / `filter`
N/A	`findIndexEnd`	N/A	N/A
`findIndex`	`findIndex`	`findIndex`	N/A
N/A	`findIndices`	`findIndices`	N/A
N/A	`findSubstring`	N/A	N/A
N/A	`findSubstrings`	N/A	N/A
`find`	`find`	`find`	`SemiSequence` / `find`
`foldl'`	`foldl'`	`foldl'`	`MonoFoldable` / `ofoldl'`
`foldl1'`	`foldl1'`	`foldl1'`	`MonoFoldable` / `ofoldl1Ex'`
`foldl1`	`foldl1`	`foldl1`	N/A
`foldl`	`foldl`	`foldl`	N/A
N/A	`foldr'`	N/A	N/A
N/A	`foldr1'`	N/A	N/A
`foldr1`	`foldr1`	`foldr1`	`MonoFoldable` / `ofoldr1Ex`
`foldr`	`foldr`	`foldr`	`MonoFoldable` / `ofoldr`
`groupBy`	`groupBy`	`groupBy`	`IsSequence` / `groupBy`
`group`	`group`	`group`	`IsSequence` / `group`
`head`	`head`	`head`	`MonoFoldable` / `headEx`
`index`	`index`	`index`	`IsSequence` / `indexEx`
`init`	`init`	`init`	`IsSequence` / `initEx`
`inits`	`inits`	`inits`	N/A
`intercalate`	`intercalate`	`intercalate`	`MonoFoldable` / `ointercalate`
`intersperse`	`intersperse`	`intersperse`	`SemiSequence` / `intersperse`
`isInfixOf`	`isInfixOf`	`isInfixOf`	`IsSequence` / `isInfixOf`
`isPrefixOf`	`isPrefixOf`	`isPrefixOf`	`IsSequence` / `isPrefixOf`
`isSuffixOf`	`isSuffixOf`	`isSuffixOf`	`IsSequence` / `isSuffixOf`
`justifyLeft`	N/A	N/A	N/A
`justifyRight`	N/A	N/A	N/A
`last`	`last`	`last`	`MonoFoldable` / `lastEx`
`length`	`length`	`length`	`MonoFoldable` / `olength`
`lines`	N/A	`lines`	`Textual` / `lines`
`mapAccumL`	`mapAccumL`	`mapAccumL`	N/A
`mapAccumR`	`mapAccumR`	`mapAccumR`	N/A
`map`	`map`	`map`	`MonoFunctor` / `omap`
`maximum`	`maximum`	`maximum`	`MonoFoldable` / `maximumEx`
`minimum`	`minimum`	`minimum`	`MonoFoldable` / `minimumEx`
N/A	`notElem`	`notElem`	`MonoFoldable` / `onotElem`
`null`	`null`	`null`	`MonoFoldable` / `onull`
`pack`	`pack`	`id`	`IsString` / `fromString`
`partition`	`partition`	`partition`	`IsSequence` / `partition`
`replace`	N/A	N/A	`IsSequence` / `replaceSeq`
`replicate`	`replicate`	`replicate`	`IsSequence` / `replicate`
`reverse`	`reverse`	`reverse`	`SemiSequence` / `reverse`
`scanl1`	`scanl1`	`scanl1`	N/A
`scanl`	`scanl`	`scanl`	N/A
`scanr1`	`scanr1`	`scanr1`	N/A
`scanr`	`scanr`	`scanr`	N/A
`singleton`	`singleton`	`singleton`	`MonoPointed` / `opoint`
`snoc`	`snoc`	`snoc`	`SemiSequence` / `snoc`
N/A	`sort`	`sort`	`SemiSequence` / `sort`
N/A	`spanEnd`	N/A	N/A
`span`	`span`	`span`	`SemiSequence` / `span`
`splitAt`	`splitAt`	`splitAt`	`IsSequence` / `splitAt`
`splitOn`	N/A	`splitOn`	`IsSequence` / `splitSeq`
N/A	`splitWith`	N/A	`IsSequence` / `splitElem`
`split`	`splitWith`	N/A	`IsSequence` / `splitWhen`
`stripEnd`	N/A	N/A	`N/A`
`stripPrefix`	`stripPrefix`	`stripPrefix`	`IsSequence` / `stripPrefix`
`stripStart`	N/A	N/A	N/A
`stripSuffix`	`stripSuffix`	N/A	`IsSequence` / `stripSuffix`
`strip`	N/A	N/A	N/A
`tail`	`tail`	`tail`	`IsSequence` / `tail`
`tails`	`tails`	`tails`	N/A
`takeEnd`	N/A	N/A	N/A
`takeWhileEnd`	`takeWhileEnd`	N/A	N/A
`takeWhile`	`takeWhile`	`takeWhile`	`IsSequence` / `takeWhile`
`take`	`take`	`take`	`IsSequence` / `take`
`toCaseFold`	N/A	N/A	`Textual` / `toCaseFold`
`toLower`	N/A	N/A	`Textual` / `toLower`
`toTitle`	N/A	N/A	N/A
`toUpper`	N/A	N/A	`Textual` / `toUpper`
`transpose`	`transpose`	N/A	N/A
`uncons`	`uncons`	N/A	`IsSequence` / `uncons`
`unfoldrN`	`unfoldrN`	N/A	N/A
`unfoldr`	`unfoldr`	`unfoldr`	N/A
`unlines`	N/A	`unlines`	`Textual` / `unlines`
`unpack`	`unpack`	`id`	`MonoFoldable` / `otoList`
`unsnoc`	`unsnoc`	`N/A`	`SemiSequence` / `unsnoc`
`unwords`	N/A	`unwords`	`Textual` / `unwords`
`words`	N/A	`words`	`Textual` / `words`
`zipWith`	`zipWith`	`zipWith`	`MonoZip` / `ozipWith`
`zip`	`zip`	`zip`	`MonoZip` / `ozip`

以上です。残念ながら万能とはいかないようで、いくつか「N/A」、すなわち対応するものがない関数もありますが、他の関数の組み合わせで実装できるものもあるでしょう。

Link to
here⚠️パフォーマンスに関わる注意事項

MonoTraversableなどに限らず、型クラスを使って関数を多相化したとき全般に言えることですが、コンパイル時にインスタンスの解決が行えなかった場合、直接対象の型の相当する関数を呼ぶより少し遅くなってしまう場合があります（参考）。

また、それに限らず、各型クラスのメソッドでない関数は、各型の相当する関数でオーバーライドできないため、効率の悪い処理になってしまう恐れがあります。例えば、ointercalate関数の実装を見ると、TextやByteStringなどについてはRULESプラグマで最適な実装を設定しているようですが、それ以外の型については一旦リストに変換してから結合する、という効率の悪そうな処理をしています。

Link to
here事例: `String`から相互変換できる型を抽象化する

最後に、最近私が作った（まだリリースしてない）ライブラリーにおいて、MonoFoldableとIsStringを使うことで、TextとString両方をサポートした関数を紹介しておきます。ただ、時間とやる気パワーが残り少なくなってしまったので、該当の箇所だけこちらからコピペして、説明は簡単にしておきます:

stringVal :: (IsString a, MT.MonoFoldable a, MT.Element a ~ Char) => CodecEnvVal a
stringVal = valByFunction CodecEnvValByFunction
  { encode = MT.otoList
  , decode = Right . fromString
  }

CodecEnvVal a型は、a型をString型と相互変換するための情報を含んだ型です。stringValの場合、名前のとおり文字列っぽい型とStringとの相互変換ができなければなりません。もちろん単純にString型だけをサポートしてText用には別途CodecEnvVal Textを作ってもいいのですが、一つのCodecEnvVal aだけで扱えた方が楽でしょうし、今回はMonoFoldableのotoListとIsStringのfromStringを使って両方をサポートすることにしました。なお、これではByteStringがサポートできませんが、ここで相互変換するStringは、要件上人間が読み書きするファイルにおける文字列を想定しているので、ByteStringはバイナリーデータにだけ使うべきだ、という立場から敢えてサポートしていません。

Link to
hereまとめ

mono-traversableパッケージをうまく使えば、自前で専用の型クラスを作らなくてもString・Text・ByteStringなどを一挙にサポートする関数が書けるかも知れません！

それでは2022年はmono-traversableでHappy Haskell String Programming!🚝

Haskellにおける記号の調べ方

2021-12-25T00:00:00Z

この記事はググって解決しづらかったこと Advent Calendar 2021の25日目の記事です。Haskell-jp WikiのHaskellの歩き方というページにもほぼ同じことを書きましたが、今回はよい機会なので実例を加えつつ詳しく紹介させてください。

Contents

Link to
here二項演算子（記号関数）の調べ方

よく知られているとおり、Haskellには二項演算子をプログラマーがかなり自由に定義できるという、とても変わった特徴があります。他のプログラミング言語でも使う標準的なもの（例: +, *, &&など）を名前空間を絞って置き換えるほか、例えばかのlensパッケージのように、ライブラリーの作者があたかも新しい構文を作り上げるかのごとく独自の二項演算子を提供することができます。

これは面白い機能ではあるものの、しばしば混乱を招く機能でもあります。後述するその他の記号との区別がつきにくいですし、一般的な検索エンジンで検索することさえままなりません。Googleはプログラミングでよく使われる記号による検索をサポートはしているものの、Haskellでしか見ないような記号の組み合わせは到底無理でしょう。

そんな背景もあり、Haskellを使う人はしばしばHoogleなどの、関数名で検索できる検索エンジンを使用することになります。こちらは二項演算子の名前での検索もサポートしています。

例えばlensパッケージでおなじみの^.で検索すると次のような結果になりました:

Hoogleによる検索結果の例

lensパッケージ以外でも、同様の^.が定義されているのが分かりますね。lensパッケージは依存関係がとても大きい一方、^.などの定義は十分単純でコピペしてもいいくらい小さいので、このようにいくつものパッケージで定義されています。

また、特によく使われる二項演算子はFPCompleteのウェブサイトでもまとめられています:

Operator Glossary

Link to
hereユーザーが定義した二項演算子ではないものの調べ方

Haskell、というかそのデファクトスタンダードな処理系であるGHCでは、言語拡張という形で長年新しい構文が提案されています¹。その中には、当然これまでにない方法で記号を使っているものもあります。そうした記号はプログラマーが定義した関数ではないので、前述のHoogleなどを使った方法が通用しません。そこで、当ブログにも何度も寄稿いただいた@takenobu_hsさんが、言語拡張によるものも含めた、Haskellの構文における記号の一覧を作ってくださいました！

takenobu-hs/haskell-symbol-search-cheatsheet

実は日本語版もQiitaにあるのですが、上記のGitHub版の方が更新されているようです。そこで、今回はおまけとして、GitHub版の方にも載っている、GHCに最近（バージョン9.2.1以降に）追加された、新しいピリオド . の使い方を紹介しましょう。

従来、Haskellでピリオドといえば関数合成を表す二項演算子でした:

ghci> f x = x + 1
ghci> g x = x * 3
ghci> h = g . f
ghci> h 2
9 -- 2 に + 1 して * 3 した結果

数学における関数合成の記号「g ∘ f」に似せてピリオドを採用したのでしょう。しかし、世は今まさに大「ピリオドといえばフィールド²へのアクセス演算子じゃろがい」時代です。それでなくてもHaskellのレコード型は扱いにくいと言われているのに、フィールドへのアクセスまで変なやり方でした³:

data SomeRecord =
  SomeRecord { field1 :: String, field2 :: Int }

someRecord = SomeRecord "value1" 2

ghci> field1 someRecord
"value1"

ghci> field2 someRecord
2

そこで、GHC 9.2からはOverloadedRecordDotという言語拡張が導入され、これを有効にしたファイルではおなじみの言語のようにピリオドでレコードのフィールドにアクセスできるようになりました:

（以下はGHCiで使用した例です）

ghci> :set -XOverloadedRecordDot

ghci> someRecord.field1
"value1"

ghci> someRecord.field2
2

-- ⚠️ピリオドの前後に空白を入れると関数合成として解釈されてしまう！
ghci> someRecord . field2

<interactive>:5:1: error:
    ? Couldn't match expected type ‘Int -> c’
                  with actual type ‘SomeRecord’
    ? In the first argument of ‘(.)’, namely ‘someRecord’
      In the expression: someRecord . field2
      In an equation for ‘it’: it = someRecord . field2
    ? Relevant bindings include
        it :: SomeRecord -> c (bound at <interactive>:5:1)

OverloadedRecordDotについてのより詳しい解説は、Haskell Day 2021における、fumievalさんの発表をご覧ください。

Link to
hereまとめ

他のプログラマーが定義した、二項演算子（記号関数）を調べるときは:
- Hoogle
- 補足: Stackageの最新のLTSから検索したいときはStackageのページ上部にあるフォームで検索してみましょう。こちらも内部はHoogleが使われています。
それ以外の場合は:
- takenobu-hs/haskell-symbol-search-cheatsheet
Haskellのレコード型に嫌気が差したら:
- Haskell Day 2021における、fumievalさんの発表を観てOverloadedRecordDot拡張について勉強しましょう。

🎁それでは2022年もHappy Haskell Hacking!!🎅

余談: ghc-proposalsに送られたPull requestを見ると、今どのような提案が議論されているか分かります。↩︎
他のプログラミング言語では「プロパティー」と呼ばれることも多いですが、ここではHaskellのレコード型における用語に合わせました。↩︎
個人的にはゲッターが関数になるのはとても直感的な気がして割と好きでしたが、確かにデメリットもとても多い仕様でした。セッターは単純な関数になってないですしね。↩︎

Bazel でも GHC 9.2.1 でビルドがしたい

2021-12-20T00:00:00Z

Haskell Morpheus GraphQL で GitHub API を試す

2021-12-09T00:00:00Z

Oath: 安全、高速、合成可能な並行処理

2021-12-03T21:25:34+09:00

TL;DR github.com 並行処理を簡潔かつ安全に記述できるライブラリを作った。ApplicativeDo拡張を使って、以下のようにoathの引数として与えたIOアクションを同時に実行し、結果を集める処理を書ける。いずれかが例外を投げた場合、残りをキャンセルするためリソースを漏らす心配がない。 evalOath $ do a <- oath $ ... b <- oath $ ... f a b 経緯 Haskellは並行処理が得意とされている。事実、軽量スレッド、MVar、STMといった処理系によるサポートが充実しており、HackageのConcurrencyカテゴリには235ものパ…

Haskell Stack で Stackage に無い GHC を使う

2021-11-28T00:00:00Z

VPC Reachability Analyzer と形式手法

2021-09-30T21:30:08+09:00

こんにちは、チェシャ猫です。先日開催された AWS Dev Day Online Japan 2021 で、AWS の VPC Reachability Analyzer とそのバックエンドである Tiros について発表してきました。公募 CFP 枠です。 www.youtube.com 講演概要このプレゼンの大きな目標は、VPC Reachability Analyzer のバックエンドである検査エンジン Tiros の論文 [Bac19] を解説することです。そのための道筋として、Section 1 で VPC Reachability Analyzer の機能を簡単に紹介した後、S…

rules_elm に elm-test するルールを追加する

2021-09-30T00:00:00Z

CI/CD Conference 2021 で Zelkova の論文について話してきました

2021-09-04T05:59:34+09:00

こんにちは、チェシャ猫です。先日開催された CI/CD Conference 2021 で、AWS の IAM Access Anazlyer のバックエンドとして使用されている検査エンジン Zelkova、およびその元となった論文について発表してきました。公募 CFP 枠です。発表の大筋は、少し前に July Tech Festa 2021 で登壇した際のものと共通です。関連リンク集などは以下の記事にまとめてあるので、よかったらこちらも合わせてお読みください。 ccvanishing.hateblo.jp 内容面では、前回の発表時間 20 分に対して今回は 40 分の枠をもらっていたので…

Bazel で生成したファイルを Haskell から参照する

2021-08-19T00:00:00Z

rules_elm で依存パッケージのインストールをキャッシュする

2021-07-31T00:00:00Z

Bazel で Haskell の Custom Setup をする

2021-07-30T00:00:00Z

July Tech Festa 2021 で IAM Access Analyzer と Zelkova について話してきました

2021-07-18T21:16:19+09:00

こんにちは、チェシャ猫です。先日開催された July Tech Festa 2021 で、AWS のアクセス制御検査ツール Zelkova について発表してきました。公募 CFP 枠です。 techfesta.connpass.com 講演概要 www.youtube.com 一般に、AWS 上のリソース設定を変更したときに何が起こるのかを事前に検査するのは難しい作業です。特に、複数の設定がマージされた結果として最終的なアクセス許可が決まるような場合、単独の項目をルールベースでチェックするだけでは限界があります。今回の発表中では、インフラに対する検査の水準を以下の 3 つのレベルに分けて定…

Haskell Day 2021を開催します

2021-06-14T00:00:00Z

Haskell Day 2021を開催します！

こんにちはkakkun61こと岡本和樹です。

この記事ではHaskell Day 2021の紹介と開催の経緯などを記載します。

Contents

Link to
here経緯

Haskell Dayは日本語で開催されるHaskellに関するイベントとしては最多の参加者を誇るイベントです。これまで2012・2016・2018・2019と開催してきました。新型コロナウイルスの影響により、残念ながら2020は開催しませんでしたが、2021はオンラインイベントとして開催します。

このようなオンラインイベントの開催は未経験だったため、さまざまなイベント形式を検討した結果、今回は事前録画動画の予約公開という形式を採用しました。生放送ももちろん検討しましたが、ノウハウ不足の中で一発勝負という生放送はリスクが大きいという判断をしました。録画公開における臨場感の不足をおぎなうことを期待し、YouTubeのプレミア公開を使用しリアルタイムチャットによる発表者と視聴者・視聴者同士の交流をできるように予定しています。

Link to
here発表者募集

現在発表者募集中です！

今回はオンライン開催ということで、お手数ですが発表者にもオンサイトのイベントと異なった準備をお願いすることになります。運営としてできるかぎりのサポートをしますので安心して応募いただければと思います。

Link to
here参加登録

Connpassにて参加登録の受け付けもしていますので視聴者の方も登録をお願いします。

その他のくわしい情報はHaskell Day 2021イベントページをご覧ください。

みなさまのご応募をお待ちしています。またお体にお気をつけください。

「相互を尊重したコミュニケーションのためのガイドライン」制定のお知らせ

2021-05-30T00:00:00Z

先日のHaskell-jp Adminsと同様に事務的な連絡で恐縮ですが、当ブログやHaskell-jpのSlack Workspace、GitHubのOrganizationなどにおけるコミュニケーションに適用される、「相互を尊重したコミュニケーションのためのガイドライン」を制定致しました。

Haskell-jp 相互を尊重したコミュニケーションのためのガイドライン

こちらはHaskell FoundationにおけるGuidelines for Respectful Communication (GRC)を日本語に翻訳し、運用主体などをHaskell-jpにおける実態に合わせて書き換えたものです。いわゆる「行動規範（Code Of Conduct。しばしば「COC」と略されます）」と同じ役割を果たすものですが、行動規範と異なり、禁止事項よりも推奨事項を数多く挙げているのが特徴です。このGRCを翻訳する前に、COCを提案した際の議論においてGRCのこうした特徴が好まれ、採用に至りました。

このGRCは、今後Haskell-jpのSlack WorkspaceやHaskell-jpのGitHubにおけるOrganizationが管理するリポジトリー、それからHaskell-jpとして開催するイベントなど、様々な場面で適用されます。参加されるみなさんはご理解の上、快適なコミュニティー活動をお楽しみください。

加えて、もちろん今秋開催予定のHaskell Day 2021においても、こちらのGRCを採用します。参加者、発表者、運営者の方々はご理解とご協力をよろしくお願いします。

[emacs][cygwin] Visual Studioのemacs / emacsclient 連携設定

2021-04-18T11:56:12.128+09:00

Visual Studioの外部ツール機能を利用して、Visual Studioで開いているファイルをショートカットキー一発で（orメニューから）emacs/emacsclientで開くことができる設定を紹介します。カーソル位置がemacsに引き継がれるのが地味に便利です。職場の都合などでビルド環境がVisual Studioだが、ビルド以外の作業は使い慣れたemacsを利用したい、という方にお勧めです。今の時代になぜWSLでなくcygwinなのか？という疑問をもたれる方がいると思いますが、このエントリはWSLがリリース前にメモを作って、ずっと公開しないまま眠っていたものです。せっかくの情報なので時代遅れを承知の上公開します。前提： "C:\cygwin64"以下にcygwinをインストールし、cygwin上でemacs/emacsclientを利用している、自分の環境を

DevOpsDays Tokyo 2021 で Infrastructure as Code のテストについて話してきました

2021-04-17T09:15:33+09:00

こんにちは、チェシャ猫です。先日開催された DevOpsDays Tokyo 2021 で Infrastructure as Code のテストについて発表してきました。公募 CFP 枠です。今回の発表は、昨年の CloudOperatorDays Tokyo 2020 での講演をほぼそのまま再現しています。内容については前回登壇時に詳細な解説記事を書いたので、こちらもご参照ください。 ccvanishing.hateblo.jp オンサイト登壇ここしばらく、どのカンファレンスもリモート開催がデフォルトになっていましたが、今回は久しぶりに会場まで行って登壇してきました。最後にオンサイト…

日本Haskellユーザーグループ管理委員会（Haskell-jp Admins）設立のお知らせ

2021-03-29T00:00:00Z

Contents

Link to
here2022/09/18 重大な追記

⚠️一般社団法人としての日本Haskellユーザーグループ管理委員会は、2022年4月16日を以て解散しました。今後は任意団体として活動を続けます。詳細は一般社団法人日本Haskellユーザーグループ管理委員会解散のお知らせをご覧ください。

以下では、記録のために設立当時の記事をほぼそのまま残しています。

去る2021年2月9日、任意団体であり明確な会員資格を持たない、日本Haskellユーザーグループ（Haskell-jp）における共有財産やコミュニケーションの場の管理・運営を担う法人として、一般社団法人日本Haskellユーザーグループ管理委員会（通称 Haskell-jp Admins。法人番号 5020005014971）を設立しました。法人格を持つことを活かして、Haskell-jp Adminsは次の事業に取り組みます。

プログラミング言語Haskellに関するイベントの企画・開催・運営
- イベントの会場を借りたり、ノベルティーを作成したりする際の名義として使用する予定です
haskell.jp ドメインの維持・管理
Haskell-jpのSlack Workspaceを始めとする、交流や情報共有を行う場の提供・管理・運営
そのほか、上記に関連して必要なこと

Link to
here背景

そもそもの設立の動機は、山下さん（@nobsun）の好意によって個人名義で保有していたhaskell.jp ドメインを共同で管理出来るようにするためでした。ドメインを団体として保有するには、法人格と、法人名義の銀行口座が必要なのです。これ以外にも、Haskell-jpとして共有する価値のあるアカウントを管理する際の名義として、随時「日本Haskellユーザーグループ管理委員会」を使用します。

Link to
here今後の活動と連絡先

Haskell-jp Adminsが出来たからといって、Haskell-jpのあり方が大きく変わることはありません。今後もSlackで質問したり議論したりブログ記事を書いたりしましょう！haskell.jpというドメインを活かし、「公式面して」自由に活動する方をいつでも待っています！

公の場で提案・相談したい場合は:
- 前述のHaskell-jpのSlack Workspaceの#randomチャンネルなどで投稿いただくか、
- haskell-jp/communityにissueとして登録したり、
- Haskell-jpのTwitterアカウント @haskell_jpにメンションをください。
プライベートに提案・相談したい場合は:
- haskell-jp-admins@googlegroups.com にメールを送ってください

我々Haskell-jp Adminsは、そうした活動をバックアップするために種々の問題に取り組んでいきます。

Link to
here現在の理事・社員

代表理事: 山本悠滋（@igrep）
社員:
- 中嶋大嗣（@nakaji_dayo)
- 山下伸夫（@nobsun）
- 岡本和樹（@kakkun61）
- 木下郁章（@fumieval）
- 廣瀬達也（@lotz84_）

Link to
here所在地

2022/09/18 編集: 法人格を廃止するとともに、契約したバーチャルオフィスの規約に従い、こちらに記載していた住所も削除しました。

Link to
here定款

こちらに一部個人情報を削除した上で掲載しています。

一般社団法人日本Haskellユーザーグループ管理委員会定款

July Tech Festa 2021 winter で CockroachDB と TLA+ について話してきました

2021-01-24T18:58:19+09:00

こんにちは、チェシャ猫です。インフラ技術のカンファレンス July Tech Festa 2021 winter で、形式手法ツール TLA+ が CockroachDB の設計に使用された事例について発表してきました。公募 CFP 枠です。 www.youtube.com 今回の登壇は、昨年の CloudNative Days Tokyo 2020 と同じ題材を扱っています。ただ、前回より持ち時間が長くなった分、前回のスライドで説明不足だった部分を拡充してあります。特に、CockroachDB 以外の TLA+ 採用事例や、分散システムにおける Chaos Engineering の位置付…

GHC 演算子優先順位トリビア

2021-01-06T07:13:09+09:00

GHC の演算子の優先順位には -1 がある（たぶん組込でしか使えない #Haskell pic.twitter.com/Xa0OIjvw5i— o̞͑kä̝mo̞͑to̞͑ kä̝zʊ̠kɪ̟ (@kakkun61) January 3, 2021

Case Analysis 関数

2021-01-06T06:30:09+09:00

今回は case analysis と呼ばれる関数の話です1。 data D a b c = C0 a b | C1 c 例えば上記のようなデータ型があった場合 case analysis 関数は次のようになります。 d :: (a -> b -> d) -> (c -> d) -> D a b c -> d d f _ (C0 a b) = f a b d _ f (C1 c) = f c 値構築子の数だけ関数を引数とし、対象のデータを最後の引数とします。それぞれの関数の型は値構築子の型に似ます。 C0 :: a -> b -> D a b c C1 :: c -> D a b c d ::…

続・刹那的純粋関数的データ構造と線形型

2021-01-01T01:44:29+09:00

The English version is at Dev. 前回の記事の追加情報です。 kakkun61.hatenablog.com pure 抜け道はなかったまあ、こういうインターフェースでありがちな pure で外に出す抜け道が存在するのですが。最後にこういうことを無思慮に書いたわけですが、Dev に書いた英語版を Reddit に載せたところ有益な情報を教えてもらえました。 www.reddit.com I think the solution to the problem with empty might be to use the Ur (for "unrestricted"…

新しいGHC拡張、NoFieldSelectorsについて

2020-12-29T19:03:47+09:00

今まで不満の多かったHaskellのレコードの扱いを改善するための一歩として、NoFieldSelectorsというGHC拡張の実装を進めている。動機 Haskellにはレコードを定義するための構文がある。 data User = User { userId :: Int , userName :: Text } こう定義すると、各フィールドごとにuserId :: User -> IntとuserName :: User -> Textというゲッターに相当する関数が生成される。これらの関数は特別な意味合いを持っており、以下のレコード操作の構文にも利用できる。構築 User { userI…

刹那的純粋関数的データ構造と線形型

2020-12-25T09:37:13+09:00

The English version is at Dev. 『純粋関数型データ構造』（以降 PFDS）の5.2章に刹那的純粋関数的キューというものが出てきます。 https://asciidwango.jp/post/160831986220/%E7%B4%94%E7%B2%8B%E9%96%A2%E6%95%B0%E5%9E%8B%E3%83%87%E3%83%BC%E3%82%BF%E6%A7%8B%E9%80%A0asciidwango.jp このキューは計算量の関係から1つの値に対して1回しか操作をしてはいけません。例えば下記操作列なら大丈夫ですが、その次の操作列では計算量が大きくな…

Writer Monadで気軽にMonad則を破る

2020-12-25T00:00:00Z

🎅この記事は、Haskell Advent Calendar 2020 25日目の記事です。
🎄Happy Christmas!!🎄

今回は先日（といっても元の質問の投稿からもう何ヶ月も経ってしまいましたが…）StackOverflowに上がったこちら👇の質問に対する回答の、続きっぽい話を書こうと思います。長いし、質問の回答からスコープが大きく外れてしまうので記事にしました。

haskell - モナド則を崩してしまう例が知りたい - スタック・オーバーフロー

MonadとMonoidにある重要な繋がりを説明した後、それを応用したWriter MonadがどうMonoidを使ってMonad則を満たしているのか証明します。そして、Writerのそうした性質を用いて簡単にMonad則を破る例を紹介することで、読者のみなさんがMonad則のみならずdo記法やMonadそのものの性質について、よりはっきりとした理解が得られることを目指します。

Contents

Link to
hereサンプルコードについて

本記事のサンプルコードは、Haskellの構文に準拠していないものを除いて、すべてreadme-testというツールの2020年12月13日時点の開発版でテストしました。こちらのツールはまだ開発中で、今後も仕様が大きく変わる可能性がありますが、この記事のサンプルコードをテストするのに必要な機能は十分にそろっています。このreadme-test自体についてはいつか改めて共有します。

また、テストの際に用いた環境は以下の通りです:

Windows 10 Pro 20H2
GHC 8.10.1
Stackage nightly-2020-08-15

Link to
here`Monad`と`Monoid`の切っても切り離せない関係

「モナドは単なる自己関手の圏におけるモノイド対象だよ。何か問題でも？」というフレーズ（原文「A monad is a monoid in the category of endofunctors, what’s the problem?」が示すとおり、モナドとモノイド、Haskellの識別子で言うところのMonadとMonoidには密接な関係があります。ぶっちゃけ、このフレーズの正確な意味を私は理解していないのですが、少なくともMonadとMonoidには重要な共通点があることは知っています。それは、どちらも単位元と結合則がある、ということです！

具体的にMonadとMonoidの単位元・結合則を見てみましょう:

Monoidの単位元: 単位元であるmemptyは、どんな値xに<>で足しても結果が変わらない！

x <> mempty = x
mempty <> x = x

Monadの単位元: returnは>>=の前に使っても後ろに使っても、mやk aの結果を変えない！

return a >>= (\a -> k a) = k a
m >>= (\a -> return a) = m

Monoidの結合則: x <> y <> zの結果は、y <> zを先に計算しようとx <> yを先に計算しようと変わらない！

x <> (y <> z) = (x <> y) <> z

Monadの結合則: m >>= \x -> k x >>= h の結果は、\x -> k x >>= hを先に計算しようと、m >>= (\x -> k x)を先に計算しようと変わらない！

m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= h

※Monadの単位元・結合則の式についてはわかりやすさのために引用元から少し形を変えています。

HaskellにおけるMonad・Monoidとは、値がそれぞれの単位元・結合則をを満たす型です¹。それ以上でも、それ以下でもありません。

それぞれの単位元・結合則を表す式は、一見して異なるものに見えるかも知れませんが、表す性質自体はよく似ています。なので、式を読んでもよく分からないという方は、上記に書いた日本語の説明をざっと眺めて覚えておいてください。特に、結合則における「～を先に計算しようと、～を先に計算しようと変わらない！」の部分がこの後とても重要になります。

Link to
here`Monoid`の例

ここまで読んで、Monadはなんか聞いたことがあるけどMonoidは初めて聞くよ、という方向けに補足すると、Monoidとは例えば次のような型の値（と、それに対する処理）です。

Sum型: 数値（Num型クラスのインスタンス）に対する、足し算を表すMonoidのインスタンス

-- これから紹介する処理に必要なモジュールのimport
import Data.Monoid

-- Sum aに対する <> は + と同等なので、
> getSum (Sum 1 <> Sum 2 <> mempty)
-- は、
1 + 2 + 0
-- と同じ。

memptyが各Monoidのインスタンスにおける単位元を返す、という点に注意してください。上記のとおり足し算の場合は0です。

Product型: 数値（Num型クラスのインスタンス）に対する、かけ算を表すMonoidのインスタンス

-- Product aに対する <> は * と同等なので、
> getProduct (Product 1 <> Product 2 <> mempty)
-- は、
1 * 2 * 1
-- と同じ。

リスト型: リスト型の値に対する、結合 (++)を表すMonoidのインスタンス

-- [a] に対する <> は ++ と同等なので、
> [1, 2] <> [3] <> mempty
-- は、
[1, 2] ++ [3] ++ []
-- と同じ

All型: Bool型の値に対する論理積&&を表すMonoidのインスタンス

> getAll (All True <> All False)
-- は、
True && False
-- と同じ

-- これが何を返すかは、想像してみてください！
getAll mempty

Any型: Bool型の値に対する論理和||を表すMonoidのインスタンス

> getAny (Any True <> Any False)
-- は、
True || False
-- と同じ

-- これも何を返すかは、想像してみてください！
getAny mempty

このように、Monoidは他のプログラミング言語でもおなじみの、多くの二項演算を表しています。これらのインスタンスはすべて、先ほど紹介した「単位元」や「結合則」のルールを守っているので、気になった方はぜひチェックしてみてください²。

Link to
here`Monoid`と`Writer`の切っても切り離せない関係

実はそんなMonadとMonoidの固い絆を象徴するようなMonadが、この世にはあります。そう、Writerです！WriterはMonoidの単位元・結合則をそのまま活かすことによってMonadの単位元・結合則を満たしたMonadであり、WriterがどうやってMonad則を満たしているのか知れば、Monad則がどうやって成立するものなのかが、すっきりクリアになることでしょう。

手始めにWriterの定義と、WriterがMonadの各メソッドをどのように実装しているか見てみましょう。「モナドのすべて」におけるWriterの紹介ページから、少しリファクタリングしつつ引用します³。

-- Writer型の定義
newtype Writer w a = Writer { runWriter :: (a, w) }

タプルに対してnewtypeしていることから分かるとおり、Writerの実態はただのタプルです。ただのタプルがどうやってMonadになるのでしょう？その答えがこちら👇:

-- WriterのMonad型クラスの実装
-- 実際のところFunctor, Applicativeのインスタンス定義も必要だけどここでは省略
instance Monoid w => Monad (Writer w) where
  return a = Writer (a, mempty)
  Writer (a, w1) >>= f =
    let Writer (b, w2) = f a
     in Writer (b, w1 <> w2)

returnの定義は比較的シンプルですね。memptyを受け取った値aと一緒にタプルに入れて返すだけです。Monadの単位元であるreturnでは、Monoidの単位元であるmemptyを使うのです。

一方、>>=はどう読めばいいでしょう？let ... in ...の結果にあたるWriter (b, w1 <> w2)に注目してください。

まず、bは>>=の右辺であるfが返した結果です。Writerの>>=が返す、Writerがラップしたタプルの一つ目の要素は、ここでfが返した値の型と一致していなければなりません。Writerにおいて>>=の型はWriter w a -> (a -> Writer w b) -> Writer w bであり、右辺にあたるfは(a -> Writer w b)という型なので、>>=全体の戻り値Writer w bとfの戻り値が一致している必要があることがわかりますよね？

さらに重要なのがw1 <> w2です。ここであのMonoidの演算子<>が出てきました！Writerは>>=の中で<>を使うMonadなんですね！一体何と何を<>しているのでしょう？まず、<>の左辺であるw1は、左辺にあたるWriterがタプルに保持していたMonoid型クラスのインスタンスの値です。そして右辺のw2は、>>=の右辺に渡した関数fがbと一緒に返したw2です。

以上のことをまとめると、Writerの>>=は、

左辺の(a, w1)におけるaをfに渡して、
fが返した(b, w2)におけるbを、
w1とw2と一緒に<>でくっつけつつ返す、

という処理を行っています。Writerは、「bを返すついでにw1とw2を<>でくっつける」と覚えてください。

Writerは、

Monadの単位元returnでMonoidの単位元memptyを使って、
Monadの結合則を満たす>>=で、これまたMonoidの結合則を満たす<>を使っているのです。

やっぱりWriterはMonoidあってのMonadと言えますね。

Link to
here`do`と`<>`

さて、この「bを返すついでにw1とw2を<>でくっつける」というWriterの振る舞いが象徴するように、大抵のMonadのインスタンスにおける>>=は、何かしら値を返すついでに、何らかの処理を行うよう実装されています。この「ついでに行われる処理」はMonadのインスタンスをdo記法の中で扱うと、ますます静かに身を隠すようになります。

こちらもWriterを例に説明しましょう。まず、例示用にWriterを作るアクションを適当に定義します。

addLogging :: Int -> Int -> Writer [String] Int
addLogging x y =
  Writer (x + y, ["Adding " ++ show x ++ " to " ++ show y ++ "."])

multLogging :: Int -> Int -> Writer [String] Int
multLogging x y =
  Writer (x * y, ["Multiplying " ++ show x ++ " with " ++ show y ++ "."])

addLoggingとmultLoggingはそれぞれ、引数として受け取った整数を足し算したりかけ算したりしつつ、「足したよ」「かけたよ」という内容の文字列を一緒に返します。Writer [String] Intにおける[String]にログとして書き込んでいるようなイメージで捉えてください。

これらをdoの中で使ってみると、よりaddLoggingやmultLoggingが「足し算やかけ算をするついでに、ログとして書き込んでいる」っぽいイメージが伝わるでしょう:

testDo :: Writer [String] Int
testDo = do
  result1 <- addLogging 3 4
  result2 <- multLogging 5 2
  addLogging result1 result2

⚠️申し訳なくもdo記法自体の解説、つまり>>=がどのようにdo記法に対応するかはここには書きません。お近くのHaskell入門書をご覧ください。

👆では、3 + 4した結果result1と、5 * 2した結果result2を足す処理を行っています。それに加えて、「足したよ」「かけたよ」というログを表す文字列のリスト[String]も一緒に返しています。do記法が>>=に変換されるのに従い、Writerの>>=が内部で<>を使い、addLogging 3 4・multLogging 5 2・addLogging result1 result2が返した文字列のリスト[String]を結合することによって、あたかもaddLoggingやmultLoggingが「値を返しつつ、ログとして書き込む」かのような処理を実現できるのがWriterにおけるdo記法の特徴です。

能書きはここまでにして、実際にどのような結果になるか見てみましょう:

> runWriter testDo
(17,["Adding 3 to 4.","Multiplying 5 with 2.","Adding 7 to 10."])

はい、3 + 4と5 * 2の結果を足し算した結果17と、addLogging 3 4・multLogging 5 2・addLogging result1 result2が一緒に返していた文字列のリスト[String]が、書いた順番どおりに結合されて返ってきました。Writerはdo記法の中に書いたWriterの値(a, w)のうち、Monoidのインスタンスであるwを<>で都度結合させているということが伝わったでしょうか？

Link to
here`Writer` `Monad`の結合則と`Monoid`の結合則

ここまでで、Writer Monadがどのように<>を使っているのか、それによって>>=やdo記法がどのように振る舞っているのか、具体例を示して説明いたしました。ここからは、WriterがMonoidの<>の結合則をどう利用することで、Monadとしての>>=の結合則を満たしているのかを示しましょう。長いので「めんどい！」という方はこちらをクリックしてスキップしてください。

そのために、Monadの結合則における>>=を、Writerの>>=として展開してみます。

(0) Monadの結合則:

m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= h

(1) mは>>=の左辺なのでWriter (a, w1)に置き換える:

※ここからは、比較しやすくするために等式=の左辺と右辺を別々の行に書きます。

let Writer (a, w1) = m in Writer (a, w1) >>= (\x -> k x >>= h)
  =
let Writer (a, w1) = m in Writer (a, w1) >>= (\x -> k x) >>= h

(2) 一つ目の>>=をWriterにおける>>=の定義で置き換える:

let Writer (a, w1) = m
    Writer (b, w2) = (\x -> k x >>= h) a
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m in Writer (a, w1) >>= (\x -> k x) >>= h

(3) 等式=の右辺における一つ目の>>=も同様に変換する:

let Writer (a, w1) = m
    Writer (b, w2) = (\x -> k x >>= h) a
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m
    Writer (b, w2) = (\x -> k x) a
 in Writer (b, w1 <> w2) >>= h

(4) 無名関数である(\x -> k x >>= h)と(\x -> k x)に、aを適用する:

let Writer (a, w1) = m
    Writer (b, w2) = k a >>= h
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m
    Writer (b, w2) = k a
 in Writer (b, w1 <> w2) >>= h

(5) 等式=の左辺における二つ目の>>=をWriterにおける>>=の定義で置き換える:

let Writer (a, w1) = m
    Writer (b, w2) =
      let Writer (c, w3) = k a
          Writer (d, w4) = h c
       in Writer (d, w3 <> w4)
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m
    Writer (b, w2) = k a
 in Writer (b, w1 <> w2)) >>= h

(6) 等式=の右辺における二つ目の>>=も同様に変換する:

let Writer (a, w1) = m
    Writer (b, w2) =
      let Writer (c, w3) = k a
          Writer (d, w4) = h c
       in Writer (d, w3 <> w4)
 in Writer (b, w1 <> w2)
  =
let Writer (a, w1) = m
    Writer (b, w2) = k a
 in let Writer (c, w3) = Writer (b, w1 <> w2)
        Writer (d, w4) = h c
     in Writer (d, w3 <> w4)

(7) Writerは、Writerと(a, w)を切り替えるだけで実質何もしていないので削除する:

let (a, w1) = m
    (b, w2) =
      let (c, w3) = k a
          (d, w4) = h c
       in (d, w3 <> w4)
 in (b, w1 <> w2)
  =
let (a, w1) = m
    (b, w2) = k a
 in let (c, w3) = (b, w1 <> w2)
        (d, w4) = h c
     in (d, w3 <> w4)

(7.5) (7)の等式をよく見ると、=の左辺においては(b, w2)と(d, w3 <> w4)が、=の右辺においては(c, w3)と(b, w1 <> w2)が等しい。

let (a, w1) = m
    (b, w2) = --           ここの(b, w2)は、
      let (c, w3) = k a
          (d, w4) = h c
       in (d, w3 <> w4) -- ここの(d, w3 <> w4)を代入したもの！
 in (b, w1 <> w2)
  =
let (a, w1) = m
    (b, w2) = k a
 in let (c, w3) = (b, w1 <> w2) -- ここで代入している！
        (d, w4) = h c
     in (d, w3 <> w4)

(8) (7.5)から、=の左辺ではb = dでw2 = w3 <> w4、=の右辺ではc = dでw3 = w1 <> w2であることがわかる。なのでそれぞれ置き換える:

let (a, w1) = m
    (c, w3) = k a
    (d, w4) = h c
 in (d, w1 <> (w3 <> w4))
  =
let (a, w1) = m
    (b, w2) = k a
    (d, w4) = h b
 in (d, (w1 <> w2) <> w4)

(9) a～d・w1～w4の変数名を、登場した順番に振り直す:

let (a, w1) = m
    (b, w2) = k a
    (c, w3) = h b
 in (c, w1 <> (w2 <> w3))
  =
let (a, w1) = m
    (b, w2) = k a
    (c, w3) = h b
 in (c, (w1 <> w2) <> w3)

等式=の左辺と右辺がそっくりな式になりましたね！

ここで、Monoidの結合則を思い出してみましょう:

x <> (y <> z) = (x <> y) <> z

そう、x <> y <> zなどと書いて3つのMonoid型クラスのインスタンスの値を<>でくっつけるときは、カッコで囲って(y <> z)を先に計算しようと、(x <> y)を先に計算しようと、結果が変わらない、というものでした！

それを踏まえて、(9)の等式=の両辺をよく見比べてみてください。異なっているのはw1 <> (w2 <> w3)と(w1 <> w2) <> w3)の箇所だけですね！つまり、Writer Monadにおける>>=の結合則は、w1 <> (w2 <> w3)と(w1 <> w2) <> w3)が等しいから、すなわちMonoidにおける<>の結合則が成り立つからこそ成立するのです。これがまさしく「MonoidとWriterの切っても切り離せない関係」なのです！

Link to
here関係を壊してみる

それではいよいよ、「MonoidとWriterの切っても切り離せない関係」を利用して、Monad則を破ってみましょう💣

Link to
here`<>`と`Monoid`の結合則

前述のとおり、Writerにおける>>=が結合則を満たすのは、WriterがラップしているMonoidな値の<>が結合則を満たしてこそ、なのでした。これは言い換えれば、その、ラップしているMonoidな値の<>が結合則を破れば、自然にWriterの>>=も結合則を破るはずです。この方法は、結合則を満たさない>>=っぽい処理をゼロから探すより遥かに簡単です。>>=のようなm a -> (a -> m b) -> m bというややこしい型の関数よりも、<>のようなa -> a -> aという型の関数の方がずっと身近ですしね！

Monoidの<>のようなa -> a -> aという型の関数で、結合則を満たさない処理 — といえば、引き算-や割り算/を思い浮かべる方が多いのではないでしょうか。と、いうわけでMonoidの例で紹介したSumやProductのように、数値に対する引き算を表すnewtype、Differenceを定義してみましょう:

newtype Difference a = Difference { getDifference :: a }

それから、Differenceを（実際には間違いですが）Monoidのインスタンスにします。最近のGHCでは、Monoidのインスタンスを定義する前にSemigroupのインスタンスにする必要があるのでご注意ください。説明しやすさのために敢えてこれまで触れてきませんでしたが、これまで何度も使った<>は実際のところMonoidの関数ではなくSemigroupの関数なんですね。Monoidは「<>で（結合則を備えた）二項演算ができるだけでなく、memptyという単位元もある」という性質の型クラスなので、「単に『<>で（結合則を備えた）二項演算ができる』だけの型クラスも欲しい！」というニーズから、Monoidの<>はSemigroupの関数となり、MonoidはSemigroupのサブクラスという関係に変わったのでした。

何はともあれ、DifferenceをSemigroupのインスタンスにしましょう:

instance Num a => Semigroup (Difference a) where
  Difference a <> Difference b = Difference (a - b)

はい、単に両辺を-で引き算するだけですね。

今度こそDifferenceをMonoidのインスタンスにします。本記事ではmemptyを直接使うことはないので何でもいいはずですが、とりあえずSumと同様に0ということにしておきます:

instance Num a => Monoid (Difference a) where
  mempty = Difference 0

😈これで<>が結合則を満たさないおかしなMonoidのインスタンス、Differenceができました！早速試して結合則を破っていることを確認してみましょう:

-- こちらは 1 - (2 - 3) と同じ
> getDifference $ Difference 1 <> (Difference 2 <> Difference 3)
2

-- こちらは (1 - 2) - 3 と同じなので...
> getDifference $ (Difference 1 <> Difference 2) <> Difference 3
-4 -- <- 当然 1 - (2 - 3) とは異なる結果に！

バッチリ破れてますね！このように<>における結合則は、引き算などおなじみの演算で、簡単に破ることができます💪

Link to
here`>>=`と`Monad`の結合則

<>における結合則を破ることができたと言うことは、Writerの>>=による結合則も、もはや破れたも同然です。先ほど定義したDifference型を使えば、>>=は途端に結合則を満たさなくなるでしょう。

例を示す前に、Writerを使う際しばしば用いられる、ユーティリティー関数を定義しておきます。実践でWriterを使いたくなったときにも大変便利なので、是非覚えておいてください:

tell :: Monoid w => w -> Writer w ()
tell w = Writer ((), w)

このtell関数は、受け取ったMonoidな値をそのまま「ログとして書き込む」関数です。結果として返す値はただのユニット()なので、気にする必要がありません。tellのみを使ってWriterを組み立てれば、「ログとして書き込む」値のみに集中することができます。これから紹介する例でもやはり関心があるのは「ログとして書き込む」値だけなので、ここでtellを定義しました。

それではtellを使って、Writerの>>=における結合則も破ってみましょう:

-- こちらは Difference 1 <> (Difference 2 <> Difference 3) と同じ
> getDifference . snd . runWriter $ tell (Difference 1) >>= (\_ -> tell (Difference 2) >>= (\_ -> tell (Difference 3)))
2

-- こちらは (Difference 1 <> Difference 2) <> Difference 3 と同じなので...
> getDifference . snd . runWriter $ (tell (Difference 1) >>= (\_ -> tell (Difference 2))) >>= (\_ -> tell (Difference 3))
-4 -- <- 当然 1 - (2 - 3) とは異なる結果に！

予想どおり一つ目のWriterと二つ目のWriterとで異なる結果となりました。1 - (2 - 3)と(1 - 2) - 3をWriterを使って遠回しに言い換えているだけなので、当然と言えば当然です。

しかしtell (Difference 1) >>= (\_ -> tell (Difference 2) >>= \_ -> tell (Difference 3))などのWriter型の式がMonadの結合則m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= hにどう対応するのか、ちょっと分かりづらいですかね？（式も長いし）一つずつ注釈を加えます:

-- こちらは m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= h の前半、
--   m >>= (\x -> k x >>= h) に相当する
>  tell (Difference 1) >>= (\_ -> tell (Difference 2) >>= (\_ -> tell (Difference 3)))
-- ^^^^^^^^^^^^^^^^^^^       ^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
--          m                x             k                             h
--

-- こちらは m >>= (\x -> k x >>= h) = (m >>= (\x -> k x)) >>= h の後半、
--   (m >>= (\x -> k x)) >>= h に相当する
>  (tell (Difference 1) >>= (\_ -> tell (Difference 2))) >>= (\_ -> tell (Difference 3))
--  ^^^^^^^^^^^^^^^^^^^       ^    ^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
--           m                x             k                             h

ラムダ式の引数xは実際には使われていない点に注意してください。これでもconstを使って\x -> const (tell (Difference 2)) xと書き換えれば、const (tell (Difference 2))がkに厳密に対応するので、上記の二組の式は>>=の結合則を破るペアだと言えます。

Link to
here`do`記法と`Monad`の結合則

前の節では、Monoidの結合則を守っていない値をラップしているWriterを作ることで、>>=の結合則を破る例を簡単に作り出せることを紹介しました。ここでは本記事の最後として、>>=の結合則を破った結果、do記法がいかに直感に反する挙動となるか紹介して、>>=の結合則を守ることが私たちにどのようなメリットをもたらすのか解説します。

例として、先ほど>>=の結合則を破るのに使った1 - 2 - 3を再利用しましょう。DifferenceをラップしたWriterで1 - 2 - 3を計算させると、次のような式になります:

tell (Difference 1) >>= (\_ -> tell (Difference 2)) >>= (\_ -> tell (Difference 3))

これをdo記法に変換すると、次のようになります:

do
  tell (Difference 1)
  tell (Difference 2)
  tell (Difference 3)

do記法における各行の間に>>=が隠れたことで、すっきりしましたね！

この状態から、do記法を使って1 - (2 - 3)と(1 - 2) - 3を表すWriterの式にするには、次のように書き換えます:

-- こちらが 1 - (2 - 3) を表す
do_1minus'2minus3' =
  do
    tell (Difference 1)
    do
      tell (Difference 2)
      tell (Difference 3)

-- こちらが (1 - 2) - 3 を表す
do_'1minus2'minus3 =
  do
    do
      tell (Difference 1)
      tell (Difference 2)
    tell (Difference 3)

コメントに書いたとおり、do_1minus'2minus3'が1 - (2 - 3)、do_'1minus2'minus3が(1 - 2) - 3と同等なWriterです。Haskellはシングルクォートを変数の名前に含めることができるので、シングルクォートでカッコを表すことにしました（まさかこんなところで役に立つとはね！）。

上記の二つの式では、カッコ()で囲う代わりにもう一つのdo記法に収めることで、do記法における各行を実行する順番をいじっています。

本当にこれで1 - (2 - 3)や(1 - 2) - 3と同等な式になっているのでしょうか？試しにrunWriterして結果を確かめてみましょう:

-- こちらが 1 - (2 - 3) を表す
> getDifference . snd $ runWriter do_1minus'2minus3'
2

-- こちらが (1 - 2) - 3 を表す
> getDifference . snd $ runWriter do_'1minus2'minus3
-4

バッチリ👌想定どおり、do_1minus'2minus3'が1 - (2 - 3) = 2を計算し、do_'1minus2'minus3が(1 - 2) - 3 = -4を計算していますね！

さてこれまでで、Writer MonadはMonoidの結合則を利用することで>>=の結合則を満たしていることを示し、ラップしているMonoidな値が結合則を満たしていなければ、必然的にWriterも結合則を破ってしまうことを、>>=やdo記法を使って具体的に示しました。それでは今挙げた、do記法で結合則を破った例は、一体何を示唆しているのでしょうか？普通にHaskellでコードを書いていて、前述のような書き換え、すなわち、

do
  tell (Difference 1)
  do
    tell (Difference 2)
    tell (Difference 3)

から、

do
  do
    tell (Difference 1)
    tell (Difference 2)
  tell (Difference 3)

への書き換え（あるいはその逆）は、一見するとそんな機会ないように思えます。しかしこれが、do記法をカッコ代わりに使うという変な方法ではなく、次のように変数に代入することで切り出していた場合、いかがでしょうか？

someSingleAction = tell (Difference 1)

someSequence = do
  tell (Difference 2)
  tell (Difference 3)

someCompositeAction = do
  someSingleAction
  someSequence

上記👆のような三つのWriterの値を、下記👇の三つの値にリファクタリングする場合です。

refactoredSequence = do
  tell (Difference 1)
  tell (Difference 2)

splitOutSingleAction = tell (Difference 3)

refactoredCompositeAction = do
  refactoredSequence
  splitOutSingleAction

あるいは、たった3行しかありませんし、一つの値に統合する方がいいかも知れません:

flattenedAction = do
  tell (Difference 1)
  tell (Difference 2)
  tell (Difference 3)

これらの書き換えは、いずれもdo記法が内部で使っている>>=の結合則を前提とすれば、可能であってしかるべきです。do記法は、適当にMonadのインスタンスの値（「アクション」などとも呼ばれます）を上から下まで列挙すれば、自動で>>=を使ってつなげてくれる、というものです。なので、適当に並べたアクションがどういう形に結合されるのか気にする必要があるのでは、安心して使えません。一方、上記の3組の式は、Writer Difference、すなわち引き算を表す「偽Monoid」をラップしているが故に、>>=の結合則を満たしておりません。結果、do記法に変えたときに並べたアクションをどこで切り出すかで、結果が変わってしまいます。これでは安心して列挙できません！

Link to
hereまとめ

以上です。これまでで、Monad則のうち結合則がなぜ重要なのか、結合則を実際に破ってみることを通じて説明しました。Monadと同様に結合則を持ったMonoidは、Monad以上にインスタンスを見つけるのが簡単で、なおかつ、例えば引き算のように「二項演算だけど結合則を満たしていない」処理を見つけるのが簡単です。本記事ではMonoidのそうした性質と、Monoidの性質でもってMonad則を満たしているWriter Monadに注目することで、簡単にMonad則を破る例を提示することができました。それから、Monadの結合則を実際に破った例を使って、Monadの結合則がdo記法を自然に書けるようにするために必要であることを示しました。これらの実例から主張したいことを一般化すると、次のとおりです:

do記法の各行の間で、値を返すついでに何かを行うのがMonadのインスタンス
do記法の各行の間で、値を返すついでに行っている処理が結合則を満たす型が、Monad則を満たすと言える
Monad則を守らない型をdo記法で使うと、do記法の結合を気にして書かなければならなくなる

それでは、2021年も🎁Happy Haskell Hacking with Monad🎁!

一応、MonadについてはそのスーパークラスであるApplicativeの則、Functorの則がありますが、Monad則を満たしていればそれらは自動的に満たせるので、ここでは省略します。↩︎
残念ながら実際のところ、Float型・Double型などの浮動小数点数に対するSumやProductは結合則を満たさない場合があります。これは他の多くのプログラミング言語にもある、浮動小数点数の悩ましい問題です。詳しくは「情報落ち」で検索してみてください。↩︎
ここでの定義は、実際に使われているtransformersパッケージのWriterの定義とは大きく異なっているのでご注意ください。実際のWriterはパフォーマンス上の都合やMonad Transformerとの兼ね合いで、幾分工夫された定義となっています。↩︎

動的配列の無難なHaskell実装

2020-12-18T21:46:26+09:00

qiita.com C++、Rust、Pythonなど、他の言語では当たり前のように多用される動的配列だが、Haskell実装は(開発を始めた時点では)見当たらなかったので作ってみたお話*1。動的配列とはミュータブルな配列の一種で、通常の配列操作だけでなく、末尾への要素の追加・削除が定数時間で行える構造である。確保しておいた領域がいっぱいになったら、その2倍の大きさの領域を確保するという方法によって、漸近的には要素の追加は定数時間となる。内部の配列には、デファクトスタンダードであるvectorパッケージを用いる。Vectorには無印(boxed)、Unboxed、Storableの三種類の…

liszt: Append onlyでリーダーとライターが分離されたKVS

2020-12-16T00:48:51+09:00

adventar.org 以前仕事で使おうとして没になったアイデアを改めて記事にまとめる。動機以前書いた記事で説明したものとほとんど一緒である。 fumieval.hatenablog.com プログラムのログをリアルタイムに監視する仕組みが欲しいが、その仕組みがダウンしても監視対象には影響を及ぼさないようにしたいというのポイントだ。そのため、ライター側はファイルに書き込み、リーダーはinotifyなどでファイルを監視するという、書き込みにサーバーを必要としない仕組みにした。さらに、途中でクラッシュしても問題ないよう、ファイルはappend-onlyとし、ファイルの最後にページを書き込…

とりとめのない GHC 線形型メモ

2020-12-13T18:56:45+09:00

GHC 9.0.1 alpha 1 がリリースされたときに線形型をいじってみていたことをメモしていなかったので思い出しながらメモしていく。 mail.haskell.org 使用バージョン GHC 9.0.0.20200925 上記リンクのもの ghcup ならそれ経由でインストールできる。 ghcups の場合は手動インストール後、下記のような設定ファイルで切り替えができるようになる1。 ghc: 9.0.1-alpha1: H:\programs\ghc-9.0.0.20200925-x86_64-unknown-mingw32\bin 線形型とは GHC では引数が1回しか使えない（1回…

Haskell AntennaのCI/CDをGitHub Actionsに移行する

2020-12-12T00:00:00Z

Haskell-jpのコンテンツの一つとしてHaskell AntennaというWebページの開発・運用をしております。

バイナリのビルドやDockerイメージのビルドにTravisCIを、バイナリを実行してページの更新をするのにDroneCIを使っていました。しかし、長らく放置していてちゃんと動作しているか怪しかったので、メンテナンスをするついでに昨今はやり（要出典）のGitHub Actionsにこれらを移行することにしました。

Contents

Link to
hereStackプロジェクトのビルド

まずはバイナリのビルドを行うように設定します。 Haskell AntennaのプログラムはHaskell Stackを利用しているので、stack buildが実行できれば良いです。

name: Build Application
on:
  pull_request: null
  push:
    branches:
    - master
jobs:
  build:
    name: ${{ matrix.os }}
    runs-on: ubuntu-18.04
    strategy:
      fail-fast: false
      matrix:
        ghc: ["8.8.4"]
    steps:
    - uses: actions/checkout@v2
    - name: Cache .stack
      id: cache-stack
      uses: actions/cache@v2
      with:
        path: ~/.stack
        key: "\
          ${{ runner.os }}-stack\
          -${{ hashFiles('**/stack.yaml.lock') }}\
          -${{ hashFiles('**/package.yaml') }}\
        "
        restore-keys: |
          ${{ runner.os }}-stack-
    - uses: haskell/actions/setup@main
      name: Setup Haskell
      with:
        ghc-version: ${{ matrix.ghc }}
        enable-stack: true
        stack-version: 'latest'
    - name: Install dependencies
      run: stack --system-ghc test --only-dependencies
    - name: Build and Test
      run: stack --system-ghc test --copy-bins --local-bin-path=./bin

これは、PRが作られたときやmasterがプッシュされたときに実行されることを想定しています。

GitHub ActionsでHaskellやHaskell Stackを使うには、~~公式が提供しているactions/setup-haskell~~ haskell/actions/setup を利用します。元々はactions/haskell-setupがありましたが、どうやらメンテナンスする人がいなくなったっぽくアーカイブされてしまいました。この記事を書いている時点では移行したばかりでちゃんとタグが切られていないため、mainブランチを指定しています。ちなみに、StackプロジェクトのGHCバージョンをhaskell/actions/setupでインストールして、stack --system-ghcをすることでキャッシュサイズを減らすことができます。

これまた余談ですが、actions/setup-haskellの方を使っていて次のようなエラーが出る場合はactions/setup-haskellのバージョンが古いです（最新では修正済みです）。haskell/actions/setupの方を使いましょう。

Installing ghc version 8.8.4
  Error: Unable to process command '::add-path::/opt/ghc/8.8.4/bin' successfully.
  Error: The `add-path` command is disabled. Please upgrade to using Environment Files or opt into unsecure command execution by setting the `ACTIONS_ALLOW_UNSECURE_COMMANDS` environment variable to `true`. For more information see: https://github.blog/changelog/2020-10-01-github-actions-deprecating-set-env-and-add-path-commands/

Link to
hereDockerイメージのビルドとプッシュ

antennaプログラムはDockerイメージにしてDocker Hubに置いてあります（これもGitHub Container Registryに移行したいですね）。なので、masterの更新に合わせてDockerイメージをビルドしてプッシュするジョブを設定します。 Dockerイメージのビルドとプッシュにはdocker/build-push-actionを使います。

# さっきと同じ設定ファイルです
name: Build Application
on:
  pull_request: null
  push:
    branches:
    - master
jobs:
  build:
    name: ${{ matrix.os }}
    runs-on: ubuntu-18.04
    strategy:
      fail-fast: false
      matrix:
        ghc: ["8.8.4"]
    steps:
    ... # 割愛
    - name: Build and Test
      run: stack --system-ghc test --copy-bins --local-bin-path=./bin
    # Build and Push Docker Image
    - name: Setup QEMU
      uses: docker/setup-qemu-action@master
      with:
        platforms: all
    - name: Setup Docker Buildx
      id: buildx
      uses: docker/setup-buildx-action@master
      with:
        version: latest
    - name: Login to DockerHub
      uses: docker/login-action@v1
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKERHUB_TOKEN }}
    - name: Build and push
      uses: docker/build-push-action@v2
      with:
        context: .
        builder: ${{ steps.buildx.outputs.name }}
        tags: haskelljp/antenna:latest
        push: ${{ github.event_name != 'pull_request' }}
        build-args: local_bin_path=./bin

masterブランチへのプッシュのときにだけDockerイメージのプッシュをして欲しいので、push: に github.event_name != 'pull_request' を設定しています。また、Haskell Stackでビルドされたバイナリファイルは--local-bin-path=./binオプションで./binに置いてあります。これをDockerfileでコピーするようにしている（下記参照）ので、docker buildの引数にlocal_bin_path=./binというのを与える必要がありました。

FROM matsubara0507/ubuntu-for-haskell:git
ARG local_bin_path
RUN mkdir -p /root/.local/bin && mkdir -p /work
ENV PATH /root/.local/bin:$PATH
WORKDIR /work
COPY ${local_bin_path} /root/.local/bin

このように前のstepまでの結果を利用するには context: . を指定する必要があります（デフォルトではgit-contextというのを使うからです）。

Link to
hereantennaプログラムの実行

最後に、masterの更新があったときにantennaプログラムを実行してHaskell Antennaページを更新するような設定をします。日毎のスケジュール実行も設定したいので、新しいワークフローを切りました。

name: Update Antenna page
on:
  schedule:
  - cron: '0 8 * * *'
  push:
    branches:
    - master
    paths-ignore:
    - 'README.md'
    - 'CHANGELOG.md'
    - 'LICENSE'
    - '.gitignore'
jobs:
  update:
    name: ${{ matrix.os }}
    runs-on: ubuntu-18.04
    strategy:
      fail-fast: false
      matrix:
        ghc: ["8.8.4"]
    steps:
    ... # Install dependenciesまでは一緒なので割愛
    - name: Build
      run: stack --system-ghc build

    - uses: actions/checkout@v2
      with:
        ref: 'gh-pages'
        path: 'temp'
    - name: Exec Application
      run: |
        cp sites.yaml temp/sites.yaml
        cp -r image/* temp/image
        cd temp && stack exec -- antenna sites.yaml
    - name: Push changes
      env:
        COMMIT_MESSAGE: Update haskell antenna. See https://haskell.jp/antenna/ for new entries!
      run: |
        git config --local user.email "bot@example.com"
        git config --local user.name "Bot"
        git status
        git add -A
        git diff --staged --quiet || git commit -m "$COMMIT_MESSAGE"
        git push origin gh-pages
      working-directory: ./temp

バイナリをビルドするところまでは一緒です。 Haskell Antennaは同じリポジトリのgh-pagesブランチに置いて、GitHub Pagesを使って公開しています。なので、同じリポジトリのgh-pagesブランチをgit cloneしなおしてサブディレクトリに置き、そこでantennaプログラムを実行して、更新があった場合にのみプッシュしています。同じリポジトリであれば、特に設定することなくプッシュできるのがGitHub Actionsのメリットですね。

Link to
hereおまけ：Zennを追加しました！

ついでに最近のアップデートによって、ZennをHaskell Antennaに載せるサイトへ追加しました（igrep氏がしてくれました、ありがとうございます）。アイコンの利用規約などがわからなかったのですが、GitHubのPR上で直接聞いてみたところ、問題ないという回答をいただきました。突然だったのにありがとうございます。

Kubernetes: kube-scheduler をソースコードレベルで理解する

2020-12-02T18:11:55+09:00

はじめに Kubernetes において、Pod を配置するための Node を決定する手続きをスケジューリングと呼び、デフォルトのクラスタでは kube-scheduler がその責務を担っています。本記事ではこの kube-scheduler のソースコードを時系列に沿って追いつつ、どのようなロジックで Pod を配置する Node が決定されるのかを解説します。なお、本記事は Kubernetes の内部実装について学ぶ勉強会 Kubernetes Internal #3 の補足資料を意図して執筆されました。本文中で参照しているソースコードのバージョンは v1.19.4 です。 Kub…

安全性-活性分解定理とその関連研究

2020-11-14T21:43:55+09:00

こんにちは、チェシャ猫です。先日行われた第 7 回 Web System Architecture 研究会で形式手法について発表してきました。普段、形式手法について登壇する際は具体例な検証例を出すことが多いですが、今回は理論側に寄せたサーベイになっています。はじめに本セッションでは、安全性-活性分解 (safety-liveness decomposition) と呼ばれる一連の結果について解説する。安全性-活性分解は、システムの仕様が与えられた時、それを安全性 (safety) および活性 (liveness) と呼ばれる、よりシンプルな特徴付けを持つクラスに分解して扱うための方法論で…

Windows から Windows コンテナーと Linux コンテナーの両方の Docker を使う

2020-11-03T02:20:40+09:00

Docker Desktop for Windows は Windows コンテナーと Linux コンテナーが使えるのだけど排他的になっている。そう思ってスクショを取るために切り替えボタンを押してみたら今はそうじゃない？Windows/Linux コンテナーの切り替え、前は完全に排他的だったと思ったけど、今は実行は両方できるのか？あとホストの再起動要らなくなってる？まあ、そもそも Docker Desktop for Windows のコンテナーが排他的なの理由が分からないのよな。で、両方のコンテナーをいじりたいのでラッパープログラムを作った。その内要らなくなりそうだけど。イメージ図…

Data.Monoid.First と Data.Semigroup.First あるいは Last

2020-10-28T22:33:09+09:00

Data.Monoid.First のドキュメントを見ていたら次の記述を見つけたことから始まる記事です。 This type will be marked deprecated in GHC 8.8, and removed in GHC 8.10. Users are advised to use the variant from Data.Semigroup and wrap it in Maybe. すでに GHC 8.10 がリリースされているのにまだなくなっていない気がしますが（GHC 9.0.1-alpha1 にもまだある）、Data.Monoid.First よりも Data.S…

動的型付けインタープリター言語 Haskell

2020-10-23T18:16:01+09:00

コンパイルを待つなんて生産性が低い！通らないコード片のエラーなんか知らない！えっ？！まだ静的型検査してコンパイルしてるの？デキるプログラマーは動的型検査！インタープリット！ main = do input <- readLn if input < 10 then putStrLn "Hi" else putStrLn ("Bad" + input) このコードを実行するにはどうしてる？まさかこうしてる？ > ghc main.hs main.hs:5:21: error: • No instance for (Num [Char]) arising from a use of ‘+’ •…

自動printfデバッグ

2020-10-02T20:45:54+09:00

関数をデバッグするために、引数と戻り値をそれぞれ表示するというのを誰しもやったことがあると思う。今回はそれを自動化するからくりをHaskellで実装してみる。目標となるのは、関数が与えられたとき、その引数と結果をターミナルに出力する関数に変換する高階関数、probe :: Traceable a => String -> a -> aである。 testDelay :: Double -> Double -> IO () testDelay dur dur' = threadDelay $ round $ (dur + dur') * 1000000 *Probe> probe "testDe…

shake + lucid + hint で静的ウェブサイト生成

2020-09-26T17:13:27+09:00

The English version is at Dev. 同人活動用のウェブサイトがあって今までは Jekyll で生成していました。これを Shake + Lucid + Hint で作成した生成器に置き換えました。 doujin.kakkun61.com shakebuild.com hackage.haskell.org hackage.haskell.org ソースコードはこちらです。 github.com 経緯 GitHub Pages をホストに選択したので最初は自然に Jekyll を選びました。レールに乗っているうちはいいのですが外れたことをしようとすると難しくなってきまし…

CloudNative Days Tokyo 2020 で CockroachDB と TLA+ について話してきました

2020-09-10T04:48:48+09:00

こんにちは、チェシャ猫です。先日行われた CloudNative Days Tokyo 2020 で、形式手法ツール TLA+ が CockroachDB の設計に使用された事例について発表してきました。公募 CFP 枠です。講演概要 CockroachDB は、Google Spanner の系譜に連なるいわゆる NewSQL データベースの一種です。強い一貫性や ACID トランザクションといった従来の関係データベースが持つ「良い特徴」を残したまま、従来の関係データベースが苦手としていた水平スケーリングにも優れるのが特徴です。CockroachDB 自身は「地理分散 (geo-dist…

一番簡単な MonadFail インスタンス

2020-09-02T02:53:28+09:00

The English version is at Dev. 導入 fail が Monad から剥がされて早や幾年、私は失敗する可能性のある計算は MonadFail を使って型を付けるのが好きです。 foo :: MonadFail m => m a こうすると IO の文脈であればその中で、純粋な文脈であれば Maybe などで具体化して呼ぶことができます。 -- IO の文脈では foo :: IO a -- 純粋な文脈では foo :: Maybe a さて、純粋な文脈として Maybe を使うと失敗のメッセージを失ってしまうことが嬉しくありません。では、Either を使えばいいの…

【#CODT2020 解説】Infrastructure as Code の静的テスト戦略

2020-07-30T17:39:35+09:00

こんにちは、チェシャ猫です。先日行われた Cloud Operator Days Tokyo 2020 で、Infrastructure as Code のテストについて発表してきました。公募 CFP 枠です。 Cloud Operator Days Tokyo 2020 は今回が初開催のイベントですが、昨年 CloudNative Days Tokyo と併設されていた OpenStack Days Tokyo が前身となっているようです。 ASCII.jp：ふれあえるオンラインイベント「Cloud Operator Days Tokyo 2020」は泥臭い？今年は OpenStack に…

data / newtype / type の使い方

2020-06-14T00:00:00Z

Haskell プログラミングにおいて，データ型は非常に重要な役割を持つ．データ型は，扱うデータをプログラミング上で安全かつ容易に加工するために用いられ，またデータに対してどのような操作ができるのかを規定する．

Haskell には，データ型を新たに定義する方法が3つある．

1つ目は type キーワードによって定義する方法で，これにより定義されたデータ型は型シノニムと呼ばれる．
2つ目は data キーワードによって定義する方法で，これにより定義されたデータ型は代数的データ型と呼ばれる．
3つ目は newtype キーワードによってある型を元に新たな型を作る方法だ．

今回は，それぞれどういう使い方をするのか，どういう違いがあるのかについて見ていきたいと思う．

Contents

Link to
here型シノニム

例えば，あなたは Web サイトを運営していて，一部年齢制限が必要なため，人の年齢が 20 歳以上かを判定する関数を書かなければいけないとする．年齢は整数だが，入力は必須でないため入力してない人もいる．その場合は，20 歳以上でないと判定する．この関数は，

isAdult :: Maybe Int -> Bool
isAdult m = case m of
  Nothing -> False
  Just x  -> x >= 20

と書ける．ただ，この定義はどこか味気ない．isAdult が受け取るデータは，年齢を表していて，整数か未詳かの状態を持つので，Maybe Int はデータを正確に捉えられている．しかし，Maybe Int に適合するデータは他に無数にあるため，isAdult が受け取るデータが年齢を表すのか知能指数を表すのか，はたまた今までお酒を飲んだことのある回数なのかは推測しないと分からない．年齢を表すデータ型を新たに定義して，それを受け取るようにすればもっとプログラムがクールになるだろう．

Haskell で新しくデータ型を定義する最も簡単な方法は，type キーワードを使って型シノニム (type synonym) を定義する方法だ．シノニムとは，別名という意味で，型シノニムは文字通り，ある型の別名を表す．今回は次のように使える:

type Age = Maybe Int

isAdult :: Age -> Bool
isAdult age = case age of
  Nothing -> False
  Just x  -> x >= 20

これで関数 isAdult は，先ほどと比べてとても明確になった．Age は Maybe Int を元に作られた型シノニムで，つまり Age は Maybe Int の別名になっている．単なる別名なので，isAdult は Maybe Int -> Bool 型の関数だと思って使うこともできる．GHCi で試してみよう:

>>> (isAdult :: Maybe Int -> Bool) (Just 22 :: Age)
True

Maybe Int を Age だと思うこともできるしその逆もできる．型シノニムと元となった型は自在に取り替え可能だ．型シノニムはとても手軽なので，Haskell の標準ライブラリでも使われている．例えば，次のようなデータ型が型シノニムで定義されている:

type String = [Char]
type FilePath = String

文字列は文字のリストと見做せる．そこから文字列によるデータ型 String は，単に文字のリスト型の型シノニムで定義されている．文字列に対してリストの関数を自由に適用できるのは，このためだ．ファイルのパスによるデータ型 FilePath は String の型シノニムで定義されている．なので，文字列の関数を自由に適用できる．

Haskell の型シノニムは，これだけに止まらずもっと強力な機能も持っている．例えば，型シノニムは型コンストラクタ，すなわち型を受け取って新たな型を作るコンストラクタに対しても作れる:

type Option = Maybe

この型シノニムを使うと，Maybe Int と書く代わりに Option Int と書くことも可能だ．部分適用された型コンストラクタに対する型シノニムも書ける:

type Failable = Either String

この型シノニムを使うと，Either String () と書く代わりに Failable () と書くことができる．

さらに型シノニムは，パラメータを持つことができる:

type List a = [a]

この型シノニムを使うと，[Int] は List Int と書ける．ただし，型シノニムはあくまで別名なので，全てのパラメータを適用した状態でしか書けないことに注意する必要がある．例えば，次のプログラムはコンパイルエラーになる:

type Apply f a = f a
type ApplyMaybe = Apply Maybe

Apply は2つのパラメータをとるが，ApplyMaybe は Apply に1つのパラメータしか渡していない．この場合，Apply Maybe という型がどういう型の別名になるか Haskell は分からないため，この型を拒否する．このプログラムを修正するには，

type Apply f a = f a
type ApplyMaybe a = Apply Maybe a

というように，Apply に全ての引数を渡してやる必要がある．こうすることで，Haskell は Apply の定義から Apply Maybe a が Maybe a の別名であると認識できるようになる ¹．

型シノニムは，他にも幾つか用途上で制限がある．1つ目は再帰的な型シノニムが作れないという制限だ．例えば，

type InfiniteList a = (a, InfiniteList a)

という定義は Haskell では却下される．相互再帰的な定義も許容されていない:

type Rec1 = [Rec2]
type Rec2 = [Rec1]

Rec1 の型を具体的に求めようとすると，[Rec2] の型になる．Rec2 はやっぱり型シノニムで，[Rec1] の別名なので，この型はさらに [[Rec1]] という型になる．このようにして具体的な型を求めようとしても永遠に型シノニムがどこかしらに入り込むことになってしまい，型シノニムが現れない型を求めることはできない．Haskell ではそのようなことがないように，そのような定義を排除している ²．

もう1つの制約は，型シノニムを型クラスのインスタンスとして使えないというものだ．例えば，次のようなことはできない:

type I = Int

class C a
instance C I

代わりに，

class C a
instance C Int

というように型シノニムを使わず書く必要がある．これは型シノニムを使って書けない唯一の例外だ．ただ，この制限は本質的なものではなく，Haskell 標準で型シノニムに対する混乱を避けるための制限になっている．もし，型シノニムに対してインスタンスを書けるようにしても，型シノニムは単なる別名なので，それは元となった型に対してインスタンスを定義してることと同じになる．このため，

f :: C a => a -> a
f x = x

という関数は，type Age = Int による型シノニム Age に対して C のインスタンスが定義されていた場合，a が Age の場合も Int の場合も許容される．これは，プログラマが意図していない動作かもしれない．つまり，年齢のデータだけにインスタンスを定義したつもりが，整数データ全般に対していつのまにかインスタンスを定義してしまったことになるからだ ³．

これらの制限はあるものの，型シノニムはデータ型を定義する上でとても強力で，しかも簡単に使用できる機能だ．

Link to
here代数的データ型

さて，型シノニムでデータ型を定義する場合には幾つかの制限があった．では，この制限を超えたデータ型を定義する方法はないのだろうか？そのような場合には代数的データ型 (algebraic datatype) を使うことができる．

代数的データ型は，複数の型の値を統合して1つの型の値として扱うデータ型の積と，複数の型の表現範囲を合わせて1つの型として扱うデータ型の和を組み合わせることで構成されている．そして，このデータ型の定義は，型シノニムと異なり完全に新しい型を作り出す．実際の例を見てみよう．

あなたは積木パズルのパーツそれぞれの面積を計算する関数を，書かなければいけない．積木パズルのパーツはそれぞれ，長方形，真円，三角形から構成されている．まずはこのパーツを Haskell のデータ型に落とし込む必要がある．それぞれのパーツにおいて，

四角形の面積は縦横の長さ
真円は半径
三角形は三辺の長さ

によって特徴付けられている．では，これを代数的データ型に落とし込んでみよう:

data PuzzleElement
  = Rect
      Double
      -- ^ 縦の長さ
      Double
      -- ^ 横の長さ
  | Circle
      Double
      -- ^ 半径
  | Triangle
    -- ^ 三つの辺の長さを与える
      Double Double Double

この定義は，PuzzleElement という新しい型を作り，3つの値コンストラクタを作る．それぞれ

Rect :: Double -> Double -> PuzzleElement
Circle :: Double -> PuzzleElement
Triangle :: Double -> Double -> Double -> PuzzleElement

という型を持つ．Rect は Double 型の値を2つ受け取り，その2つの値を PuzzleElement 型の1つの値として統合する．つまり，Double 型2つの積を作る．Circle や Triangle も同様だ．そして，PuzzleElement 型は3種類の積の値のいずれかを表し，すなわちこれら3種類の積の和を表す．このように，積和によって新しいデータ型を定義できるのが data 宣言であり，それによって定義されるのが代数的データ型になる．

代数的データ型の値から統合した値を取り出したい時は，case 文を使ったパターンマッチを行う:

areaMeasure :: PuzzleElement -> Double
areaMeasure x = case x of
  Rect w h -> w * h
  Circle r -> r * r * pi
  Triangle s1 s2 s3 ->
    let s = (s1 + s2 + s3) / 2
    in sqrt $ s * (s - s1) * (s - s2) * (s - s3)

areaMeasure によってパズルのピースの面積を求めることができるようになった．

前に紹介した型シノニムは，ある型に対してその別名を与えるだけだった．それに比べ，代数的データ型では新しいデータ型を作り，その型の値を作る値コンストラクタを定義する．そして，型シノニムと大きく異なる点は，型システム上からは新たに定義された型しか分からず，実際にそのデータ型がどういう型から構成されるか分からない点にある．PuzzleElement 型の値は，もしかしたら Double 型の2つの値から Rect コンストラクタを介して作られているかもしれないし，Double 型1つの値から Circle コンストラクタを通して作られているかもしれない．これは実行時にその関数でパターンマッチをしてみて初めて分かることだ．型シノニムでは，型システムからそれがどういう型を元にしていたか分かるが，代数的データ型で観測できるのは新たに作られたデータ型があることだけだ．この違いは，代数的データ型と型シノニムの制約の違いに表れてくる．代数的データ型では，型シノニムの時に挙げたような制約はない．

例えば，代数的データ型は型シノニムと同様，パラメータをとることができ，さらに部分適用も可能だ ⁴:

data Apply f a = Apply (f a)
type ApplyMaybe = Apply Maybe

これは Haskell の正しいプログラムになる．Apply は，2つのパラメータをとる型コンストラクタになっていて，データ型 Apply f a の値を作る方法として，f a 型の値から値コンストラクタ Apply :: f a -> Apply f a を通す方法がある．ApplyMaybe は Apply Maybe の型シノニムになっていて，これを使えば Apply Maybe Int と書く代わりに ApplyMaybe Int と書けるようになる．ApplyMaybe の定義は，Apply に対して1つのパラメータしか渡していない．にも関わらず正しいというのが，型シノニムと異なる点になる．

再帰的なデータ型を代数的データ型で定義することも可能だ:

data List a
  = Cons a (List a)
  | Nil

データ型 List a は a 型の要素を持つ単連結リストを表す．値コンストラクタが List a 型の値を受け取ることがポイントだ．型シノニムでは，その型の定義に自身を含めることはできなかった．これは実際の具体的な型を求めようとした時，その計算が永遠に終わらなくなってしまうからだった．代数的データ型 List a ではその型は単に新しい型として作られ，実際にその型の値がどういう型の値によって構成されているか知る必要はない．List a はそれ自体が具体的な型であり ⁵ ，それ以上計算する必要はないからだ．代数的データ型において，定義された型とその型の値を作る方法は分離されている．そのため，データ型の計算においてその型の値を作る方法は考慮されない．よって，自身が定義中で用いられても，型シノニムのようにデータ型の計算が永遠に終わることがないということはないため，その操作が許容されている．

もちろん，新しい型が定義されるため，型クラスのインスタンスを混乱なく定義できる．代数的データ型を作成した時，基本的なインスタンスを定義することは Haskell プログラミングにおいてよくあることだ．Haskell では，言語機能としてそれを支援する機能がある．それは，deriving 構文というもので，Eq / Ord などの標準的な型クラスを，データ型の定義から自動で導出してくれる．例えば，List a に対して使ってみると，以下のようになる:

data List a
  = Cons a (List a)
  | Nil
  deriving (Eq, Ord, Show)

このように代数的データ型は，型シノニムでは定義できなかったデータ型を定義することができる．そして，代数的データ型は全く新しい型を作ることもできる:

data Nat
  = Succ Nat
  | Zero

このデータ型 Nat は，他の型には依存しない全く新しい型だ．このように，代数的データ型は型シノニムと異なり全く新しい構造を作り出すことができる．

ただ，その代わり既存の関数を流用できなくなってしまう場合がある．例えば，

data Tuple a b = Tuple a b

は，(a, b) と構造が同じであり，(a, b) に対する関数 fst :: (a, b) -> a を適用できてもいいはずだ．ところが，データ型 Tuple a b とその値コンストラクタは型システム上は切り離されているため，自身の値が (a, b) の値と同じ方法でしか構成できないことを知らない．Tuple a b と (a, b) において型上で言及できることは，それらが異なる型であるということだけだ．なので，fst に Tuple a b 型の値を渡すことはできない．これは，もし型シノニムを使って，

type Tuple a b = (a, b)

と定義した場合は解決する問題だ ⁶．

このように両者にはトレードオフがあり，利用目的に合った使い分けをするのがいいだろう．

さて，data 宣言の構文は他に2つ，便利な機能がある．

1つは正格性フラグと呼ばれる機能で，値コンストラクタにおいて引数を正格に評価することを強制できる．例えば，

data StrictTuple a b = StrictTuple !a !b

というように，正格性フラグ ! を使った定義を行うと，値コンストラクタ StrictTuple :: a -> b -> StrictTuple はその引数を正格に評価してから格納するようになる．通常，

data Tuple a b = Tuple a b

のように正格性フラグを使わない定義では，

>>> case Tuple undefined undefined of Tuple _ _ -> ()
()

のように値コンストラクタは受け取った引数の評価を行わず，素直にそのままの形で遅延させて格納するため，エラーを出す式を渡してもその式の評価を行わない限りエラーにはならない．これは通常の関数の動作と同じになる．ところが，正格性フラグを使用した StrictTuple の場合，

>>> case StrictTuple undefined undefined of StrictTuple _ _ -> ()
*** Exception: Prelude.undefined

のように引数の評価を行うため，エラーを出す式を受け取った場合値コンストラクタの適用においてその式を評価しエラーを出す．データ型を作成する際，その元となる式の評価を強制させることはパフォーマンスに大きく寄与する．そのため，そのようなことを支援するために正格性フラグは設けられている．

また，代数的データ型の値コンストラクタはフィールド名を持つことができる:

data Tuple a b = Tuple
  { firstVal  :: a
  , secondVal :: b
  }

この場合，型コンストラクタ Tuple，値コンストラクタ Tuple :: a -> b -> Tuple a b の他に，関数 firstVal :: Tuple a b -> a， secondVal :: Tuple a b -> b が作られる．また，値コンストラクタの呼び出しにおいて特別なレコード構文 Tuple { firstVal = 0, secondVal = 1 } を使用でき，またレコード更新構文 (Tuple 2 1) { firstVal = 0 } を使用できる．これらは両者 Tuple 0 1 と同様の値が作成される．

Link to
hereある型を元に新たな型を作る (Datatype Renaming)

さて，これまで見てきたように，型シノニムは型の別名を定義し，代数的データ型は型の積和により新たなデータ型を定義するものだった．Haskell にはもう1つデータ型を定義する方法がある．それが newtype 宣言だ．この宣言によって作られるデータ型は，型システム上は代数的データ型と同じように扱われ，実行時は型シノニムと同様の動作をする．

newtype 宣言の構文は，data 宣言と同じような形をしている:

newtype Identity a = Identity a

フィールド名をつけることもできる:

newtype Identity a = Identity
  { unIdentity :: a
  }

この場合 data 宣言と同様に，型コンストラクタ Identity，値コンストラクタ Identity が作られることになる．ただし，data 宣言と異なり newtype は積和の機能を使用することはできない．単にある1つの型を受け取る値コンストラクタしか定義できない．なので，

newtype Unit = Unit
newtype Tuple a b = Tuple a b
newtype Enum = A | B | C

はいずれも受け入れられない．この newtype の制約はいまいちよく分からない．では，このような制約によりどのような違いが出るのだろうか？ newtype と data は型システム上は違いはない．しかし，パターンマッチの動作など，実行時の動作に少し差異が設けられている．例えば，通常

data DataIdentity a = DataIdentity a

において，

>>> case undefined :: DataIdentity () of DataIdentity _ -> ()
*** Exception: Prelude.undefined

のようにエラーを出す式をパターンマッチで分解しようとするとエラーが出力される．ところが，newtype によって作られた値コンストラクタの場合，

>>> case undefined :: Identity () of Identity _ -> ()
()

のようにパターンマッチ時にエラーが出されることはない．Haskell では newtype で作られた値コンストラクタが実行動作に影響することはないと規定されている．よって，上のパターンマッチは，以下と同様の動きをすることになっている:

>>> case undefined :: Identity () of _ -> ()
()

このように値コンストラクタを指定しないパターンマッチの場合，data 宣言で作られたものもエラーを出さない:

>>> case undefined :: DataIdentity () of _ -> ()
()

よって，data と newtype で作られた値コンストラクタの動作が異なるのは，パターンマッチにおいて値コンストラクタを指定した場合だけということになる．

では，newtype はなぜ値コンストラクタを無視するよう規定されているのだろう？これは，newtype によるデータ型が実行時の動作として型シノニムと同様の動作をすることを目的としてしているからだ．値コンストラクタが無視されるのは，

newtype Identity a = Identity a

という宣言は，

type IdentitySynonym a = a

という宣言と同様の意味を持って欲しいことを Haskell の設計者が意図しているからだ．よって，

>>> case undefined :: Identity () of Identity _ -> ()
()

の動作は，

>>> case undefined :: IdentitySynonym () of _ -> ()
()

のように，代数的データ型ではなく型シノニムに合わせてあるため，data 宣言主体に見ると一見不思議な動作をしていたというわけだ．

さて，ではなぜわざわざ型シノニムとは別に newtype 宣言を導入したのだろうか？型シノニムには幾つか制約があったのを思い出して欲しい．そして，それらの制約は代数的データ型では解決されたのだった．それは type 宣言が単に型の別名を導入するのに対し，data 宣言が完全に新たな型を作るからだった．newtype はその点に着目し，実行時には単なる別名として動作するが型システム上は完全に別の新たな型を導入することで，type 宣言同様ある型の別名を作りたいものの型シノニムの制約は回避したい需要を満たすようにしたものだ．

例えば，大文字小文字を区別しない文字列データを考えてみよう．この場合，"aBc" == "Abc" であって欲しいが，これは型シノニムで

type CaseInsensString = String

と定義するだけでは，

>>> ("aBc" :: CaseInsensString) == ("Abc" :: CaseInsensString)
False

のままだ．そこで，newtype を使って，

import qualified Data.Char as Char

newtype CaseInsensString = CaseInsens String

instance Eq CaseInsensString where
  CaseInsens s1 == CaseInsens s2 = go s1 s2
    where
      go []       []       = True
      go []       (_:_)    = False
      go (_:_)    []       = False
      go (c1:cs1) (c2:cs2) = Char.toLower c1 == Char.toLower c2 && go cs1 cs2

とすれば，

>>> CaseInsens "aBc" == CaseInsens "Abc"
True

とできる．型シノニムは単なる String の別名なので，String と異なるインスタンスを新しく定義することはできない．それに対して，newtype によるデータ型は代数的データ型と同様に自由に定義することができる．そして，値コンストラクタ CaseInsens は単なる飾りであり，実行時には完全に無視されるため，CaseInsensString は動作としては String の別名としてみることができる．

newtype は型シノニムでの制約であった，

再帰的なデータ型が定義できない
型コンストラクタに対する部分適用ができない

といった問題も解決する．このように newtype は型シノニムの問題を改善したデータ型を定義するが，data 宣言と同様型シノニムでは起きなかった問題も一緒に顕在化させてしまう．

上の例で，CaseInsens は飾りだと言ったが，実際にはこの値コンストラクタは必要不可欠であり，重要な役割を持っている．例えば，

>>> CaseInsens "aBc" == CaseInsens "Abc"
True

の例は，片方だけ

>>> "aBc" == CaseInsens "Abc"

としてしまうと，コンパイルエラーになってしまう．なぜなら，(==) は2つの引数が同じ型の値である必要があり，"aBc" の型である String と CaseInsens "Abc の型である CaseInsensString は全く異なる型であるからだ．つまり，値コンストラクタ CaseInsens は，実行時には何の影響も与えないが，型システム上は全く異なる型の値であることを示すマーカーとなる．そして，型シノニムではデータ型は単なる別名であったが，newtype は data と同様全く新たな型として導入する道を選んだため，元の型として受け入れてもらうことが出来なくなってしまったのだ．

といっても，これは一長一短である．data と同様 newtype で作られた型は，型シノニムのように既存の関数を使い回すことができない．その反面，データの意味に沿わないプログラムを型によって弾くことができるという点は長所になる場合もある．例えば，"aBc" == CaseInsens "Abc" の例は，一体どのような結果を返すべきか一見して分からない．両者は単なる文字列と，大文字小文字を区別しない文字列という異なるデータを表しており，その比較は定義されないとするのが自然だろう．このような場合に，型シノニムでは定義されないことを表す方法はなかったが，newtype は元の型と異なる型を持つので，そのような仕組みを作ることができる．

さて，newtype において値コンストラクタは実行時に何の影響も及ぼさないことと，何故そうなっているかについて分かってもらえただろうか？この影響は，パターンマッチ以外にも表れる．例えば，newtype の値コンストラクタに正格性フラグの機能はない．

newtype StrictNewtype = StrictNewtype !Int

というプログラムは，Haskell では受け入れられない．なぜなら，これを受け入れた場合，値コンストラクタがあるかどうかによって実行時の動作が変わってしまうからだ．ただ，その他の data 宣言の機能は使用できる．deriving も使用できる．newtype で作られたデータ型は，元のデータ型のインスタンスを継承することはできない．全く新たな型を作ったため，更地の状態から始まる．ただし，deriving を使うことでインスタンスを用意に導出することは可能だ．ただ，標準クラスのインスタンスしか自動で導出できないため，自身で定義した型クラスなどのインスタンスは一から書く必要がある．そのことには，注意する必要があるだろう ⁷．

最後に少し応用的な newtype の使い方を紹介しよう．newtype は上のように目的に合わせて型を既存の型から作る他，型シノニムの制約によって定義できない型上の計算を実現するのにも使用できる．例えば，

newtype Fix f = Fix (f (Fix f))

という変わったデータ型を使うと，型上の不動点演算をエミュレートできる．また，newtype を使うことで幽霊型による曖昧な型を避けることもできる．例えば，

type WithAnn ann a = a

readShow :: (Read a, Show a) => WithAnn a String -> String
readShow s = show $ read s

を考える．この関数 readShow は，WithAnn で引数に a を使っているにもかかわらず a が曖昧な型になるため弾かれる．なぜなら，型シノニム WithAnn a String は String と書いてるのと同じであり，readShow は

readShow :: (Read a, Show a) => String -> String

という型を持つのと同様になってしまうからだ．このため，制約だけに a が現れることになってしまい，曖昧な型になってしまう．この例のような，型シノニムが具体化されてしまうことで曖昧な型が生じる問題は，newtype を使用することで回避できる:

newtype WithAnn ann a = WithAnn a

readShow :: (Read a, Show a) => WithAnn a String -> String
readShow (WithAnn s) = show $ read s

Haskell は型システム上は WithAnn a String が実行時に単なる String の別名として扱われることを知らず，これを1つの具体化された型として認識する．このため，実際には a が引数の値に何ら関与しない場合も，型 a を伴う型として残る．よって，この場合は a は曖昧な型にならず，WithAnn a String の a の部分にあてがわれる型から特定することができる．このように，型シノニムで早期に元となった型に具体化されることで生じる問題は，newtype を使うことで実際に値を作る箇所とパターンマッチの箇所での型計算に遅延させることができ，回避できる場合がある．

Link to
hereまとめ

Haskell の3つのデータ型定義方法について紹介した．

型シノニムは，ある型に対してその別名を与えることで，データ型を定義するものだった．簡易で元の型に対する関数をそのまま流用でき，使いやすい反面，部分適用ができない，再帰的データ型が定義できない，型クラスのインスタンスにできないと言う制約があった．

代数的データ型は複数の型の積和によって全く新しいデータ型を定義するものだった．型シノニムであった制約を回避でき，新たな構造を導入できるが，関数の流用が困難な場合があり型シノニムとの使い分けが必要だった．

newtype によるデータ型は，型システム上は代数的データ型と，実行時の動作は型シノニムと同様といった，それぞれの中間をとったようなものだった．型シノニムのような関数の流用ができない場合はあるものの，その代わり型シノニムの制約を回避でき，型システム上は全く異なる振る舞いを行うことも可能だった．

これらは，それぞれが一長一短を持ち，目的にあった使い分けをする必要がある．この記事が，そのような場合の助けになればいいと思う．では，今回はこれで．

型シノニムに対して部分適用を許容する一般的な方法は，型上にもラムダ抽象にあたる表現を導入することである．ただ，この場合型上の演算が停止しない場合があり，型システムが決定不能になる．このため，Haskell では型シノニムに対しての部分適用は許容していない．↩︎
等価再帰データ型 (equirecursive types) と呼ばれる特別な型を型システムに導入することで，このような型を許容する理論は存在するが，この理論はとても複雑で型検査のアルゴリズムも難しくなりがちである．↩︎
ただ，このような混乱が起こるかもしれないことを許容し，利便性のため型シノニムをインスタンス定義で使いたい場合，TypeSynonymInstances という GHC 拡張を有効にすることで許容されるようになる．↩︎
型上の計算によって，実際の型が特定される型シノニムとは異なり，代数的データ型の型コンストラクタはそれ自体がもう計算できないものになる．それは部分適用されても同様であり，部分適用を許容することで型シノニムと同様の問題は起こらない．これが，代数的データ型で部分適用が許容されている理由になる．↩︎
実際にはパラメータ a の部分に具体的な型を当てはめないといけないが，当てはめればそれは完全に具体的な型になる．↩︎
なお，代数的データ型でも型シノニムと同様の利点を手に入れるための研究は，Haskell では盛んに行われている．例えば，Generic / Data 型クラス，lens パッケージなどを使うことで，構造が同じだが異なるデータ型で関数が流用できない問題を回避できる場合がある．↩︎
GHC 拡張では，deriving 構文の拡張として強力な機能がいくつか搭載されている．特に newtype によるデータ型の場合は，GeneralizedNewtypeDeriving や DerivingVia 拡張を使えば，インスタンスの自動導出の範囲を大幅に拡大できる．↩︎

Haskell 環境構築ツールフローチャートを作りました

2020-06-06T12:24:04+09:00

前に環境構築についての記事を書いたのですが、初学者向けにパッと見て分かるようにフローチャートにしました。kakkun61.hatenablog.comGoogle ドライブ図形描画のファイルはこちらです。コメントを付けることができます。docs.google.com

[mac] Mojavaクリーンインストール

2020-05-06T17:02:25.994+09:00

Mojavaへのアップデートを契機にmac book airを初期化して環境をクリーンセットアップしました。自分にとって使いやすい環境の設定手順および、インストールしたアプリ群の情報をメモがわりに残しておきます。システム環境設定トラックパッド軌跡の速さを速くする「スクロールとズーム」内の「スクロールの方向」を「ナチュラル」にする「その他のジェスチャー」内の全てのチェックを外すアクセシビリティマウスとトラックパッドトラックパッドオプション「ドラッグを有効にする」にチェック →ダブルタップでドラッグできるようになる「ドラッグロックなし」を選択 →トラックパッドから手を離すとドラッグ解除キーボードキーボード F1, F2などのキーを標準のファンクションキーとして利用する：チェック修飾キー：ControlとOptionを

[linux] gnupgによる暗号化処理時の確認プロンプトを抑制する方法

2020-05-06T16:37:57.790+09:00

gnupgを用いてファイルを暗号化する際、予めインポートした公開鍵に対してtrust設定をしておかないと、指定した公開鍵毎に以下のような警告が発せられます。 % gpg -e -r abc@test.org a.txt gpg: AAAA4C0DD6F2ZZZZ: この鍵が本当に本人のものである、という兆候が、ありません sub elg2048/AAAA4C0DD6F2ZZZZ 2020-05-06 Hiroyuki Kurokawa <abc@test.org> 主鍵フィンガープリント: <snip> 副鍵フィンガープリント: <snip> この鍵は、このユーザIDをなのる本人のものかどうか確信できません。今から行うことを＊本当に＊理解していない場合には、次の質問にはnoと答えてください。それでもこの鍵を使いますか? (y

家から出ない生活４週間

2020-04-29T17:02:08+09:00

出社非推奨になったのを機に家から出ない生活を始めて４週間が経った。今までやったことをまとめていく。食料品せっかくだから生活で縛りプレイをしてみようと思って Amazon と Yodobashi を禁止にしている。この２社は最近評判が良くないこともあるし。業務スーパーの通販いわゆるネットスーパーはサイトが激重になっていたり配達可能日がすべて☓になっていたりで機能不全を起こしているようだった。そこで飲食店がメインターゲットであろう業務スーパーなら今空いているだろうという読み。ここではピザ材料、冷凍野菜、割り箸などを入手している。とにかく業務スーパーの通販を最大限利用するには冷凍室の容積が…

2019 年のスライド一挙公開、あるいは 2020 年の方針

2020-01-01T08:37:23+09:00

あけましておめでとうございます。2019 年は大変お世話になりました。2020 年も張り切っていきましょう。さて、2019 年には結構な回数の外部発表を行いました。これらの発表内容のうち一部は単独のブログ記事としてまとめてありますが、機を逸してしまって記事化されていないものも相当数あります。そこで本記事では、2019 年中に行った発表を一覧としてまとめてみました。 2019 年の活動実績 2019 年の登壇は全部で 19 件でした。うち（先着や抽選ではなく）CFP に応募して採択されたものは 4 件です。チェシャ猫が普段活動している領域は、Twitter の Bio にも書いてある通り、大…

barbies-thで気軽にHKDを堪能しよう [Haskell AdC 14]

2019-12-25T22:43:29+09:00

ミーハーな読者なら、barbiesというライブラリをご存知の方も多いと思う。そう、HKDを扱う定番ライブラリだ。HKDは、同アドベントカレンダーにも寄稿されている他、Haskell Dayでも紹介された(https://assets.adobe.com/public/b93f214d-58c2-482f-5528-a939d3e83660)注目の技法だ。Higher-Kinded Data (HKD) について - Qiita HKDは、一番簡単な場合であるはずのIdentityを使うと着脱が面倒になるという問題がよく知られている。Data.Barbie.BareモジュールのWearという型族…

OpenShift.run 2019 で Kubernetes のスケジューリングについて話してきました

2019-12-21T21:24:23+09:00

先日行われた OpenShift コミュニティのイベント OpenShift.run 2019 にて、Kubernetes Scheduler とその関連ツールについて講演してきました。公募 CFP 枠です。 OpenShift のイベントでありながら、OpenShift についてはまったく触れずひたすら Kubernetes の内部実装を解説する異色の登壇でした。実際、40 分枠の講演の中で（RedHat 社以外も含め）ベンダニュートラルな立場で登壇したのは自分だけだったようです。これは私見ですが、逆に言えばそういう内容でも CFP 採択されているというのは、運営側も「単なるマーケティングイ…

postgresql-pure を開発しました

2019-12-06T00:03:21+09:00

この記事は Haskell Advent Calendar 2019 の6日目の記事です。 hackage.haskell.org postgresql-pure は Haskell の PostgreSQL ドライバー（クライアントライブラリー）で次のような目標で開発しました。マルチコア環境でのパフォーマンス向上暗黙のロックを回避するマルチプラットフォーム対応 C ライブラリーの libpq への依存をなくして特に Windows でのビルドを容易にする既存ライブラリーとしては postgres-wire が高速だがそれは Windows をサポートしていない pure Haskel…

最強にして最速のビルダー、mason

2019-12-05T19:10:10+09:00

Haskell Advent Calendar 2019 5日目この冬、神速のサンタクロースがやってくる—— Haskellにおいて、バイト列の表現はByteStringが定番である。ByteStringはPinned領域に直接格納され、空間効率はリストに比べればはるかに良い。しかし、Pinned領域にあるとヒープフラグメンテーションが起こりやすくなるということでもあり、細かい文字列をつなぎ合わせるような使い方はパフォーマンスに悪影響が及ぶ。そのような問題を避けるため、ビルダーと呼ばれる構造が用意されている。 Data.ByteString.Builderは、word8 42 <> byte…

状態機械を合成してデッドロックを検出できる Go 言語パッケージを作ってみました

2019-11-30T21:59:50+09:00

はじめにマルチスレッドで動作するプログラムの設計は難しい問題です。個々のスレッドの動作は単純に見えても、複数が並行して動作する場合の動作は組み合わせ論的に複雑になります。また、タイミングに依存する不具合は狙って再現することが難しく、通常の単体テストによる検出にも限界があります。そんなとき、有効な手法がモデル検査です。システムの取りうる状態をあらかじめ網羅的に探索することで、「実際に動作させた際にごく低い確率で踏むバグ」であっても、動作させることなく設計段階で発見することが可能になります。ところでちょうど先日、デッドロック発見器を自作するハンズオンに参加する機会がありました。内容は非常にシ…

FFI で Haskell から Rust を利用する

2019-11-21T23:37:54+09:00

Rust で作ったライブラリーを静的リンクして Haskell（GHC）から使う例と説明を書いた。 github.com

GHC 環境構築概観と PowerShell

2019-11-20T22:22:37+09:00

Haskell の開発環境を構築する方法は何通りかあり、新しいツールが出ると「今はこれだ」とほめるブログも公開されますがそれが初学者を混乱させることがよくあります。本記事ではビルドツールのインストールにしぼり、開発支援、例えば ghc-mod・haskell-ide-engine・hhp には言及しません。いくつか典型的な構築方法を確認した後、新たに私が作成したツールを紹介しより初学者を混乱に落とし入れます。重鎮 Haskell Platform www.haskell.org Haskell 解説書史1の第1波から第3波までのデファクトスタンダードであった重鎮 Haskell Plat…

最近の自分の Haskell 開発環境（Windows）

2019-10-23T20:32:39+09:00

id:syocy のブログを見たので Windows で自分がどうしているかをメモしておく。 syocy.hatenablog.com Stack 最近は ghcup があるがシェルスクリプト製で自分は PowerShell ユーザーなので stack を使っている。（ghcup はなんで Haskell 製じゃないんだ1？） GHC 8.8 を使うには resolver は ghc-8.8 や nightly を指定する。まだ LTS にはなっていない。エディターエディターは Spacemacs を使っている。前は IntelliJ IDEA に HaskForce プラグインを入れて使…

HaskellやっていくGHC8.8.1令和元年白露の候

2019-09-14T23:40:48+09:00

GHC 8.8.1 が出たので雑に環境を整えていきます。 OS: Ubuntu 18.04 LTS on VirtualBox on Windows screenshot GHC, Cabal 最近は ghcup で入れている。 $ ghcup upgrade $ ghcup list --tool all $ ghcup install 8.8 $ ghcup install-cabal latest ~/.ghcup/bin と ~/.cabal/bin にPATHが通っていない場合は通しておく。 stack は手になじまない感じがして最近使っていない。 stack のいいところとしてスク…

単純で頑強なメッセージングシステム、franz

2019-09-07T11:54:37+09:00

Haskell製の新しいメッセージングシステムfranz(フランツ)の紹介。 github.com 背景取引所にあるマシンで取引プログラムを実行するのが我々の仕事だが、朝8時に起動したらあとは昼寝したり酒を飲んだりというわけにはいかない。モニタリングしたり、分析のためにデータを残しておく必要がある。そのため、プログラムによって解析しやすい形でログを出力する。今までは複数の種類のレコードをシリアライズし、一つのファイルに連結させる独自のフォーマットを10年近く使っていたが、書いていて恥ずかしくなるような多数の問題を抱えていた。柔軟性が乏しい: 32bit整数や文字列などの単純な値しか格納で…

Minecraft 1.14サーバーを運用してみた

2019-08-15T19:54:48+09:00

Minecraft 1.14 "Village and Pillage"は、サブタイトルの通り村人と略奪者をテーマにしたアップデートだ。主な楽しみ方村人の取引システムが一新され、以前よりもバリエーションに富み、かつリーズナブルな取引ができるようになった。余ったアイテムを換金したり、有益なアイテムを入手できるようになるだろう。ランタン、焚火などの新たな光源や、壁や階段の変種、さらには鐘なども追加され、建築の楽しみも大きく増した。だが、良いことばかりではない――新たなイリジャー(邪悪な村人)、ピリジャーが出現するようになったのだ。条件を満たすと発生する襲撃から村を守る死闘、そして安全な拠点づ…

CloudNative Days Tokyo 2019 登壇こぼれ話 #CNDT2019

2019-07-30T11:26:34+09:00

先日行われた CloudNative Days Tokyo 2019 で、Kubernetes のスケジューリングについて発表してきました。公募 CFP 枠です。 www.youtube.com 今回の発表は、実は技術的に目新しい内容をほとんど含んでいません。各トピックは今までいくつかの勉強会で LT として発表しているものがほとんどです。ただし、普段の発表では時間が短いこともあって断片的になりがちだった内容を 40 分の枠で再構成し、スケジューリングについて初めて聞く人にとっても入り口のギャップを少なく、できるだけ学習曲線がなだらかになるようにすることを念頭に置いてプレゼンを組み立てました…

関数のメモ化

2019-07-29T04:03:51+09:00

ブログに書いてみるとよく分からなくなってきました 🙃 Haskell-jp で回答をもらいました。 @lotz84_ さんの記事や GHC のプロファイルに出てくる CAF がよく分かってなかったのをまとめる。 qiita.com fact のメモ化 lotz さんの記事の階乗 fact 関数を題材にする。 fact :: Int -> Integer fact 0 = 1 fact n = fromIntegral n * fact (n-1) lotz さんの記事よれば、次の実装だとメモ化されるとのこと。 -- | 関数をメモ化する関数 memoize :: (Int -> a) -> I…

[mac] El Capitanへのアップグレード関連作業まとめ

2019-07-13T19:19:56.684+09:00

YosemiteからEl Capitan（10.11.2）へアップグレードしました。旧環境で起動できていたアプリケーションが起動できなくなったり、コマンドが見つからなくなる、といった問題が発生しましたが一通り解決できたので、その内容をまとめておきます。＃ポストし忘れてた･･･。今更な情報ですが自分の備忘録の意味もあるので公開。 El Capitanの新機能に伴う問題・設定の修正 OS X El Capitan：日本語入力のライブ変換モードをオフにする [システム環境設定] - [キーボード]を開く [入力ソース]タブを選択「ライブ変換」のチェックを外す MacPortsのアップデート Yosemite環境でインストールしたMacPortsはそのままでは利用できない。以下のようなエラーメッセージが表示される。 % port qv installed Error:

Docker Meetup Tokyo #31 で Kubernetes 1.15 について話してきました

2019-07-06T21:30:29+09:00

先日行われた Docker Meetup Tokyo #31 で、Kubernetes 1.15 の Scheduler 周りの新機能について発表してきました。 Kubernetes の Pod Preemption を利用すると、より重要な Pod にノードの計算リソースを割り当てる優先的に割り当てることができ、コストの最適化につながります。しかし優先度の低い Pod は実行中に強制的に終了されることとなり、長時間かかるバッチ処理が途中で中断されてしまうという弊害もあります。本スライドでは、Kubernetes 1.15 から Alpha 機能として導入された NonPreemptingP…

Kubernetes 1.15: SIG Scheduling の変更内容

2019-07-05T15:51:46+09:00

はじめに本記事では、Kubernetes 1.15 のリリースノートからスケジューリングに関する内容をまとめました。なお、SIG Scheduling の変更内容については既に他の方から翻訳記事が出ていますが、本記事は後発ということもあり、すべての機能を実際に触ってみた上でサンプルコードを添えて解説していきます。 Kubernetes 1.15: SIG Scheduling の変更内容 1.15 の新着情報 (1.15 What’s New) 今回、完全な変更ログは https://relnotes.k8s.io/ で、絞り込み可能なフォーマットで公開されています。確認とフィードバック…

Traversable API

2019-06-13T15:55:57+09:00

与えられたConnectionを通じて、指定したKeyに対応するByteStringを取り出すような、シンプルなKey-ValueストアのAPIを考えてみよう。 type Key = ByteString fetchOne :: Connection -> Key -> IO ByteString ネットワーク越しにたくさんのデータを取得したいとき、何度もこれを呼び出していては効率が悪い。一度にまとめて取り出せるように拡張するなら、このように書ける。 fetchMany :: Connection -> [Key] -> IO [ByteString] 悪くはないが、この型はたとえば「["fo…

Fun Fun Functional (1) で Haskell と Firebase を使ってライブコーディングしてきました

2019-05-29T19:45:39+09:00

先日行われた Fun Fun Functional (1) で、Haskell と Firebase を使った Web アプリの作り方について発表してきました。使用した要素技術は、GHCJS 上のフレームワーク Miso と、Fireabse SDK を呼び出すための DSL である JSaddle です。 GHCJS は Haskell のソースコードを JavaScript に変換するコンパイラで、GHC をフォークすることによって開発されています。 github.com Miso は GHCJS 上で The Elm Architecture を実装するためのフレームワークです。Mis…

技術書典 5 ふりかえり

2019-04-16T00:36:48+09:00

え？6？いやいや 5 ですよ？ techbookfest.org 池袋慣れ親しんだ秋葉原の地を飛び出して池袋にやってきました。めちゃくちゃ広くてびっくりです。秋葉原通運会館からアキバスクエアにやってきたときも思いましたが、同じ感想がもう一度。ガラス張りじゃなくなったので外の行列見てやばいやばい言えなくなったのはほんのちょっとだけ残念です。か61 kakkun61 という名前でもろもろアカウントを取っているのですが、今回は卓番号が「か61」ということでまさに自分のための場所でした。覚えやすい！そんな弊卓の様子です。落新刊落としました…… フィルムカメラに目覚めた結果土日をそれに使っ…

楽園へ行きたい

2019-04-01T18:59:27+09:00

楽園へ行きたい。森と平原に囲まれた、街のはずれの小屋に住みたい。朝は、小鳥たちのさえずりと窓から射し込む陽の光で目覚めたい。昼は、コーヒーと焼き菓子を用意して一服したい。夜は、天の河の向こうに思いを馳せながら眠りたい。月曜日は大学に行き、エルフの先生の下で言語学を学びたい。火曜日は研究室にこもり、ドラゴンの教授と研究に没頭したい。水、木曜日は道具鍛治と修繕の仕事をしたい。金曜日は都に向かい、品を売って食材と情報を仕入れたい。土曜日は酒場に集まり、仲間たちと杯を交わしたい。日曜日は使い魔を連れ、公園をゆったり散歩したい。春は、花々を眺めながら、渡り鳥たちにしばしの別れを告げ…

特級シリアライズライブラリ、winery 1.0解禁

2019-03-21T17:21:01+09:00

fumieval.hatenablog.com あれから9ヶ月…wineryのバージョン1.0をついにリリースした。前回までのあらすじデータの保存や通信に直列化は不可欠の概念である。 binaryなどの直列化ライブラリは、レコードのフィールド名などの情報が欠けており、構造が変わると互換性を持たせることができない。一方、JSONやCBORなどのフォーマットで愚直にフィールド名などを残すと極めて冗長になり、時間・空間効率が悪い。コード生成が前提のProtobufなどはHaskellの既存のデータ構造との相性がよくない。そんな現状に殴り込みをかけたのがwineryだ。値を「スキーマ」と「デ…

Docker Meetup Tokyo #28 で Scheduler のカスタマイズについて話してきました

2019-02-27T03:24:21+09:00

先日行われた Docker Meetup Tokyo #28で、Kubernetes Scheduler の挙動をカスタマイズする方法について発表してきました。なお Scheduler のカスタマイズについては、つい最近 Kubernetes Meetup Tokyo #16 でも発表しています。ドキュメント類へのリンクも含めてまとめたものが以下の記事です。 ccvanishing.hateblo.jp 両方のスライドを見比べて頂ければ分かる通り、内容としてはオーバラップしている部分がかなりあります。ただし、前回はあくまでも Scheduling Framework の解説であったのに対し…

Servant と Relational Record でウェブアプリケーション開発

2019-02-26T19:58:06+09:00

Servant とは Servant は型レベルプログラミングによって、ウェブアプリとしてのインターフェースと実装との差異を防ぐことのできるウェブアプリフレームワークです。 haskell-servant.readthedocs.io 日本語記事としては lotz さんのこちらが分かりやすいので、参考にしてください。 qiita.com Haskell Relational Record とは Haskell Relational Record は言語内 DSL によって SQL を生成するもので、正しくない SQL に相当するものは型エラーとなります。 khibino.github.io こ…

Kubernetes Meetup Tokyo #16 で Scheduling Framework について話してきました

2019-02-22T19:39:16+09:00

先日行われた Kubernetes Meetup Tokyo #16 で、現在 Scheduling SIG で進められているプロジェクト Scheduling Framework について発表してきました。 Kubernetes では、Pod をどの Node に配置するかを決める手続きをスケジューリングと呼びます。古典的な Kubernetes の用途、すなわち通常の long-running なサーバ群の管理においては、Pod のスケジューリングは比較的シンプルな問題でした。すなわち、Node の障害時でも可用性が保てるように Pod を複数の Node に散らし、一度立ち上がった P…

旅のチェックリスト

2019-02-15T18:18:06+09:00

筆者が旅に出る際に確認する項目をまとめた。事前の準備渡航ビザ: 必要な場合もあるので事前に確かめよう。 ESTA(アメリカの場合): どんな理由であれUSに入国する場合申請する必要がある。大抵すぐ承認されるが、遅くとも出発の72時間前に済ませるべきである。宿: 好みに応じてホテルでもAirBnBなどで民泊を予約しても。後者はキッチンが用意されているところもある。交通手段: 電車は大抵の場合当日で大丈夫だが、もちろん船舶や航空機の場合は予約が必須である。冷蔵庫の整理: 日持ちしないものは消費してしまおう。携帯するもの財布: 財布は現金やカードを収納する。リスク回避の観点から財布は省…

ある期間内に更新されたデータを素早く検索できるモデル

2019-02-12T19:10:02+09:00

特定の技術とは関係ない、誰でも思いつきそうな、でも便利なお話。こんなケースを考えてみよう。人気のトレーディングカードゲームAugur Unlimitedを扱うショップ「しらさぎ商店」では、1000種類にも及ぶカードの買い取り・販売をしている。記録のため、カードごとに日時、価格、在庫数などをまとめたレコードを毎日データベースに書き込んでいる。新着・売り切れや、価格の変化などを、指定された期間について一覧で表示するようなWebページを作りたいとオーナーは考えた。しかし、ユーザーからの要求ごとに全データの差分を取るのは、あまり効率的な手段とはいえない。レアなカードでもない限り価格は一定であるこ…

Haskell Windows Ctrl-C 動作確認

2019-01-30T23:46:38+09:00

コードコードは前回記事と同じです（再掲）。 Git リポジトリーはこちら。 import Control.Concurrent import Control.Monad import System.Exit import System.IO import System.Win32.Console.CtrlHandler main :: IO () main = do tid <- myThreadId let handler event = do if event == cTRL_C_EVENT then do putStrLn "goodbye!" killThread tid pure …

Haskell で Ctrl-C を制御する（Windows）

2019-01-25T01:51:19+09:00

Ctrl-C 等の割り込みの扱い方です。 tl;dr System.Win32.Console.CtrlHandler を使います。 Ctrl-C が押されたらクロージングの処理を伴って終了するプログラムを書いてみます。 import Control.Concurrent import Control.Monad import System.Exit import System.IO import System.Win32.Console.CtrlHandler main :: IO () main = do tid <- myThreadId let handler event = do i…

GHCの線形型プロトタイプを試すだけ

2019-01-08T02:01:09+09:00

GHCに線形型を導入すると以下のような良い事があるらしい。リソース安全性: ファイルハンドル、ソケット、DBコネクションのようなリソースについて、これらを提供するAPIの設計者が安全な使用を強制できる。リソース解放後のアクセス、二重解放、解放忘れを防止することができる。レイテンシ: リソースAPIの実装をうまくやるとoff-heap(GCの対象外)でリソースを確保・解放できる。GC対象が少なくなることによりGCによってプログラムが停止する時間を減らせる。並列性: 過剰な直列化を強要しない。リソース安全性を保ちつつもできる限り並列化できる。詳しくはproposal。この記事では線形型G…

戊戌の追憶

2018-12-27T21:38:53+09:00

この記事は、筆者が過ごした2018年を簡潔に振り返り、その経験を糧とすることを狙う。 1月第二鰓弓由来側頸嚢胞という先天異常が原因で首が化膿し、激痛に苦しんでいた。対人関係のトラブルなどもあり軽い錯乱状態にあったのか、自分が知らない間に高い買い物をすることがあった。 drinkery: Boozy streaming library というストリーム処理ライブラリを作った。当初はすべて酒関係の用語を用いていたが、批判を受けてそこはやめた。今思えばそれで正解だった気がする。パフォーマンスはモナディックなAPIを持つライブラリの中ではトップクラスで、双方向性や多入力多出力のような発展的な機能も…

Elias-Fano encoding: 単調増加する数列をほぼ簡潔に表現する

2018-12-21T20:11:08+09:00

Haskell Advent Calendar 2018 20日目単調増加する自然数の列を、最低限のビット数で表現するための興味深いテクニックと、Haskellによる実装を紹介する。 Elias-Fano encoding この手法は、簡潔データ構造に分類されるもの一つであるが、厳密には条件を満たさないため疑似簡潔データ構造と呼ばれる。1970年代、Peter EliasとRobert Mario Fanoによって独立して発見された。例題として1, 1, 4, 10, 17, 22, 23, 30という列をエンコードしてみよう。まず、それぞれの数を上位3ビットと下位2ビットに分割する。列の…

Kubernetes 1.13: SIG Scheduling の変更内容

2018-12-06T19:54:33+09:00

はじめに本記事では、Kubernetes 1.13 の CHANGELOG からスケジューリングに関する内容をまとめました。主な変更点 https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.13.md#sig-scheduling 1.13 における SIG Scheduling の取り組みは主に安定性に焦点を当てており、いくつかの大きな機能の導入は次のバージョンまで延期することになりました。特記すべき変更として次に挙げる 2 点があります。 #69824: Taint based Eviction の有効化 Ta…

We Are JavaScripters! @26th で Elm と Firebase の連携について話してきました

2018-11-24T23:27:05+09:00

先日行われた We Are JavaScripters! @19th で Elm と JavaScript ライブラリの連携について発表してきました。 Elm の初心者向けの解説としてよく Msg, Model, update からなるアーキテクチャが挙げられていますが、今回の発表ではもう一歩だけ進んで、Cmd と Sub を使って Elm から JavaScript のライブラリを呼ぶ方法について解説しました。サーバとしての JS ライブラリ他の AltJS では JavaScript を呼び出す際、ソースコードの内部に埋め込む形になるのが普通です。例えば Haskell を Java…

Windows で Haskell iconv をビルドする

2018-11-19T19:13:49+09:00

GHC 8.0 以前についてはこちらを参考に。 teratail.com GHC 8.2 以降で stack を使う場合をここではとりあげる。確信はないのだが、GHC 8.2 から GHC 自体が iconv に依存しなくなったのか、$(stack path --programs)\ghc-8.0.2\mingw\lib から libiconv.a と libiconv.dll.a がなくなっているため GHC 8.0 以前のようにビルドができなくなっている。なので、まず libiconv を取得する。 stack exec -- pacman -S libiconv-devel インスト…

「名前の束縛」という名の束縛

2018-10-31T15:00:56+09:00

実用的なプログラミングにおいて、名前と概念を結びつける「束縛」はほぼ必須の概念である。しかし、その言葉には大きな誤解と混乱が根付いていた。事の発端となったのは「Haskellにおいては、変数は値を代入するものではなく、値に束縛するものである」という議論である*1 *2。しかし、これは大きな誤解を孕んでいる。言葉の定義に立ち返ってその誤解を解いていこう。束縛とバインディング実は「束縛」には二つの意味がある。一つは、数学的な意味での変数の束縛*3、もう一つは、識別子と実体の結合という意味での束縛*4だ。前者は変数の導入と言い換えることもできる。ラムダ計算におけるラムダ抽象と変数の関係もこれ…

『Yesod 入門』商業誌化

2018-09-01T08:25:57+09:00

同人誌で発売していた『遠回りして学ぶ Yesod 入門』がこのたびインプレス R&D より『Haskell で作る Web アプリケーション遠回りして学ぶ Yesod 入門』として商業誌化されることになりました。 www.impressrd.jp 同人誌版からの変更点は主に、日本語が読みやすくなった対応バージョンが上がった点です。章が増えたり減ったりはしていません。あと、表紙がかわいくなりました。かわいい。商業誌では Amazon と honto にてオンデマンド印刷の紙の書籍も購入できるようになっています。紙はこれまで即売会でしか販売していなかったので初めて通信販売で買えるようにな…

Windows で haskell-ide-engine をビルドする

2018-08-16T17:34:50+09:00

手順 1. ソースコード取得。 git clone git@github.com:haskell/haskell-ide-engine.git 2. Unicode を扱う ICU の古いバージョンが要るので取得。自分の使うバージョンの text-icu の changelog を見て、必要な ICU のバージョンを探す。執筆時点では 53 だった。 http://site.icu-project.org/download/53#TOC-ICU4C-Download 任意の場所に展開する。以降、展開先の箇所を $icu と表記する。 $icu\bin64 にある dll の名前を変える。（要…

Dhallによるリッチな設定ファイル体験

2018-07-14T19:52:55+09:00

(この記事のレギュレーション: lts-11.9) Dhall という設定記述用言語があり、使ってみたところ良い感じだったので紹介します。なお、この記事は先日某所で発表したものの拡大版になります。 speakerdeck.com Dhallとは何か Dhallについて短かく表現するなら公式サイトの以下の説明が分かりやすいです。 You can think of Dhall as: JSON + functions + types + imports データ表現にプログラマブルさと静的な検査とファイルのインポートを加えたものというわけです。まだ開発中のためかあまりアピールされていませんがツー…

[linux][cygwin] unzipコマンドで "error: invalid compressed data to inflate" というエラーメッセージがでたら？

2018-06-06T01:11:48.468+09:00

zipアーカイブの中に長さが0のファイルが含まれていると、unzipコマンドでは以下のようなエラーメッセージが表示されて、解凍することができません。アーカイブが壊れていなくてもエラーになります。 % unzip hoge.zip error: invalid compressed data to inflate このような場合には、-tzipオプションを指定して7zコマンドを実行することで、エラーを回避して解凍できます。パスワード保護されているzipアーカイブも問題なく解凍できました。 % 7z x -tzip hoge.zip manページによると、以下のフォーマットがサポートされていて、デフォルトは7zとのこと。 The program supports 7z (that implements LZMA compression algorithm), ZIP

日持ちする直列化のためのライブラリ「winery」

2018-06-03T19:50:24+09:00

人類は、酒と共に発展してきたと言っても過言ではない。穀物や果実などを酒に変換することにより、糖を除く栄養を保ったまま、高い保存性を持たせることができる。酒は人々の喉を潤し、時に薬として使われた。プログラミングにおいても、終了したら消えてしまうデータを、保存性の高いバイト列に変えたい場面がよくある。そのような操作を直列化(シリアライズ)と呼び、いくつかのアプローチが存在する。コード生成タイプ Protocol Buffers、cap'n'protoなどデータの構造を記述する言語(スキーマ)から、データ構造およびシリアライザ・デシリアライザをコードごと生成する。幅広い言語で使える一方、作れる…

技術書典 4 にサークル参加した

2018-04-27T02:09:41+09:00

4月22日に開催された『技術書典 4』にサークル参加してきました。 techbookfest.org 技術書典は1と2に個人で参加して3は会社として参加して今回の4は会社と個人と2サークルにかかわっていました。超技術書典を抜くと皆勤です。個人サークル既刊として『遠回りして学ぶ Yesod 入門』を増刷し、新刊は『手続き Haskell』を持っていきました。 doujin.kakkun61.com doujin.kakkun61.com 数字売り上げ部数は、どんぶり勘定ですが（特に Yesod 本のダウンロードカードが完全に記憶による）下記の通りとなりました。 Yesod 本紙 + P…

Haskellで再帰的な構文木にFix(不動点)を導入してみる

2018-03-20T22:43:20+09:00

まえおき例によって僕の記事など読まなくても下記のリンクで解説されているので、 Haskell楽しいなと思う人はこちらをどうぞ。 An Introduction to Recursion Schemes 生きるのに疲れた人は半分白目のゆるい気持ちで以降を読んでね。 Haskellで抽象構文木 (AST) にメタデータを付与する以前この記事でASTへのメタデータの埋め込み方について少し整理して、下記のようなアプローチがあることを明らかにした。メタデータを保存するための値コンストラクタをASTのブランチとして定義するメタデータを保存するラッパーを定義する加えて Fixを使ってなんかファン…

[haskell] http-clientライブラリを利用してHaskellでHTTPクライアント機能を実装する

2018-03-05T09:34:57.715+09:00

Haskellでは、http-clientライブラリを用いることで、HTTPクライアント機能を簡単に実装できます。http-client以外にも何種類かライブラリがありますが、今回はhttp-client, http-client-tlsの機能と使い方をまとめておきます。本エントリで紹介するhttp-client, http-client-tlsライブラリの機能：単純なHTTP GETリクエスト主要な型の説明 Managerのカスタマイズ https proxy設定タイムアウト値の設定 Requestのカスタマイズベーシック認証リクエストヘッダ Responseの操作ストリーミング受信レスポンスヘッダの参照エラーハンドリング単純なHTTP GETリクエスト {-# LANGUAGE

[haskell] stack install cryptoniteがno such instruction: `rdrand %r8'エラーで失敗する問題の対処方法

2018-02-25T15:34:07.378+09:00

手許の環境（mac）で、cryptoniteライブラリのビルドがエラーになる問題が発生したが、ネットの情報を元に解決できたので、その症状と手順をblogに残しておく。エラーの症状： stack install cryptoniteで以下のようなエラーが発生。 % stack install cryptonite -- While building custom Setup.hs for package cryptonite-0.24 using: /Users/xxx/.stack/setup-exe-cache/x86_64-osx/Cabal-simple_mPHDZzAJ_2.0.1.0_ghc-8.2.2 --builddir=.stack-work/dist/x86_64-osx/Cabal-2.0.1.0 build --ghc-options "

Haskellの実行バイナリにファイルを埋め込む

2018-02-14T16:08:33+09:00

コンパイルしてできる実行バイナリにファイルを埋め込みたいことがある。アプリのGUIで使うアイコンとか機械学習の学習済みモデルとか。 Go では (現在では非推奨らしいが) go-bindata を使う場面だろうか。 Haskell ではそういうときには [file-embed](https://hackage.haskell.org/package/file-embed) パッケージが使える。たとえば `[project root]/resources/lorem.txt` に置かれた [lorem ipsum](https://ja.wikipedia.org/wiki/Lorem_ipsum) テキストを埋め込む場合:

HaskellでDiscordのBotを作る

2018-02-11T18:53:06+09:00

Discordはゲーミング向けのテキストチャットと音声通話を兼ねるプラットフォームであり、「テキストチャンネル」と「ボイスチャンネル」の二種を好きなだけ作ることができる。もちろん音声を全チャンネルに常時垂れ流すわけには行かないので、通話するにはボイスチャンネルに参加するという手順を踏む必要がある。しかし、例えば誰かがやっているゲームに混ざろうとしてボイスチャンネルに参加しても、チャンネル外のユーザーにはいかなる通知も発生しないため、気づかれないままのことがよくある。そこで、ボイスチャンネルに参加したとき、テキストチャンネルにその旨を投稿するボットを用意すれば、気軽に通話の合図を送れる。全員に…

Haskellで抽象構文木 (AST) にメタデータを付与する

2018-01-03T18:59:20+09:00

2018-01-04 追記: ここで全部語り尽くされている気がしたので、Labelling AST Nodes with locations なにもこんなブログ読むことはないのかもしれない。 megaparsecを使って構文解析器を書いている。構文解析やっているとASTにソースファイルの位置情報とかをメタデータとして乗せたくなるが、どんな感じで実装するのか調べた。僕自身はどのアプローチをとるのか決まっていない。問題やりたいこと megaparsec, parsecなどのコンビネータライブラリはジェネレータ系のalex + happyと比べると幾分まともなエラーメッセージを吐くようにな…

ガバガバAltJSを作った(言語実装 Advent Calendar 2017)

2017-12-24T20:24:04+09:00

qiita.com JavaScriptを書いていると、頻出する継続渡しのリフレインにうんざりさせられる。 foo.bar(function(result){ qux.baz(function(data){ hoge(function(r){ ... }); }); }); そこで、腕試しに継続モナドをベースにしたAltJS、jatkoを作った。フィンランド語で「継続」という意味だ(継続戦争から知った人も多いだろう)。しかし、なんの考えもなしに653行Haskellを書いた結果ガバガバな言語になってしまった。 Hello, world Haskellにだいぶ近いのでなんとなく読めるはず。 in…

HaskellのABC(Haskell Advent Calendar 6th)

2017-12-19T20:35:00+09:00

Haskellといえば一文字変数名、一文字変数名といえばHaskellという{{要出典}}ほどにHaskellでは一文字の変数名がよく使われている。これは名前を考えるのをサボっているとは限らない。多相性によって変数が具体的な性質を持たないがゆえに、具体的な名前がつけられないというのが主な理由だ。あるいは、適切な名前があっても、既存の名前と被っているという場合もある。かといって完全なランダムというわけでもないので、一文字変数名はどのように選べばいいか考察していこう。 a よくある種: * アルファベットの最初であるaは汎用性が高い。型変数に使うのが王道だ。値レベルの変数として単体で使うことは意外…

Left Recursionの悪夢再び

2017-12-17T21:20:53+09:00

はじめに Happyで生成したパーサのコンパイル遅すぎてもう限界だったのでparser combinatorに戻ってきた。そしてまた現れたのだ、やつが。。。。問題やろうとしてることは以前と変わらない。 SML Definitionを読んで型の注釈を表す式 ty を解析しようとしているが、左無限再帰が起きてしまって解析が終了しないというもの。 ty ::= tyvar (1) type variable such as 'a { tyrow i } (2) record type tyseq longtycon (3) type constructor with type argumen…

GHCの中間言語Coreへの脱糖を覗き見る

2017-12-10T19:50:16+09:00

Haskell (その3) Advent Calendar 2017 11日目の記事。(予約投稿知らなかったのでフライングになった) GHCがコンパイルの途中で中間表現として用いるCoreの生成っぷりを観察する。観察して、あーはいはいなるほどね(わかってない)、と言うだけになりそう。はじめに GHCはHaskellのソースコードを低レベルなコードへとコンパイルする過程で様々なpass(コンパイルのステージ)を通じてプログラムデータを変換する。俯瞰図は下記のリンクに詳しい。 Compiling one module: HscMain 僕がGHCの話をどこかで聞きかじってかっこいいな、と思っ…

A Tour of Go in Haskellを作ったのと、GoとHaskellの比較

2017-12-03T09:52:10+09:00

A Tour of Go in Haskell (日本語版/英語版) というサイトを作ったので、それの紹介をします。 https://a-tour-of-go-in-haskell.syocy.net/ja_JP/index.html Haskell は Go と同じく軽量スレッドやチャネルの機能があり、並行並列が得意な言語です。このサイトは A Tour of Go という Go のチュートリアルの並行性の章を題材として２つの言語を比較しています。

ステートマシン猛レース

2017-10-17T17:23:22+09:00

ストリーム処理ライブラリはHaskellにおいて競争の激しい分野の一つだ。ストリーム処理ライブラリとは大雑把に言うと、IOなどの作用を絡めながら値の列(ストリーム)を生成したり、処理したりする構造を提供するライブラリである。多くのライブラリは、以下の3種の構造を定義している。生産者(プロデューサー): IOなどのアクションを伴いつつ値を生成する。消費者(コンシューマー): 多くの場合モナド変換子になっており、await :: Consumer s m sのようなアクションを組み合わせ、値の列を処理するプログラムを書ける。変換者(トランスデューサー): 入力を受け取りながら、出力もできる。…

WindowsでのHaskell開発環境構築(2017年秋版)

2017-10-11T23:01:17+09:00

身の丈に合わないと形容されても仕方ないようなハイスペックなPCを買った。開発環境は当然作り直すことになるので、その軌跡を残しておく。 MSYS2 まずはMSYS2を入れる。これでツールチェーンが揃い、minttyというターミナルエミュレータもついてくる。 $ pacman -Syuu $ pacman -Sy git stack Haskellのビルドツールであるstackのインストーラを入手する。処理系から依存パッケージまで無難かつ自動的に用意してくれるので便利だ。 Home - The Haskell Tool Stack ただしstackはMSYS2上ではうまく動作しない。設定ファイル(…

SMLの関数適用を構文解析する時の問題

2017-09-30T19:30:43+09:00

まだ構文解析器で苦労している。今回も詰まっているのは構文のconflict。問題これが関数適用 app : exp exp これが二項演算子適用 infixapp : exp vid exp この時に入力を x y z とすると２つの解釈ができてしまうことになる。 ((x y) z) とするネストした関数適用なのか x y z とする二項演算子の適用なのかParserが判断つけられない。前者ならreduceするが後者ならshiftする。なのでこれはshift/reduce conflictが起きていると言える。 happyはデフォルトでshiftするので二項演算子として解釈される。 …

好きなプログラミング言語の好きなところについて思った

2017-09-24T23:41:26+09:00

改めて最近実感すること。 Haskell, Elm, Clojureほんと好き。 Scala勉強しなきゃなーと思いながらClojureを触ってしまうことが多かったのだけれど、その理由が少しずつわかってきた。いい言語たちいままで少しだけ触れてきたJava, Python, Scala, Goはいずれもとても大きなユーザを抱えている。どの言語もたくさんのユーザを得るために現場で使えるようなエコシステムをどんどん投下してあっという間に大きなユーザベースを獲得した。プログラミングのしやすさを大事にして、誰でもすんなり入門できるように設計されている。僕が入門できるくらいだから本当に敷居が低く…

GoのTickerみたいなやつをHaskellで作った

2017-08-27T00:30:35+09:00

github.com 作った。 GoのTickerはとてもシンプルな関数で、指定した周期でチャネルに値を送るスレッドを生成する。一定間隔で何かの処理を行いたいときに利用する。今回作ったHaskell版もだいたい同じようなものを提供する。実際のところパッケージにするには小さすぎる気もするけど、 Haskellパッケージ製作の練習をしたかったのでHackageのアカウントを取ってHackageに上げた。練習のため、HaddockによるAPIドキュメントおよびhspecとdoctestによるテストも書いてある。あとは何かCIを導入してGithubのページにCIのステータスを表示するような…

HaskellとJSON、そしてレコード型

2017-08-14T23:58:30+09:00

HaskellのJSON周りについて、こうやるのがいいんじゃないかという私の現在のやり方を書きます。題材としては、 Swagger Petstore に記されている REST API にリクエストを投げてレスポンスを取り出すというのをやります。 (Swagger ですが scaffold は使わず自分で HTTP クライアントライブラリを使います)。基本方針は「出力は厳密に入力には寛容に」(出典失念) です。もくじ JSONの前に: レコードのフィールドへのアクセス JSONの前に: レコードのデフォルト値 Haskellのデータ型→JSON JSONデータを含むHTTPリクエストレス…

FRPクライシス

2017-08-06T15:49:01+09:00

FRP(Functional Reactive Programming)は、リアクティブプログラミングと関数型プログラミングの性質を持つプログラミングパラダイムである。FRPは古典的FRPと矢矧のFRPに大別される。古典的FRP 古典的(Classical)FRPは、非連続的な値の列Eventと、常に何らかの値を取るBehaviourの二種類の構造を導入したものである。代表的な実装としてreactive-banana、euphoria、reflexなどが挙げられる。 Haskellにおいては、EventはIOを通じて非同期的に生成できる設計が多い。Eventはマップやフィルタリングができ、…

快速のExtensible effects

2017-08-02T23:04:22+09:00

extensibleは拡張可能レコードだけでなく拡張可能作用(extensible effects)も用意している。拡張可能作用は一時期Haskell界隈で話題になったものの、今では人気も下火になってしまった。新しいバージョンをリリースした今、拡張可能作用の動機と使い方について改めて紹介しよう。難行の一次関数 Haskellでモナドをカスタマイズする方法としては、transformersのモナド変換子がよく使われている。モナド変換子は、モナドをパラメータとして取り、新たな能力を付与したモナドにする構造だ。例えば、StateT sはモナド変換子の一つである。任意のアクションm aはliftを使…

左再帰を含む構文解析むずい

2017-07-03T16:37:49+09:00

やろうとしていること Haskellのparsecを使ってSMLの構文を解析し構文木を生成する。やっていること SMLの構文解析はいろいろステップがある。リテラル (special constants) 識別子 (identifier) 型注釈 !!イマココ!! パターンマッチ式宣言モジュール構文リテラルや識別子はなんとか倒して、いま型注釈の解析に取り組んでいるところ。苦戦しているところこの型注釈の構文解析で例の問題に突き当たった。左再帰問題だ。 SMLの型注釈の構文はこんな感じ。 ty ::= tyvar { } tyseq longtycon ty -> …

Haskellerの好きなところ

2017-05-21T16:28:55+09:00

僕はHaskellが好き。なんだけど、同じくらいHaskellもくもく会の常連の人達が好き。ちょっとした型についての質問から、いつの間にかホワイトボード上で証明とか書き出して「あー、ほんとだー、そういうことかー」って言ってる感じが好き。解らないことがあったら自分で検証するっていう、問題に対する誠実で真っ直ぐな態度を持っている人達が好き。 Haskellではそういう解らないところを形式的に検証する方法や知識がよく整備されていると思う。(とても難しいものもあるけど) きっと他のコミュニティにもそういう人はたくさんいる。でもHaskellもくもく会にはそういう人達が間違いなくいるのを僕は知って…

Haskellの代数データ型をJava的なインタフェースと捉える

2017-05-20T17:41:25+09:00

Haskellの代数データ型は僕にとってJavaのインタフェースに近い。データ型がインタフェースでそのデータを受け取る関数がインタフェースのメソッドに相当する。データをパターンマッチで分解して値コンストラクタ別の関数定義をするのは、インタフェースに対する実装を与えているものだと考えている。 data Maybe a mapMaybe :: (a -> b) -> Maybe a -> Maybe b Maybe aというデータ型があるとする。これがインターフェース。 mapMaybeという関数があるとする。これがメソッド。インタフェースに実装を与えていく。まずはデータ構造としてのイン…

Haskellは真面目なアプリケーション開発に向いている

2017-05-20T02:50:21+09:00

qiita.com ↑の記事で（主題ではないと思うものの）Haskellの批判に結構な分量が割かれていて、その批判のなかに「ちょっと違うんじゃないかな」という点がいくつかあったので反論ぽいことを書きます。 "Haskell は真面目なアプリケーション開発には向いてない"についてこれには多分いくつか事例を挙げればよくて、 Facebook ではスパム等の攻撃と戦うためのシステムを Haskell で作っています。 Fighting spam with Haskell | Engineering Blog | Facebook Code | Facebook (この記事を書いている Simon …

超技術書典でGHCJSの本を出します

2017-04-26T00:54:15+09:00

【告知】ニコニコ超会議2017と併催される超技術書典Day1(4/29)にて、GHCJSの入門的な本を出します。@y_taka_23 さんのスペースに委託する形になります。Haskell×JavaScriptに興味のある方はぜひA-04まで。 #技術書典 #超技術書典 pic.twitter.com/zUhiVc3CyX — しょしー超技術書典A-04 (@syocy) 2017年4月25日出します。 GHCJSの仕組みの話はほとんどなくて、あくまで使い方とか周辺事情の話になります。 GHCJSって昔は導入すること自体が難しくて、他のHaskell系AltJSに水をあけられている感があった…

[haskell][yesod] TypedContentを利用してクライアントが要求するフォーマットでレスポンスを返す

2016-12-17T15:16:26.835+09:00

Yesod Advent Calendar 2016の6日目の記事です。 RESTfulなAPIを提供する場合、クライアントの都合にあわせて、フォーマットを変えてレスポンスを返したいケースがあります。サーバー上で管理しているDBから、表現だけをHTML, JSON, XML, CSVなどに変更して返すイメージです。例えば、人物情報（名前、年齢、性別など）の一覧を返す際には以下のようなデータが返されることになります。 HTML <table border> <tr> <th>name</th> <th>sex</th> <th>age</th> </tr> <tr> <td>Taro Yamada</td>

Haskellライブラリ所感2016

2016-12-07T00:00:45+09:00

(これは Haskell Advent Calendar 2016 の7日目の記事です) 今年使ったり調べたりした Haskell ライブラリを広く紹介していく企画です。あくまで今年使ったものなので新しいものばかりではないです。また記事の性質上、紹介するものが偏っていてもご容赦ください。 Hackage にはすごい数のライブラリが登録されていて、頼もしいことですが目が回りそうにもなってしまいます。この記事が Haskell のライブラリを調べる上での指針になったら幸いです。なおこの企画と方向性が似ているものとして State of the Haskell ecosystem ( 20…

[haskell][yesod] stackのnewコマンドで指定できるyesod関連templateの説明

2016-12-03T23:37:28.283+09:00

現状、stackで指定できるyesod関連のtemplatesには以下のものがあります。どのtemplateに何が用意されているのか、知りたかったのですがどこにも説明されていないようなので、調べてまとめてみました。 % stack templates | grep yesod yesod-hello-world （←現時点では削除されています） yesod-minimal yesod-mongo yesod-mysql yesod-postgres yesod-postgres-fay yesod-simple yesod-sqlite 以下、各テンプレートの説明です。後に出てくるテンプレートほど内容が複雑になっています。テンプレートを指定して新しいプロジェクトを生成する場合は以下のコマンドを実行します。 % stack new プロジェクト名 yesod-???

[emacs] emacs上のgrep関連機能、複数ファイルの一括置換手順のまとめ

2016-11-30T10:03:25.873+09:00

emacs上でgrep関連の機能を利用する際のTIPSをまとめておきます（よく忘れて調べ直すので…）。 grepコマンドのオプション指定ディレクトリ以下のファイルを再帰的に検索 -R DIR シンボリックリンクを辿る -r DIR シンボリックリンクは辿らない検索対象をファイル名でフィルタする --include=GLOB GLOBにファイル名を指定する。"*.cpp"のようにワイルドカード（*,?,[...]）を指定可能検索対象から指定ファイル・ディレクトリを除外する --exclude=GLOB GLOBに除外するファイルのファイル名を指定する（ワイルドカード指定可能）。 --exclude-dir=DIR DIRに指定されたディレクトリをスキップ使用例

[cygwin] cygwin64セットアップメモ

2016-11-28T00:47:36.358+09:00

自分向け備忘録。cygwin64環境をセットアップする際の手順をまとめておきます。設定 ssh-agent関連 ssh-agentの重複起動を防ぐ ssh-agentのために秘密鍵セットアップ ~/.ssh/ ※group/otherのrw権限は削除 ssh-agentがパスワードを覚えてくれなくなった問題への対処 pingのエラー回避ユーザーのアカウント名、ホームディレクトリの変更 /etc/passwdを編集する GNU screen でlessやvimの終了後に画面クリアをしない方法改行コードにCR+LFが用いられているbashスクリプトを実行するための設定 tcshのデフォルト補完設定のイマイチな部分を修正環境変数 HOME ホームディレクトリを設定 SHELL "/bin/tcsh"とすることでデフォルトのシェルが切り替わる

HaskellのロガーKatipを試す

2016-10-31T02:55:12+09:00

モチベ Haskell の実行時ログ出力を行うライブラリは monad-logger が一番有名っぽい。これは Yesod 陣営が開発しているから安心感があるし、バックエンドが fast-logger なので速度も信頼できる。ただ (自分の調べ方が悪いのかもしれないが) ちょっと自分の用途には機能が足りなかった。具体的には以下の機能: ログにタイムスタンプを付記したい。ロガーに名前をつけたい。ファイルサイズか日付でログローテーションしたい。 Katip という別のロガーライブラリは機能が豊富のようなので今回はそれを試してみる。 (この記事のHaskell環境: lts-6.23) K…

続・Haskellの最近の例外ハンドリング

2016-08-28T17:55:00+09:00

前回の記事ではHaskellの例外ハンドリングには exceptions パッケージを使えばいいのではないかと書いた。ところが今年の6月に safe-exceptions という exceptions を拡張したようなパッケージがさる FPComplete から発表された。そこでこの記事では safe-exceptions について調べてみる。おそらくほぼ FPComplete の発表の受け売りになってしまうので英語を読める人は原文を読む方がいいかもしれない。さすが FPComplete だけあってこれは既に LTS Haskell に入っている。この記事では lts-6.14…

[haskell][yesod] YesodにおけるRESTfulなJSON API実装チュートリアル

2016-08-28T17:53:43.356+09:00

HaskellのwebフレームワークであるYesodにおいて、RESTful APIを実装する手順を紹介します。Haskell上のデータ構造をJSONテキストに変換する、逆に、JSONテキストをパースしてHaskell上のデータ構造を生成する、といった処理が非常に簡単に実現できます。加えて、コードを書かなくてもバックエンドのDBとのORマッピングが可能になっており、効率的に開発することができます。ここで紹介しているコードはgithubにコミットしています。準備： json-sampleというプロジェクト名でYesodのscaffolding siteをセットアップする空のプロジェクト生成 % stack new json-sample yesod-sqlite --system-ghc "--system-ghc"は省略可能。インストール済みのghcを使うことを指示し

[haskell][yesod] stack対応版Yesod tutorial

2016-07-17T18:06:36.108+09:00

HaskellのwebサービスフレームワークにYesodというフレームワークがあります。Yesodに触れたことのない開発者向けに書かれたチュートリアルの一つにYesod tutorialがあり、手順に沿っていくだけで簡単なwebサービスを動作させることができ、Yesodで何ができるかを簡単に理解できるようになっています。ただ残念なことに、このYesod tutorialの記載は内容が古く、stackを利用した現行の手順とマッチしなくなっています。stackに対応している最新環境（Yesod 1.4.x）における順があると役に立つと思い、書き起こしてみました。 Before the real start（はじめに） Install（インストール手順） stackをインストールする。以下のサイトが参考になります。 installation instructions for

[haskell][yesod] stack exec -- yesod devel で devel.hs: getAddrInfo: does not existというエラーになる問題の対処方法

2016-07-17T17:39:43.279+09:00

Widnwos環境での現象： windows上でyesodのscafolding siteをセットアップし、さあ起動！ブラウザから接続確認してOKとなるはずが、なぜか「The application isn't built」という表示が出てしまいました。このときターミナルには以下のようなログが出力されていました。 % stack exec -- yesod devel Yesod devel server. Type 'quit' to quit Application can be accessed at: http://localhost:3000 https://localhost:3443 If you wish to test https capabilities, you should set the following variable: export

Haskellの最近の例外ハンドリング

2016-07-02T17:44:26+09:00

どうもHaskellには標準のControl.Exceptionモジュールだけでなくmtlやexceptionsやexceptionalといった例外を扱うためのパッケージがあるらしいのだが、そのあたりのパッケージの選び方や使い方についてまとまった情報を見つけられなかった。 HaskellWiki例外のページも少々古いようで、deprecatedなものや統合される前のパッケージを書いていたりする。調べた限り、mtlとexceptionsが今の主流っぽい。その2つの使い方をまとめる。なおバージョンはlts-6.1を基準としている。 mtl mtlパッケージのControl.Monad.Exc…

[haskell][persistent][sqlite] Persistentパッケージ利用時にテーブルにインデックスを生成する方法

2016-01-30T17:12:12.076+09:00

PersistentパッケージにはMigration機能が備わっており、自動的にテーブルを生成してくれます。スキーマ変更を行った際にも、変換が可能な限りテーブル内のレコードを保持したまま新しいスキーマに変換してくれます（Migration機能については過去のエントリでまとめています）。自分が利用する上で、インデックスやトリガーを生成する手順が紹介されておらず困っていたのですが、rawExecuteという関数を用いることで自由にDDLを発行できることがわかりました。以下その手順とサンプルを紹介しておきます。サンプルコード：以下は、personテーブルのnameカラムにインデックスをs生成するサンプルです。runMigration実行直後に、runExecuteを実行することでインデックスを生成しています。このサンプルではインデックスを生成しているだけですが、同じ手順でトリガーの

[haskell][gcc][win] Windows版Haskell Platform付属のgccでC++11のコードをコンパイルする方法

2016-01-15T00:45:37.692+09:00

Windows版のHaskell Platformにはmingwが同梱されておりgccが含まれています。現在自分のPCにはHaskell Platform 2014.2.0.0をインストールしているのですが、これに付属されているgccでC++11のコードをコンパイルしようとすると、以下のようなエラーになってしまいました。 % gcc -std=c++11 cpp11.cpp cc1plus.exe: error: unrecognized command line option '-std=c++11' -stdオプションで"c++11"を指定しても、認識してくれません。本家のサイトによると、'-std=c++11'オプションはgcc 4.7でサポートされたようです。これに対し、Haskell Platform 2014.2.0.0に付属されているgccのバージョンを確認したところ

[sqlite] SQLiteのロック・トランザクション関連仕様の整理

2016-01-06T12:11:40.986+09:00

SQLiteは共有ロック・排他ロックの仕組みを備えており、プロセス内の複数スレッド、だけでなく、プロセスをまたぐ状態でSQLが同時に発行されても適切に処理されます。トランザクションに複数のモードが存在し、指定するモードに依って取得されるロックが変わります。さらにSQLの内容に依存してロック状態が遷移するため、複数プロセスがアクセスしたときの挙動を正確に把握できるよう、仕様を整理してみました。（文中の「プロセス」は、正確には「プロセス、もしくはスレッド」を意味します。） DBのロック状態の種類： UNLOCKED ロックされていない状態。誰も読み書きしていない。DBの初期状態。 SHARED read可、write不可な状態。複数プロセスが同時にSHAREDロックを取得可能。複数プロセスが同時にreadできることを意味する。DBがこの状態にあるとき、他のプロセスからの

[haskell][stack] stack exec ghciで”Couldn't match expected type"エラーが発生する問題の対処

2015-11-08T15:09:21.187+09:00

先日、haskellのパッケージ管理をcabalからstackに移行して「便利〜！」と感動していたところなのですが、stach exec ghciでソースをロードしようとすると"Couldn't match expected type: xxxxx"とエラーが発生する問題に遭遇しました。ネットの情報を参考に解決することができたのでその手順をまとめておきます。問題： stack buildは成功するにもかかわらず、stack exec ghci xxx.hs（xxx.hsはbuild対象のファイル）がエラーになる。 stack exec ghci実行時のエラーログ： % stack exec ghci FileToVec.hs GHCi, version 7.10.2: http://www.haskell.org/ghc/ :? for help [1 of 1]

[cygwin] cygwinのシェル起動時にPATHの先頭に/usr/binと/usr/local/binが勝手に追加されないようにする

2015-11-04T22:29:43.126+09:00

cygwinのデフォルトの設定では、シェル起動時に以下の2つのディレクトリが自動的にPATHの先頭に追加されます。 /usr/local/bin /usr/bin cygwinでインストールされているコマンドと同名の別コマンドを優先して起動したい場合には、この設定が邪魔になります。これを無効にするには以下の方法があります。お好みでどちらかを選択してください。 /etc/profileもしくは/etc/csh.loginの該当処理をコメントアウトする（bash / tcsh） cygwinがPATHを上書きしているのは、/etc/profile（bashの場合）と/etc/csh.login（tcshの場合）です。これらのスクリプトを編集することで、/usr/binと/usr/local/binが勝手に追加されないようにできます。 ORIGINAL_PATHでPATHを上書き

[ssh] OpenSSHのアップデートでssh-agentがパスワードを覚えてくれなくなった問題への対処

2015-09-06T00:44:24.703+09:00

ssh-agent/ssh-addを利用してsshを用いたサーバーへのログイン時のパスワード入力を省略している方、OpenSSHのアップデートにより、毎回パスワード入力を求められるようになった場合は以下の設定を疑ってみてください。問題の症状： OpenSSHパッケージを最新版にアップデートすると発生するようになった問題です。ssh-agentを起動してssh-addで鍵を正しく登録しているにも関わらず、sshコマンドを実行する度に"password:"というプロンプトが表示されてパスワードの入力を求められてしまいます。環境：問題に遭遇＆解決した私のcygwin環境では以下のバージョンで問題が発生することを確認しました。 OpenSSH_7.0p1, OpenSSL 1.0.2d 9 Jul 2015 OpenSSH_7.1p1, OpenSSL 1.0.2d 9 Jul

Haskell Antenna

HaskellでABC454を解く

HaskellでABC453を解く

Haskellのモナドを何が何でも理解する（Pythonでもわかる）

Haskell の数値計算ライブラリで logSumExp の実装を読む

AIはアウトプットだけじゃない。学習ツールとして使ってみた。

[windows] Windows11セットアップ・設定項目のメモ

証明: Applicative の合成は Applicative

MySQL 8.4対応のシンプルなHA管理ツールをHaskellで自作した話

Haskellのfoldl、foldl'、foldrを比較してみた

PythonのrequestsっぽいHTTPクライアントをHaskellで作った

（仮）絶対できるHaskell 抄「圏論とファンクター」

【TypeScriptよりいいもの】未だ応用されきっていない、型システム本来の力の簡単紹介【読み物】

[cygwin] cygwinセットアップ・環境構築手順メモ

HaskellのFunctorが圏論の関手であるというのはどういうこと？

含意(→)の用例：マンガ「数字であそぼ。」の論理パズルを解く

BuriKaigi 2026 で Lean によるコンパイラの証明について話してきました

HaskellでGTK 4 tutorialを進めている

シェルで関数型プログラミング

関数型プログラミングの疑問「副作用を起こさないプログラムなんてありえない」

GHCへの私の貢献2025

各言語特有っぽい構文: Haskell

HaskellとWin32 APIでウィンドウを表示する

なぜ3次元回転はいろいろなのか：完全ガイドと実装tips

高階作用にも対応しconduitも使えるエフェクトシステムであるYafteeの紹介

HaskellでAtCoderやってたけどやっと茶色コーダーになれたので振り返り

FunctorチュートリアルとBiinvariant Opticsへの展望

ダンジョン生成に一様分布を求めるのは間違っているだろうか

TypeScript使いがHaskellに入門して、プログラミングパラダイムの「解像度」が上がった話

クロックパズルを単因子論で解く

簡単なHaskellのみでServant並に高機能なライブラリーを作ろうとした振り返り

Link to here動機

Link to hereできたもの

Link to here(1) 最も単純な例

Link to here(2) ステータスコードを指定した例

Link to here(3) パスの中に含まれる整数を処理する例

Link to hereContent-Typeを複数指定する

Link to hereサーバーアプリケーションとしての使い方

Link to hereTemplate Haskellによる、クライアントの生成

Link to hereドキュメントの生成

Link to here何故開発を止めるのか

Link to here想定通りにできなかったもの: レスポンスに複数のパターンがあるとき

Link to hereパスのパーサー: 実は<$>がすでに危ない

Link to here実装し切れなかったもの

Link to here類似のライブラリー・解決策

Link to hereOkapi

Link to hereIHP

Link to here終わりに

飛行機の中で Haskell プロジェクトをビルドする

Shake のキャッシュが効いてなかった

「関数の副作用の有無」よりも大事なもの

関数型まつり 2025 で AWS と定理証明について話してきました

GHCデバッグ日誌 CI編

PHPerKaigi 2025 で AWS のポリシー言語 Cedar について話してきました

GHCのSIMDサポートの進捗：整数ベクトルの演算

never型があると便利か（言語処理系実装者の観点から）

Haskellで雑にA/Bテストの検定

GHCへの私の貢献2024

コンパイル時定数しか受け付けない引数

YAPC::Hakodate 2024 で様相論理について話してきました

[ThinkPad] タッチパッド（trackpoint）の中央ボタンをマウスの中ボタンにアサインする方法

#技術書典 16 で Go を使って #自作モデル検査器 をつくる本を頒布します

技術書典16に、Haskellでの型レベルプログラミングの本を出します

Haskell で Open Telemetry を利用してオブザーバビリティーを向上させよう

GHCへの私の貢献2023

[ATOK] 候補ウィンドウがカーソル位置ではなく、画面中央に固定表示されるようになってしまった

[windows] Windows10セットアップ・設定項目のメモ

Haskell/GHCのSIMDについて考える

Developers Summit 2023 Summer でサーバーレスについて話してきました

意地でも関心を分離する

リリースされていない変更が溜まるのを防ぐGitHub Action「tocenbough」

ローカルk8sの上に色んなサービスを立てて壊す

2022 年、アウトプットの思い出

きりたんぽ鍋を作る

Elm 用の Octicons パッケージを作る

CloudNative Days Tokyo 2022 に「謎は全て解けた！ 安楽椅子探偵に捧げる AWS ネットワーク分析入門」というタイトルで登壇してきました

AWS Dev Day 2022 Japan に「サーバーレスは操作的意味論の夢を見るか？」というタイトルで登壇してきました

wd コマンドをリリースした

一般社団法人としてのHaskell-jp Admins解散のお知らせ

Link to here背景

Link to
here動機

Link to
hereできたもの

Link to
here(1) 最も単純な例

Link to
here(2) ステータスコードを指定した例

Link to
here(3) パスの中に含まれる整数を処理する例

Link to
hereContent-Typeを複数指定する

Link to
hereサーバーアプリケーションとしての使い方

Link to
hereTemplate Haskellによる、クライアントの生成

Link to
hereドキュメントの生成

Link to
here何故開発を止めるのか

Link to
here想定通りにできなかったもの: レスポンスに複数のパターンがあるとき

Link to
hereパスのパーサー: 実は`<$>`がすでに危ない

Link to
here実装し切れなかったもの

Link to
here類似のライブラリー・解決策

Link to
hereOkapi

Link to
hereIHP

Link to
here終わりに

#技術書典 16 で Go を使って #自作モデル検査器をつくる本を頒布します

CloudNative Days Tokyo 2022 に「謎は全て解けた！安楽椅子探偵に捧げる AWS ネットワーク分析入門」というタイトルで登壇してきました

Link to
here背景

Link to
here今後の活動

Link to
here今後の連絡先

Link to
heremono-traversableパッケージの紹介

Link to
heremono-traversableパッケージにおける型クラスのメソッドと、各種文字列型向け関数の対応表

Link to
here⚠️パフォーマンスに関わる注意事項

Link to
here事例: `String`から相互変換できる型を抽象化する

Link to
hereまとめ

Link to
here二項演算子（記号関数）の調べ方

Link to
hereユーザーが定義した二項演算子ではないものの調べ方

Link to
hereまとめ

Link to
here経緯

Link to
here発表者募集

Link to
here参加登録

Link to
here2022/09/18 重大な追記

Link to
here背景

Link to
here今後の活動と連絡先

Link to
here現在の理事・社員

Link to
here所在地

Link to
here定款

Link to
hereサンプルコードについて

Link to
here`Monad`と`Monoid`の切っても切り離せない関係

Link to
here`Monoid`の例

Link to
here`Monoid`と`Writer`の切っても切り離せない関係

Link to
here`do`と`<>`

Link to
here`Writer` `Monad`の結合則と`Monoid`の結合則

Link to
here関係を壊してみる

Link to
here`<>`と`Monoid`の結合則

Link to
here`>>=`と`Monad`の結合則

Link to
here`do`記法と`Monad`の結合則

Link to
hereまとめ

Link to
hereStackプロジェクトのビルド

Link to
hereDockerイメージのビルドとプッシュ