小编tib*_*bbe的帖子

我有一个问题,说服编译器两个De Bruijn索引变量是相同的.我有以下深度嵌入DSL,De Bruijn索引代码基于Manuel Chakravarty 将HOAS术语GADT转换为de Bruijn术语GADT:

{-# LANGUAGE GADTs #-}

data Ix env t where
    ZeroIx ::             Ix (env, t) t
    SuccIx :: Ix env t -> Ix (env, s) t

-- | Heterogeneous equality for 'Ix'. Note, this only ensures that
-- the indices are equal as integers; it does not ensure that their
-- type environments are equal. (Though we do require that the types
-- of the values they're bound to to be the same, i.e. …

我正在尝试使用node.js运行使用GHCJS构建的程序.但是,我收到以下错误:

SyntaxError: Too many variables declared (only 131071 allowed)
    at Module._compile (module.js:439:25)
    at Object.Module._extensions..js (module.js:474:10)
    at Module.load (module.js:356:32)
    at Function.Module._load (module.js:312:12)
    at Function.Module.runMain (module.js:497:10)
    at startup (node.js:119:16)
    at node.js:906:3

1. 是否可以增加节点中允许的变量数量？
2. 是否有更好的实用程序来运行JS文件,这将允许更多的变量
3. 是否有可以自动减少变量数量的优化工具？

请注意,这是机器生成的JS,因此我不希望手动完成并减少变量的数量.

欢迎任何想法.

我们说如果函数的参数是严格的

f ? = ?

但是我们怎么说一个函数在其参数中是非严格的呢？我们可以说一个函数是非严格的,如果

f ? ? ?

？

这如何扩展到许多参数的函数,我们可能会或可能不会根据其他参数的值来评估参数？

我在使用Haddock文档更好地记录Haskell函数的严格性属性的上下文中问这个问题.

我有几个Jenkins矩阵项目,我在CSV文件中输出基准测试结果(即执行时间).我想将这些执行时间绘制为构建号的函数,因此我可以看到我的项目是否随着时间的推移而退化.

我想在GHC Haskell编译器中实现C的uint-to- doublecast 的等价物.我们已经实现了int-到- double使用FILD或CVTSI2SD.是否有这些操作的无符号版本,或者我应该uint将转换前的最高位置零(从而丢失范围)？

在Python模式下，如果我将重点放在x下面的函数定义中的参数上

def f(x):
  #   ^------ point here
  print x

x在功能正文中的使用以黄色突出显示。

• 这是如何运作的？
• 如果要编写自己的Emacs模式，如何为我的语言添加这种突出显示？

我正在尝试在LLVM中对标记的联合（也称为求和类型）进行编码，并且在保持编译器前端平台不可知的同时似乎不太可能。想象一下，我有这个标记的联合（用Rust表示）：

enum T {
    C1(i32, i64),
    C2(i64)
}

要在LLVM中进行编码，我需要知道最大变量的大小。这又需要我知道所有字段的对齐方式和大小。换句话说，我的前端需要

• 跟踪所有事物的大小和对齐方式，
• 创建一个虚拟结构（适当填充）以表示可以适合任何变体的最大类型（例如{[2 x i64]}，假设标签可以与i32字段在同一词中），
• 最后要么使用压缩结构，要么告诉LLVM我假设哪种“数据布局”，因此我的计算与LLVM匹配

当前在LLVM中编码标记联合的最佳方法是什么？

在这个简单的例子中

#[inline(never)]
fn apply<F, A, B>(f: F, x: A) -> B
    where F: FnOnce(A) -> B {
    f(x)
}

fn main() {
    let y: i64 = 1;
    let z: i64 = 2;
    let f = |x: i64| x + y + z;
    print!("{}", apply(f, 42));
}

传递给的闭包apply作为LLVM IR传递{i64*, i64*}*:

%closure = type { i64*, i64* }
define internal fastcc i64 @apply(%closure* noalias nocapture readonly dereferenceable(16)) unnamed_addr #0 personality i32 (i32, i32, i64, %"8.unwind::libunwind::_Unwind_Exception"*, %"8.unwind::libunwind::_Unwind_Context"*)* @rust_eh_personality { …

我正在关注'快速而艰难地学习Haskell'并且我能够完成大部分工作,但我对以下代码示例有两个问题.

1. 在第一个函数中,为什么我不需要,l但在第二个版本中我需要l？
2. 在evenSum1,当递归调用函数时,将filter一次又一次地在列表上调用,或者filter在第一次调用时只调用一次？

.

evenSum = accumSum 0 
    where 
        accumSum n [] = n
        accumSum n (x:xs) =
                        if even x
                                then accumSum (n+x) xs
                                else accumSum n xs

evenSum1 l = mysum 0 (filter even l)
    where
        mysum n [] = n
        mysum n (x:xs) = mysum (n+x) xs

Rust使用冒号将标识符与类型分开,例如

let x: u8 = 1;

但是,对于函数返回类型 - 而是使用>.例:

fn f() -> u8 { ... }

有人可能会在这里使用冒号:

fn f(): u8 { ... }

虽然使用箭头有一些优先权(例如在Haskell中),但我很好奇这个选择背后的历史原因.另外,我也很好奇它是纯粹的美学原因还是使用箭头有一些技术原因,例如简化解析.