注意:这是一种练习,我正在尝试了解事物的工作原理。
我正在努力使在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
下面是我的程序。在这一点上,我不明白为什么它不起作用,但是由于某些原因,变量没有改变。
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 (*)
[请帮助我了解这里有什么问题以及如何改进代码。谢谢。
毋庸置疑,这在Haskell要做的事很愚蠢;但如果能够帮助您学习一些东西,我全力尝试愚蠢的事情。
我认为您可能应该回避一个更简单的问题,并在尝试类似此类的复杂操作之前对State monad进行更多的试验;从您发布的代码段中我怀疑您的直觉有点偏离。
您当然可以做这种事情,但是在State 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
此代码从文字数创建一个新的“变量”,它是通过从环境中获取一个新的变量名,将其包装在构造函数中,然后使用提供的值将其存储在环境中来实现的。请注意,我们增加了freshVar数字,因此下一个文字将获得不同的变量ID。
getVar :: Var -> Imperative Int getVar v = gets (fromJust . M.lookup v . vars) setVar :: Var -> Int -> Imperative () setVar v n = modify (\s -> s{vars=M.insert v n (vars s)})
这些是一些帮助程序,它们在变量映射中查找变量或设置变量。
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 (*)
要执行您的版本的变异操作,我们需要两个变量,查找它们的当前值,执行该操作,然后将结果存储到左侧的变量中。
现在我们可以定义while
while :: Imperative Bool -> Imperative () -> Imperative () while cond act = do continue <- cond if continue then act >> while cond act else return ()
我们可以接受任何返回布尔值作为条件的命令性语句;用户可以根据需要在语句中查找变量的状态。我们只运行语句,如果要继续,请先单击
act
,然后递归,否则返回。
f :: Int -> Int f n = run $ do i <- lit n while ((>0) <$> getVar i) $ do one <- lit 1 i -= one getVar i
有点罗word(我们可以简化一下,但是会使合并器更加复杂)。我们将
i
定义为值为n
的新变量,然后检查条件是否大于0
。在循环体中,我们定义一个值为1
的变量,然后从变量i
中减去它。
循环终止后,我们检查i
的值
run :: Imperative a -> a run m = evalState m (Env 0 M.empty)
这里是我们上面使用的
run
函数,它只是在未定义变量的情况下运行状态。
如果您尝试一下,您将看到它成功命中零;您可以添加一条trace语句以查看命中的值:
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