看完觉得做这么多事要解决的主要问题吧，就是是有人把一堆 jar 包等巨型文件提交了上去

#80 楼 @gaowenzhen 我都用过，一直在用，一直觉得不怎么样。像你这么说的一般都没怎么用过

我也有问题：

1. 怎么实现的？
2. 可以导出数据吗？
3. 如果不能导出数据，可以做 SVD 分解吗？
4. 如果不能导出数据，可以跑机器学习分析吗？

Ruby 实现更简单

class Node < Struct.new :nodes, :w
  def output r, code
    if nodes.is_a?(Array)
      fst, snd = nodes
      fst.output r, code + '0'
      snd.output r, code + '1'
    else
      r[nodes] = code
    end
  end
end

def huffman histogram
  nodes = histogram.map {|k, w| Node.new k, w }
  while nodes.size > 1
    fst, snd, *nodes = nodes.sort_by &:w
    nodes << Node.new([fst, snd], fst.w + snd.w)
  end
  r = {}
  nodes.first.output r, ''
  r
end

h = huffman a: 3, b: 4, c: 5, d: 6, e: 8
p h #=> {:c=>"00", :d=>"01", :a=>"100", :b=>"101", :e=>"11"}

#9 楼 @yfractal 那是因为 sussman 讲 SICP 讲了二十年，讲腻了

很多的，做交易所的有各种每秒百万请求的配单系统轮子

这篇是 Python 2 的，过时啦

你可以纹个 Piet 写的 http://www.dangermouse.net/esoteric/piet.html

swig -c++ 编译的么？#include <cstring>

可以先花两小时学习下相关资料

https://en.wikipedia.org/wiki/Online_analytical_processing

https://en.wikipedia.org/wiki/Extract,_transform,_load

有可能是被劫持，或者证书过期。

如果一定要爬，可以跳过 ssl 验证

result = open url, ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE, &:read

现在 windows 只用 jruby 的话还可以...

假设 B 和 C 继承 A, D 继承 B 和 C

  A
 / \
B   C
 \ /
  D

在 Python 中，如果 B 带实例变量 a, C 也带实例变量 a, 那么 D.a 应该算哪个？使用者需要记住语言规范的定义才知道，而且如何操作另一个也是麻烦的事情。

Ruby 的实例变量不区分是哪个 module 或者 class 设置的，只要名字一样就是同一个。

module 可以做菱形继承，但是没有 C++ 和 Python 里菱形继承的问题

Rubinius 是推倒重来，问题也很多：

• C++ 标准各编译器不一样，也不能像 C 一样愉快的用 vim/emacs 编写
• C ext 支持还是不够稳定
• Rubinius 的内存 footprint 大很多，和 jruby 一样 benchmark 好看但在常见的 Ruby 应用场景往往比 MRI 慢

你装个 msys2 也可以，不过某些偏门点的包也装不上，而且速度慢一些

赞！

前面的 [] 加 index, 最后一个不用加

<input name="child_name[0][a1][0][a1-1][]" value="a1-1-1">
<input name="child_name[0][a1][0][a1-1][]" value="a1-1-2">
<input name="child_name[0][a1][1][a1-2][]" value="a1-2-1">
<input name="child_name[0][a1][1][a1-2][]" value="a1-2-1">

意思是去掉 -%> 后面的空格

http://ruby-doc.org/stdlib-2.3.0/libdoc/erb/rdoc/ERB.html

2.1 和 2.2 区别没这么大吧，应该很好升...

第 1 步把每个月都当成 31 天，算多了，所以第 2 步要减少，减少多少呢？很可惜是不规则的...

我们找个最简单的函数，利用整数算术压缩表示这个减少的天数，就假设是 (a*month + b)/c 吧

@months = *3..12
acc = 0
#            2  3  4  5  6  7  8  9  10 11 12
@days_diffs = [3, 0, 1, 0, 1, 0, 0, 1, 0, 1].map do |e|
  acc += e
end

def valid? a, b, c
  @months.zip @days_diffs do |x, y|
    return false if (a * x + b)/c != y
  end
  true
end

valid_nums = []
0.upto 100 do |a|
  0.upto 100 do |b|
    1.upto 100 do |c|
      if valid?(a, b, c)
        valid_nums << [a, b, c]
      end
    end
  end
end

p \
  valid_nums.sort_by {|(a, b, c)| a + b + c }

可以看到，其实第 2 步的公式不是最巧妙的，排名第 6 ...

[[2, 11, 5], [3, 14, 7], [4, 17, 9], [4, 22, 10], [5, 20, 11], [4, 23, 10], ...

第 2 步这么写更简单

(b) if the month is after February, subtract (2*month+11)/5 from dayNum

#4 楼 @fantasticfears 告诉用户 brew install icu4c 就好，参见 https://github.com/brianmario/charlock_holmes

其实 mac 自带的 ICU 版本非常的老，不如 brew install 的新版本好，如果 iOS 或者桌面程序中用 ICU, 一般都建议编译个新的自己打包

C++ 的 ABI 不管用什么方式都不好处理，exception 一抛你就内存泄漏了，建议只用 C 的...

#2 楼 @fantasticfears ICU 用的 native 大小端序，Ruby 可以像这样简单的检测：

LITTLE_ENDIAN = ([256].pack('S*') == [256].pack('S<*')) # 不然就是 big endian

moving GC 的 Haskell 更麻烦，得把内容拷到 heap 去

是用 C 实现的，源代码在 https://github.com/hpricot/hpricot/blob/master/ext/hpricot_scan/hpricot_scan.rl

先保证你安装了 https://github.com/MarioRicalde/SCSS.tmbundle

使用：选中一段 scss 或者选中所有文本，然后用这个命令

FFI 没大问题的应该... 不过写 C-ext 执行更快一点，而且 FFI gem 本来就是个 C-ext

从 UChar* 生成 Ruby 字符串，可以直接调 Ruby 的 CAPI rb_str_new(uchar_pointer, uchar_length * 2)

然后在 Ruby 中 str.force_encoding('utf-16le').encode('utf-8')

自己 ctag 跑一下 Ruby 源代码加索引就可以了

#13 楼 @zamia

由于 PG 的 MVCC 实现，每个记录都有个隐藏的 version 字段，所以乐观锁的情形用 repeatable read 就可以了：

Account.transaction isolation: :repeatable_read do
  account = Account.find 1
  account.balance -= 100
  account.save!
end

但是 MySQL 的 repeatable read 其实和 PG 不同，它允许 A 事务读取的内容在 commit 之前被 B 事务修改而不回滚其中任何一个，所以 MySQL 还是需要手动加锁。

PG 的 MVCC 实现能否代替乐观锁呢？是的，而且 MVCC 能保证多个记录的 invariance, 乐观锁只能搞一个记录。

悲观锁呢？一般是直接用 serializable 级别就可以了也不用手动锁，PG 是用 SSI 实现，不锁表的。

btw, 如果悲观锁了或者用 serializable 隔离级别，照样可能 rollback, 也可以做重试的

#6 楼 @mizuhashi functor 没那么玄乎，认为它是函数上的函数就可以了...

可以看看 The category design pattern http://www.haskellforall.com/2012/08/the-category-design-pattern.html

functor 是 category 之间的函数 自函子 endofunctor 意思是定义域和值域都是同一个 category, 基本等于废话可以不管。

有单位元，运算符又满足结合律，就是 幺半群 monoid 的定义. monad 中，单位元是 return, 满足结合律的运算符是 bind (>>=)

换句话说，monad 是定义在函数上的代数结构，它有单位元，又有满足结合律的运算符。

如果在 Ruby 数组上找 monad, 那么以 [] 为单位元，以 .flat_map 为满足结合律的运算符，就构成一个 Array Monad. 例如把这段 Haskell 代码贴进 ghci

let a = 2
let b = [3, 4]
let c = ['a', 'b']
:{
do
  x <- return a
  y <- b
  z <- c
  return (x, y, z)
:}

执行结果是 [(2,3,'a'),(2,3,'b'),(2,4,'a'),(2,4,'b')]. 注意 do notation 其实是一个让你省略括号和缩进的语法糖，再把 return 换成 [], 解除语法糖后是这样的意思：

[a] >>= \x ->
  b >>= \y ->
    c >>= \z ->
      [(x, y, z)]

那么对应 Ruby 代码是这样：

a = 2
b = [3, 4]
c = ['a', 'b']
[a].flat_map do |x|
  b.flat_map do |y|
    c.flat_map do |z|
      [[x, y, z]]
    end
  end
end

执行结果是 [[2, 3, "a"], [2, 3, "b"], [2, 4, "a"], [2, 4, "b"]]

如果在 Ruby 对象上找 monad, 那么以 .itself 为单位元，以 .try 为满足结合律的运算符，那就构成一个 Maybe Monad

具体例子留作练习哈

有各种各样找 monad 的方式，但只要记住 "自函子上的幺半群", 没有一个能逃出你的眼睛...