Sake-lang

puts("Hello, Sake!")
puts(String.upcase("operations carry their type"))

$ sake hello.sake
Hello, Sake!
OPERATIONS CARRY THEIR TYPE

name = "sake"
puts(name.upcase)
puts(name.strip.capitalize)

$ sake method_call.sake
method_call.sake:2:11: error: method call on a value `name.upcase` is not allowed
  hint: String.upcase(name)
  hint: Symbol.upcase(name)
method_call.sake:3:17: error: method call on a value `name.strip.capitalize` is not allowed
  hint: String.strip(name).capitalize
  hint: String.strip(name).Symbol.capitalize
(exit status 2)

puts(String.upcse("sake"))
puts(Strng.reverse("sake"))
puts(Integer.to_string(42))

$ sake typo.sake
typo.sake:1:13: error: undefined function `String.upcse`
  hint: did you mean `String.upcase`?
typo.sake:2:6: error: undefined type or module `Strng`
  hint: did you mean `String`?
typo.sake:3:14: error: undefined function `Integer.to_string`
  hint: did you mean `Integer.to_int`?
(exit status 2)

line = "pear, Apple ,fig"

# Left to right: the value on a step's left is its first argument. A step names its type where the
# type changes (String.split gives an Array), and the others continue with the type named last.
puts(String.split(line, ",")
  .Array.map { |s| String.strip(s).downcase }
  .sort
  .join(" < "))

# Top to bottom: `_` is the previous statement's value.
String.split(line, ",")
Array.map(_) { |s| String.strip(s).size }
puts("longest: #{Array.max(_)}")

$ sake chains.sake
apple < fig < pear
longest: 5

puts(7 / 2)           # Integer / Integer truncates toward -infinity, as in Ruby
puts(-7 / 2)
puts(7 % 3)
puts(7 / 2.0)         # mixing Integer and Float gives Float
puts(2 ** 10)
puts(Float.round(3.14159, 2))
puts(Float.round(2.5))   # without digits: an Integer
puts(Integer.+(1, 2))    # the operator written with its type
puts("ab" * 3)
puts("a" < "b")
p(1/3r + 1/6r)
p(2r ** -1)

$ sake numbers.sake
3
-4
1
3.5
1024
3.14
3
3
ababab
true
(1/2)
(1/2)

total = 10
label = "items: "
puts(label + total)

$ sake binop_error.sake
binop_error.sake:3:6: error: Arithmetic.+: the operands are (String, Integer), which the left operand's type does not support [type]
(exit status 2)

$ sake --strict=0 binop_error.sake
binop_error.sake:3: in <main>: TypeError: Arithmetic.+: no implementation for (String, Integer); defined for (any two of Integer, Float, Rational, Complex), (String, String), (Array, Array), (Time, Integer), (Time, Float), (Time, Rational)
(exit status 1)

puts(Integer.+(1, 2.5))        # Integer's +: a Float on the right is fine
puts(Integer.+(2.5, 1))        # but the left operand must be an Integer

$ sake typed_op_error.sake
typed_op_error.sake:2:6: error: Integer.+: argument 1 must be Integer, but is Float [type]
(exit status 2)

# == compares by content, and is false between different types (as in Ruby)
p([1, "a"] == [1, "a"])             # Tuples, Arrays, Hashes, Sets and Records: by content
p(1 == "1")
p([2, "b"] < [2, "c"])               # Tuples and Arrays are ordered element by element
scores = Any[["ann", 90], ["bob", 72], ["cy", 90]]
p(Array.sort_by(scores) { |name, s| [-s, name] })   # a Tuple as the sort key: score down, name up
x = 5
p([-x, !(x > 3)])                    # -x runs the -@ of x's type; !x is `x ? false : true`

$ sake comparing.sake
true
false
true
[["ann", 90], ["cy", 90], ["bob", 72]]
[-5, false]

def square(x) = x * x

def fib(n)
  if n < 2
    n
  else
    fib(n - 1) + fib(n - 2)
  end
end

def min_max(a, b)
  return a, b if a < b
  [b, a]
end

puts(square(12))
puts(square(1.5))           # functions without types are polymorphic
puts(fib(20))
lo, hi = min_max(9, 4)      # a Tuple is destructured by multiple assignment
puts(lo)
puts(hi)
p(min_max(1, 2))

$ sake functions.sake
144
2.25
6765
4
9
[1, 2]

# Optional parameters, then keyword parameters, as in Ruby.
def greet(name, greeting = "Hello", punct: "!", times: 1)
  String.*("#{greeting}, #{name}#{punct} ", times)
end

def area(w:, h: w) = w * h    # w: is required; h's default reads w

puts(greet("Ruby"))
puts(greet("Ruby", "Hi"))
puts(greet("Ruby", times: 2))
puts(greet("Sake", "Yo", punct: "?"))
p(area(w: 3))
p(area(h: 2, w: 5))
times = 3
punct = "."
puts(greet("you", times:, punct:))     # `k:` alone passes the variable k

$ sake params.sake
Hello, Ruby! 
Hi, Ruby! 
Hello, Ruby! Hello, Ruby! 
Yo, Sake? 
9
10
Hello, you. Hello, you. Hello, you. 

def area(w:, h: w) = w * h
def total(xs, init = 0) = Array.sum(xs, init)
p(area(width: 3))        # no such keyword, and w: is missing
p(total(Any[1], 0, 1)) # too many arguments
p(total(Any[1], start: 0))

$ sake params_errors.sake
params_errors.sake:3:3: error: area needs keyword argument `w:`
params_errors.sake:3:8: error: area has no keyword parameter `width`
params_errors.sake:4:3: error: wrong number of arguments for total (given 3, expected 1..2)
params_errors.sake:5:17: error: total takes no keyword arguments
(exit status 2)

def fizzbuzz(n)
  if n % 15 == 0
    "FizzBuzz"
  elsif n % 3 == 0
    "Fizz"
  elsif n % 5 == 0
    "Buzz"
  else
    Integer.to_s(n)
  end
end

i = 1
while i <= 15
  print(fizzbuzz(i), " ")
  i += 1
end
puts

n = 27
steps = 0
until n == 1
  n = Integer.even?(n) ? n / 2 : 3 * n + 1
  steps += 1
end
puts("collatz(27) steps: #{steps}")
puts("small") unless steps > 100
puts("ok") if steps == 111

$ sake control.sake
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 
collatz(27) steps: 111
ok

def describe(x)
  case x
  in Integer | Float then "number #{x}"
  in String then "string #{x}"
  in nil then "nothing"
  in {name:} then "record named #{name}"
  in :ok then "ok symbol"
  else "other"
  end
end
Point = Struct.new(:x, :y)
p(describe(3)); p(describe(2.5)); p(describe("s")); p(describe(nil)); p(describe({name: "r"})); p(describe(:ok)); p(describe(Point.new(1, 2)))

def pick(c) = c ? 1 : ""
v = pick(true)
if v in Integer
  p(v + 1)
else
  p(String.size(v))
end
p((Point.new(1, 2) in Point))
p(("s" in Integer | Float))

$ sake patterns.sake
"number 3"
"number 2.5"
"string s"
"nothing"
"record named r"
"ok symbol"
"other"
2
true
false

# `x => T` asserts a type: after it, x is a T; a value that does not match raises
# NoMatchingPatternError, and is reported before running when the checker sees it.
class Config
  attr_reader host, port
  def initialize(c) = @port = 80
  def set_port(c, p)
    p => Integer              # the knowledge "a port is an Integer", on the write
    @port = p
  end
end
c = Config.new("example.com")
Config.set_port(c, 8080)
p(c)
v = Array.first(Any[3, 4])  # Integer or nil
v => Integer                  # also a check for nil: v + 1 needs none
p(v + 1)
Config.set_port(c, "eighty")

$ sake pattern_assert.sake
pattern_assert.sake:7:5: error: `=> Integer`: the value is String, which does not match [type]
  hint: reached by the call at line 17
(exit status 2)

def only_ints(x)
  case x
  in Integer then x * 2
  end
end
p(only_ints(4))
p(only_ints("a"))

$ sake patterns_exhaustive.sake
patterns_exhaustive.sake:2:3: error: case/in: no `in` branch matches String [type]
  hint: add an `in` branch for it, or an `else`
  hint: reached by the call at line 7
(exit status 2)

nums = Any[3, 1, 4, 1, 5, 9, 2, 6]

Array.each(Any[1, 2, 3]) { |x| print(x * 10, " ") }
puts
p(Array.map(nums) { |x| x * x })
p(Array.select(nums) { it > 3 })                   # `it` names the only parameter
p(Array.sort_by(nums) { -_1 })                     # so does _1
puts(Array.reduce(nums, 0) { |acc, x| acc + x })
Array.each_with_index(Any["a", "b"]) { |s, i| puts("#{s}#{i}") }
Integer.times(3) { |i| print(i, " ") }
puts

$ sake blocks.sake
10 20 30 
[9, 1, 16, 1, 25, 81, 4, 36]
[4, 5, 9, 6]
[9, 6, 5, 4, 3, 2, 1, 1]
31
a0
b1
0 1 2 

def twice(x) = yield(yield(x))

def each_pair(a)
  Array.each(a) { |x| yield([x, x * x]) }   # yield a Tuple...
  a
end

def first_over(a, limit)
  Array.each(a) { |x| return x if x > limit }   # return leaves first_over
  0
end

puts(twice(3) { |x| x + 4 })
each_pair(Any[1, 2, 3]) { |x, sq| puts("#{x} -> #{sq}") }   # ...destructured here
puts(first_over(Any[1, 5, 10], 4))
odd_only = Array.map(Any[1, 2, 3, 4]) { |x| next 0 if Integer.even?(x); x }
p(odd_only)

$ sake yield.sake
11
1 -> 1
2 -> 4
3 -> 9
5
[1, 0, 3, 0]

def twice(x) = yield(yield(x))
def add(a, b) = a + b

puts(twice(1))
puts(add(1, 2) { |x| x })
Array.each(Any[1, 2])

$ sake block_errors.sake
block_errors.sake:4:6: error: twice uses `yield` but no block is given
  hint: a function that checks `block_given?` may be called without a block
block_errors.sake:5:6: error: add does not take a block (it has no `yield`)
block_errors.sake:6:7: error: Array.each requires a block
(exit status 2)

nums = Any[3, 8, 12, 5]
found = Array.each(nums) { |n| break n if n > 10 }    # break ends the call; its value is the call's
p(found)
pairs = Any[["a", 1], ["b", 2]]
Array.each_with_index(pairs) { |(name, n), i| puts("#{i}: #{name}=#{n}") }  # a parameter taken apart
Array.each(Any[[1, 2, 3], [4, 5, 6]]) { |head, *rest| p([head, rest]) }  # the rest, as an Array

$ sake blocks_more.sake
12
0: a=1
1: b=2
[1, [2, 3]]
[4, [5, 6]]

# block_given?: a function that may be called with or without a block.
def info(msg = nil)
  msg = yield if block_given?
  puts("INFO #{msg}")
end
info("plain")
info { "built only when logged: #{Array.sum(Any[1, 2, 3])}" }

def total(xs)
  return Array.sum(xs) unless block_given?
  Array.map(xs) { |x| yield x }.sum
end
p(total(Any[1, 2, 3]))
p(total(Any[1, 2, 3]) { |x| x * x })

# &b passes the function's own block on to another call.
def each_twice(xs, &b)
  Array.each(xs, &b)
  Array.each(xs, &b)
  nil
end
each_twice(Any["a", "b"]) { |s| print(s) }
puts

$ sake block_optional.sake
INFO plain
INFO built only when logged: 6
6
14
abab

class Point               # a type with two fields, read-only from outside
  attr_reader x, y
  def add(a, b) = Point.new(@x + Point.x(b), @y + Point.y(b))
  def norm2(p) = @x * @x + @y * @y           # @x: field x of the first argument, Point.x(p)
  def to_s(p) = "(#{@x}, #{@y})"             # used by puts and "#{...}"
end

class Counter
  attr_reader name
  attr_accessor count
  def initialize(c) = @count = 0
  def bump(c) = @count += 1                  # inside the class, @count += 1 writes the field
end

a = Point.new(1, 2)                          # an instance: one argument per field
b = Point.add(a, Point.new(3, 4))
puts(b)
p(b)                                         # p shows the fields
p([Point.norm2(b), Point.x(b)])
p(a == Point.new(1, 2))                      # == compares the fields

c = Counter.new("hits")                      # count takes its default
d = c                                        # the same instance: values are shared, not copied
Counter.bump(d)
Counter.set_count(c, Counter.count(c) + 10)   # accessor: writable from outside too
p(c)

$ sake instances.sake
(4, 6)
#<struct Point x=4, y=6>
[52, 4]
true
#<struct Counter name="hits", count=11>

# initialize(c) runs after T.new has stored the fields: checks and conversions on every construction.
class Config
  attr_reader host, port
  def initialize(c)
    @port = 80 if @port == nil
    @port => Integer
    @host = String.downcase(@host)
  end
  def next_port(c) = @port + 1
end
p(Config.new("EXAMPLE.com"))
p(Config.new("h", 8080).next_port)

class Temp
  attr_reader celsius
  def initialize(t) = @celsius = Float(@celsius)    # a conversion: the field is always a Float
end
p(Temp.new(20))
p(Temp.new("21.5"))
Config.new("h", "eighty")      # reported for this call

$ sake initialize.sake
initialize.sake:6:5: error: `=> Integer`: the value is String, which does not match [type]
  hint: reached by the call at line 20
(exit status 2)

# B < A: A's definitions written again in B. Point3 is not a Point.
class Point
  attr_reader x, y
  def sum(pt) = @x + @y
  def describe(pt) = "#{name(pt)}(#{@x}, #{@y}) sum=#{sum(pt)}"
  def name(pt) = "Point"
end
class Point3 < Point
  attr_accessor z
  def initialize(p)
    @z = 0 if @z == nil
  end
  def sum(pt) = @x + @y + @z
  def name(pt) = "Point3"
end
class ParseError < Exception
  attr_reader line
end
puts(Point.describe(Point.new(1, 2)))
puts(Point3.describe(Point3.new(1, 2, 3)))
p(Point3.new(4, 5))
begin
  raise ParseError.new("bad", 3)
rescue ParseError => e
  p([Exception.message(e), e.ParseError.line])
end

$ sake class_paste.sake
Point(1, 2) sum=3
Point3(1, 2) sum=6
#<struct Point3 x=4, y=5, z=0>
["bad", 3]

Point = Struct.new(:x, :y)

class Point
  def add(a, b) = Point.new(x(a) + x(b), y(a) + y(b))
  def to_s(p) = "(#{x(p)}, #{y(p)})"       # used by puts and "#{...}"
end

def Point.scale!(p, k)           # same as defining `scale!` inside `class Point`
  set_x(p, x(p) * k)
  set_y(p, y(p) * k)
  p
end

a = Point.new(1, 2)
b = a                             # b and a are the same value
Point.scale!(b, 10)
puts(a)                           # uses Point.to_s; the change through b is visible through a
puts("sum: #{Point.add(a, Point.new(5, 5))}")
p(a)
puts(Point.x(a))

$ sake data.sake
(10, 20)
sum: (15, 25)
#<struct Point x=10, y=20>
10

Point = Struct.new(:x, :y)

class Point
  def norm2(p) = @x * @x + @y * @y           # @x is Point.x(p): p is the first argument
  def move(p, dx, dy)
    @x += dx                                 # Point.set_x(p, Point.x(p) + dx)
    @y += dy
    p
  end
end

pt = Point.new(3, 4)
puts(Point.norm2(pt))
Point.move(pt, 1, 1)
p(pt)
puts(Point.norm2(7))

$ sake data_shorthand.sake
data_shorthand.sake:4:18: error: Point.x: argument 1 must be Point, but is Integer [type]
  hint: reached by the call at line 16
data_shorthand.sake:4:23: error: Point.x: argument 1 must be Point, but is Integer [type]
  hint: reached by the call at line 16
data_shorthand.sake:4:28: error: Point.y: argument 1 must be Point, but is Integer [type]
  hint: reached by the call at line 16
data_shorthand.sake:4:33: error: Point.y: argument 1 must be Point, but is Integer [type]
  hint: reached by the call at line 16
(exit status 2)

class Point
  attr_reader x, y
end
pt = Point.new(1, 2)
puts(pt.x)
Point.set_x(pt, 5)
puts(Point.z(pt))
puts(Point.new(1))

$ sake instance_errors.sake
instance_errors.sake:5:9: error: method call on a value `pt.x` is not allowed
  hint: Point.x(pt)
instance_errors.sake:6:7: error: field `x` of Point is read-only (attr_reader)
  hint: inside `class Point`, use `@x = value`; or declare it with `attr_accessor x`
instance_errors.sake:7:12: error: undefined function `Point.z`
instance_errors.sake:8:12: error: wrong number of arguments for Point.new (given 1, expected 2)
(exit status 2)

Point = Struct.new(:x, :y)
Line = Struct.new(:from, :to)

def length(l)
  dx = Point.x(Line.to(l)) - Point.x(Line.from(l))
  dy = Point.y(Line.to(l)) - Point.y(Line.from(l))
  Math.sqrt(dx * dx + dy * dy)
end

puts(length(Line.new(Point.new(0, 0), Point.new(3, 4))))
puts(length(Point.new(3, 4)))

$ sake data_runtime_error.sake
data_runtime_error.sake:5:16: error: Line.to: argument 1 must be Line, but is Point@L11 [type]
  hint: reached by the call at line 11
(exit status 2)

$ sake --strict=0 data_runtime_error.sake
5.0
data_runtime_error.sake:5: in length: TypeError: Line.to: argument 1 must be Line, got Point
  from data_runtime_error.sake:11: in <main>
(exit status 1)

module Geometry                              # a module: functions only, no instances
  module_function
  def dist2(ax, ay, bx, by) = (ax - bx) ** 2 + (ay - by) ** 2
end

module Shape                                 # a mixin: what includers share, and what they must define
  def area(s) = raise(NotImplementedError)
  def describe(s) = "area #{area(s)}"        # area: the includer's own
end

class Square              # a class: a type, with instances
  attr_reader side
  include Shape
  def area(q) = @side * @side
end

class Disc
  attr_reader r
  include Shape
  def area(d) = 3 * @r * @r
end

p(Geometry.dist2(0, 0, 3, 4))
puts(Square.describe(Square.new(2)))         # Square's describe, borrowed from Shape
puts(Shape.describe(Disc.new(1)))            # dispatch: the describe of the argument's type

$ sake class_module.sake
25
area 4
area 3

module Summary                       # mixin functions: they need `each` and `count` from the includer
  def total(c)
    sum = 0
    each(c) { |x| sum += x }
    sum
  end
  def average(c) = total(c) / count(c)
end

class Basket     # `class` adds operations to a type
  attr_reader items
  include Summary
  def each(b) = Array.each(@items) { |x| yield(x) }
  def count(b) = Array.size(@items)
end

class Countdown
  attr_reader n
  include Summary
  def each(c) = Integer.downto(@n, 1) { |i| yield(i) }
  def count(c) = @n
end

module Units                         # `module_function`: called directly, as Units.km
  module_function
  def km(m) = m / 1000.0
end

b = Basket.new(Any[3, 4, 5])
puts(Basket.total(b))                # static: Basket's total (borrowed from Summary)
puts(Summary.total(Countdown.new(4)))  # dispatch: the total of the argument's type
puts(Units.km(2500))

$ sake modules.sake
12
10
2.5

module Shape                             # a body of only `raise NotImplementedError`: each includer defines it
  def area(s) = raise(NotImplementedError)
  def describe(s) = "area #{Shape.area(s)}"
end
Square = Struct.new(:side)
class Square
  include Shape
  def area(q) = @side * @side
end
Circle = Struct.new(:r)
class Circle
  include Shape                          # forgot area
end
puts(Shape.describe(Square.new(2)))
puts(Shape.describe(Circle.new(1)))

$ sake required_errors.sake
required_errors.sake:3:29: error: Shape.area: Circle includes Shape but does not define area, which Shape requires (`raise NotImplementedError`) [type]
  hint: define `def area(...)` in class Circle
  hint: reached by the call at line 15
(exit status 2)

module Summary
  def total(c) = each(c) + 1
end
module Empty
  include Summary
end
puts(Summary.total(1))

$ sake module_errors.sake
module_errors.sake:5:3: error: `include Summary` in Empty: Summary.total needs `each`, which Empty does not define (used at line 2)
module_errors.sake:7:14: error: Summary.total is a mixin function, and no type includes Summary
  hint: to call it as Summary.total(...), mark it with `module_function`
(exit status 2)

class Money
  attr_reader cents
  include Arithmetic
  include Comparable
  def +(a, b) = Money.new(@cents + Money.cents(b))
  def <=>(a, b) = @cents <=> Money.cents(b)
  def to_s(m) = "$#{@cents / 100}.#{String.rjust(Integer.to_s(@cents % 100), 2, "0")}"
end
a = Money.new(150)
b = Money.new(275)
puts(a + b)
p(a < b)
p(Array.sort(Any[b, a]))
p(Array.max(Any[a, b]))
p(a == Money.new(150))
p(Array.include?(Any[a], Money.new(150)))
class Grid
  attr_reader cells
  include Indexable
  def [](g, k) = Array.at(@cells, k)
  def []=(g, k, v)
    Array.[]=(@cells, k, v)
  end
end
g = Grid.new(Any[1, 2, 3])
g[1] = 20
g[2] += 1
p(Any[g[0], g[1], g[2]])

$ sake operators.sake
$4.25
true
[#<struct Money cents=150>, #<struct Money cents=275>]
#<struct Money cents=275>
true
true
[1, 20, 4]

Leaf = Struct.new(:weight)
Node = Struct.new(:weight, :left, :right)

# The operation lists the types its argument may have.
def weight(t) = (Leaf|Node).weight(t)
def size_of(x) = (String|Array).size(x)

puts(weight(Leaf.new(3)) + weight(Node.new(5, Leaf.new(1), Leaf.new(1))))
puts(size_of("sake") + size_of(Any[1, 2]))
puts(size_of(42))

$ sake union_call.sake
union_call.sake:6:18: error: (String|Array).size: argument 1 must be String or Array, but is Integer [type]
  hint: reached by the call at line 10
(exit status 2)

def label(x) = "top: #{x}"

module Door
  module_function
  def open(d) = label("door")              # Door.label wins over the top-level label
  def label(x) = "door: #{x}"
  def show(d) = puts(open(d))              # Door.open wins over the top-level open
end

def open(x) = label("top")

Door.show(1)
puts(open(1))
puts(Door.open(1))

$ sake scope.sake
door: door
top: top
door: door

pair = [1, "one"]                 # a literal is a Tuple
n, word = pair
puts(word)
puts(Tuple.size(pair))

xs = Any[1, "two", 3.0]         # Any[...] has no declared element type
Array.push(xs, nil)
p(xs)

ws = String.split("to be or not to be", " ")
p(ws)
puts(Array.map(ws) { String.capitalize(it) }.join(" "))

fs = Float[]                      # T[...] declares the element type
Array.push(fs, 1.5, 2.5)
puts(Array.sum(fs))
Array.push(fs, 3)

$ sake collections.sake
collections.sake:17:1: error: Array.push: an element must be Float, but is Integer [type]
(exit status 2)

def stats(xs)
  total = Array.sum(xs)
  {count: Array.size(xs), total: total, mean: total / Array.size(xs)}
end

r = stats(Any[3, 5, 10])
p(r)
r => {mean:, count: n}        # take fields apart by name
puts(mean)
puts(n)
p({y: 2, x: 1})               # field order does not matter
r => {median:}

$ sake records.sake
records.sake:12:7: error: the pattern needs field `median`, but the value is {count: Integer, mean: Integer, total: Integer} [type]
(exit status 2)

squares = []                  # a Tuple of length 0, not an Array
Integer.times(3) { |i| Array.push(squares, i * i) }

$ sake ruby_habits.sake
ruby_habits.sake:2:24: error: Array.push: argument 1 must be Array, but is [] [type]
  hint: `[...]` is a Tuple with a fixed length; for a growable Array, write `Any[...]`
(exit status 2)

counts = {}
names = {"a" => 1}

$ sake empty_braces.sake
empty_braces.sake:1:10: error: `{}` is an empty Record, not a Hash
  hint: for a Hash, write `Hash.new`; for a growable list, `Any[]`
empty_braces.sake:2:10: error: `{"a" => ...}` is not a Hash in Sake: `{name: value}` makes a Record
  hint: for a Hash, write `Hash.of("a" => ...)`
(exit status 2)

words = String.split("the quick brown fox", " ")
p(words[0])
p(words[-1])
p(words[10])                   # outside the Array: nil, as in Ruby
words[1] = "slow"
p(words)

counts = Any[0, 0, 0]
counts[1] += 1
p(counts)

t = [1, "one"]
t[0] = 2                       # a Tuple keeps the type of each position
p(t)

best = nil
best ||= Array.max(Any[3, 9, 4])
p(best)
p(t[2])                        # a Tuple's length is part of its type

$ sake indexing.sake
indexing.sake:19:3: error: Indexable.[]: the index is outside the Tuple [Integer, String] [type]
(exit status 2)

Point = Struct.new(:x, :y)
ps = Point[1, 2]

$ sake typed_array_errors.sake
typed_array_errors.sake:2:12: error: Point[]: element 1 must be Point, got Integer
  hint: Point.new(1, 2) creates one Point; Point[...] is an Array of Point
(exit status 2)

grid = Array.new(3, 0)                 # three zeros; Array.new(3) { |i| i * i } computes each
squares = Array.new(4) { |i| i * i }
p([grid, squares])
p([Any[1, 2] + Any[3], Any[1, 2, 2, 3] - Any[2], Any[0] * 3])
a = Any[1, 2, 3]
a[0], a[2] = a[2], a[0]                # swap: elements (and fields) can be assignment targets
p(a)
p("sake-lang"[0, 4])                   # two indexes: start and length
key, value, extra = String.split("lang=sake", "=")   # missing elements are nil, as in Ruby
p([key, value, extra])
prices = Float[1.25, 2.5]
p(Array.sum(prices, 0.0))              # the start value: an empty Array sums to 0.0, not 0

$ sake arrays_more.sake
[[0, 0, 0], [0, 1, 4, 9]]
[[1, 2, 3], [1, 3], [0, 0, 0]]
[3, 2, 1]
"sake"
["lang", "sake", nil]
3.75

events = Tuple[]                         # an Array of Tuples, filled below
Array.push(events, [:deposit, 500])
Array.push(events, [:note, "rent due"])
Array.push(events, [:withdraw, 120])
balance = 0
Array.each(events) do |kind, arg|
  case kind                              # the Symbol tag tells which Tuple it is,
  in :deposit then balance += arg        # so here arg is an Integer
  in :withdraw then balance -= arg
  in :note then puts("note: #{String.upcase(arg)}")  # and here a String
  end
end
p(balance)

$ sake tagged.sake
note: RENT DUE
380

def labels(n)
  out = Any[]                          # any element type: it is whatever gets pushed
  Integer.times(n) { |i| Array.push(out, "#{i}") }
  out
end
p(Array.sum(labels(3)))                  # the mistake shows up here, far from the push

$ sake elements_untyped.sake
elements_untyped.sake:6:3: error: Array.sum: an element must be Integer|Float|Rational|Complex, but is String [type]
(exit status 2)

def labels(n)
  out = Integer[]                        # an Array of Integer
  Integer.times(n) { |i| Array.push(out, "#{i}") }  # the mistake shows up where it is made
  out
end
p(Array.sum(labels(3)))

$ sake elements_typed.sake
elements_typed.sake:3:26: error: Array.push: an element must be Integer, but is String [type]
  hint: reached by the call at line 6
(exit status 2)

s = "key=value; name=Sake; lang=ruby"
p(String.index(s, "="))            # a position
p(String.index(s, "=", 4))         # searching from position 4
m = Regexp.match(/(\w+)=(\w+)/, s, 11)   # matching from a position
p([m[1], m[2]]) if m
p(String.gsub(s, /(\w+)=/) { |kv| String.upcase(kv) })  # a block gives each replacement
p(String.gsub("cat hat", /[ch]at/, Hash.of("cat" => "dog", "hat" => "cap")))
p(String.split(s, "; "))
p(format("%-6s|%5.2f|%03d", "ab", 3.14159, 7))
p(String.bytes("é"))                  # UTF-8 bytes
p(String.unpack("\x01\x00\x02\x00", "v*"))  # binary data, as Ruby's unpack
p(Array.pack(Any[72, 105], "C*"))

$ sake strings.sake
3
15
["name", "Sake"]
"KEY=value; NAME=Sake; LANG=ruby"
"dog cap"
["key=value", "name=Sake", "lang=ruby"]
"ab    | 3.14|007"
[195, 169]
[1, 2]
"Hi"

text = "the cat and the hat and the bat"
counts = Hash.new(0)
Array.each(String.split(text, " ")) { |w| counts[w] += 1 }
p(counts)
top = Hash.max_by(counts) { |w, n| n }
p(top)
p(Array.tally(String.chars("banana")))

ages = Hash.of("ann" => 31, "bob" => 25)
ages["cy"] = 40
Hash.each(ages) { |name, age| puts(format("%-4s %3d", name, age)) }
p(ages["nobody"])                        # a missing key gives nil
p(Hash.fetch(ages, "nobody", 0))

p(Range.to_a(1..5))
p(Range.select(1..20) { it % 7 == 0 })
p(Any[10, 20, 30, 40][1..2])

seen = Set.new
Array.each(Any[3, 1, 3, 2, 1]) { Set.add(seen, it) }
p(seen)

m = String.match("2026-10-01", /(\d+)-(\d+)-(\d+)/)
p(MatchData.captures(m)) if m
p(String.scan("a1b22c333", /\d+/))
p(:ok)

$ sake ruby_types.sake
{"the" => 3, "cat" => 1, "and" => 2, "hat" => 1, "bat" => 1}
["the", 3]
{"b" => 1, "a" => 3, "n" => 2}
ann   31
bob   25
cy    40
nil
0
[1, 2, 3, 4, 5]
[7, 14]
[20, 30]
Set[3, 1, 2]
["2026", "10", "01"]
["1", "22", "333"]
:ok

Node = Struct.new(:value, :next)

def build(n)
  head = nil
  Integer.downto(n, 1) { |i| head = Node.new(i, head) }
  head
end

def sum(node)
  total = 0
  while node                      # nil and false are the only falsy values
    total += Node.value(node)
    node = Node.next(node)
  end
  total
end

def second(node)
  rest = Node.next(node)
  return 0 if rest == nil
  Node.value(rest)
end

list = build(4)
puts(sum(list))
puts(second(list))
puts(Node.next(list) == nil)
puts(Node.next(list).next.next.next.value)

$ sake nil.sake
10
2
false
nil.sake:28: in <main>: TypeError: Node.value: argument 1 must be Node, got nil
  hint: Node.next may be nil (nil is stored at line 5)
  hint: check the value first: `if x`, `while x`, `return unless x`, or `x != nil`
(exit status 1)

Node = Struct.new(:value, :next)

def second(node) = Node.next(node).value

def second_checked(node)
  rest = Node.next(node)
  rest ? Node.value(rest) : 0
end

list = Node.new(1, Node.new(2, nil))
puts(second(list))
puts(second_checked(list))

$ sake strict.sake
2
2

$ sake --strict strict.sake
2
2

ParseError = Exception.new(:line)        # an exception type: message, then its own fields

def parse(s)
  raise ParseError.new("empty input", 1) if String.empty?(s)
  raise ArgumentError, "too long" if String.size(s) > 5
  String.to_i(s)
end

Array.each(Any["", "123456", "42"]) do |s|
  begin
    p(parse(s))
  rescue ParseError => e                 # list the types to rescue (a module groups several)
    puts("line #{ParseError.line(e)}")
  rescue ArgumentError => e
    puts(Exception.message(e))
  ensure
    puts("--")
  end
end

def safe_div(a, b)
  a / b
rescue ZeroDivisionError
  0
end
p(safe_div(1, 0))
v = Hash.of("a" => 1).fetch("b") rescue -1
p(v)

$ sake exceptions.sake
line 1
--
too long
--
42
--
0
-1

$ sake --strict=4 exceptions_flow.sake
exceptions_flow.sake:11:1: warning: rescue OtherError: the begin body never raises OtherError [unused-rescue]
  hint: remove this rescue, or raise OtherError in the body
exceptions_flow.sake:5:3: error: raise: ParseError may reach the top level without being rescued [unrescued]
  hint: rescue it, or check with a level below 4
(exit status 2)

# Sake has no value constants. `once { ... }` computes a value the first time its place runs and
# keeps it for the whole program: a table built once, read by every call.
def squares = once do
  puts("building the table")
  Array.map(Range.to_a(0..9)) { |i| i * i }
end
def weekday(i) = once { String["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] }[i % 7]

p(squares[4])
p(Array.sum(squares))     # the same table: "building" is printed once
p(weekday(1))
p(weekday(10))

$ sake once.sake
building the table
16
285
"Mon"
"Wed"

# require "json" reads json.sake next to this file, or else Sake's library sakelib/json.sake.
require "json"
require "base64"

data = JSON.parse("{\"name\": \"Sake\", \"tags\": [\"ruby\", \"types\"]}", symbolize_names: true)
p(data)
puts(JSON.generate(Hash.of(ok: true, n: Any[1, 2])))
puts(JSON.pretty_generate(Hash.of("a" => Any[1, 2])))
p(Base64.strict_encode64("Sake"))
p(ARGV)             # the program's arguments: bin/sake libraries.sake a b
warn("a warning goes to stderr")

$ sake libraries.sake
{name: "Sake", tags: ["ruby", "types"]}
{"ok":true,"n":[1,2]}
{
  "a": [
    1,
    2
  ]
}
"U2FrZQ=="
[]
a warning goes to stderr

# IO values: IO.stdin, IO.stdout, IO.stderr, and File.open. One type, IO, for all of them.
def report(io, title, rows)
  IO.puts(io, "== #{title}")
  Array.each(rows) { |k, v| IO.puts(io, format("%-5s %3d", k, v)) }
end

rows = Any[["ann", 31], ["bob", 25]]
report(IO.stdout, "to stdout", rows)
path = "io_example.tmp"
File.open(path, "w") { |f| report(f, "to a file", rows) }  # closed after the block
File.open(path) do |f|
  p(IO.gets(f))
  p(IO.readlines(f))
end
File.delete(path)

$ sake io.sake
== to stdout
ann    31
bob    25
"== to a file\n"
["ann    31\n", "bob    25\n"]

# Threads share the variables around their block; a Queue passes values between them.
q = Queue.new
workers = Array.map(Range.to_a(1..3)) do |id|
  Thread.new do
    sum = 0
    Range.each(1..(id * 100)) { |i| sum += i }
    Queue.push(q, [id, sum])
  end
end
Array.each(workers) { |t| Thread.join(t) }
results = Array.new(3) { Queue.pop(q) }.sort
p(results)
lock = Mutex.new
count = 0
ts = Array.map(Range.to_a(1..4)) { Thread.new { Integer.times(1000) { Mutex.synchronize(lock) { count += 1 } } } }
Array.each(ts) { |t| Thread.join(t) }
p(count)

$ sake threads.sake
[[1, 5050], [2, 20100], [3, 45150]]
4000

Item = Struct.new(:name, :price, :qty)

def total(items) = Array.reduce(items, 0) { |acc, it| acc + Item.price(it) * Item.qty(it) }

items = Item[Item.new("apple", 120, 3), Item.new("pear", 200, 1)]
puts(total(items))
cheap = Array.select(items) { Item.price(it) < 150 }
puts(Array.map(cheap) { Item.name(it) }.join(", "))

$ sake types.sake
560
apple

$ sake --types types.sake
passes: 2
checks: proven=13 partial=0 error=0 unknown=0
sites: arrays 3, structs 2 (Item 2); instantiations 1
arrays:
  L5: declared Item
  L7 Array.select: init Item -> Item
  L8 Array.map: init String -> String
fields:
  Item@L5.name: String
  Item@L5.price: Integer
  Item@L5.qty: Integer
  Item@L5.name: String
  Item@L5.price: Integer
  Item@L5.qty: Integer

$ sake --types strict.sake
passes: 2
checks: proven=4 partial=0 error=0 unknown=0
sites: arrays 0, structs 2 (Node 2); instantiations 2
arrays:
fields:
  Node@L10.value: Integer
  Node@L10.next: nil
  Node@L10.value: Integer
  Node@L10.next: Node@L10

class Account   # read-only from outside; changed only below
  attr_reader owner, balance, history
  def open(owner) = Account.new(owner, 0, Tuple[])     # the history holds Tuples

  def deposit(acct, amount)
    @balance += amount
    Array.push(@history, [:deposit, amount])
    acct
  end

  def withdraw(acct, amount)
    if @balance < amount
      Array.push(@history, [:refused, amount])
      return false
    end
    @balance -= amount
    Array.push(@history, [:withdraw, amount])
    true
  end

  def statement(acct)
    puts("Statement for #{@owner}")
    Array.each(@history) do |kind, amount|
      puts(format("  %-10s%6d", kind, amount))
    end
    puts(format("  %-10s%6d", "balance", @balance))
  end
end

alice = Account.open("Alice")
Account.deposit(alice, 500)
Account.withdraw(alice, 120)
Account.withdraw(alice, 1000)
Account.statement(alice)

$ sake bank.sake
Statement for Alice
  deposit      500
  withdraw     120
  refused     1000
  balance      380

Point = Struct.new(:x, :y)
PI = 3.14159
class Point
  def origin = self
end
eval("1 + 1")

$ sake forbidden.sake
forbidden.sake:2:1: error: Sake has no value constants; a constant names a class (`Point = Struct.new(:x, :y)`, `Err = Exception.new(:msg)`), and a value goes in a function
  hint: define a function instead: `def pi = 3.14159`
forbidden.sake:4:16: error: Sake has no `self`
forbidden.sake:6:1: error: `eval` is not allowed in Sake (it defeats static analysis)
(exit status 2)