anchor.diff:    static Option<_HuffmanNode> _buildTree(AVLTree<_HuffmanNode> nodes) => nodes.min().map((l) {
       final withoutL = nodes.remove(l);
       return withoutL.min().bind((r) {
  -      final withoutR = withoutL.remove(r);
  -      return _buildTree(withoutR.insert(new _InternalHuffmanNode(l.frequency+r.frequency, l.char+r.char, l, r)));
  +      final withoutLR = withoutL.remove(r);
  +      return _buildTree(withoutLR.insert(new _InternalHuffmanNode(l.frequency+r.frequency, l.char+r.char, l, r)));
       }) | l;
     });
   
  
positive.code:   static IMap<String, IList<Bit>> _buildCodeBook(_HuffmanNode tree) {
      IMap<String, IList<Bit>> buildCodes(_HuffmanNode node, IMap<String, IList<Bit>> codes, IList<Bit> code) => node.fold(
          (internalNode) {
            final leftCodes =  buildCodes(internalNode.left, codes, cons(Bit.ZERO, code));
            return buildCodes(internalNode.right, leftCodes, cons(Bit.ONE, code));
          }, (leafNode) {
            return codes.put(leafNode.char, code.reverse());
  
negative.code:   // Technique: Deep recursion without fear, using Trampoline primitives tcall and treturn
    // Technique: IList destructuring using uncons
    String decode(IList<Bit> compressed) {
      Trampoline<String> loop(_HuffmanNode current, IList<Bit> compressed, String decompressed) => current.fold(
          (internalNode) =>
              compressed.uncons(() => treturn(decompressed), (bit, bits) {
                final nextNode = (bit == Bit.ONE ? internalNode.right : internalNode.left);
                return tcall(() => loop(nextNode, bits, decompressed));
              })
          , (leafNode) =>
              tcall(() => loop(_tree, compressed, decompressed+leafNode.char))
      );
      return loop(_tree, compressed, "").run();
    }
  
  }
  