anchor.diff:      W = normalize_rw_value(W0),
       DW = normalize_rw_value(DW0),
       PW = normalize_rw_value(PW0),
  -    Options = case ReturnBody of 1 -> [returnbody]; true -> [returnbody]; _ -> [] end,
  +    Options = case ReturnBody of
  +        1 -> [returnbody];
  +        true -> [returnbody];
  +        _ ->
  +            case ReturnHead of
  +                true -> [returnbody];
  +                _ -> []
  +            end
  +    end,
       case C:put(O, make_option(w, W) ++ make_option(dw, DW) ++
                      make_option(pw, PW) ++ [{timeout, default_timeout()} | Options]) of
           ok when is_binary(ReturnKey) ->
  
positive.code:             send_error("~p", [Reason], State)
      end;
  process_message(#rpbputreq{bucket=B, key=K, vclock=PbVC, content=RpbContent,
                             w=W0, dw=DW0, pw=PW0, return_body=ReturnBody},
                  #state{client=C} = State) ->
  
      case K of
  
negative.code:         ok ->
              send_msg(#rpbputresp{}, State);
          {ok, Obj} ->
              Contents = riak_object:get_contents(Obj),
              PbContents = case ReturnHead of
                  true ->
                      %% Remove all the 'value' fields from the contents
                      %% This is a rough equivalent of a REST HEAD
                      %% request
                      BlankContents = [{MD, <<>>} || {MD, _} <- Contents],
                      riakc_pb:pbify_rpbcontents(BlankContents, []);
                  _ ->
                      riakc_pb:pbify_rpbcontents(Contents, [])
              end,
              PutResp = #rpbputresp{content = PbContents,
                                    vclock = pbify_rpbvc(riak_object:vclock(Obj)),
                                    key = ReturnKey
                                },
              send_msg(PutResp, State);
          {error, notfound} ->
              send_msg(#rpbputresp{}, State);
          {error, Reason} ->
              send_error("~p", [Reason], State)
      end;
  