Real types.
One binary.
Nothing shared.

Blocks, classes, and end

Classes, mixins, blocks and end-delimited bodies, with an expressive object model. Types are optional annotations layered on top, checked when you write them.

class Order
  include Comparable

  def initialize(total: Int)
    @total = total
  end

  def <=>(other: Order) = @total <=> other.total()
  def total() = @total
end

orders = [Order.new(30), Order.new(10), Order.new(20)]
orders.sort().map() do |order|
  order.total()
end
# => [10, 20, 30]

Real threads, light fibers

A Thread is an OS thread with its own heap, so there are no data races by construction. Fibers give you generators and coroutines inside one thread.

left = Thread.new(square, 6)
right = Thread.new(square, 7)
left.join() + right.join()   # => 85

steps = Fiber.new(countdown)
steps.resume()   # => 3
steps.resume()   # => 2

Mailboxes and supervisors

Threads talk through bounded channels, and a supervisor restarts a worker that crashes. A failure stays inside the worker that had it.

jobs = Channel.new(4)
worker = Thread.new(producer, jobs)

item = jobs.receive()   # blocks until a value arrives

sup = Supervisor.new()
sup.add_child(fetch_loop)
# fetch_loop crashes? it is restarted;
# nothing else is touched

Packages you install, not frameworks you adopt

Mjolnir is a data mapper: entities are plain structs, queries are values, and one Repo does the I/O. HTTP servers, routing, GraphQL, jobs, Redis and WebSockets are packages too.

struct User(id: Int, name: String, email: String)
end

users = Mjolnir::Schema.new("users",
  {"id": :int, "name": :string, "email": :string},
  build_user)
repo = Mjolnir::Repo.new(db)

changeset = Mjolnir::Changeset.cast(users, nil, attrs,
    ["name", "email"])
  .validate_required(["name", "email"])
  .validate_format("email", "@")

case repo.insert(changeset)
when Mjolnir::Ok  then "saved"
when Mjolnir::Err then "rejected"
end

All packages →