标签: arrows

这个问题基本上是使用GHCi在Haskell程序中调试无限循环的重复.那里的作者手动解决了它,虽然我想知道其他解决方案.

(我的特殊问题)

我有一个包含递归调用的箭头代码,

testAVFunctor = proc x -> do
    y <- errorArrow "good error" -< x
    z <- isError -< y
    (passError ||| testAVFunctor) -< trace "value of z" z

本errorArrow应使递归testAVFunctor无法执行,因为这将导致ISERROR返回一个Left (AVError "good error")应依次选择passError路由,绕过递归调用.

非常奇怪的是,在功能组合等热门网站上插入"跟踪"调用会导致程序发出有限量的输出,然后冻结.不是我对无限期扩张问题的期望.(见编辑1)

如果有人这么好奇我在这里上传了我的源代码.

编辑1

我没有找到正确的地方(如果你想看看源,显然avEither正在循环).我到那里的方法是编译二进制文件,然后运行gdb:

• gdb主要
• r (运行代码)
• Ctrl + C (发送中断).回溯将毫无用处,但你可以做的就是被击中
• s (步骤).然后,按住回车键; 你应该看到很多方法名称飞过.希望其中一个是可识别的.

您可以使用ghc标志-O0进行编译以禁用优化,这可以显示更多方法名称.

编辑3

显然,proc x -> do上面的块导致代码生成组合器,组合器调用AVFunctor.arr …

我正在尝试使用 Haskell 解析一些 XML 文件。对于这项工作，我使用HXT来获取有关实际应用中箭头的一些知识。所以我对箭头主题很陌生。

在 XPath （和HaXml）中，可以按位置选择节点，例如：/root/a[2]/b

即使在一遍又一遍地阅读文档之后，我也无法弄清楚如何使用 HXT 做类似的事情。

这是我正在使用的一些示例代码：

module Main where

import Text.XML.HXT.Core

testXml :: String
testXml = unlines
    [ "<?xml version=\"1.0\"?>"
    , "<root>"
    , "    <a>"
    , "        <b>first element</b>"
    , "        <b>second element</b>"
    , "    </a>"
    , "    <a>"
    , "        <b>third element</b>"
    , "    </a>"
    , "    <a>"
    , "        <b>fourth element</b>"
    , "        <b>enough...</b>"
    , "    </a>"
    , "</root>"
    ]

selector :: ArrowXml a => a XmlTree …

在这篇文章中出色的答案的引导下，我试图获得一个ArrowLoop不使用箭头表示法的工作示例。在我完全理解箭头在幕后的工作原理之前，我对使用箭头表示法感到不舒服。话虽这么说，我已经构建了一个小程序，基于我对 Arrows 的（有限）理解应该可以工作。然而，它最终以可怕的异常终止<<loop>>：

module Main where

import Control.Wire
import FRP.Netwire

farr :: SimpleWire (Int, Float) (String, Float)
farr = let
  fn :: Int -> Float -> ((String, Float), SimpleWire (Int, Float) (String, Float))
  fn i f = (("f+i: " ++ (show (fromIntegral i + f)), f + 0.1), loopFn)

  loopFn :: SimpleWire (Int, Float) (String, Float)
  loopFn = mkSFN $ \(i, f) -> fn i f
  in
   mkSFN $ \(i, _) -> fn i 0.0 …

我是Haskell的新手,我一直在玩Arrows.我想写一个工具,可以编程"拆解"以前构建的箭头.作为一个潜在的应用程序,想象一个函数,它接收一个箭头并返回一个有向图,代表所有连接,分裂,扇出等.

例如,(f &&& g)>>> h产生类似的东西

    ----- f ----
---|            |--- h -----
    ----- g ----

我最初认为我可以通过模式匹配来做到这一点,如下面的简单(改编自haskell.org箭头教程),但它没有用.

module Main(main) where

import Control.Arrow
import Control.Category
import Prelude hiding (id, (.))

newtype SimpleFunc a b = SimpleFunc {runF :: (a -> b)}

instance Arrow SimpleFunc where
    arr f = SimpleFunc f
    first (SimpleFunc f) = SimpleFunc (mapFst f) where 
        mapFst g (a,b) = (g a, b)
    second (SimpleFunc f) = SimpleFunc (mapSnd f) where 
        mapSnd g (a,b) = (a, g b)

instance Category …

三个月后更新

我在下面的回答中使用netwire-5.0.1+ sdl,在使用Arrows和Kleisli Arrows进行I/O的功能反应编程结构中.虽然太简单,不能被称为"游戏",但它应该是非常可组合的并且非常可扩展.

原版的

我正在学习Haskell,并尝试用它制作一个小游戏.但是,我想看看小型(规范)文本游戏的结构.我也尽量保持代码尽可能纯净.我现在正在努力了解如何实施:

1. 主循环.这里有一个例子如何在Haskell中编写游戏循环？但似乎接受的答案不是尾递归.我不确定这是否重要.据我了解,内存使用量会增长,对吧？
2. 国家转型.不过,我认为这与第一个问题非常相关.我试了一下State,在http://www.gamedev.net/page/resources/_/technical/game-programming/haskell-game-object-design-or-how-functions-can-get-you中试了一下-apples-r3204,但是虽然单个组件可以在有限的步骤中工作和更新,但我看不出如何在无限循环中使用它.

如果可能的话,我想看一个基本上最小的例子:

1. 要求玩家反复输入内容
2. 满足某些条件时,请更改状态
3. 当满足其他一些意愿时,退出
4. 理论上可以无限时间运行而不会破坏内存

我没有任何可用的代码,因为我无法获得最基本的东西.我在网上找到的任何其他材料/示例都使用其他一些库,比如SDL或GTK驱动事件.我发现在Haskell中完全写的唯一一个是http://jpmoresmau.blogspot.com/2006/11/my-first-haskell-adventure-game.html,但是那个在主循环中看起来不像是一个尾递归(同样,我不知道这是否重要).

或者,可能Haskell不打算做这样的事情？或者我可能应该放入mainC？

编辑1

所以我在https://wiki.haskell.org/Simple_StateT_use中修改了一个小例子,使它更简单(并且它不符合我的标准):

module Main where
import Control.Monad.State

main = do 
  putStrLn "I'm thinking of a number between 1 and 100, can you guess it?"
  guesses <- execStateT (guessSession answer) 0
  putStrLn $ "Success in " ++ (show guesses) ++ " tries."
  where
    answer = …

我正在使用具有两种不同风格的Slick滑块,对于我的网页,但我遇到箭头问题.你能帮我么？

这是我的主要.slider,我用它来设置它的上一页和下一个箭头

http://prntscr.com/7kdpgo

在这里我使用了.filtering类的Slick,但我不想要这些箭头.如何在此处禁用它们并在设计中添加它们？

http://prntscr.com/7kdq03

我正在通过为comm语言实现一个简单的解释器来学习如何在Haskell中使用Arrows 。

我有一个eval函数，该函数将一个表达式求值为一个值，但是当输入任何表达式时，eval会无限期地循环。

-- Interp.hs

eval :: A Expr Val
eval = proc e -> case e of
    Lit x -> returnA -< Num x
    Var s -> do
        lookup -< s
    Add e1 e2 -> do
        v1 <- eval -< e1
        v2 <- eval -< e2
        case (v1, v2) of
            (Num x, Num y) -> returnA -< Num (x + y)

在GHCI中执行此操作会导致无限循环

*Interp> unpack eval M.empty (Lit 1)

在添加表达式的情况下注释掉eval确实会导致表达式给出结果

例如

-- Interp.hs

eval :: A Expr Val …

众所周知，Applicative概括Arrows。在习语是健忘，箭都一丝不苟，单子是混杂由Sam林德利，菲利普·沃德勒和Jeremy Yallop纸据说Applicative是相当于静态箭头，这是其下述同构持有箭头：

arr a b :<->: arr () (a -> b)

据我所知，它可以通过以下方式说明：

注：newtype Identity a = Id { runId :: a }。

Klesli Identity是一个静态箭头，因为它包裹k :: a -> Identity b。同构只是删除或添加包装器。

Kleilsi Maybe不是k = Kleisli (const Nothing)存在的静态箭头- 所有f :: a -> bs 都对应于Just . f，并且k在同构中没有位置。

但在同一时间都Kleisli Identity和Kleisli Maybe是Arrow实例。因此，我看不出泛化是如何工作的。

在Wikibooks上的Haskell/Understanding Arrows 教程中 …

F# 中的箭头是否有“proc”符号的实现？在 Haskell 中，它看起来像这样：

mean2 :: Fractional a => Circuit a a
mean2 = proc value -> do
    t <- total -< value
    n <- total -< 1
    returnA -< t / n

注意proc关键字和-<符号。

理想情况下，这可能会以某种方式使用计算表达式，但我也对其他方法持开放态度。

我想根据 John Hughes 的论文Generalizing Monads to Arrows编写一个解析器。在通读并尝试重新实现他的代码时，我意识到有些事情不太合理。在一节中，他根据 Swierstra 和 Duponchel 的论文Deterministic, error-correcting combinator parsers using Arrows展示了一个解析器实现。他描述的解析器类型是这样的：

data StaticParser ch = SP Bool [ch]
data DynamicParser ch a b = DP (a, [ch]) -> (b, [ch])
data Parser ch a b = P (StaticParser ch) (DynamicParser ch a b)

组合运算符看起来像这样：

(.) :: Parser ch b c -> Parser ch a b -> Parser ch a c
  P (SP e2 st2) (DP f2) . P (SP e1 …