小编tib*_*bbe的帖子

核心是GHC的中间语言.阅读核心可以帮助您更好地了解您的计划的性能.有人问我关于阅读Core的文档或教程,但我找不到多少.

有哪些文档可供阅读GHC Core？

这是我到目前为止所发现的:

• 像C一样快地编写Haskell:利用严格性,懒惰性和递归性
• Haskell和C一样快:在高海拔地区工作以获得低水平的性能
• RWH:第25章.分析和优化
• CUFP的高性能Haskell演讲(幻灯片65-80)

我正在尝试使用Bootstrap CSS的jQuery插件动态创建警报消息.我想创建和销毁某些事件的警报(例如AJAX成功/错误).这是我的代码的非工作片段:

var alertVisible = false;
function fetchData() {
    function onDataReceived(stats) {
        if (alertVisible) {
            $(".alert-message").alert("close");
        }
        alertVisible = false;
        // Do stuff with data...
    }

    function onError() {
        $(".alert-message").alert();
        alertVisible = true;
    }

    $.ajax({
        dataType: 'json',
        success: onDataReceived,
        error: onError,
        cache: false
    });
};

这是相应的HTML:

<div class="row">
  <div class="alert-message error fade in hide span16" data-alert="alert">
    <a class="close" href="#">&times;</a>
    <p>Lost connection to server.</p>
  </div>
</div>

我的第一个问题是默认显示警报.我可以通过使用hide类来解决这个问题.但是,如果您关闭警报(通过单击关闭按钮),则创建新断言不再有效(我猜DOM元素已消失).你是如何使用Bootstrap警报的？

我最近阅读了[1]和[2],它们讲的是组织形态(和动力学),它们是可以表达动态编程的递归方案.不幸的是,如果您不了解类别理论,那么这些论文是不可访问的,即使那里的代码看起来像Haskell.

有人可以用一个使用真实Haskell代码的例子来解释histomorphisms吗？

1. 重新审视组织和动力学
2. 动态规划的递归方案

鉴于深度嵌入简单的数据处理DSL [1]:

{-# LANGUAGE GADTs, StandaloneDeriving #-}

import Data.List
import Text.Show.Functions

data Dist e where

    Concat :: [Dist [a]] -> Dist [a]

    -- We use ConcatMap as a primitive because it can express e.g.
    -- both map and filter.
    ConcatMap :: (a -> [b]) -> Dist [a] -> Dist [b]

    -- Expensive to traverse input (think distributed file).
    Input :: Dist [a]

    Let :: Name -> Dist e -> Dist e -> Dist e

    -- We're not dealing with name …

在Haskell中的类型安全可观察共享中 Andy Gill展示了如何在DSL中恢复Haskell级别上存在的共享.他的解决方案在data-reify包中实现.是否可以修改此方法以与GADT一起使用？例如,鉴于此GADT:

data Ast e where
  IntLit :: Int -> Ast Int
  Add :: Ast Int -> Ast Int -> Ast Int
  BoolLit :: Bool -> Ast Bool
  IfThenElse :: Ast Bool -> Ast e -> Ast e -> Ast e

我想通过将上面的AST转换为恢复共享

type Name = Unique

data Ast2 e where
  IntLit2 :: Int -> Ast2 Int
  Add2 :: Ast2 Int -> Ast2 Int -> Ast2 Int
  BoolLit2 :: Bool -> Ast2 Bool
  IfThenElse2 :: Ast2 Bool …

在Scala中使用许多较新的语言特性,可以实现可组合的组件系统,并使用所谓的Cake Pattern创建组件,Martin Odersky在可扩展组件抽象论文中以及最近的演讲中描述了这种模式.

Cake Pattern中使用的一些Scala功能具有相应的Haskell功能.例如,Scala implicits对应于Haskell类型类,Scala的抽象类型成员似乎对应于Haskell的关联类型.这让我想知道Cake Pattern是否可以在Haskell中实现以及它看起来像什么.

Cake模式可以在Haskell中实现吗？Scala功能在这样的实现中对应哪些Haskell功能？如果Cake模式无法在Haskell中实现,那么哪些语言功能可能无法实现？

为什么会出现一个r在Data.List.unfoldr？是仅仅为了对称foldr,还是有其他原因,这种展开应该被认为是正确的联想？

当我考虑添加一个展开时Data.HashMap,我想到了r这个名称中包含一个名字的理由.HashMaps有左右两折.我没有看到为什么展开会比左边更正确的原因.

如何查找和重写引用相同绑定名称的表达式？例如,在表达式中

let xs = ...
in ...map f xs...map g xs...

表达式map f xs和表达式都map g xs引用相同的绑定名称,即xs.是否有任何标准的编译器分析可以让我们识别这种情况并将两个map表达式重写为例如

let xs = ...
    e = unzip (map (f *** g) xs)
in ...fst e...snd e...

我一直在考虑树遍历的问题.例如给定AST:

data Ast = Map (a -> b) -> Ast -> Ast
         | Var String
         | ...

我们可以尝试编写一个树遍历来检测这种情况,但这似乎很难,因为Map引用相同的两个节点Var可能出现在树中广泛不同的地方.如果您反转AST中的所有引用,使其成为图形,这种分析似乎更容易做,但我想看看是否有任何替代方法.

我们可以xs在表达式的列表中融合两个遍历

(map f xs, map g xs)

像这样

unzip (map (\x -> (f x, g x)) xs)

有没有自动进行这种融合的研究？

(如果其中一个返回的列表在另一个之前被消耗,则存在创建空间泄漏的风险.我更有兴趣防止额外的遍历而xs不是节省空间.)

编辑:我实际上并不打算将融合应用于实际的内存中Haskell列表,其中这种转换可能没有意义,具体取决于是否unzip可以与其消费者融合.我有一个我知道unzip可以融合的设置(参见"FlumeJava:简单,高效的数据并行管道").

在Hadoop MapReduce中是否可以使用多个不同的映射器进行多个输入？每个映射器类都处理不同的输入集,但它们都会发出同一个reducer所消耗的键值对.请注意,我不是在谈论链接映射器,我说的是并行运行不同的映射器,而不是顺序运行.