Haskell 中使用 State-Monad 的类设置方法

Question

我最近看了 Haskell 的 Monad - State。我已经能够创建与这个 Monad 一起操作的函数，但我试图将行为封装到一个类中，基本上我试图在 Haskell 中复制这样的东西：

class A {
  public:
  int x;
  void setX(int newX) {
      x = newX;
  }
  void getX() {
      return x;
  }
}

如果有人可以提供帮助，我将非常感激这。谢谢！

Answer 1

我首先要指出的是，至少可以说，Haskell 并不鼓励传统的 OO 风格的开发；相反，它具有非常适合“纯函数”操作的功能和特性，而这在许多其他语言中是找不到的；简而言之，尝试从其他（传统语言）“引入”概念通常是一个非常糟糕的主意。

但我试图将行为封装到一个类中

因此，我想到的第一个主要问题是为什么？您肯定想用这个（传统的面向对象概念）类做一些事情吗？

如果这个问题的大致答案是：“我想对某种数据构造进行建模”，那么您最好使用类似的东西，

data A = A { xval :: Int }

> let obj1 = A 5
> xval obj1
5
> let obj2 = obj1 { xval = 10 }
> xval obj2
10

它演示了纯粹的、不可变的数据结构，以及“getter”函数和破坏性的更新（利用记录语法）。这样，您就可以根据需要将这些“数据结构”映射到新数据结构的函数组合来完成所需的任何工作。

现在，如果您绝对需要某种状态模型（事实上，回答这个问题需要一些经验来准确了解什么是本地状态与全局状态），< em>只有这样你才会深入研究使用 State Monad，比如：（

module StateGame where

import Control.Monad.State

-- Example use of State monad
-- Passes a string of dictionary {a,b,c}
-- Game is to produce a number from the string.
-- By default the game is off, a C toggles the
-- game on and off. A 'a' gives +1 and a b gives -1.
-- E.g 
-- 'ab'    = 0
-- 'ca'    = 1
-- 'cabca' = 0
-- State = game is on or off & current score
--       = (Bool, Int)

type GameValue = Int
type GameState = (Bool, Int)

playGame :: String -> State GameState GameValue
playGame []     = do
    (_, score) <- get
    return score

playGame (x:xs) = do
    (on, score) <- get
    case x of
         'a' | on -> put (on, score + 1)
         'b' | on -> put (on, score - 1)
         'c'      -> put (not on, score)
         _        -> put (on, score)
    playGame xs

startState = (False, 0)

main = print $ evalState (playGame "abcaaacbbcabbab") startState

无耻地摘自 这教程）。请注意，除了“put”和“get”单子函数之外，在状态单子的上下文中还使用了类似的“纯不可变数据结构”，这有助于访问状态单子中包含的状态单子。

最后，我建议您问自己：您真正想通过这个 (OO) 类模型实现什么目标？ Haskell 不是典型的面向对象语言，尝试一对一地映射概念只会在短期（也可能是长期）让您感到沮丧。这应该是一个标准的口头禅，但我强烈建议您学习Real World Haskell这本书，其中作者能够深入研究选择任何一种工具或抽象而不是另一种工具或抽象的更详细的“动机”。如果您坚定的话，您可以在 Haskell 中对传统的 OO 构造进行建模，但我不建议这样做 - 除非您有这样做的真正理由。

Answer 2

将命令式代码转换为纯函数式上下文需要进行一些排列。

setter 会改变对象。由于懒惰和纯粹，我们不允许直接在 Haskell 中这样做。

也许，如果我们将 State monad 转录为另一种语言，它会更加明显。您的代码是用 C++ 编写的，但因为我至少想要垃圾收集，所以我将在这里使用 java。

由于 Java 从未定义过匿名函数，因此首先我们将为纯函数定义一个接口。

public interface Function<A,B> {
    B apply(A a);
}

然后我们就可以组成一个纯粹的不可变对类型。

public final class Pair<A,B> {
    private final A a;
    private final B b;
    public Pair(A a, B b) {
        this.a = a;
        this.b = b;
    }
    public A getFst() { return a; }
    public B getSnd() { return b; }
    public static <A,B> Pair<A,B> make(A a, B b) {
        return new Pair<A,B>(a, b);
    }
    public String toString() {
        return "(" + a + ", " + b + ")";
    }
}

有了这些，我们实际上可以定义 State monad：

public abstract class State<S,A> implements Function<S, Pair<A, S> > {

    // pure takes a value a and yields a state action, that takes a state s, leaves it untouched, and returns your a paired with it. 
    public static <S,A> State<S,A> pure(final A a) {
        return new State<S,A>() {
            public Pair<A,S> apply(S s) {
                return new Pair<A,S>(a, s);
            }
        };
    }
    // we can also read the state as a state action.
    public static <S> State<S,S> get() {
        return new State<S,S>() {
            public Pair<S,S> apply(S, s) {
                return new Pair<S,S>(s, s);
            }
        } 
    }

    // we can compose state actions
    public <B> State<S,B> bind(final Function<A, State<S,B>> f) {
        return new State<S,B>() {
            public Pair<B,S> apply(S s0) {
                Pair<A,S> p = State.this.apply(s0);
                return f.apply(p.getFst()).apply(p.getSnd());
            }
        };
    }

    // we can also read the state as a state action.
    public static <S> State<S,S> put(final S newS) {
        return new State<S,S>() {
            public Pair<S,S> apply(S, s) {
                return new Pair<S,S>(s, newS);
            }
        } 
    }
}

现在，状态 monad 内部确实存在 getter 和 setter 的概念。这些称为镜头。 Java 中的基本表示如下：

public abstract class Lens[A,B] {
    public abstract B get(A a);
    public abstract A set(B b, A a);
    // .. followed by a whole bunch of concrete methods.
}

这个想法是，lens 提供对 getter 的访问，该 getter 知道如何从 A 中提取 B，以及 setter 知道如何获取 B 和一些旧的 A，并替换部分内容A，产生一个新的 A。它不能改变旧的 A，但可以用替换的字段之一构造一个新的 A。

我在最近的波士顿地区 Scala 爱好者会议上就这些问题发表了演讲。您可以在此处观看演示文稿。

回到 Haskell，而不是在命令式的环境中谈论事情。我们可以

import Data.Lens.Lazy

从 导入comonad-transformers 或 此处提到的其他镜头库之一。该链接提供了成为有效镜头必须满足的法律。

然后您要寻找的是某种数据类型，例如：

data A = A { x_ :: Int }

使用镜头

x :: Lens A Int
x = lens x_ (\b a -> a { x_ = b })

现在您可以编写看起来像

postIncrement :: State A Int
postIncrement = do
    old_x <- access x
    x ~= (old_x + 1)
    return old_x

使用 Data.Lens.Lazy。

上面提到的其他镜头库提供类似的组合器。

Answer 3

首先，我同意 Raeez 的观点，这可能是错误的方法，除非你真的知道为什么！如果你想将某个值增加 42（比如说），为什么不编写一个函数来为你做到这一点呢？

这与传统的面向对象思维方式有很大的不同，在传统的面向对象思维方式中，你有一些盒子，里面有值，你把它们拿出来，操纵它们，然后把它们放回去。我会说，直到你开始注意到这个模式“嘿！我总是把一些值当作一个参数，最后返回它稍微修改一下，加上一些其他值，所有的管道都变得混乱了！”你真的不需要 State monad。 （学习）Haskell 的部分乐趣在于寻找新方法来绕过有状态的 OO 思维！

也就是说，如果您绝对想要一个带有 Int 类型的 x 的盒子，您可以尝试制作自己的 get 和 put 变体，如下所示：

import Control.Monad.State

data Point = Point { x :: Int, y :: Int } deriving Show

getX :: State Point Int
getX = get >>= return . x

putX :: Int -> State Point ()
putX newVal = do
    pt <- get
    put (pt { x = newVal })

increaseX :: State Point ()
increaseX = do
    x <- getX
    putX (x + 1)

test :: State Point Int
test = do
    x1 <- getX
    increaseX
    x2 <- getX
    putX 7
    x3 <- getX
    return $ x1 + x2 + x3

现在，如果您在 ghci 中评估 runState test (Point 2 9)，您将得到 (12,Point {x = 7, y = 9}) （因为12 = 2 + (2+1) + 7 并且状态中的 x 最后被设置为 7）。如果您不关心返回的点，可以使用evalState，您将只得到12。

这里还需要做一些更高级的事情，例如使用类型类抽象出 Point ，以防您有多个数据结构，这些数据结构的行为类似于 x 但最好留给另一个问题，在我看来！