Examples

using std;
 
/** Runs the example that prints a greeting. */
function main() void {
  println("Hello, Sun!");
}
 
manifest {
    libraries: ["stdlib.moon"]
}

sun --compile -o main main.sun
./main
# Hello, Sun!

using std;
 
/**
 * Classes are stack-allocated value types. They are passed by `ref` and
 * carry methods, including an `init` constructor.
 */
class Point {
  public var x: i32;
  public var y: i32;
 
  /** Initializes the fixture fields used by this example or regression test. */
  init(x_: i32, y_: i32) {
    this.x = x_;
    this.y = y_;
  }
 
  /**
   * Manhattan distance to another point. Class arguments are passed by ref.
   */
  public method manhattan(other: ref Point) i32 {
    var dx = this.x - other.x;
    if (dx < 0) {
      dx = -dx;
    }
    var dy = this.y - other.y;
    if (dy < 0) {
      dy = -dy;
    }
    return dx + dy;
  }
}
 
/** Runs the example that constructs and uses class values. */
function main() i32 {
  var origin = Point(0, 0);
  var p = Point(3, 4);
 
  var dist = p.manhattan(origin);  // 7
  println(dist);
  return 0;
}
 
manifest {
    libraries: ["stdlib.moon"]
}

./build.sh
./main

build/sun --emit-moon -o build/stdlib.moon stdlib/stdlib.sun

bash scripts/fetch-openssl.sh
examples/100-git_library/build.sh
bash examples/100-git_library/test.sh

examples/100-git_library/build.sh --refresh-sources

manifest {
    libraries: ["stdlib.moon", "$SUN_SERVE/sun_serve.moon"]
}
 
using std;
using sun_serve;
 
/** Checks polling results and HTTP helpers from the imported library. */
function check_library() ServerResult<i32> {
  var alloc = make_heap_allocator();
  var layout = try probe_epoll_layout(alloc);
  var poller = try Epoll(alloc, layout, 1);
  if (try poller.wait(0)) != 0 {
    return ServerResult.Ok(3);
  }
  // An invalid descriptor must produce an owned error across the Moon boundary.
  match poller.add(-1, 0, 0) {
    ServerResult.Ok => {
      return ServerResult.Ok(4);
    },
    ServerResult.Error(error) => {
      if error.message().length() == 0 {
        return ServerResult.Ok(5);
      }
    },
    (error: const ref IError) => {
      eprintln(error.message());
      return ServerResult.Ok(6);
    }
  };
  if status_has_no_body(200) {
    return ServerResult.Ok(1);
  }
  if status_has_no_body(204) {
    println(version());
    println(reason_phrase(200));
    return ServerResult.Ok(0);
  }
  return ServerResult.Ok(2);
}
 
/** Reports unexpected library failures and returns the integration status. */
function main() i32 {
  return match check_library() {
    ServerResult.Ok(status) => status,
    (error: const ref IError) => {
      eprintln(error.message());
      return 7;
    }
  };
}

build/sun --lib-path build -lcublas -lcudart -lpthread examples/110-gpu-matrices/main.sun

/** Multiplies two matrices on the GPU and prints the result. */
manifest { libraries: ["stdlib.moon", "cuda.moon"] }
using std;
using cuda;
 
/** Uploads a matrix twice, multiplies on the GPU, and downloads the product. */
function run() GpuResult<void> {
  var alloc = make_heap_allocator();
  var gpu = try open_device(0);
  var a_cpu = Matrix<f32>([[1.0f32, 2.0f32], [3.0f32, 4.0f32]], alloc);
  var b_cpu = Matrix<f32>([[1.0f32, 2.0f32], [3.0f32, 4.0f32]], alloc);
  var a = try gpu.upload(a_cpu);
  var b = try gpu.upload(b_cpu);
  var c = try (a * b);
  var c_cpu = Matrix<f32>(alloc, [2, 2]);
  try c.copy_to_host(c_cpu);
  println(c_cpu[0, 0]);
  println(c_cpu[0, 1]);
  println(c_cpu[1, 0]);
  println(c_cpu[1, 1]);
  return GpuResult.Ok;
}
 
/** Prints failures and returns a failing process status. */
function main() i32 {
  return match run() {
    (error: const ref IError) => {
      println(error.message());
      1;
    },
    _ => 0
  };
}

using std;
 
/**
 * An interface declares behaviour that classes can implement. Functions can
 * accept `ref Interface` and dispatch dynamically to the concrete type.
 */
interface Drawable {
  /** Prints a description of this shape through its drawing interface. */
  public method draw() void;
}
 
/** A drawable circle used to demonstrate interface dispatch. */
class Circle implements Drawable {
  public var radius: f64;
 
  /** Initializes the fixture fields used by this example or regression test. */
  init(r: f64) {
    this.radius = r;
  }
 
  /** Prints a description of this shape through its drawing interface. */
  public method draw() void {
    println("Drawing circle with radius:");
    println(this.radius);
  }
}
 
/** A drawable square used to demonstrate interface dispatch. */
class Square implements Drawable {
  public var side: f64;
 
  /** Initializes the fixture fields used by this example or regression test. */
  init(s: f64) {
    this.side = s;
  }
 
  /** Prints a description of this shape through its drawing interface. */
  public method draw() void {
    println("Drawing square with side:");
    println(this.side);
  }
}
 
/**
 * `shape` is dispatched dynamically based on its concrete type.
 */
function render(shape: ref Drawable) void {
  shape.draw();
}
 
/** Runs the example that dispatches drawing methods through an interface. */
function main() i32 {
  var c = Circle(5.0);
  var s = Square(10.0);
 
  render(c);
  render(s);
  return 0;
}
 
manifest {
    libraries: ["stdlib.moon"]
}

./build.sh
./main

using std;
 
/** Returns either a quotient or a concrete arithmetic failure. */
function divide(a: i32, b: i32) ArithmeticResult<i32> {
  if (b == 0) {
    return ArithmeticResult.DivisionByZero(DivisionByZeroError());
  }
  if (a == -2147483648 and b == -1) {
    return ArithmeticResult.Overflow(OverflowError());
  }
  return ArithmeticResult.Ok(a / b);
}
 
/** Handles an arithmetic result without requiring one arm per error. */
function show(a: i32, b: i32) void {
  match divide(a, b) {
    ArithmeticResult.Ok(value) => println(value),
    (error: const ref IError) => println(error.message())
  };
}
 
/** Exercises successful division and a recoverable zero divisor. */
function main() i32 {
  show(10, 2);
  show(10, 0);
  return 0;
}
 
manifest {
  libraries: ["stdlib.moon"]
}

./build.sh
./main

using std;
 
// The code under test: distance helpers in a module. `half` is private, but
// privacy is module-scoped, so tests declared inside the module reach it.
/** Groups declarations used by this compiler regression test. */
module distance {
  /** Returns half of the supplied value for the testing example. */
  function half(n: i64) i64 {
    return n / 2;
  }
 
  /** Returns the midpoint of two values for the testing example. */
  public function midpoint(a: i64, b: i64) i64 {
    return a + distance.half(b - a);
  }
 
  /**
   * A test is a function declared with `test_function`: no parameters, no
   * return annotation, and propagates failed assertions with `try`.
   */
  test_function halves() {
    try std.test.assert_eq(distance.half(10), 5);
  }
 
  /** Checks finds the midpoint. */
  test_function findsTheMidpoint() {
    try std.test.assert_eq(distance.midpoint(2, 10), 6);
  }
}
 
/**
 * A fixture is an ordinary class: init is the setup, deinit the teardown.
 * Propagating a failed assertion drops locals, so teardown runs whether
 * the test passes or fails.
 */
class ScratchBuffer {
  public var data: Vec<i64>;
 
  /** Initializes the fixture fields used by this example or regression test. */
  init() {
    var alloc = make_heap_allocator();
    this.data = Vec<i64>(alloc, 4);
    this.data.push(1);
  }
 
  /** Records fixture teardown so the test can check cleanup behavior. */
  deinit() {
    // The Vec releases itself; a real fixture would remove temp files,
    // close connections, and so on.
  }
}
 
/** Checks starts with one entry. */
test_function startsWithOneEntry() {
  var fx = ScratchBuffer();
  try std.test.assert_eq(fx.data.size(), 1);
}
 
/** Runs the example that uses functions exercised by the example tests. */
function main() i32 {
  // The production binary never contains the tests above.
  var m = distance.midpoint(2, 10);
  println(`midpoint(2, 10) = ${m}`);
  return 0;
}
 
manifest {
    test_files: ["more_tests.sun"]
    libraries: ["stdlib.moon"]
}

using std;
 
// A test-only file, listed under `test_files:` in the manifest. It is
// loaded only when compiling tests, and it reopens `module distance` so its
// tests reach the module's private items too.
/** Groups declarations used by this compiler regression test. */
module distance {
  /** Checks midpoint of equal points is that point. */
  test_function midpointOfEqualPointsIsThatPoint() {
    try std.test.assert_eq(distance.midpoint(4, 4), 4);
  }
}

./build.sh
./main            # the program; contains no test code
./main_test       # runs the 4 tests, exit 0 when all pass
sun test main.sun # same tests, JIT

using std;
 
/** Demonstrates a class whose destructor runs when its value leaves scope. */
class Foo {
  /** Creates an empty fixture value for this example or regression test. */
  init() {}
 
  /** Prints a message to demonstrate when scope cleanup runs. */
  deinit() {
    println("Foo deinit was called.");
  }
}
 
/** Runs the example that demonstrates class cleanup at scope exit. */
function main() void {
  var foo = Foo();
  println("Exiting main, foo will go out of scope and deinit will be called.");
}
 
manifest {
    libraries: ["stdlib.moon"]
}

./build.sh
./main

using std;
 
/** Runs the example that creates and invokes captured functions. */
function main() i32 {
  var multiplier: i32 = 10;
 
  // A lambda captures `multiplier` from the enclosing scope by closure.
  var scale = (x: i32) => i32 {
    return x * multiplier;
  };
 
  var total: i32 = 0;
  for (var i: i32 = 1; i <= 5; i = i + 1) {
    total = total + scale(i);  // 10 + 20 + 30 + 40 + 50
  }
 
  println(total);  // 150
  return 0;
}
 
manifest {
    libraries: ["stdlib.moon"]
}

./build.sh
./main

using std;
 
/** Runs the example that calls through transitive compiled-library dependencies. */
function main() void {
  println(moon1.moon1());
}
 
manifest {
    libraries: ["stdlib.moon", "moon1.moon"]
}

/** Returns a value obtained through the example's first compiled-library dependency. */
public module moon1 {
  /** Returns a value obtained through the example's first compiled-library dependency. */
  public function moon1() i32 {
    return 1 + moon2.moon2();
  }
}
 
manifest {
    source_files: []
    libraries: [{ path: "moon2.moon"}]
}

/** Returns a value obtained through the example's second compiled-library dependency. */
public module moon2 {
  /** Returns a value obtained through the example's second compiled-library dependency. */
  public function moon2() i32 {
    return 2 + moon3.moon3();
  }
}
 
manifest {
    source_files: []
    libraries: ["moon3.moon"]
}

/** Supplies the value exported by the example's transitive library dependency. */
public module moon3 {
  /** Supplies the value exported by the example's transitive library dependency. */
  public function moon3() i32 {
    return 3;
  }
}
 
manifest {
    source_files: []
    libraries: []
}

./build.sh
./main

{
  "root": true,
  "sun_path": ["."],
  "entrypoints": [
    { "path": "life.sun", "type": "library", "output_name": "life.moon" },
    { "path": "main.sun", "type": "binary", "output_name": "main" }
  ]
}

SUN_BIN=./build/sun bash examples/65-debug/build.sh
bash examples/65-debug/test.sh
python3 -m json.tool examples/65-debug/life_debug/moon.json

public module life {
  public function answer() i32 {
    return 42;
  }
}

/** Exits successfully when the compiled library returns the expected value. */
function main() i32 {
  return life.answer() - 42;
}
 
manifest {
  libraries: ["life.moon"]
}

// Listener: accepts one connection and prints received message
using std;
 
/** Performs the operation and propagates returned failures. */
function run() Result<void> {
  var alloc = make_heap_allocator();
  var buf = ContiguousBuffer<u8>(alloc, 256);
 
  var listener = TcpListener();
  try listener.bind_loopback(8080);
  try listener.listen(1);
  println("Listening on 127.0.0.1:8080...");
 
  var client = try listener.accept();
  println("Client connected");
 
  while (true) {
    var n = try client.recv(buf);
    if (n <= 0) {
      println("Connection closed");
      break;
    }
    var str = try String(alloc, buf, n);
    println(str);
  }
 
  client.close();
  listener.close();
 
  return Result.Ok;
}
 
/** Reports errors and sets the process exit code. */
function main() i32 {
  return match run() {
    (e: const ref IError) => {
      println(e.message());
      1;
    },
    _ => 0
  };
}
 
manifest {
    libraries: ["stdlib.moon"]
}

// Talker: connects and sends a message
using std;
 
/** Performs the operation and propagates returned failures. */
function run() Result<void> {
  var stream = TcpStream();
  try stream.connect_local(8080);
  println("Connected to 127.0.0.1:8080");
 
  try stream.send_str("Hello from talker!");
  println("Message sent");
 
  stream.close();
 
  return Result.Ok;
}
 
/** Reports errors and sets the process exit code. */
function main() i32 {
  return match run() {
    (e: const ref IError) => {
      println(e.message());
      1;
    },
    _ => 0
  };
}
 
manifest {
    libraries: ["stdlib.moon"]
}

./build.sh

./listener   # terminal 1
./talker     # terminal 2

// Receiver: binds a UDP port and prints one datagram and its sender
using std;
 
/** Performs the operation and propagates returned failures. */
function run() Result<void> {
  var alloc = make_heap_allocator();
  var buf = ContiguousBuffer<u8>(alloc, 256);
 
  var socket = UdpSocket();
  try socket.bind(ipv4_loopback(), 9090);
  println("Waiting on 127.0.0.1:9090...");
 
  var datagram = try socket.recv_from(buf);
  var text = try String(alloc, buf, datagram.length());
  println(text);
 
  var from = datagram.addr();
  println("From address:");
  println(from.to_string(alloc));
 
  socket.close();
 
  return Result.Ok;
}
 
/** Reports errors and sets the process exit code. */
function main() i32 {
  return match run() {
    (e: const ref IError) => {
      println(e.message());
      1;
    },
    _ => 0
  };
}
 
manifest {
    libraries: ["stdlib.moon"]
}

// Sender: sends one datagram to the receiver
using std;
 
/** Performs the operation and propagates returned failures. */
function run() Result<void> {
  var socket = UdpSocket();
  try socket.bind(ipv4_any(), 0);  // port 0: the OS picks a free port
  try socket.send_str_to("Hello from sender!", ipv4_loopback(), 9090);
  println("Datagram sent");
 
  socket.close();
 
  return Result.Ok;
}
 
/** Reports errors and sets the process exit code. */
function main() i32 {
  return match run() {
    (e: const ref IError) => {
      println(e.message());
      1;
    },
    _ => 0
  };
}
 
manifest {
    libraries: ["stdlib.moon"]
}

./build.sh

./receiver   # terminal 1
./sender     # terminal 2

// HTTP server: serves a small webpage on http://127.0.0.1:8080
using std;
 
/** Runs the example that serves HTTP requests. */
function main() i32 {
  var alloc = make_heap_allocator();
  var server = HttpServer(alloc);
  match server.bind_loopback(8080) {
    SystemResult.Ok => {},
    SystemResult.Error(e) => {
      println(e.message());
      return 1;
    }
  };
  println("Serving on http://127.0.0.1:8080");
 
  server.serve(
    (req: ref HttpRequest, resp: ref HttpResponse) => void {
      if (req.path.equals_literal("/")) {
        resp.set_body("<html><body><h1>Hello from Sun!</h1><p>This page is served by the Sun standard library.</p></body></html>");
      } else {
        resp.set_status(404);
        resp.set_body("<html><body><h1>404 Not Found</h1></body></html>");
      }
    }
  );
  return 0;
}
 
manifest {
    libraries: ["stdlib.moon"]
}

./build.sh

./server

curl -i http://127.0.0.1:8080/         # 200 with the page
curl -i http://127.0.0.1:8080/missing  # 404

using std;
using tls;
 
var client = HttpsClient(alloc);
var host = String(alloc, "example.com");
var response = client.get(host, "/");

// An HTTPS GET with the tls bundle's HttpsClient.
//
// The certificate is verified against the system CA store and checked
// against the hostname; a bad certificate returns an error.
 
using std;
using tls;
 
/** Carries request, system, or response access failures. */
enum RequestResult { Ok, Tls(tls.TlsError), System(Error), Bounds(IndexOutOfBoundsError) }
 
/** Performs the operation and propagates returned failures. */
function run() RequestResult {
  var alloc = make_heap_allocator();
  var client = HttpsClient(alloc);
  var host = String(alloc, "example.com");
 
  var response = try client.get(host, "/");
 
  print("status: ");
  println(response.status);
  print("body bytes: ");
  println(response.body.length());
 
  // Print the first line of the body
  var end: i64 = 0;
  while (end < response.body.length() and (try response.body.at(end)) != b'\n') {
    end = end + 1;
  }
  var first_line = try response.body.substr(alloc, 0, end);
  println(first_line);
 
  return RequestResult.Ok;
}
 
/** Reports errors and sets the process exit code. */
function main() i32 {
  return match run() {
    (e: const ref IError) => {
      println(e.message());
      1;
    },
    _ => 0
  };
}
 
manifest {
    libraries: ["stdlib.moon", "tls.moon"]
}

./build.sh
./client
ldd client        # Linux: not a dynamic executable
otool -L client   # macOS: system libraries only, no OpenSSL

using std;
using std.thread;
using std.time;
 
/**
 * Take the front item, if there is one. The lock is held for exactly as long
 * as this function runs: the guard is released when `g` goes out of scope at
 * the end of it, so the caller can wait without stalling the producer.
 */
function take_one(q: const ref Shared<Queue<i64>>) Option<i64> {
  var g = q.lock();
  return g.get().pop();
}
 
// The two thread bodies, as lambdas at global scope. Each takes the handle it
// works through as a parameter rather than capturing one: spawn moves its
// arguments into the thread, so the handle is the thread's from the moment it
// starts, and is released when the thread ends. A global lambda captures
// nothing at all — globals are read directly — so the same one can be spawned
// as often as you like.
 
// Push ten squares onto the queue.
var produce = (q: Shared<Queue<i64>>) => i32 {
  var i: i64 = 1;
  while (i <= 10) {
    // The lock is held just long enough to push: the guard is released at
    // the end of each iteration.
    var g = q.lock();
    g.get().push(i * i);
    i = i + 1;
  }
  return 0;
};
 
// The consumer knows how many items to expect, so it stops after ten rather
// than needing the producer to tell it when to stop.
var consume = (q: Shared<Queue<i64>>) => i32 {
  var received: i64 = 0;
  var total: i64 = 0;
 
  while (received < 10) {
    match (take_one(q)) {
      Option.Some(item) => {
        received = received + 1;
        total = total + item;
      },
      // Nothing queued yet. Step aside rather than spin on the lock —
      // take_one released it before returning.
      Option.None => {
        sleep(create_duration_micros(100));
      }
    };
  }
 
  return _convert<i32>(total);
};
 
/** Runs the example that coordinates producer and consumer threads. */
function main() i32 {
  var alloc = make_heap_allocator();
 
  // One queue, two owners. Sun never copies a class implicitly, so each
  // thread needs its own handle, made with an explicit clone().
  var queue = Shared<Queue<i64>>(alloc, Queue<i64>(alloc));
 
  var producer = spawn(produce, queue.clone());
  var consumer = spawn(consume, queue.clone());
 
  producer.join();
  var total = consumer.join();
 
  // Both threads have finished, so the last handle can read without a race.
  var g = queue.lock();
  println(`items left: ${g.get().size()}`);
  println(`total: ${total}`);
 
  return 0;
}
 
manifest {
    libraries: ["stdlib.moon"]
}

./build.sh
./main
# items left: 0
# total: 385