String type in mojo

[pcupit]

In the following experiment on the playground I am getting errors. I added a str method to MyInt but doesn't solve the problem. Wondering what the definition of string is in Mojo.

import String
import Math

struct MyInt:
    var value: Int
    
    
    fn __assign__(inout self, val : Int):
        self.value = val
        
    fn __add__(self : MyInt,  rhs: Int) -> Int:
        return self.value + rhs
    
    fn __add__(self : MyInt, rhs: MyInt) -> MyInt:
        return self.value + rhs.value

    fn __int__(inout self: MyInt, rhs: Int):
        self.value = rhs
        
    fn __str__(inout self: MyInt) -> StringRef:
        return StringRef("{self.value}")
        
    fn __init__(inout self, rhs: Int):
        self.value = rhs
         
#    fn __init__(inout self, rhs: F32):
#        self.value = math.ceil(rhs)
        
    
    fn __lt__(self:MyInt, rhs: MyInt) -> Bool:       
          return self.value < rhs.value
        
    fn __eq__(self:MyInt, rhs: MyInt) -> Bool:       
           return self.value == rhs.value   
       
    fn __iadd__(inout self:MyInt, inout rhs: MyInt):
        self.value = self.value + rhs.value    # OK

    fn __copyinit__(inout self, other: MyInt):
        self.value = other.value
    
        
    
struct MyPair:
    var first: MyInt
    var second: MyInt

    # We use 'fn' instead of 'def' here - we'll explain that soon
    fn __init__(inout self, first: MyInt, second: MyInt):       
        self.first = first
        self.second = second
        
    fn __add__(self: MyPair,  rhs: MyPair) -> MyPair:
        return MyPair(self.first + rhs.first, self.second + rhs.second)
      
        
    #fn __iadd__(inout self:MyInt, inout rhs: MyInt):
    #    self.value = self.value + rhs.value    # OK
    #
    
    fn __lt__(self, rhs: MyPair) -> Bool:       
           return self.first < rhs.first or
              (self.first == rhs.first and
               self.second < rhs.second)
        
   # fn __copyinit__(inout self, other: MyPair):
   #     self.first.value = other.first.value
   #     self.second.value = other.second.value
        
def pairTest() -> Bool:
    
    let p = MyPair(1, 2)
    let q = MyPair(3, 42)
    
    var z = p+q
   # print(z)
    print(z.second)
    
    return p < q
    #return p < q # gives a compile-time error

if (pairTest()):
    print("Success")
else:
    print("Not success")

Errors:

error: Expression [24]:70:10: no matching function in call to 'print':
print(z.second)
~~~~~^~~~~~~~~~

/.modular/Kernels/mojo/Stdlib/IO.mojo:274:1: candidate not viable: callee expects 0 arguments, but 1 was specified
fn print():
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:279:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to 'DType'
fn print(t: DType):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:288:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to 'String'
fn print(x: String):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:298:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to 'StringRef'
fn print(x: StringRef):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:308:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to 'StringLiteral'
fn print(x: StringLiteral):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:317:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to 'Bool'
fn print(x: Bool):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:326:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to 'FloatLiteral'
fn print(x: FloatLiteral):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:335:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to 'Int'
fn print(x: Int):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:344:1: candidate not viable: callee expects 2 input parameters but 0 were provided
fn print[
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:369:1: candidate not viable: callee expects 1 input parameter but 0 were provided
fn print[type: DType](x: Atomic[type]):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:382:1: candidate not viable: callee expects 1 input parameter but 0 were provided
fn print[length: Int](shape: DimList):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:408:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to 'object'
fn print(obj: object):
^

/.modular/Kernels/mojo/Stdlib/IO.mojo:427:1: candidate not viable: argument #0 cannot be converted from 'MyInt' to '_Printable'
fn print(*elements: _Printable):
^

[strangemonad]

Until mojo has traits, there isn't a clean implementation of __str__ and __repr__ that are usable for a polymorphic implementation of print. The print builtin currently has a hard coded number of implementations. Specifically, until traits and classes are implemented, the print function has no way to know that your custom type implements __str__ and that calling __str__ is the python convention for converting to a string that should be called when printing

The easiest thing (until traits and classes) is to manually convert to the string representation you want e.g. print("{my_int.value}") or print(my_int.__str__()). If you're curious, the error points to the IO🔥 file that implements print