anchor.diff:        // Technique: Folding an IMap into an AVLTree of leaf nodes, for use as a priority queue
         final AVLTree<_HuffmanNode> leafNodes = characterFrequencies
             .foldLeftKV(new AVLTree(_HuffmanNode.order, emptyAVLNode()), (t, char, freq) => t.insert(new _LeafHuffmanNode(freq, char)));
  -      return _buildTree(leafNodes).map((tree) {
  -        final codeBook = _buildCodeBook(tree);
  -        return new HuffmanCodec._internal(tree, codeBook);
  -      });
  +      return _buildTree(leafNodes).map((tree) => new HuffmanCodec._internal(tree, _buildCodeBook(tree)));
       }
     }
   
  
positive.code:   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)));
      }) | l;
    });
  
  
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();
    }
  
  }
  