anchor.diff:    // 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 tree, _HuffmanNode current, IList<Bit> compressed, String decompressed) => current.fold(
  +    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(tree, nextNode, bits, decompressed));
  +              return tcall(() => loop(nextNode, bits, decompressed));
               })
           , (leafNode) =>
  -            tcall(() => loop(tree, tree, compressed, decompressed+leafNode.char))
  +            tcall(() => loop(_tree, compressed, decompressed+leafNode.char))
       );
  -    return loop(_tree, _tree, compressed, "").run();
  +    return loop(_tree, compressed, "").run();
     }
   
   }
  
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:   static Option<_HuffmanNode> _buildTree(AVLTree<_HuffmanNode> nodes) => nodes.min().map((l) {
      final withoutL = nodes.remove(l);
      return withoutL.min().bind((r) {
        final withoutLR = withoutL.remove(r);
        return _buildTree(withoutLR.insert(new _InternalHuffmanNode(l.frequency+r.frequency, l.char+r.char, l, r)));
      }) | l;
    });
  
  