レコードがあればバリアントがが実装できる．
{-# LANGUAGE Rank2Types #-}
-- パターンマッチ自体をレコードとして表現する
data MatchEither a b c = MatchEither { whenLeft :: a -> c, whenRight :: b -> c }
-- レコードとして表現されたバリアント
newtype RecEither a b = RecEither { unRecEither :: forall c. MatchEither a b c -> c }
-- コンストラクタ
left :: a -> RecEither a b
left x = RecEither (\match -> whenLeft match x)
right :: b -> RecEither a b
right x = RecEither (\match -> whenRight match x)
instance (Show a, Show b) => Show (RecEither a b) where
show m = unRecEither m (MatchEither {
whenLeft = \x -> "Left (" ++ show x ++ ")",
whenRight = \x -> "Right (" ++ show x ++ ")" })
instance Monad (RecEither a) where
return = right
(>>=) m k = unRecEither m (MatchEither { whenLeft = left, whenRight = \x -> k x })
レコードのそれぞれのフィールドを，パターンマッチのそれぞれの節だと考え，そこからひとつ選び取ることでバリアントを表現する．
レコードなくてもλ式だけでいいんじゃない？
レコードがあればバリアントができると言うけれども，実際のところ，レコードはなくてもいい．
RecEither は forall c. MatchEither a b c -> c のように表現されているが，これは， forall c. (a -> c, b -> c) -> c のようにしても同じことであるし，カリー化して forall c. (a -> c) -> (b -> c) -> c としても，同じことである．すると left x = \f g-> f x となって，けっきょく，λ式だけでいいことになってしまう．
{-# LANGUAGE Rank2Types #-}
newtype LambdaEither a b = LambdaEither { unLambdaEither :: forall c. (a -> c) -> (b -> c) -> c }
-- コンストラクタ
left :: a -> LambdaEither a b
left x = LambdaEither (\whenLeft _ -> whenLeft x)
right :: b -> LambdaEither a b
right x = LambdaEither (\_ whenRight -> whenRight x)
instance (Show a, Show b) => Show (LambdaEither a b) where
show m = unLambdaEither m (\x -> "Left (" ++ show x ++ ")") (\x -> "Right (" ++ show x ++ ")")
instance Monad (LambdaEither a) where
return = right
(>>=) m k = unLambdaEither m left (\x -> k x)
バリアントでレコードを実装する？
双対と言うからには，バリアントを使うことでレコードが実装できそうだが，このことについて触れている文献を，いまのところ知らない．
したがってわたしの独自研究になってしまうわけで，不正確かもしれないが，こういう方法もある．
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE LambdaCase #-}
data MatchPair a b c = Fst (a -> c) | Snd (b -> c)
newtype VarPair a b = VarPair { unVarPair :: forall c. MatchPair a b c -> c }
pair :: a -> b -> VarPair a b
pair x y = VarPair (\case { Fst f -> f x ; Snd f -> f y })
fst' :: VarPair a b -> a
fst' p = unVarPair p (Fst id)
snd' :: VarPair a b -> b
snd' p = unVarPair p (Snd id)
こっちのほうも，やはり，たとえばペアは `\x y z -> z x y`` と実装することができるし(Church pair)，バリアントをわざわざ使う必要はない．
多相レコードで多相バリアントを実装
レコードでバリアントができるなら，多相レコードで多相バリアントができる．
多相レコードで多相バリアントを実装する方法は， SML# のドキュメントに書かれている．
多相レコードは， Row Polymorphism や， Haskell なら OverloadedRecordFields と呼ばれるものである．
その理屈なら， OverloadedRecordFields を使えば，多相バリアントに当たるものがつくれるはずなのだが，まだちゃんと試していない．
SML# のコードであることに注意．
fun left x match = #whenLeft match x
fun right x match = #whenRight match x
val return = right
infix 1 >>=
fun op >>=(m, k) = m { whenLeft = left, whenRight = (fn x => k x) }
これで left と right は多相バリアントになっている．
例としては，たとえば， left/right/middle というみっつのラベルを持つバリアントがあったとする．
fun left x match = #whenLeft match x
fun right x match = #whenRight match x
val return = right
infix 1 >>=
fun op >>=(m, k) = m { whenLeft = left, whenRight = (fn x => k x) }
fun middle x match = #whenMiddle match x
(*
* Haskell で書くと
* bind m k = case m of
* Left x -> Left x
* Middle x -> Middle x
* Right x -> k x
*)
fun bind(m, k) = m { whenLeft = left, whenMiddle = middle, whenRight = (fn x => k x) }
(* left 1 は >>= に対しても bind に対しても使える！！ *)
val l1 = left 1
val it = l1 >>= (fn x => right x)
val it = bind(l1, (fn x => middle x))
多相バリアントで多相レコードを実装
多相バリアントで多相レコードを実装するには，次のようにすればいい．
let id x = x
let pair x y = function `Fst f -> f x | `Snd f -> f y
let fst p = p (`Fst id)
let snd p = p (`Snd id)
let triple x y z = function `Fst f -> f x | `Snd f -> f y | `Third f -> f z
let third p = p (`Third id)
(* fst は pair/triple のどちらに対しても使える *)
let i = fst (pair 1 2)
let j = fst (triple 1 2 3)
参考文献
Chapter 7. SML#の拡張機能：レコード多相性 § 7.7. 多相バリアントの表現
多相レコードで多相バリアントを表現する