Adding Functions to Objects in Flogram

In Flogram, functions can be embedded within objects, allowing you to encapsulate behavior with data. This enables more organized and reusable code. Here’s how you can add functions to objects:

Defining Functions Inside Objects

Functions within an object are defined by simply indenting the function definition under the object declaration.

Accessing Object Variables with self

The self keyword within the function allows you to access variables belonging to the instance of the object the function is called on. An instance of an object is a specific realization of the object, containing its own set of data.

Here’s an example:

object Rectangle:
  length: FP32
  width: FP32

  fn area() -> (a: FP32):
    return self.length * self.width

Here’s how you can use the area function:

fn main():
  r := Rectangle(length = 5, width = 2)
  # r.area() calls the function area on instance r of Rectangle
  draw(r.area())  # outputs 10

Mutating Variables with Functions

If a function within an object mutates (changes) variables belonging to the object, the mut keyword must precede the fn keyword in the function declaration:

object Counter:
  mut value: I32 = 0

  mut fn increment():
    self.value = self.value + 1

mut must also be used when calling a function that changes variables that belong to an object

Here’s an example using the Counter object:

fn main():
  mut c := Counter()  # c.value = 0
  mut c.increment()  # this is equivalent to c.value = c.value + 1
  draw(c.value)  # outputs 1

Productivity Tip!

Avoid attaching functions to objects unless it really makes sense for the object to own that function. Using stand-alone functions that accept objects as parameters instead often leads to more maintainable code.

Example for the Code Editor

object Point2D:
  mut x: FP32
  mut y: FP32

  fn distanceTo(other: Point2D) -> (distance: FP32):
    lengthX := self.x - other.x
    lengthY := self.y - other.y
    squareX := lengthX * lengthX
    squareY := lengthY * lengthY
    sum := squareX + squareY
    distance := sqrt(sum)
    return distance

  mut fn moveBy(dx: FP32, dy: FP32):
    self.x = self.x + dx
    self.y = self.y + dy
    return

fn main():
  p1 := Point2D(x = 1.0, y = 2.0)
  p2 := Point2D(x = 4.0, y = 6.0)
  draw(p1.distanceTo(p2)) # calculates the distance

  p1.moveBy(3.0, 4.0)         # moves p1
  draw(p1.distanceTo(p2)) # calculates the new distance