小编Mai*_*tor的帖子

下面的标记会停止指向页面的链接,而无需提供完整的URL:

<a href="foo.html">link</a>

所以,如果你点击它example.com/,你会去example.com/foo.html.有没有办法创建一个链接,example.com:port/foo.html而不是去？

我总是相信GHCJS,由于显而易见的原因,与手动编写和优化的代码相比,生成了非常慢的JavaScript程序.不过,在尝试时,我注意到它并没有我想象的那么糟糕.我决定运行一系列小基准来掌握真正的表现,这一点特别让我感到惊讶.该程序只需用"1"填充一个数组并将它们加起来.

哈斯克尔:

import Data.Array.Repa
len  = 1024*1024*64
arr  = fromFunction (Z :. len) (const 1) :: Array D DIM1 Float
main = sumAllP arr >>= print

JavaScript的:

var len = 1024*1024*64
var arr = [];
var sum = 0;
for (var i=0; i<len; ++i)
    arr[i] = 1;
for (var i=0; i<len; ++i)
    sum += arr[i];
console.log(sum);

还有一个粗略的基准:

apple1$ ghcjs -O2 bench_fill.hs -funfolding-use-threshold10000 -funfolding-keeness-factor1000 -o bench_fill.js; time node bench_fill.js/all.js
Linking bench_fill.js (Main)
6.7108864e7

real    0m1.543s
user    0m1.512s
sys 0m0.033s

apple1$ time …

我一直在考虑如何实现unfold以下类型的等价物:

data Tree a = Node (Tree a) (Tree a) | Leaf a | Nil

由于unfold列表标准返回值和下一个种子,因此并不是很明显.对于此数据类型,它没有意义,因为在到达叶节点之前没有"值".这样,返回新种子或停止值只是真的有意义.我正在使用这个定义:

data Drive s a = Stop | Unit a | Branch s s deriving Show

unfold :: (t -> Drive t a) -> t -> Tree a
unfold fn x = case fn x of
    Branch a b -> Node (unfold fn a) (unfold fn b)
    Unit a     -> Leaf a
    Stop       -> Nil

main = print $ unfold go …

使用类似于Morte/CoC的语言,我试图证明这个简单的陈述there are lists of arbitrary lengths.为此,我写了以下类型:

? n:Nat ->
(ThereIs (List Nat)
  (Equal Nat 
    (List.length Nat l) 
    n)))

ThereIs是依赖对(Sigma).一切都是教会编码的.为证明这一点,我写了以下证据:

? n:Nat ->
(ThereIs.this (List Nat)
  (? l:(List Nat) -> (Equal Nat (List.length Nat l) n))
  (List.replicate Nat n Nat.Zero)
  (Equal.refl Nat n))

奇怪的是,我得到一个类型不匹配错误d(即Nat类型的自由变量)和? c:* -> ? b:(c -> c) -> ? a:c -> (d c b a).但是那个后期,当eta减少时,只是d!由于我没有准备好eta-reducer,我改为使用以下"无用识别"功能:

? n: Nat ->

? Nat:* ->
? Succ: (Nat -> Nat) ->
? …

我得到这个试图上呈现three.js所立方体,使用THREE.MeshBasicMaterial()和加载质感.

这是正常的吗？我该如何解决？

假设您在第640行并在第671行注意以下内容:

if (jumps_over(quick_fox[brown],the_lazy_dog)) the_lazy_dog.bark(); 

导航到"树皮"的最有效方法是什么？

这个程序:

{-# LANGUAGE MultiParamTypeClasses, TemplateHaskell, TypeFamilies #-}

import Data.Vector.Unboxed.Deriving

data Node = Node Int Int Int Int Int Int Int deriving (Show)
derivingUnbox "Node"
    [t| Node -> (Int, Int, Int, Int, Int, Int, Int) |]
    [| \ (Node a b c d e f g) -> (a,b,c,d,e,f,g) |]
    [| \ (a,b,c,d,e,f,g) -> Node a b c d e f g |]

main = print 7

无法编译,出现此错误消息:

debox_error.hs:6:1:
    No instance for (Data.Vector.Generic.Base.Vector
                       Data.Vector.Unboxed.Base.Vector
                       (Int, Int, Int, Int, Int, Int, Int))
      arising …

我正在创建一个文件,Common.hs它导出我常用的函数.它还用我喜欢的版本取代了一些Prelude的功能:

-- Common.hs
module Common 
import qualified Prelude as Prelude
import qualified Data.Foldable as Foldable

sum      = Foldable.sum  -- I want to replace Prelude's sum
print    = Prelude.print -- I want to export Prelude's print
type Int = Prelude.Int   -- I want to export Prelude's Int
... etc (huge list) ...

这样,每当我创建一个新的Haskell文件时,我只需要导入Common并编译它-XNoImplicitPrelude:

-- Test.hs
import Common
main = print (sum [1,2,3]) -- will be the `sum` version I want

这种方法似乎有效,但我无法想出如何导出类型类:

-- Test.hs
import Common …

我想加快以下功能:

{-# LANGUAGE BangPatterns #-}

import Data.Word
import Data.Bits
import Data.List (foldl1')
import System.Random
import qualified Data.List as L

data Tree a = AB (Tree a) (Tree a) | A (Tree a) | B (Tree a) | C !a
    deriving Show

merge :: Tree a -> Tree a -> Tree a
merge (C x) _               = C x
merge _ (C y)               = C y
merge (A ta) (A tb)         = A (merge ta tb)
merge (A ta) (B tb) …

依赖类型Lambda编码论文的自我类型(由Peng Fu和Aaron Stump提出)提出了自我类型,据推测,它足以在构造微积分上编码归纳原理和Scott编码数据类型,而不会使系统不一致或引入悖论.

那篇论文的符号太重了,我无法完全理解如何实现它.

究竟什么是Fix和Self的主要区别？或者,换句话说:在什么点上应该限制天真实施的Fix,以便它不会在核心演算上留下任何不一致？