The first language I made.
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
toy_lang list all bulitin funcs and classes Sep 5, 2018
LICENSE
README.md
index.html

README.md

Toy Lang

Toy lang was started from a gist. It's the first language I made. ES6 modules support is required.

  • Keywords: if, else, while, def, return, and, or, not, new, class, this, arguments, throw, try, catch, nonlocal, switch, case, default, break, import, as, from
  • Literals: 3.14 (number), true, false, 'Hello, World' (string), \r, '\n', '\t', '\\', '\''
  • Operators: new, ., ==, !=, >=, >, <=, <, and, or, not, +, -, *, /, %, &, |, ^, <<, >>
  • Assigns: =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
  • Built-in functions: input, print, println, hasValue, noValue, range, iterate, typeof, isInstance
  • Built-in classes: Object, Module, Class, Function, Number, String, List, Traceable, Exception
  • Comment: #

Play It

Examples (More examples)

  • Hello World
# Is a language easier if 'Hello World' is easier?

import '/lib/toy'

println('Hello World')
println('Hello {0}'.format('World'))
println(String.format('Hello {0}', 'World'))
toy.hello()
  • Multiplication Table
def print_row(n) {
    i = 2
    while i < 10 {
        print('{0}*{1}={2}\t'.format(i, n, i * n))
        i += 1 
    }
    println()
}

iterate(1, 10).forEach(print_row)
  • Tower of Hanoi
def hanoi(n, a, b, c) {
    if n == 1 {
        println('Move sheet from {0} to {1}'.format(a , c))
    } 
    else {
        hanoi(n - 1, a, c, b)
        hanoi(1, a, b, c)
        hanoi(n - 1, b, a, c) 
    }
}

hanoi(3, 'A', 'B', 'C')
  • Factorial
def factorial(n) {
    if n == 0 {
        return 1
    }

    return n * factorial(n - 1)
}

# use \ to wrap long lines
range(1, 6).map(n -> '{0}! = {1}'.format(n, factorial(n))) \
           .forEach(println)
  • Tricolour
def adjust(flags) {
    b = 0
    w = 0
    r = flags.length() - 1
    while flags.get(w) == 'B' and w < flags.length() {
        w += 1
    }
    while flags.get(r) == 'R' and r > 0 {
        r -= 1
    }
    while w <= r {
        switch flags.get(w) {
            case 'W'
                w += 1
            case 'B'
                flags.swap(b, w)
                w += 1
                b += 1
            default
                flags.swap(r, w)
                r -= 1
        }
    }
    return flags
}

flags = 'RWBBWRWR'.split('')
println(adjust(flags))
  • Class
class AccountException(Exception) {
    def init() {
        this.super(Exception, 'init', arguments)
    }
}

class Account {
    # it's a field
    balance = 0 

    def init(number, name) {
        this.number = number
        this.name = name
    }

    def deposit(amount) {
        if amount <= 0 {
            throw new AccountException('must be positive')
        }

        this.balance += amount
    }

    def toString() {
        return '{0}, {1}, {2}'.format(this.number, this.name, this.balance)
    }
}

acct = new Account('123', 'Justin')
acct.deposit(100)

println(acct)

try {
    acct.deposit(-100)
}
catch e {
    e.printStackTrace()
}
  • Built-in Classes
def sum(lt) {
    return 0 if lt.isEmpty() else (lt.get(0) + sum(lt.slice(1)))
}
    
lt = range(1, 11)
println('{0}={1}'.format(lt.join('+'), sum(lt)))

println((new String('aBc')).toUpperCase())
println((new String('aBc')).toLowerCase())
  • Closure
def foo() {
    x = 10
    def inner(y) {
        # closure closes the variable x, not its value
        return x + y
    }
    x = 30 
    return inner
}

f = foo()
println('f(20) is ' + f(20))

def orz() {
    x = 10
    class Inner {
        y = x
        def init(p) {
            # closure closes the variable x, not its value
            this.z = x + p
        }

        def x() {
            # closure closes the variable x, not its value
            return x
        }
    }
    x = 30
    return Inner
}

clz = orz()
obj = new clz(20)

println('obj.x() is ' + obj.x())
println('obj.y is ' + obj.y)
println('obj.z is ' + obj.z)

def foo2(x) {
    def getX() {
        return x
    }

    def setX(v) {
        nonlocal x = v
    }

    return [getX, setX]
}

accessor = foo2(10)
getX = accessor.get(0)
setX = accessor.get(1)

println(getX()) 
setX(100)
println(getX())
  • Lambda expression
max = (n1, n2) -> n1 if n1 > n2 else n2
println(max(10, 20))

# you may also use parentheses to wrap wrapping long lines
([1, 2, 3, 4, 5].filter(elem -> elem >= 2) 
                .map(elem -> elem * 100)   
                .forEach(println))

(range(1, 10)
  .map(n -> range(2, 10).map(i -> '{0}*{1}={2}'.format(i, n, i * n)).join('\t'))
  .forEach(println))

def foo3(x, y) {
    return () -> x + y
}

println(foo3(10, 20)())

def orz() {
    x = 10
    return (y, z) -> x + y + z 
}

println(orz()(100, 200))

# IIFE
(() -> println('XD'))()
(x -> println(x))('XD')
println(((x, y) -> x + y)(1, 2))
  • Mixin
class Ordered {
    def lessThan(that) {
        return this.compare(that) < 0
    }

    def lessEqualsThan(that) {
        return this.lessThan(that) or this.equals(that)
    }

    def greaterThan(that) {
        return not this.lessEqualsThan(that)
    }

    def greaterEqualsThan(that) {
        return not this.lessThan(that)
    }
}

class Circle {
    def init(radius) {
        this.radius = radius
    }

    def compare(that) {
        return this.radius - that.radius
    }

    def equals(that) {
        return this.radius == that.radius
    }
}

Circle.mixin(Ordered)

c1 = new Circle(10)
c2 = new Circle(20)

println(c1.lessThan(c2))
println(c1.lessEqualsThan(c2))
println(c1.greaterThan(c2))
println(c1.greaterEqualsThan(c2))
  • Inheritance 1
class PA {
    def init() {
        println('PA init')
    }

    def ma(x, y) {
        println(x)
        println(y)
    }
}

class PB {
    def mb() {
        println('mb')
    }
}

class C(PA, PB) {
    def init() {
        this.super(PA, 'init')
        println('C init')
    }

    def mc() {
        println('mc')
    }

    def ma(x, y) {
        this.super(PA, 'ma', arguments)
        println('c.ma()')
    }
}

c = new C()
c.ma(10, 20)
c.mb()
c.mc()
  • Inheritance 2
class Ordered {
    def lessThan(that) {
        return this.compare(that) < 0
    }

    def lessEqualsThan(that) {
        return this.lessThan(that) or this.equals(that)
    }

    def greaterThan(that) {
        return not this.lessEqualsThan(that)
    }

    def greaterEqualsThan(that) {
        return not this.lessThan(that)
    }
}

class Circle(Ordered) {
    def init(radius) {
        this.radius = radius
    }

    def compare(that) {
        return this.radius - that.radius
    }

    def equals(that) {
        return this.radius == that.radius
    }
}

c1 = new Circle(10)
c2 = new Circle(20)

println(c1.lessThan(c2))
println(c1.lessEqualsThan(c2))
println(c1.greaterThan(c2))
println(c1.greaterEqualsThan(c2))
  • meta programming 1
println(Object.ownMethods())
Object.deleteOwnMethod('toString')    
println(Object.ownMethods())

def toString() {
    props = this.ownProperties()
    # each prop is a List instance which contains name and value
    return  props.map(prop -> prop.join()).join('\n')
}

o1 = new Object()
o1.x = 1
o1.y = 2
o1.z = 3
println(toString.apply(o1))

(o2 = new Object([
    ['x', 10], 
    ['y', 20]
]))
println(toString.apply(o2))

def foo4(p) {
    return this.x + this.y + this.z + p
}

# The 2nd parameter of the apply method accepts a List instance. 
println(foo4.apply(o1, [40]))
  • meta programming 2
class PA {
    def pa() {
        println('pa')
    }
}

class PB {
    def pb() {
        println('pb')
    }
}

class C {
    def c() {
        println('c') 
    }
}

println(C.parents())
C.parents([PA, PB])
println(C.parents())

(new C()).pa()
(new C()).pb()
(new C()).c()

def toString() {
    return this.class().name()
}

Orz = new Class('Orz', [PA, PB], [toString])
orz = new Orz()
orz.pa()
orz.pb()
println(orz)

openhome.cc