Haskell 使哈斯克尔成为当务之急

注意：这是一个练习，我试图了解事情是如何运作的

我正试图在哈斯凯尔做到这一点：

f :: Integer -> Integer
f n = def $ do
  i      <- var n
  while i (>0) $ do
    i      -= lit 1
  return i
-- for now, my program returns n 

f:：Integer->Integer
f n=def$do
我要10美元
i-=1
返回i
--现在，我的程序返回n

下面是我的程序。在这一点上，我无法理解为什么它不起作用，但出于某种原因，变量没有改变

import Control.Monad.State


data Lit a = Lit a
type Variable a = State Integer a


def :: Variable (Lit a) -> a
def (State f) = fromLit . fst . f $ 0 

fromLit :: Lit a -> a
fromLit (Lit a) = a

lit :: a -> Lit a
lit l = Lit l

var :: a -> Variable (Lit a)
var v = State $ \x -> (lit v, x)

while :: Lit a -> (a -> Bool) -> Variable () -> Variable ()
while (Lit r) cond act = do
                 if cond r then do
                          _ <- act
                          while (Lit r) cond act
                    -- or act >> while (Lit r) cond act
                 else return ()


op :: (Integer -> Integer -> Integer) -> Lit Integer -> Lit Integer -> Variable ()
op f (Lit a) (Lit b) = State $ \n -> ((), if n == a then f a b else n)
-- that is, if the state is (a) change it to (f a b), else don't change it

(+=) = op (+)
(-=) = op (-)
(*=) = op (*)

import Control.Monad.State
数据点亮a=点亮a
类型变量a=状态整数a
def:：变量（点亮a）->a
def（状态f）=fromLit。fst。f$0
fromLit:：lita->a
fromLit（lita）=a
点亮：：a->点亮a
发光l=发光l
变量：：a->变量（点亮a）
var v=状态$\x->（亮v，x）
while:：lita->（a->Bool）->Variable（）->Variable（）
当（发光r）条件动作=do时
如果有条件，那就做吧
_>当（灯光）接通时
否则返回（）
op:：（整型->整型->整型）->整型->整型->整型->变量（）
op f（Lit a）（Lit b）=状态$\n->（（），如果n==a，则f a b else n）
--也就是说，如果状态是（a），将其更改为（fab），否则不更改它
（+=）=op（+）
（=）=op（-）
（*=）=op（*）

---

请帮助我理解这里的错误以及如何改进代码。谢谢。

不用说，在哈斯凯尔这样做是愚蠢的；但我完全赞成尝试愚蠢的事情，如果它能帮助你学到一些东西的话

我认为在尝试像这样复杂的事情之前，你可能应该退回到一个更简单的问题上来，对状态单子进行更多的实验；从您发布的代码片段来看，我怀疑您的直觉有点不正确

当然可以这样做，但是在状态monad中处理“任意”类型的变量是很棘手的（状态必须有固定的类型）。您可以使用

Dynamic

和

Proxy

以相对类型安全的方式执行此操作；但我认为这可能还是有点遥不可及

我们将从存储Int类型的变量开始。我不确定您使用的是哪个

State

monad，但我将使用

mtl

中的变量

import Control.Monad.State
import qualified Data.Map as M
import Data.Maybe

data Var = Var Int
  deriving (Show, Eq, Ord)

data Env = Env {freshVar :: Int, vars :: M.Map Var Int}
  deriving Show

type Imperative a = State Env a

我已经定义了

Env

类型，它跟踪我们“创建”的所有变量，还有一个“新名称”生成器，它只是一个Int，在定义变量时不断向上计数

lit :: Int -> Imperative Var
lit n = do
    varID <- gets freshVar
    let newVar = Var varID
    modify (\s -> s{freshVar=n+1, vars=(M.insert newVar n (vars s))})
    return newVar

这些是一些在变量映射中查找变量或设置变量的助手

getVar

使用

fromJust

这通常是不安全的；但是如果您只使用“lit”定义新变量，那么它就可以正常工作

op :: (Int -> Int -> Int) -> Var -> Var -> Imperative ()
op f aVar bVar = do
    a <- getVar aVar
    b <- getVar bVar
    setVar aVar (f a b)

(+=) = op (+)
(-=) = op (-)
(*=) = op (*)

我们可以接受任何返回布尔值作为条件的命令语句；如果需要，用户可以在语句中查找变量的状态。我们只需运行语句，如果我们想继续，我们将执行

操作
然后递归，否则返回

f :: Int -> Int
f n = run $ do
  i <- lit n
  while ((>0) <$> getVar i) $ do
    one <- lit 1
    i -= one
  getVar i

下面是我们上面使用的
run
函数，它只运行state，没有定义变量

如果你尝试一下，你会看到它成功地达到零；您可以添加一个跟踪语句，查看它命中的值：

import Debug.Trace
f :: Int -> Int
f n = run $ do
  i <- lit n
  while ((>0) <$> getVar i) $ do
    getVar i >>= traceShowM
    one <- lit 1
    i -= one
  getVar i

>>> f 10
10
9
8
7
6
5
4
3
2
1
0

import Debug.Trace
f:：Int->Int
f n=运行$do
i 0）getVar i）$do
getVar i>>=traceShowM
一个>>F10
10
9
8.
7.
6.
5.
4.
3.
2.
1.
0
不用说，在哈斯克尔做这件事是愚蠢的；但我完全赞成尝试愚蠢的事情，如果它能帮助你学到一些东西的话

我认为在尝试像这样复杂的事情之前，你可能应该退回到一个更简单的问题上来，对状态单子进行更多的实验；从您发布的代码片段来看，我怀疑您的直觉有点不正确

当然可以这样做，但是在状态monad中处理“任意”类型的变量是很棘手的（状态必须有固定的类型）。您可以使用
Dynamic
和
Proxy
以相对类型安全的方式执行此操作；但我认为这可能还是有点遥不可及

我们将从存储Int类型的变量开始。我不确定您使用的是哪个
State
monad，但我将使用
mtl
中的变量

import Control.Monad.State
import qualified Data.Map as M
import Data.Maybe

data Var = Var Int
  deriving (Show, Eq, Ord)

data Env = Env {freshVar :: Int, vars :: M.Map Var Int}
  deriving Show

type Imperative a = State Env a

我已经定义了
Env
类型，它跟踪我们“创建”的所有变量，还有一个“新名称”生成器，它只是一个Int，在定义变量时不断向上计数

lit :: Int -> Imperative Var
lit n = do
    varID <- gets freshVar
    let newVar = Var varID
    modify (\s -> s{freshVar=n+1, vars=(M.insert newVar n (vars s))})
    return newVar

这些是一些在变量映射中查找变量或设置变量的助手
getVar
使用
fromJust
这通常是不安全的；但是如果您只使用“lit”定义新变量，那么它就可以正常工作

op :: (Int -> Int -> Int) -> Var -> Var -> Imperative ()
op f aVar bVar = do
    a <- getVar aVar
    b <- getVar bVar
    setVar aVar (f a b)

(+=) = op (+)
(-=) = op (-)
(*=) = op (*)

我们可以接受任何返回布尔值作为条件的命令语句；如果需要，用户可以在语句中查找变量的状态。我们只需运行语句，如果我们想继续，我们将执行
操作
然后递归，否则返回

f :: Int -> Int
f n = run $ do
  i <- lit n
  while ((>0) <$> getVar i) $ do
    one <- lit 1
    i -= one
  getVar i

下面是我们上面使用的
run
函数，它只运行state，没有定义变量

如果你尝试一下，你会看到它成功地达到零；您可以添加一个跟踪语句，查看它命中的值：

import Debug.Trace
f :: Int -> Int
f n = run $ do
  i <- lit n
  while ((>0) <$> getVar i) $ do
    getVar i >>= traceShowM
    one <- lit 1
    i -= one
  getVar i

>>> f 10
10
9
8
7
6
5
4
3
2
1
0

import Debug.Trace
f:：Int->Int
f n=运行$do
i 0）getVar i）$do
getVar i>>=traceShowM
一个>>F10
10
9
8.
7.
6.
5.
4.
3.
2.
1.
0
我不同意反对票，我认为这是一个关于如何建模命令式结构的很好的练习（好吧，只要你不在日常代码中使用这种样式：-））。无论如何，
State Integer
不是适合的monad，除非您的命令式程序只使用一个变量。您可能需要
状态（VariableName->Integer）
，或者
映射
以提高效率。为了提高效率，我会使用
ST s
。@chi，这里的
VariableName
是什么？它可以是
String
，也可以是您想要用于变量名的任何类型。原则上也可以使用
Int
。如果需要，可以称为“位置”或“参考”i