Otherwise, we won't know if there's a broken image in a web page.
A quick tip on enabling broken image placeholders in Firefox 3 and beyond
In short, put the following in:
Firefox/Profiles/[depends]/chrome/userContent.css
/*
* Show image placeholders
*/
@-moz-document url-prefix(http), url-prefix(file) {
img:-moz-broken{
-moz-force-broken-image-icon:1;
width:24px;
height:24px;
}
}
讓我覺得很困惑的東西在上一篇裡忘記講了。
在傳統的 imperative 程式裡，我們很自然會去想 flow, 會去想
程式是怎麼執行的。一行一行地執行，最簡單的說法大概是這樣。
而在 haskell 的程式裡，因為所有的東西都是 immutable, 再加上
所謂 lazy evaluation, call-by-need, whatever, 因此我們變得要
去描述問題，而非撰寫「步驟」去解決問題。也因此，我們無法
預測 runtime 上程式到底是怎麼執行的。到底是先算 A, 還是先算 B?
之前我還一直無法從這種「順序」的概念中逃離，所以對於 foldr
和 foldl, 我的理解一直變成 foldr 是從右邊開始，反之則從左邊開始。
這樣想很容易理解，因為我（們）寫程式太習慣「順序」了。在簡單的
例子中，大概也看不太出很大的差別。但如果試著用 IO 去觀察其真正的
執行順序的話，就會注意到這完全是無法解釋的。因為事實上，foldr
和 foldl 的結果是一種結構，而非一連串的順序。
foldr (-) 0 [1,2,3,4,5] 展開會是 1 - (2 - (3 - (4 - (5 - 0))))
foldl (-) 0 [1,2,3,4,5] 展開會是 ((((0 - 1) - 2) - 3) - 4) - 5
foldr 是向右結合，foldl 則是向左結合。cons list 也是一種向右結合的結構，
因此我們也會說，foldr 在 cons list 上，其實只是把 constructor 換掉而已。
我們不能把 fold 的結果看成一個數值，而應該是一種結構才對。一個很
簡單的例子，試著把 [1,2,3,4,5] 用 foldr 印出來看看：
foldr (curry (print . fst)) (return ()) [1..5]
updated 2011-05-14 22:44 或
foldr (const . print) (return ()) [1..5]
如果這樣寫不好懂的話，這是寫成 lambda 的樣子：
foldr (\i io -> print i) (return ()) [1..5]
如果我們試著去 evaluate 這個，也就是餵給 ghci 這個「結構」，
結果是我們只會得到一個 1, 而不是這個：
5
4
3
2
1
難道這樣應該說，foldr 其實是從左邊開始算才對嗎！？
回頭看剛剛的展開：1 - (2 - (3 - (4 - (5 - 0))))
用想像的，把裡面的 - 改成 curry (print . fst)
可以注意到，其實我們根本不在乎 print 後的結果 ( IO () ),
因此 evaluate 這個結構，就好像我們對一個 cons list 呼叫 head 一樣，
拿了第一個值，然後後面的根本就不需要，於是全部不會執行。
正確的寫法是這樣：
foldr (\i io -> io >> print i) (return ()) [1..5]
updated 2011-05-14 22:44 或
foldr (flip (>>) . print) (return ()) [1..5]
我們必須強迫算出 1 之前，必須先算出後面的東西。這整個展開來，就會變成...
return () >> print 5 >> print 4 >> print 3 >> print 2 >> print 1
monad law 告訴我們 bind 是 associative 的，所以這邊括號省略了。
而 foldl 的話則是：
foldl (\io i -> io >> print i) (return ()) [1..5]
updated 2011-05-14 22:44 或
foldl (flip (flip (>>) . print)) (return ()) [1..5]
展開來則是：
return () >> print 1 >> print 2 >> print 3 >> print 4 >> print 5
印出來就會是：
1
2
3
4
5
也就是說，唯一真正可以控制順序的，只有 IO monad 的 bind...
或是我們可以這麼說，我們總要有一個地方，可以說我們需要某個值？
不然程式要怎麼「開始」跑呢..? 或許可以這樣想像，haskell 的程式
就是一個巨大的 term, 所謂的執行程式，其實就是開始 reduce 的意思。
而這個神秘的開始 reduce, 大概就是 main 吧..
updated: 2011-05-08 13:14 後來自己實驗發現 data/newtype
其實沒有 strictness 上的差別，Learn You a Haskell for Great Good!
這邊有點誤導...
Charles Nutter 非常深刻且誠懇的一篇
My Thoughts on Oracle v Google
實在長得有點誇張.... 看很久一直沒看完，中間又跳掉一大段 :o
之前的一點文摘在 buzz 上。
作者非常活躍，產出非常多，對很多東西都很有貢獻。
隨著 bundler 的發展，rubygems 也如火如荼在發展...
以前更新都不會有什麼問題，但在 1.3.7 之後，更新就常常
會造成一些奇怪的問題。
剛剛跑 rubygems_update 就很怪，會碰到詭異的錯誤。
然後發現自己的 ruby 好像也怪怪的，就乾脆砍掉重灌 :s
brew uninstall ruby
brew install ruby
重灌好之後，果然跑 gem up --system 就正常了，奇哉怪也。
接著跑 gem list 就能看到成千上萬的 deprecation warnings 呀呀呀
雖然他聲稱跑 gem pristine --all 可以修正現有的 gemspec,
但我跑過很多次（每次還跑很久...），問題一直沒有解決，還是狂噴
warnings, 太礙眼了。
還是自己寫 script (find + exec sed) 比較穩當...
find ~/.gem/ruby/1.9.1 -name '*.gemspec' -exec gsed -i -E 's/ s\.default_executable = %q\{.+\}//' '{}' ';'接著看起來就正常了。另外，我之前老是碰到什麼 gemspec 裡的 dateIt is not possible in Haskell to define the type of natural numbers, nor
the type of lists of natural numbers (or lists of anything else), nor any
other inductive type!
Robert Harper is here referring to the *lifting* behavior of Haskell
data types, where you may have exotic values using ⊥ when you
make for a sum. For example, type `Either a b` has all elements of a,
all elements of b, plus a ⊥ element. So this is not exactly a disjoint
sum (for a precise definition of what he means by “sum”, see the
categorical definitions of sum and product).
More precisely, all types in Haskell are pointed (not necessarily
lifted). But, yes.
To expand on Bob’s reply: his point (and what he complains about in
his post) is that this type in fact does not represent the natural
numbers in a lazy language, because the type is unavoidably
inhabited by additional “values”. For example,
nonnat :: Nat nonnat = Succ nonnatDespite the type, this is not a natural number, and inductive principle
don’t apply. Strict semantics, like in ML, precludes such examples.
A lot of commenters here seem to think that the definition
data Nat = Zero | Succ !Natdisallows “nonstandard” inhabitants, but this is obviously false.
The “strictness” annotation in!Natjust requires that the
argument toSuccbe in head normal form, not
be fully evaluated. Thus, you can easily define:
loop :: Nat loop = Succ loopwithout running afoul of the “strictness” annotation. Indeed,
you can also define:
bad :: Nat bad = Succ (Succ undefined)and GHC will not complain about the innerSuccbeing applied
toundefined.
In Haskell the strict definition ofNatmeans thatfix Succ
(omega/infinity) is intensionally equal to_|_(which ML types
do contain as it is a Turing Complete language, i.e. you can
write non-terminating definitions). The values which can inhabit
this type are therefore equivalent to the least fixed point of
its definition and hence are the inductive naturals, and
equivalent to the ML type.
In a lazy language non-termination is a value, whereas in an eager
language it is an effect. In particular, variables in a lazy language
range over computations, including the non-terminating computation,
whereas in a strict language they range only over values. Given a
variable x of type nat, if natural number induction were valid, you
could prove that x is either zero or a successor. This is true for ML,
but false for Haskell, because x could be “bottom”, ie the
non-terminating computation, which is a value. For this reason no
inductive type, not even the Booleans, are definable in Haskell. It is
not a matter of strictness annotations on data declarations, it is a
matter of the most fundamental level of semantics of the entire
language itself.
const True undefined 我們還是會True, 就算得到了這個 term, 也不代表裡面的 Nat (undefined)const True undefinedWe almost recover Nat if we set a to be (), but they’re not quite
isomorphic: every () might actually be a bottom, so while [()] and [⊥]
are equivalent to one, they are different. In fact, we actually want to
set a to the empty type. Then we would write 5 as [⊥, ⊥, ⊥, ⊥, ⊥].
I'm happy to announce that we have released the second
public alpha version of CuBeat, which can be found on
Google Code downloads page. Currently, we have 4 releases,
Windows 32 bit, Mac OS X 64 bit, and Linux 32/64 bit.
If you're interested about the source, it is hosted
on Github, licensed under Apache License 2.0.
Other information can be found in the distribution.
Feel free to contact the development team via devblog,
or contact me directly by anyway if you have any question,
thanks!
* * *
我很榮幸在此宣佈，我們釋出了 CuBeat 的第二個公開測試版，
大家可以在 Google Code 的下載頁面上找到。目前我們有四個
版本可以下載，分別是 Windows 32 bit, Mac OS X 64 bit,
和 Linux 32/64 bit.
如果對原始檔（源碼）有興趣的話，目前放在 Github 上，
以 Apache License 2.0 釋出。
其他資訊可以在下載下來的檔案中找到。
如果有任何問題，可以至開發部落格留言，或是用任何方法聯繫我，
謝謝！
