anchor.diff:  
   -spec store(t(credentials_type())) ->
       hope_result:t(ok, oauth1_storage:error()).
  -store(#t{type=Type, id={Type, Key}, secret={Type, Value}}) ->
  +store(#t{id={Type, Key}, secret={Type, Value}}) ->
       Bucket = type_to_bucket_name(Type),
       oauth1_storage:put(Bucket, Key, Value).
   
  
positive.code:             Error
      ;   {ok, Secret} ->
              T = #t
                  { type   = Type
                  , id     = {Type, ID}
                  , secret = {Type, Secret}
                  },
              {ok, T}
  
negative.code:     {CredentialsType, oauth1_uuid:t()}.
  
  -record(t,
      { id     :: id(credentials_type())
      , secret :: secret(credentials_type())
      }).
  
  %% t() is really meant to be opaque, but alas - Dialyzer does not (yet) support
  %% polymorphic opaque types :(
  -type t(CredentialsType) ::
      #t
      { id     ::     id(CredentialsType)
      , secret :: secret(CredentialsType)
      }.
  
  
  -spec generate(credentials_type()) ->
      t(credentials_type()).
  generate(Type) ->
      #t
      { id     = {Type, oauth1_uuid:generate()}
      , secret = {Type, oauth1_uuid:generate()}
      }.
  
  -spec get_id(t(credentials_type())) ->
      id(credentials_type()).
  get_id(#t{id={Type, _}=ID, secret={Type, _}}) ->
      ID.
  
  -spec get_secret(t(credentials_type())) ->
      secret(credentials_type()).
  get_secret(#t{id={Type, _}, secret={Type, _}=Secret}) ->
      Secret.
  
  -spec id_to_bin(id(credentials_type())) ->
  