小编Agn*_*yay的帖子

使用以下定义:

lenDigits n = length (show n)
factorial n = product [1..n]

我评估以下内容

Prelude> ((lenDigits . factorial) 199) <= 199
False
Prelude> (\i -> ((lenDigits . factorial) i) <= i) 199
True

这种行为的原因是什么？在我看来,第一个表达式与第二个表达式相同,lambdas减少了.

根据Haskell Wikibook,以下关系<$>并<*>保持:

f <$> x = pure f <*> x

他们声称,人们可以证明这个定理是算子和适用法则的结果.

我不知道如何证明这一点.任何帮助表示赞赏.

请考虑以下两个变体:

myReadListTailRecursive :: IO [String]
myReadListTailRecursive = go []
    where 
    go :: [String] -> IO [String]   
    go l = do {
                 inp <- getLine;
                 if (inp == "") then 
                     return l;
                 else go (inp:l);
                }

myReadListOrdinary :: IO [String]
myReadListOrdinary = do
        inp <- getLine
        if inp == "" then
            return []
        else
            do
                moreInps <- myReadListOrdinary
                return (inp:moreInps)

在普通的编程语言中,人们会知道尾递归变体是更好的选择.

但是,通过这个答案,显然haskell的递归实现与重复使用递归堆栈的实现并不相似.

但是因为在这种情况下,所讨论的程序涉及行动和严格的单子行列,我不确定是否适用相同的推理.事实上,我认为在这种IO情况下,尾递归形式确实更好.我不确定如何正确推理这一点.

编辑:大卫杨指出,这里最外面的电话是(>>=).即使在这种情况下,这些风格中的一种是否优于另一种？

有一些算法,如Edmond算法或Boruvka算法,它要求程序员创建一个图形,该图形是通过将一些节点收缩到一个节点中,然后再将其扩展回来获得的.

收缩的正式描述如下:

让我们G与顶点的图V和边E.让我们C成为一个连接组件G.G相对于的收缩C被定义为图形V - nodes(C) + C*,其中C*是表示收缩组分的"超级节点".不涉及顶点的边缘C是原样的.C现在连接有端点的边C*.

我不清楚如何使用邻接列表等表示来实现这样的算法原语.

什么是一种优雅而有效的方式来表示图形,以便它们可以签约,同时记住用于扩展它们的相关数据？

在系统F中,类型exists a. P可以被编码为forall b. (forall a. P -> b) -> b使用存在性的任何系统F术语可以根据关于打字和缩减规则的该编码来表达.

在"类型和编程语言"中,将显示以下练习:

我们可以根据存在类型编码通用类型吗？

我的直觉说这是不可能的,因为在某种程度上,"存在包装"机制并不像"类型抽象"机制那样强大.我如何正式展示这个？

我甚至不确定我需要证明什么才能正式显示这个结果.

我正在尝试定义一系列具有不同类型状态的状态机。特别是，更“复杂”的状态机具有通过组合更简单状态机的状态而形成的状态。

（这类似于面向对象的设置，其中一个对象具有多个也是对象的属性。）

这是我想要实现的简化示例。

data InnerState = MkInnerState { _innerVal :: Int }

data OuterState = MkOuterState { _outerTrigger :: Bool, _inner :: InnerState }

innerStateFoo :: Monad m => StateT InnerState m Int
innerStateFoo = do
  i <- _innerVal <$> get
  put $ MkInnerState (i + 1)
  return i

outerStateFoo :: Monad m =>  StateT OuterState m Int
outerStateFoo = do
  b <- _outerTrigger <$> get
  if b
    then
       undefined
       -- Here I want to "invoke" innerStateFoo
       -- which should …

我看过这篇文章，它对什么是自由 monad 进行了一些抽象的描述。我也理解 Monad Transformers 是什么，并且我理解（在某种程度上）为什么它们会有用。

我不知道免费 monad 用于什么或 monad 转换器库是什么。我也听说过mtl vs free monad 辩论，但我不确定它是什么，因为我在互联网上找不到任何关于此的讨论。

有人能解释一下这个争论是关于什么的吗？

假设我要计算 {1,2,..100} 的 80 个元素子集的数量，使得它们的总和为 3690。

我有以下模型：

array[1..100] of var 0..1: b;

constraint (sum (i in 1..100) (i*b[i])) == 3690;
constraint (sum (i in 1..100) (b[i])) == 80;

solve satisfy;

为了计算解决方案的总数，我运行

$ ./minizinc --all-solutions ~/Documents/code/xmas.mzn > sol.out
$ wc -l sol.out

本质上，我正在打印所有的解决方案并计算它们。有没有一个更简单的 minizinc 语句来代替solve satisfy它让我计算解决方案而不是找到它们？

我试图通过打结来形成像数据结构这样的无限网格.

这是我的方法:

import Control.Lens

data Grid a = Grid {_val :: a,
                    _left :: Grid a,
                    _right :: Grid a,
                    _down :: Grid a,
                    _up :: Grid a}

makeLenses ''Grid

makeGrid :: Grid Bool -- a grid with all Falses
makeGrid = formGrid Nothing Nothing Nothing Nothing

formGrid :: Maybe (Grid Bool) -> Maybe (Grid Bool) -> Maybe (Grid Bool) -> Maybe (Grid Bool) -> Grid Bool
formGrid ls rs ds us = center
  where
    center = Grid False leftCell …

我正在读这篇文章,其中说:

好吧,重点是箭头符号禁止符号允许的一些计算.特别是所有"箭头动作"必须"静态地"知道".

它解释说:

静态知道"意味着如果我们有几行箭头符号

> -- y <- action1 -< x

> -- z <- action2 -< y

然后表达式action2不能依赖于x或箭头符号行左侧的任何约束.

据我了解,这种限制使箭头值得.

现在,我正在努力学习Opaleye,我注意到它使用箭头将各种东西组合在一起.

为什么Opaleye使用箭头？为什么箭头适合这项工作？使这个限制有用的数据库/查询是什么？