sapphire-lang 0.6.0

Gradually typed scripting language where every value is an object and types are optional, checked at runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

# nested_classes.spr — nested class definitions and dot-notation namespaces

# Basic nested class access via Outer.Inner
class Geometry {
  class Point {
    attr x: Int
    attr y: Int

    def to_s() {
      "(#{self.x}, #{self.y})"
    }

    def distance_to(other) {
      dx = self.x - other.x
      dy = self.y - other.y
      # integer approximation of sqrt(dx^2 + dy^2)
      dx * dx + dy * dy
    }
  }

  class Rectangle {
    attr top_left
    attr bottom_right

    def width() {
      self.bottom_right.x - self.top_left.x
    }

    def height() {
      self.bottom_right.y - self.top_left.y
    }

    def area() {
      self.width() * self.height()
    }
  }
}

origin = Geometry.Point.new(x: 0, y: 0)
corner = Geometry.Point.new(x: 3, y: 4)
print "Origin: #{origin.to_s()}"
print "Corner: #{corner.to_s()}"
print "Squared distance: #{origin.distance_to(corner)}"

tl = Geometry.Point.new(x: 1, y: 1)
br = Geometry.Point.new(x: 5, y: 4)
rect = Geometry.Rectangle.new(top_left: tl, bottom_right: br)
print "Rectangle #{rect.width()}x#{rect.height()}, area=#{rect.area()}"

# Nested class as a superclass via dot notation
class Animals {
  class Animal {
    attr name: String

    def speak() {
      "..."
    }

    def introduce() {
      "I am #{self.name} and I say: #{self.speak()}"
    }
  }
}

class Dog < Animals.Animal {
  def speak() {
    "woof"
  }
}

class Cat < Animals.Animal {
  def speak() {
    "meow"
  }
}

d = Dog.new(name: "Rex")
c = Cat.new(name: "Whiskers")
print d.introduce()
print c.introduce()
print d.is_a?(Animals.Animal)