Actors

actor Counter {
  state let count: i64 = 0
  
  fn increment() {
    self.count += 1
  }
  
  fn get() -> i64 {
    return self.count
  }
}

actor BankAccount {
  state let balance: f64 = 0.0
  state let owner: str
  
  fn deposit(amount: f64) {
    self.balance += amount
  }
  
  fn withdraw(amount: f64) -> Result<f64, Error> {
    if amount > self.balance {
      return Err("Insufficient funds")
    }
    self.balance -= amount
    return Ok(self.balance)
  }
}

let counter = Counter{}
let account = BankAccount{owner: "Alice"}

actor Counter {
  state let n: i64 = 0
  
  fn inc() {
    self.n += 1
  }
  
  fn get() -> i64 {
    return self.n
  }
}

fn main() {
  let c = Counter{}
  c.inc()
  print(c.get())  # 1
}

main()

# Coming soon
actor Worker {
  fn process(data: bytes) -> Result<str, Error> {
    # Process data
    return Ok("Done")
  }
}

fn main() {
  let worker = Worker{}
  let result = await worker.process(data)
}

let counter1 = Counter{}
let counter2 = Counter{}

counter1.inc()
counter2.inc()
counter2.inc()

print(counter1.get())  # 1
print(counter2.get())  # 2

actor Counter {
  state let n: i64 = 0
  
  fn increment() {
    self.n += 1
  }
  
  fn decrement() {
    self.n -= 1
  }
  
  fn get() -> i64 {
    return self.n
  }
  
  fn reset() {
    self.n = 0
  }
}

actor BankAccount {
  state let balance: f64 = 0.0
  state let owner: str
  
  fn constructor(owner_name: str) {
    self.owner = owner_name
  }
  
  fn deposit(amount: f64) {
    self.balance += amount
  }
  
  fn withdraw(amount: f64) {
    if amount <= self.balance {
      self.balance -= amount
    }
  }
  
  fn get_balance() -> f64 {
    return self.balance
  }
}