小编Mai*_*tor的帖子

Foldl和folr是FP和Haskell的两个非常重要的函数,但是我从来没有听过太多关于unsided fold的内容:

fold f [a,b,c,d] = (f (f a b) (f c d))

也就是说,操作二进制关联函数的折叠(因此应用顺序无关紧要).如果我没记错的话,这在数据库中很常见,因为它可以并行化.所以,关于它,我问:

1. 像折叠一样,它是普遍的吗？
2. 像foldr一样,你能用它定义每个重要的功能吗？
3. 是否有融合规则,类似于foldr/build和unfoldr/destroy？
4. 为什么几乎没有提到？
5. 还有什么值得一提的考虑？

我有一个10mb +二进制文件,这是我的客户端工作所必需的.每次我的客户端访问该站点时,该文件都会大一点.因此,请考虑我的客户端在一天内访问该页面20次.与每次新访问一样,文件已经改变了一点,它不能被缓存,所以他将下载至少200mb - 即使在白天,文件只改变了0.1mb.

有没有办法避免这种巨大的带宽浪费？

通常,对于编程语言实现,期望使用按位运算符标记数字.在C中,您可以使用union来标记double:

typedef union Tag_ { double d; long long i; } Tag;
double tag(double x){ Tag tmp; tmp.d = x; tmp.i |= 1; return tmp.d; };
double isTagged(double x){ Tag tmp; tmp.d = x; return tmp&1; };

有什么方法可以模仿JavaScript上的这种行为？排除使用按位运算符,因为它将双精度转换为Uint32s.我需要一个数学解决方案.

这是一个关于风格的简单问题.我一直在用:

import Linear
point  = V3 1 2 3
scaled = fmap (* 2) point

要么...

scaled = (* 2) <$> point

这是预期的方式,还是由标量运算符进行适当的乘法？

我在我的OSX Yosemite上安装了CUDA.我已经下载了accele-examples包并用它编译cabal install.它编译正确.但是,当我运行这些示例时,我注意到它们没有提供在CUDA下运行的选项.例如:

vh:accelerate-crystal apple1$ ./accelerate-crystal
EKG monitor started at: http://localhost:8000

accelerate-crystal (c) [2011..2013] The Accelerate Team

Usage: accelerate-crystal [OPTIONS]

Available backends:
  *  interpreter  reference implementation (sequential)

这使得它们运行缓慢(显然,击败了目的).如何在编译的示例上启用CUDA？

我有一个简单的单人纸牌游戏:

data Player = Player {
    _hand :: [Card],
    _deck :: [Card],
    _board :: [Card]}
$(makeLenses ''Player)

有些卡片有效果.例如,"Erk"是具有以下效果的卡片:

Flip a coin. If heads, shuffle your deck.

我已经实现了它:

shuffleDeck :: (MonadRandom m, Functor m) => Player -> m Player
shuffleDeck = deck shuffleM

randomCoin :: (MonadRandom m) => m Coin
randomCoin = getRandom

flipCoin :: (MonadRandom m) => m a -> m a -> m a
flipCoin head tail = randomCoin >>= branch where
    branch Head = head
    branch Tail = …

在这篇论文中，作者建议在 lambda 术语之间进行翻译：

data Term = Zero | Succ Term | App Term Term | Lam Term

和交互网络：

data Net = -- if I understood correctly
    Apply Net Net Net 
    | Abstract Net Net Net
    | Delete Net Net Int
    | Duplicate Net Net Net Int
    | Erase Net

不幸的是我无法理解他的编译算法。似乎缺少实际的算法，我不知道他对第三页上的图像是什么意思。我已经尝试通过查看已发布的源代码来理解它，但是作者使用他自己的图形重写 DSL 来定义它，所以我必须先学习它。翻译是如何作为普通 Haskell 函数实现的？

lambda演算的n元组通常定义为:

1-tuple:     ? a t . t a
1-tuple-fst: ? t . t (? a . a)

2-tuple:     ? a b t . t a b
2-tuple-fst: ? t . t (? a b . a)
2-tuple-snd: ? t . t (? a b . b)

3-tuple:     ? a b c t . t a b c
3-tuple-fst: ? t . t (? a b c . a)
3-tuple-snd: ? t . t (? a b c . b)
3-tuple-trd: …

给定一个类型,只有一种显而易见的方法来实现一个Additive实例,从Linear库到它.方便的是,Additive有一个通用的实现,所以我们可以使用deriving它.不幸的是,它取决于Applicative实例的存在,这是不可导出的,所以你仍然需要声明它:

{-# LANGUAGE DeriveGeneric, DeriveFunctor #-}

import Linear
import GHC.Generics
import Control.Applicative

data Foo a = Foo a a a deriving (Show, Functor, Generic1)

instance Additive Foo

instance Applicative Foo where
    pure x = Foo x x x
    Foo f g h <*> Foo x y z = Foo (f x) (g y) (h z)

main = print $ Foo 1 2 3 ^+^ Foo 4 5 6

有没有办法自动派生Additive,而不必声明Applicative实例？

假设我有一个scott编码的列表,例如:

scott = (\ c n -> c 1 (\ c n -> c 2 (\ c n -> c 3 (\ c n -> n))))

我想要一个接收这种类型的列表并将其转换为实际列表([1,2,3])的函数,除了这样的函数不能递归.也就是说,它必须是eta-beta正常形式.这个功能存在吗？