なんかメモ

ヤック殺人事件。

http://hackage.haskell.org/packages/archive/derp/0.1.5/doc/html/src/Text-Derp.html

parser :: (Ord a) => ParserRec Parser a -> FPValue Bool -> Parser a
parser p n = fix $ \ self -> Parser p n (memoFun (deriveImp self)) (compactImp self)

この定義は（ボクにとって）分かりやすいものではないので、もうちょっとはっきりと Mutually Open Recursive っぽくしてみる。

type Open t = t -> t

(<+>) :: Open t -> Open t -> Open t
l <+> r = \p -> l (r proceeed)

compactP :: (Ord a) => Open (Parser a)
compactP p = p { parserCompact = compactImpl p }

deriveP :: (Ord a) => Open (Parser a)
deriveP p = p { parserDerive = deriveImpl p }

memoP :: (Ord a) => Open (Parser a)
memoP p @ Parser { parserDerive } = p { parserDerive = memoFun parserDerive }

simpleP :: (Ord a) => ParserRec Parser a -> FPValue Bool -> Open (Parser a)
simpleP r n p = p { parserRec = r, parserNullable = n }

parser :: (Ord a) => ParserRec Parser a -> FPValue Bool -> Parser a
parser r n = fix $ memoP <+> deriveP <+> compactP <+> (simpleP r n)

かなり長くなったけどこうなる。これを scala にそのまま翻訳すると…

abstract class Parser[A] {
  def rec : ParserRec[Parser, A]
  def nullable : FPValue[Bool]
  def derive(t : Token) : Parser[A]
  def compact : Parser[A]
}

abstract class SimpleP[A](
  val rec : ParserRec[Parser, A],
  val nullable : FPValue[Bool]
) extends Parser[A]

abstract class CompactP[A](
  private val r : ParserRec[Parser, A],
  private val n : FPValue[Bool]
) extends SimpleP[A](r, n) {
  def compact : Parser[A] = compactImp this
  private def compactImp(p : Parser[A]) : Parser[A] = ...
}

abstract class DeriveP[A](
  private val r : ParserRec[Parser, A],
  private val n : FPValue[Bool]
) extends CompactP[A](r, n) {
  def derive (t : Token) : Parser[A] = deriveImp(this)(t)
  private def deriveImp(p : Parser[A]) : Token -> Parser[A] = ...
}

class MemoP[A](
  private val r : ParserRec[Parser, A],
  private val n : FPValue[Bool]
) extends DeriveP[A](r, n) {
  override def derive(t : Token) : Parser[A] = ...
}

def parser[A](r : ParserRec[Parser, A], n : FPValue[Bool]) : Parser[A] = new MemoP(r, n)

長い…直訳すぎて色々無駄があるので自然な定義にする。

abstract class Parser[A] {
  def rec : ParserRec[Parser, A]
  def nullable : FPValue[Bool]
  def derive(t : Token) : Parser[A]
  def compact : Parser[A]
}

abstract class CompactP[A] extends Parser[A] {
  def compact : Parser[A] = compactImp this
  private def compactImp(p : Parser[A]) : Parser[A] = ...
}

abstract class DeriveP[A] extends CompactP[A] {
  def derive (t : Token) : Parser[A] = deriveImp(this)(t)
  private def deriveImp(p : Parser[A]) : Token -> Parser[A] = ...
}

abstract class MemoP[A] extends DeriveP[A] {
  override def derive(t : Token) : Parser[A] = ...
}

class ConcreateP[A](val rec : ParserRec[Parser, A], val nullable : FPValue[Bool]) extends MemoP[A]

def parser[A](r : ParserRec[Parser, A], n : FPValue[Bool]) : Parser[A] = new ConcreateP(r, n)

依然長いけど（ボクにとって）分かりやすくなった。

しかし問題はそこではなくて deriveImp や compactImp なのですが…