a.md

The example runs, as long as you use the included prelude (it really only needs the first couple of lines):

$ ruby -rprelude alias.rb

input.roy

// Alias for a primitive type
type Int = Number

// Alias for a structural type
type Person = {name: String, age: Int}

// Function with aliased type annotation
let personName (p: Person) = p.name
console.log (personName {name: "Brian", age: 21})

// Value with aliased type annotation
let ben: Person = {name: "Ben", age: 18}
let anyName a = a.name
console.log (anyName ben)

output.rb

# encoding: utf-8
# // Alias for a primitive type
# // Alias for a structural type
# // Function with aliased type annotation
personName = lambda do |p|
    return p.name;
end;
console.log[(personName[OpenStruct.new({
    "name" => "Brian",
    "age" => 21
})])];
# // Value with aliased type annotation
ben = OpenStruct.new({
    "name" => "Ben",
    "age" => 18
});
anyName = lambda do |a|
    return a.name;
end;
console.log[(anyName[ben])];

prelude.rb

# encoding: utf-8
eval("require 'ostruct'");
eval("def console; OpenStruct.new(log: lambda { |*x| puts x.join(' ') }); end");
id = lambda do |a|
    return a;
end;
flip = lambda do |f, a, b|
    return f[b, a];
end;
not_ = lambda do |a|
    return         (if (a) then
            false;
        else
            true;
        end
    );
end;
even = lambda do |a|
    return (a % 2) == 0;
end;
odd = lambda do |a|
    return not_[(even[a])];
end;
succ = lambda do |n|
    return n + 1;
end;
pred = lambda do |n|
    return n - 1;
end;
# //let compose f g = λx → f (g x)
# //let ∘ = compose
# //let elem =
# //let ∈ = elem
# //let ∉ = not_ ∘ elem
# //let negate n = -n
# // List type
# // data List a = Cons a (List a) | Nil
# // let map f l = match l
# //   case (Cons v r) = Cons (f v) (map f r)
# //   case Nil = Nil
# // let filter f l = match l
# //   case (Cons v r) = if (f v) then
# //       Cons v r
# //     else
# //       r
# //   case Nil = Nil
# // let head l = match l
# //   case (Cons v _) = v
# // let tail l = match l
# //   case (Cons _ r) = r
# //   case Nil = Nil
# // let empty l = match l
# //   case (Cons a b) = false
# //   case Nil = true
# // let length l = match l
# //   case (Cons _ r) = 1 + (length r)
# //   case Nil = 0
# // let foldl f i l = match l
# //   case (Cons v r) = foldl f (f i v) r
# //   case Nil = i
# // let replicate n v =
# //   if (n == 0) then
# //     Nil
# //   else
# //     Cons v (replicate (n - 1) v)
# // let take n l = match l
# //   case (Cons v r) = if n == 0 then
# //       Nil
# //     else
# //       Cons v (take (n - 1) r)
# //   case Nil = Nil
# // Option type
class Some < Struct.new(:_0); def self.[](a_0); Some.new(a_0); end; end;;
class None; def self.[](); None.new(); end; end; ;
maybe = lambda do |n, f, o|
    return lambda {
        if(o.is_a?(Some))
            s = o._0;
            return f[s];
        end        
if(o.is_a?(None))
            return n;
        end
    }.call;
end;
optionMonad = OpenStruct.new({
    "return" => lambda do |x|
        return Some[x];
    end,
    "bind" => lambda do |x, f|
        return lambda {
            if(x.is_a?(Some))
                a = x._0;
                return f[a];
            end            
if(x.is_a?(None))
                return None;
            end
        }.call;
    end
});
# // Either type.
class Left < Struct.new(:_0); def self.[](a_0); Left.new(a_0); end; end;;
class Right < Struct.new(:_0); def self.[](b_0); Right.new(b_0); end; end;;
# // Math constants.
π = Math::PI;
π2 = π * 2;
# // tauday.com
τ = π2;