mojo_0.6_play.🔥

# https://docs.modular.com/mojo/changelog.html?utm_content=273987722&utm_medium=social&utm_source=twitter&hss_channel=tw-1483918307484848132

fn main() raises:
  testtraits()
  testdestructable()
  testMovableCopyable()
  testSaveTensor()

# Traits

fn testtraits():
  print("testtraits")
  let thingone = woman()
  let thingtwo = mallard()
  thingone.move()
  thingtwo.makeNoise()

  makeloudmovement(thingone)
  makeloudmovement(thingtwo)

  # can't have a DynamicVector of a trait even if it inherits from CollectionElement
  var things: DynamicVector[woman] = DynamicVector[woman]()
  things.append(thingone)
  print("Done")

trait locomotable:
  fn move(self):
    ...

trait noisy:
  fn makeNoise(self):
    ...

trait noisymover(locomotable, noisy):
    ...

trait duck(noisymover, CollectionElement):
    ...

trait human(noisymover,CollectionElement):
    ...

@value
struct woman(human):
  fn move(self):
    print("walking")
  
  fn makeNoise(self):
    print("hello")

@value
struct mallard(duck):
  fn move(self):
    print("waddle")

  fn makeNoise(self):
    print("quack")

fn makemove[t: locomotable](tocheck: t):
  tocheck.move()

fn makesound[t: noisy](tocheck: t):
  tocheck.makeNoise()

fn makeloudmovement[t: noisymover](tocheck: t):
  tocheck.move()
  tocheck.makeNoise()

# Destructable

fn testdestructable():
  print("testdestructable")
  let thing = Mustdie(10)
  print(thing)
  print("len()",len(thing))
  print("int()", int(thing))
  print("Done")


@value
struct Mustdie(Destructable, Stringable, Intable, Sized):
  var ptr: Pointer[Int]
  var size: Int

  fn __init__(inout self, size: Int):
    self.size = size
    self.ptr = Pointer[Int].alloc(size)
    for i in range(self.size):
      self.ptr[i] = i

  fn __del__(owned self):
    print("Deleting mustdie:", self.size)
    self.ptr.free()

  fn __str__(self) -> String:
    var result:String = ""
    for i in range(self.size):
      result += String(self.ptr[i])
    return result

  fn __int__(self) -> Int:
    var total: Int = 0
    for i in range(self.size):
      total += self.ptr[i]
    return total

  fn __len__(self) -> Int:
    return self.size


# movable, copyable

struct van(Movable, Copyable, CollectionElement):
  var thing: Int

  fn __init__(inout self):
    print("van init")
    self.thing = 0

  fn __moveinit__(inout self: van, owned existing: van ):
    print("van moveinit")
    self.thing = existing.thing

  fn __copyinit__(inout self: van, existing: van ):
    print("van copyinit")
    self.thing = existing.thing

  fn __del__(owned self):
    print("del")

  
fn testMovableCopyable():
   print("testMovableCopyable")
   var vans: DynamicVector[van] = DynamicVector[van]() 
   vans.append(van())
   print("len vans",len(vans))
   print("Done")
   # surprising del before
   # explict calling del on vans weird also
   #

fn testSaveTensor() raises:
   from random import rand
   from tensor import Tensor, TensorSpec, TensorShape
   from utils.index import Index

   let test = rand[DType.float32](10,10,3)
   let spec = TensorSpec(DType.float32, 10, 10, 3)
   var tensor = Tensor[DType.float32](spec)
   # i'm sure there is a better way of doing this
   for i in range(9):
     for j in range(9):
       for k in range(2):
         tensor[Index(i,j,k)] = test[i,j,k]
   tensor.save("./cool")