kuroko/test.krk

#!/home/klange/Projects/kuroko/kuroko
import system
# You may want to look at this in an editor with the syntax highlighting
# set to Python. Not even bim has a highlighter for Kuroko yet.

if False:
    print "Kuroko has Python-style syntax"
    print "with significant whitespace."

    print "Blank lines are ignored."
    # Comments should work, too.
    print "None of this should print, since it's in an `if False:`"

# Coincidentally, Lox has a print statement like Python 2 did.
# I don't know if I'll keep it (haven't we all moved on to Python 3?)
# but for now it's what we have. You _can_ put parens around print values,
# including immediately after the 'print' token, and it'll work just fine.
# Actually the way the scanner works, there's a lot of stuff that doesn't
# need whitespace even though you might think it should have it...
print "This is the first line that should print."

# Concatenation currently requires the first argument be a string.
# Other values then get converted to strings as you go.
print "We can do simple concatenation " + 123 + "."

# Lox only has a 'Number' type for numerical values, but we have
# Integer and Floating to separate the two.
print 4.2 * 9.7 # Should be 40.74
print 1 + 2 + 3

# Other bases:
print "Hex: " + 0xFF + " Octal: " + 0o123 + " Binary: " + 0b1010

# This `for init, cond, step:` syntax is possibly temporary? I do intend to
# implement iterators and `for VAR in ITER:` like in Python, but C-style for
# loops are also useful...
for i = 0, i < 10, i = i + 1:
    print "i = " + i

# Functions work like in Python, though currently no default values.
def function(arg): # And of course the parser will handle comments here...
    print "This is a function that does a thing!"
    if arg == "demo": # Or here...
        print "You passed 'demo' as an argument!"
    else: # And definitely here.
        print "You passed something else."
    return 42

print "This code is after the function definition"

# While I'm following the book, variable declarations are explicit with `let`.
# I don't know if I want to implement Python's scoping rules, which are a bit
# ... different from other languages in that lots of control flow that you
# would normally think of as introducing scope does not do so in Python. For
# now we're following traditional scoping rules, and a simple `let foo` at
# the head of the appropriate block should work okay.
let result = function("demo")
print "The function call returned: " + result

# `sleep()` is a native function bind. Lox has `clock` as an example, but I
# figured something with arguments would be more useful? The purpose of this
# language is to be used for writing syntax highlighters, configs, and also
# plugins for bim, so native bindings are going to be very important.
result = system.sleep(0.1)

print "Call to sleep returned: " + result

function("something else")

# This is some stuff to test closures
class Funcs:

let funcs = Funcs()
if True:
    let a = 1
    def f():
        print a
    let b = 2
    def g():
        print b
    let c = 3
    def h():
        print c
    funcs.f = f
    funcs.g = g

funcs.f()
funcs.g()

def outer(): # test
    #foo
    #multiple lines
    let x = "outside"
    def inner():
        print x
    return inner

print "Function is defined, creating it..."
let closure = outer()
print "And executing the result..."
# This should correctly print "outside"
closure()

# This is surprisingly similar to Python already...
print "Let's do some classes."
class Test: # This is a test class
    # `self` is actually optional - it's implictly passed.
    # If you include it in a parameter list, it's completely ignored.
    def __init__(self):
        self.foo = "bax"

    # Look, a method!
    def doAThing():
        print "yay: " + self.foo

print Test
let test = Test()
print test
test.doAThing()
test.foo = "bar"
print test.foo
print test.doAThing
test.doAThing()


class SuperClass():
    def __init__(self):
        self.a = "class"
    def aMethod(self):
        print "This is a great " + self.a + "!"
    def __str__(self):
        return "(I am a " + self.a + ")"
    def __get__(self, ind):
        return "(get[" + ind + "])"
    def __set__(self, ind, val):
        print "(set[" + ind + "] = " + val + ")"

class SubClass(SuperClass):
    def __init__(self):
        self.a = "teapot"

let subclass = SubClass()
subclass.aMethod()

# Nope
#print self
# Also nope
#def notAMethod():
#    print self
# Definitely nope
#def notAMethoDeither(self):
#    print self

print "Subclass says: " + subclass

subclass.__get__(123)
print subclass[123]
subclass[456] = "test"

print "Let's make a hashmap:"
let hash = system.HashMap()
hash["hello"] = "world"
print hash["hello"]

print "Let's make some lists:"
let list = system.List()
print "Length before: " + list.length()
list.append(1)
list.append(2)
list.append(3)
print "Length after: " + list.length()
for j = 0, j < list.length(), j = j + 1:
    print "j=" + j + ", list[j]=" + list[j]

print "Can we call properties of strings?".length

return 0