小编sev*_*evo的帖子

Prelude> :i ($)
($) ::
  forall (r :: GHC.Types.RuntimeRep) a (b :: TYPE r).
  (a -> b) -> a -> b
        -- Defined in ‘GHC.Base’
infixr 0 $

它有什么不同(a -> b) -> a -> b？有b没有不适合新型签名？

我试图通过给它一个镜头参数来重构我的函数(从xml-lens包中).我错过了关于类型量词的一些东西.这里发生了什么？

*Main> let z name = listToMaybe $ pom ^.. root ./ ell name . text
*Main> :t z
z :: Text -> Maybe Text
*Main> let z name l = listToMaybe $ pom ^.. l ./ ell name . text

<interactive>:13:38:
    Couldn't match expected type ‘(Element -> f Element)
                                  -> Document -> f Document’
                with actual type ‘t’
      because type variable ‘f’ would escape its scope
    This (rigid, skolem) type variable is bound by
      a type expected …

我正在学习Haskell并开始注意以下函数中的常见后缀:

debugM
mapM_
mapCE

这被称为匈牙利表示法.但与此同时,我可以使用类型类来编写非模糊代码,如:

show
return

因为喜欢功能map是如此普遍,在很多情况下使用时,为什么不让类型检查挑选的正确版本的多态性map,fmap,mapM,mapM_或mapCE？

在这次访谈中, Stepanov展示了如何max在C++中实现泛型函数.

尝试以面向对象的方式实现一个简单的事情,比如max.我不知道怎么做.使用泛型编程我可以写:

template <class StrictWeakOrdered>
inline StrictWeakOrdered& max(StrictWeakOrdered& x,
StrictWeakOrdered& y) {
return x < y ? y : x;
}

and
template <class StrictWeakOrdered>
inline const StrictWeakOrdered& max(const StrictWeakOrdered& x,
const StrictWeakOrdered& y) {
return x < y ? y : x;
}

Run Code Online (Sandbox Code Playgroud)

(你确实需要&和const&).

为什么需要两次编写代码？这是否需要帮助编译器进行优化或减少错误的约定？是max一种特殊情况下的身体const版本是相同的？

N个参数的函数应该有多少有效const和非const置换来定义完整的API？

我试图了解是什么决定了类型参数是否必须是名义上的.

虽然GADT和类型族在某种意义上看起来不同,但它们不是"简单容器",因为它们的实例定义可以"查看"它们的参数,简单类型是否明显需要名义参数,比如Set？

有没有办法从表达简化中解脱出来？

例如,给出这个表达式:

(+) <$> a <*> b $ 1

我很想看到一个可以解释它意味着什么的工具.这对于初学者来说非常费力(在源中找到正确的实例函数定义,检查运算符优先级)以简化包含所有步骤的表达式:

fmap (+) a <*> b $ 1

见定义在Data.Functor

(.) (+) a <*> b $ 1  

见FMAP在Control.Monad.Instances对instance Functor ((->) r)

等等.

编辑:为了澄清,我正在寻找一种方法来使用实际的函数定义重写表达式,以便新手可以理解这个表达式的结果.怎么说到(<$>) = fmap这里？我不知道如何使用hoogle和其他工具找到特定的实例定义(源).

编辑:更改了不正确的原始表达式以匹配以下减少.

计算a的深度需要什么最小(最一般)的信息Data.Tree？是一个Data.Foldable足够的实例？

我起初试图fold一个Tree和被困试图找到合适的Monoid相似Max.有些东西告诉我,因为Monoid(这会计算深度)需要是关联的,它可能不能用于表达需要了解结构的任何折叠(如1 + maxChildrenDepth),但我不确定.

我想知道什么样的思维过程会让我在这种情况下得到正确的抽象.

我对WAI界面进行了好奇的观察,虽然看起来很简单,但我惊讶地看到它在当前表格中需要多少次迭代才能稳定下来!

我曾认为CPS风格对于资源安全来说是最有趣的事情,但看起来还有很多值得学习的东西!

$ git log -p --reverse -- wai/Network/Wai.hs | grep '\+type Application'
+type Application = Request -> Iteratee B.ByteString IO Response
+type Application = Request -> ResourceT IO Response
+type Application = Request -> C.ResourceT IO Response
+type Application = Request -> IO Response
+type Application = Request -> (forall b. (Response -> IO b) -> IO b)
+type Application = Request -> (Response -> IO ResponseReceived)
                            -> IO ResponseReceived

一些考古学产生了一些令人不满意的结果:

$ git log --reverse -G 'type …

新的Haskell程序员很快就会去看看如何foldr实现.嗯,代码过去很简单(不要指望新手知道OldList或者FTP).

新代码如何工作？

-- | Map each element of the structure to a monoid,
-- and combine the results.
foldMap :: Monoid m => (a -> m) -> t a -> m
foldMap f = foldr (mappend . f) mempty

-- | Right-associative fold of a structure.
--
-- @'foldr' f z = 'Prelude.foldr' f z . 'toList'@
foldr :: (a -> b -> b) -> b -> t a -> b
foldr f z …

与其他类型级函数相比,Haskell中"类型构造函数"概念的独特之处是什么？

据我所知他们:

• 允许用户在编译期间向它们应用参数
• 在提供有限数量的参数后,会产生一个简单的类型(例如,不是约束)