小编Cac*_*tus的帖子

这是场景:我已经编写了一些带有类型签名的代码,并且GHC抱怨无法推断x~y某些x和y.你通常可以将GHC作为一个骨骼并简单地将同构函数添加到函数约束中,但这有几个原因:

1. 它并不强调理解代码.
2. 你可以得到5个约束,其中一个就足够了(例如,如果5个被一个更具体的约束暗示)
3. 如果你做错了什么或者GHC没有帮助,你最终可能会受到假的限制

我只花了几个小时与案例3作斗争.我正在玩syntactic-2.0,我试图定义一个与域无关的版本share,类似于在中定义的版本NanoFeldspar.hs.

我有这个:

{-# LANGUAGE GADTs, FlexibleContexts, TypeOperators #-}
import Data.Syntactic

-- Based on NanoFeldspar.hs
data Let a where
    Let :: Let (a :-> (a -> b) :-> Full b)

share :: (Let :<: sup,
          Domain a ~ sup,
          Domain b ~ sup,
          SyntacticN (a -> (a -> b) -> b) fi) 
      => a -> (a -> b) -> a
share = sugarSym Let

和GHC could not …

假设我们得到一个n个整数的数组,代表一天的股票价格.我们希望找到一对(buyDay,sellDay) ,与buyDay≤sellDay,例如,如果我们买了股票buyDay卖了上sellDay,我们将最大限度地提高我们的利润.

显然,通过尝试所有可能的(buyDay,sellDay)对并从所有这些对中充分利用,该算法有一个O(n ²)解决方案.但是,是否有更好的算法,也许是在O(n)时间运行的算法？

我遇到了一个非常奇怪的功能.

当我试图在主线程上运行动画时,它不会启动.当我使用运行所述动画

getView().post(new Runnable() {
            @Override
            public void run() {
                getView().startAnimation(a);
            }
        });

它确实开始了.

我CurrentThread在开始动画之前打印过并打印出来main.

显然,我在这里遗漏了一些东西,因为两者都应该在主线程上启动动画......我的猜测是,当post将任务添加到队列中时,它会在更"正确的时间"开始,但我很想知道这里发生的事情更深入.

编辑:让我清楚一点 - 我的问题是,为什么在帖子上启动动画会导致它启动,当在主线程上启动动画时没有.

Don Stewart 在大型演讲中的Haskell提到了Phantom Types:

data Ratio n = Ratio Double
1.234 :: Ratio D3

data Ask ccy = Ask Double
Ask 1.5123 :: Ask GBP

我读了他们关于他们的要点,但我不理解他们.另外,我在这个主题上阅读了Haskell Wiki.但我仍然错过了他们的观点.

使用幻影类型的动机是什么？

当一个RTL块包含对同一个寄存器的多个赋值时,我无法理解Kansas Lava的行为.这是版本号1:

foo :: (Clock c) => Signal clk Bool
foo = runRTL $ do
    r <- newReg True
    r := low    
    return $ var r

这表现得像我预期的那样:

*Main> takeS 10 foo :: Seq Bool
low | low | low | low | low | low | low | low | low | low | ? .

生成的VHDL是:

architecture str of assignments is
  signal sig_2_o0 : std_logic;
begin
  sig_2_o0 <= '0';
  OUTPUT <= sig_2_o0;
end architecture str; …

在不同的问题上,我发现了关于使用(->)Monads实例的评论中的提示,例如用于实现无点样式.

至于我,这有点过于抽象.好吧,我已经看到了Arrow实例,在(->)我看来,它(->)可以在实例表示法中使用,但不能在类型声明中使用(这可能只是另一个问题的东西).

有没有任何例子使用(->)Monad的例子？还是一个很好的链接？

很抱歉,如果这个问题可能已经在这里讨论过,但是搜索" (->)Monad实例"会给你很多次点击,因为你可以想象......因为几乎所有关于Haskell的问题都涉及到(->)"Monad".

根据着名的论文,成语是不经意的,箭头是一丝不苟的,monad是混杂的,箭头的表达能力(没有任何额外的类型)应该在应用函子和monad之间严格地说:monads相当于ArrowApply,并且Applicative应该等同于纸张称为"静态箭头".但是,我不清楚这种"静态"意味着什么限制.

玩弄的问题有三种类型类,我是能够建立应用性函子和箭头,这是我在与知名等价的上下文中呈现之间的等价Monad和ArrowApply.这种结构是否正确？(我在厌倦之前证明了大部分的箭法).这是不是意味着Arrow并且Applicative完全一样？

{-# LANGUAGE TupleSections, NoImplicitPrelude #-}
import Prelude (($), const, uncurry)

-- In the red corner, we have arrows, from the land of * -> * -> *
import Control.Category
import Control.Arrow hiding (Kleisli)

-- In the blue corner, we have applicative functors and monads,
-- the pride of * -> *
import Control.Applicative
import Control.Monad

-- Recall the well-known result that every …

我们知道免费的monad是有用的,像Operational这样的包可以很容易地定义新的monad,只关注特定于应用程序的效果,而不是monadic结构本身.

我们可以很容易地定义"自由箭头",类似于如何定义自由单子:

{-# LANGUAGE GADTs #-}
module FreeA
       ( FreeA, effect
       ) where

import Prelude hiding ((.), id)
import Control.Category
import Control.Arrow
import Control.Applicative
import Data.Monoid

data FreeA eff a b where
    Pure :: (a -> b) -> FreeA eff a b
    Effect :: eff a b -> FreeA eff a b
    Seq :: FreeA eff a b -> FreeA eff b c -> FreeA eff a c
    Par :: FreeA eff a? b? -> FreeA eff a? …

我不时地在Haskell文档中注意到以下内容:(例如在Data.Text)中:

融合

什么是融合,我该如何使用它？

我是一个Haskell新手,并且在弄清楚如何模式匹配时遇到了一些麻烦ByteString.在[Char]我的函数的版本是这样的:

dropAB :: String -> String
dropAB []       = []
dropAB (x:[])   = x:[]
dropAB (x:y:xs) = if x=='a' && y=='b'
                  then dropAB xs
                  else x:(dropAB $ y:xs) 

正如所料,这会过滤掉字符串中出现的所有"ab".但是,我在尝试将其应用于a时遇到问题ByteString.

天真的版本

dropR :: BS.ByteString -> BS.ByteString
dropR []         = []
dropR (x:[])     = [x]
<...>

产量

Couldn't match expected type `BS.ByteString'
       against inferred type `[a]'
In the pattern: []
In the definition of `dropR': dropR [] = []

[]显然是罪魁祸首,因为它是一个常规String而非一个ByteString.Subbing in …