Since this returns a PyResult, should it actually be called TryIntoPyStringRef?

Sure. If it has to be try_into_pystringref this gets a bit unwieldy, but I guess there won't too many callers.

Yeah, had the same concern for TryIntoObject (that's why I dropped the Py and Ref, since in practice you know it's referring to a PyObject from context and working with the value types instead of refs is pretty exceptional.

Aha! The analogy to TryIntoObject is what I need to get the right shape of this. It's TryIntoRef<T>. I this will be really useful eventually, and could replace TryFromObject?

How does this look now?

I this will be really useful eventually, and could replace TryFromObject?

TryFromObject is a bit different, e.g. it wouldn't make sense TryIntoRef for isize, but that is done for TryFromObject so we can accept it as a fn parameter. (Sorry if I caused confusion by typoing TryFromObject as TryIntoObject above).

But if my plan for PyObjectRef to eventually be a type alias for PyRef<dyn PyObjectPayload> works out, then this would prevent us from every needing a TryIntoObject and TryFromObject could be replaced with a TryFromRef.

How does this look now?

This looks great!

I think creating impl TryIntoRef<PyInt> for isize does make sense.

They're sort of doing the same thing, in one case allowing us to write flexible parameters for functions that can be called from rust, in the other flexible paremeters for functions that can be called from python.

Oh sorry that isize example was poorly thought out. I basically just meant that they are going in opposite directions:

TryIntoRef: Self -> Ref
TryFromObject: Ref -> Self

I see now. They overlap in the one specific case where I've used TryFromObject (Self is PyRef), but there are other implementations.

These impls do seem a bit redundant since we already have similar ones for PyString. Could we do something like:

impl<T: Into<PyString>> IntoPyStringRef for T

Or to generalize it further:

impl<V: PyValue, T: Into<V>> IntoPyRef<V> for T

I don't think it works.

Assuming you meant:

impl<T: Into<PyString>> TryIntoPyStringRef for T
{
    fn into_pystringref(self, vm: &mut VirtualMachine) -> PyResult<PyStringRef> {
        Ok(PyString::from(self).into_ref(vm))
    }
}

It complains because:

help: the trait `std::fmt::Display` is not implemented for `T`

And fixing that:

47 | impl TryIntoPyStringRef for PyStringRef {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `pyobject::PyRef<obj::objstr::PyString>`

if you allow it to use the version it derives then it ends up formatting the object using the default formatter and you get: "'str' object" instead of the string. (I was expected to lose object identity in that case, surprised to lose object value.)

This default implementation for ToString is the issue:

impl<T> ToString for T where
    T: Display + ?Sized,