Introduction

Komodo is a programming language to test ideas in a fast and easy way. It is ideal for problems with basic discrete structures, like numbers and words. Komodo tries to make operating with these entities as easy as possible while minimizing the amount of code needed to achieve a successful implementation. Komodo is a scripting language regarding its flexibility, but it is a pretty specific language with a lot of assumptions about how things should be. Komodo is an experimental language, and some of its features are there because I had a personal preference for them.

Komodo draws inspiration from Picat, SETL and the Wolfram Language (I blame my university homework for the last one). It definitely has influence from (wait for it) Python and JavaScript, which are languages that I used for several years before learning more programming paradigms. Komodo is in part a result of my frustrations with these languages.

Komodo is unstable (I just add what I want) and in active development. Here is the source code.

This document is a guide to show how to use Komodo.

Tip: You can search for terms in this document using the 🔍 icon at the top of the page, or pressing the s key.

Installation

Currently, you can install Komodo downloading binaries or building from source.

Download binaries

There are pre-compiled binaries for x86-64 Linux here. If this is not your architecture, you will have to build from source.

You can use this to install Komodo for all users (requires root access):

curl --proto '=https' --tlsv1.2 -sSf https://komodo-lang.org/install.sh | sh

You can also install Komodo (only for your user) with these commands:

wget https://github.com/danilopedraza/komodo/releases/download/v0.4.1/komodo
chmod +x komodo
mv komodo $HOME/.local/bin

Build from source

You can build and install Komodo using the Rust infrastructure. Komodo is not published in crates.io, so you will have to clone the GitHub repository. To run the following commands you must have Rust installed.

git clone https://github.com/danilopedraza/komodo.git
cd komodo/core
cargo build --release
chmod +x target/release/komodo
cp target/release/komodo $HOME/.local/bin

Now you should be able to use Komodo from the command line with the komodo command.

Alternatively, you can try Komodo by running cargo run --all-features in the komodo/core directory.

Using Komodo

There are two ways to use Komodo: by executing files, and by interacting with the REPL. Here, we show you how to do both.

Also, we are going to show you some tools that might be helpful.

Using the REPL

To start the REPL, you just have to type komodo in the terminal. It will show you something like this:

>>> 

You can type a Komodo expression, and it will evaluate it. Let's try something simple:

>>> "Hello, world!"
"Hello, world!"

You can do arithmetic:

>>> 2 + 2
4

You can store values with a let expression:

>>> let a := 1 + 0.5
1.5
>>> a + 0.5
2.0

Executing files

The Komodo interpreter can read files provided by you. You just have to type komodo <path>. Create a file called fib.komodo and put the following in it:

let fib(0) := 0
let fib(1) := 1
let fib(n) := fib(n - 1) + fib(n - 2)

println(fib(10)) # 55

Now, in the same directory where the file is, type komodo fib.komodo.

VSCode Extension

There is a VSCode extension available for Komodo. Right now, it just adds syntax highlighting. It is published in the VS Marketplace and OpenVSX, so you can easily search it in VSCode and VSCodium.

Code examples

If you like to learn by doing or looking at examples, you can find some in the code repository and Rosetta Code.

Programming with Komodo

In this chapter, we will see the basic properties of Komodo and how to use them to build programs. This chapter will show every feature that Komodo offers you, with some examples.

Tip: When a line of code starts with >>> , you should try to copy the code after that and execute it in the REPL to see the results.

Core elements

What is Komodo good at?

The aim of Komodo is to easily express experimental solutions to problems.

What does experimental mean here? They are probably not complete nor correct solutions. When people solve a problem, they usually get to the solution iteratively. They start by some intuition-based guess, and tweak until it satisfies all of the problem's constraints. Komodo wants to make this process easier, making assumptions that are reasonable and offering tools that are convenient.

What is Komodo bad at?

Everything else. We also have to confess that, currently, Komodo is painfully slow. This will probably hurt the user experience and limit the use cases of the language.

Expression-oriented

Komodo is an expression-oriented language, which means that almost everything that you write returns something.

For example, languages like Python or JavaScript have a clear distinction between statements (pieces of code that declare something) and expressions (pieces of code that describe a value). JavaScript has statements like for, if, and let, and expressions like 5 or () => null. You can't do something like let a = (let b = 5);, because the value in the right does not describe a value, and the point of the let statement is to save a value!

In Komodo, we think of this differently. Every piece of code that you write returns something. For example, the expression let a := 1 returns 1, and the expression let chr := 'x' returns 'x'.

Komodo does have some statements, but they are a few.

With pattern matching

Pattern matching is the main mechanism to write rules in Komodo. You can use it when declaring functions. For example, this code computes the 10th Fibonacci number:

let fib(0) := 0
let fib(1) := 1
let fib(n) := fib(n - 1) + fib(n - 2)

fib(10) # 55

This code gives the last element of a list:

let last([val]) := val
let last([first|tail]) := last(tail)

last([1, 2, 3]) # 3

The [first|tail] expression represents a list whose first element is first and tail is a list with the rest. This syntax exists in languages like Prolog, Erlang, and Picat.

With weak typing

komodo does not enforce type rules, so you can pass any type to a function. This feature is motivated for two reasons:

• Komodo does not have mechanisms like polymorphism. Weak typing (with pattern matching) allows to (kinda) solve the same problem that polymorphism solves.

• It enriches pattern matching! And invites you, dear programmer, to use it.

Caching/memoization by default

You can save the result of certain function calls, to avoid repetitive calculations. This is very useful when writing recursive functions. Take the fibonacci example again:

let fib(0) := 0
let fib(1) := 1
let fib(n) := fib(n - 1) + fib(n - 2)

fib(10) # 55

The recursive call repeats a lot of calculations because is calling the same recursive function two times, and they will do the same (leading to exponential growth on the number of calls!). With large enough inputs (something like fib(50)), the program will be unacceptably slow. We can fix this just by adding a word:

let fib(0) := 0
let fib(1) := 1
let memoize fib(n) := fib(n - 1) + fib(n - 2)

fib(10) # 55

Adding memoize before defining a function will save the results computed from that call, so they can used later, when the function is called with the same arguments again.

Types

Komodo has a very simple type system. You cannot create custom types in Komodo. Let's describe all of them and see a few examples.

Numerical types

Komodo has three kinds of numbers, and each of them has their own type: Integers, Floats, and Fractions.

Let's see how to generate, manipulate, and do operations with numbers.

Integers

The Integer type represents a signed, arbitrary size whole number. You can write integers in the following ways:

• In binary form, starting the number with 0b or 0B: 0b10, 0b001, 0B1011,...

  Writing 0b only, with nothing after it, is illegal.

• In octal form, starting the number with 0o or 0O: 0o15, 0O80, 0o01,...

  Writing 0o only is illegal, just like with binary numbers.

• In decimal form, the most common way of describing them: 15, 1, 0,...

  The decimal format does not allow unnecessary zeros: 000 is illegal, as well as 0001, for example.

  Basically, all leading zeros are illegal when you are writing decimal numbers.

• In hexadecimal form, starting the numbers with 0x or 0X: 0xff, 0x1e, 0x01,...

  As you may have guessed, writing 0x alone is illegal.

Komodo implements all the essential arithmetic operations between integers. It also implements bitwise operations.

Even when you can write integers in these formats, Komodo will always print them in decimal by default. For example, if you type 0b1011 in the REPL, like this:

>>> 0b1011

You get the following result:

11

That makes sense: 1011 in binary is just 11 in decimal.

Floats

The Float type represents a double precision floating-point binary number, equivalent at first to the one specified in the IEEE 754 standard. The difference is that floats have arbitrary precision, so they will increase their digits when necessary.

You can write floats as two decimal integers with a dot in between: 0.1, 0.5, 115.2555,...

Komodo implements all the essential arithmetic operations between floats. When you operate an integer and a float, the result will be a float.

Fractions

The Fraction type represents a rational number, a ratio between two integers, where one of them is non-zero.

You can write fractions as two integers separated by the // operator: 0 // 1, 1 // 2, 7 // 3,...

Actually, // is an operator receiving integers as inputs, you can create fractions with non-constant values:

>>> let x := 2
2
>>> x // 3
2 // 3
>>> (5*x) // 7
10 // 7

Characters

The Char type represents any Unicode symbol. You can write chars with single quotes, like this: 'a', '\'', '\\',...

You can "multiply" chars and get a string:

>>> 3*'z'
"zzz"

You can concatenate chars and get a string:

>>> 'a' + 'z'
"az"

Strings

The String type represents a sequence of Unicode symbols. You can write strings with double quotes: "foo", "\"bar\"", "hello world",...

You can make operations between characters and strings:

• You can concatenate strings:

  >>> "ab" + "cd"
  "abcd"
  

• You can concatenate chars and strings:

  >>> "ab" + 'c'
  "abc"
  

• You can "multiply" strings too:

  >>> "F" + "U"*10
  "FUUUUUUUUUU"
  

Tuples

The Tuple type represents an ordered collection of Komodo values. You can write tuples with round parenthesis: (), (1, "foo"),...

The purpose of tuples is to put values together. You can use the empty tuple as a "null" value, which you use to say that is nothing to return. In fact, Komodo builtins use the empty tuple in that way, and some constructions, like for loops, return ().

Lists

The List type represents a sequence of Komodo values. You can add values to lists, which is something you can't do with tuples. You can write lists with square brackets: [], [1, 2], ["foo", 'z', 5.5, []],...

• You can concatenate lists:

  >>> [1, 2] + [3]
  [1,2,3]
  

• You can prepend elements to a list:

  >>> [1|[2, 3]]
  [1,2,3]
  

  This is known as the cons notation. The name comes from a basic function in Lisp.

• You can check if a value is inside the list:

  >>> 1 in [2]
  false
  >>> 1 in [1, 5]
  true
  

• You can write lists by comprehension:

  >>> [x*2 for x in 0..3]
  [0,2,4]
  

Lists are the most basic container in Komodo. They will be very useful.

Sets

The Set type represents an unordered collection of Komodo values. You can write sets with braces: {}, {1, 2}, {1, 1, "2"},...

• You can get the union between two sets:

  >>> {1, 2} + {2, 3}
  {1, 2, 3}
  

• You can get the difference between two sets:

  >>> {1, 2} - {2, 3}
  {1}
  

• You can check if a set is a subset of another:

  >>> {} < {1, 2}
  true
  >>> {1, 2} < {1, 2}
  false
  >>> {1, 2} <= {1, 2}
  true
  >>> {1} <= {1, 2}
  true
  

• You can add elements to a set:

  >>> {5|{"a", 1}}
  {1, 5, "a"}
  

• You can check if a value is an element of a set:

  >>> 0 in {}
  false
  >>> {1} in {0, {1}}
  true
  

• You can write sets by comprehension:

  >>> {k % 2 for k in 0..10}
  {0, 1}
  

Sets are very useful when you do not need an ordered collection, but you do need to join collections frequently, avoid repetitions, and check if some element is inside the collection.

Dictionaries

The Dict type represents a collection of key-value pairs, when keys and values are Komodo values. You can write them as pairs between braces:

{5 => 7, "foo" => "bar", [1, 'x'] => {55, 9}}

Let's say that the variable data has a value of the Dict type. You can get a value from data with its key by writing data[key]:

>>> let data = {"bar" => 1}
{"bar" => 1}
>>> data["bar"]
1

When a key in a Dict is of the String type, You can use another notation:

>>> let data = {"bar" => 1}
{"bar" => 1}
>>> data.bar
1

Functions

Functions are Komodo values. You can pass other values to them (the input), and they are going to return another value that depends on these values (the output).

Functions are the main characters of Komodo: They are the main tool to describe routines and reuse them.

There are two ways of describing functions: named functions and anonymous functions. But first, we'll look at some (named functions) that come pre-implemented and included when you write a Komodo program: the builtin functions.

Builtin functions

Komodo has some built-in functions for basic utilities. Komodo offers more helpful functions in the standard library, but you can do some basic things with these. Let's take a look at them.

I/O Functions

These functions allow you interact with the standard input and output of your system.

• print(value): Prints whatever you pass it. Komodo will convert any Komodo value into its string representation in pass it to standard output.

  Returns an empty tuple ().

  Here is an example:

  >>> print(1)
  1()
  

  The () at the end is strange, but has a reason: print does not put a linebreak after printing, and since we are using the REPL, the return value of print, the empty tuple, is printed afterwards with nothing in between.

• println(value): Prints whatever you pass it, with a linebreak at the end.

  Returns the empty tuple ().

  Here is an example:

  >>> println(0)
  0
  ()
  

  Here's the difference: println puts a linebreak after the 0, so its actual return value goes in a new line. Remember, this is something specific to the REPL. When you execute a file with Komodo code, it will only print what you want to print, by calling print or println.

• getln(): Takes a line from standard input and returns it.

  Here is an example:

  >>> "Hello, " + getln() + "!"
  Danilo # you should type your name in this part, I just put my name
  Hello, Danilo!
  

Assert

This function allows you to make assertions while your program is executing, and to stop it they do not hold.

• assert(value): Takes a Komodo value. When that value is the boolean true, it does nothing. Otherwise the program stops, with an error message saying that the assertion failed. It always returns the empty tuple.

  Here is an example:

  >>> assert(25)
  Failed assertion
  >>> assert(25 % 2 = 1)
  ()
  

• assert(value, msg): Does the same as assert(value), but when if the assertion fails, it adds msg to the error message. msg can be anything, it will be converted into its string representation. It always returns the empty tuple.

  Here is an example:

  let x := 25
  >>> assert(x % 2 = 0, String(x) + " is not an even number")
  

Casting functions

These functions allow to convert values of certain type into types of another. In some cases the types can't be equivalent, so Komodo will do some assumptions about how would you like to transform values. For these cases, the standard library has some functions that allow you to do different transformations.

• Integer(value): Casts any number into an integer. Rounds down when necessary. Fails when you pass it something that is not a number.

• Float(value): Casts any number into a float. It will return the closest approximation. Fails when you pass it something that is not a number.

• List(value): Turns sets and ranges into lists. If you pass it something else, it will fail.

• Set(value): Turns lists and ranges into lists. If you pass it something else, it will fail.

• String(value): Turns any Komodo value into its string representation.

Misc

• len(container): Returns the length of a set or a list. If you pass it something else, it will fail.

• sorted(list): Returns the input list, but sorted. If you pass it something else, it will fail.

Named functions

Named functions are... just that: functions that always have a name.

Let's see the Fibonacci example again:

let f(0) := 0
let f(1) := 1
let f(n) := fib(n - 1) + fib(n - 2)

In this example, each line defines a pattern that the input can match and a result when the input matches. This function can be phrased as:

• When the input of fib is 0, its output is 0.
• When the input of fib is 1, its output is 1.
• When the input of fib is n (something other than 0 or 1), its output is fib(n - 1) + fib(n - 2).

Of course, you can define functions with only one pattern:

let half(n) := n * 0.5

This will work just fine.

The thing with patterns is that defining piecewise functions can become the preferred way of doing things. You can get very comfortable and write stuff like this:

let isZero(0) := true
let isZero(n) := false

This can be cute, but maybe is better to use a simpler approach, like this:

let isZero(n) := n = zero

You can also define a function with more than one line of code:

let fibPrint(n) :=
    let val := fib(n)
    println("fib(" + String(n) + "): " + String(val))
    val

In this example, fib is the function with the same name that we defined above.

Anonymous functions

And... yeah. Anonymous functions are just functions without a name, or functions that don't have a name necessarily.

Let's say you have a list like this:

>>> let data := [5, 24, 9, 1]
[5, 24, 9, 1]

and you want a list with the values of that list multiplied by 2.

There are several ways of doing this. You could use a recursive named function:

let double([]) := []
let double([first|tail]) := [first*2|double(tail)]
assert(double(data) = [10, 48, 18, 2])

This works just fine. You can use an anonymous function to do the same like this:

from utils import map
let double(data) := data.map(val -> val * 2)
assert(double(data) = [10, 48, 18, 2])

Should you prefer one over the other? I think yes. This reason is simple: map is a function that applies a change to all the elements of the list, and that's exactly what we want. The map function, combined with the anonymous function val -> val * 2, gets us a very short implementation that relies on code that was previously written for us in the standard library.

This is the main use of anonymous functions: writing them in-place to pass them to other functions. However, you can do something like this:

let inspect := value ->
    println(value)
    value

You have created a variable called inspect, whose value is... a function. This will just behave like a function. However, you can also do this:

var inspect := value ->
    println(value)
    value

The only difference is that we used the var keyword to create the inspect variable. This makes inspect mutable, so you can do this:

inspect := 1

and this will work just fine.

Pattern matching

Pattern matching is a core functionality of Komodo. The idea is that you should be able to express almost any logic as a pattern and a corresponding action.

You can use patterns almost everywhere.

Destructuring

The first use for pattern matching in Komodo occurs in variable declarations.

Let's imagine you have a list of values like this:

>>> let data := [5, 442, 533, 2, 5334]
[5, 442, 533, 2, 5334]

Maybe you want some values from there. Komodo allows you to do that using pattern matching. You can do this:

>>> let [first, _, _, fourth, ..] := data
[5, 442, 533, 2, 5334]

and then, the variables first and fourth will have the values 5 and 2, respectively:

>>> (first, fourth)
(5, 2)

You can do this with every Komodo value.

With functions

Functions are, in my opinion, the place where using patterns is the most fun and productive. You can use patterns to describe rules easily, doing a lot of work with very little code.

The thing with patterns is that they can do a lot of background work for you, at the cost of describing your problem in a pattern matching compatible way.

Let's see this with an example. We want to reduce the size of a piece of text by applying a transformation. We transform the word

aabcccdd

into the list

[('a', 2), ('b', 1), ('c', 3), ('d', 2)]

Basically, we want to reduce the size of the word by putting every character with the number of times it is repeated. This will save us some space if the word has a lot of repetitions.

If you have tried to do this using loops, conditionals, and an accumulator list, you know that it's kinda tricky. Patterns and recursion offers us a nice, short, and simple solution:

let transform("") := []
let transform([first|tail]) := transform((first, 1), tail)
let transform(tuple, []) := [tuple]
let transform((currentChar, count), [currentChar|tail]) :=
    transform((currentChar, count + 1), tail)
let transform(tuple, tail) := [tuple|transform(tail)]

We just solved the problem in a pattern matching compatible way: every possible case is represented as a pattern and an action to perform when that case appears. The solution is simple and easy to understand for humans, so it is a good implementation.

case expressions

case expressions allow you to do the same that we did with functions, but without defining a function. You write an expression that pairs patterns and results, and the action from the first matched pattern is performed:

We can implement the previous example with a case expression:

let transform("") := []
let transform([first|tail]) := transform((first, 1), tail)

let transform(tuple, tail) :=
    case (tuple, tail) do
        (tuple, []) => [tuple]
        ((currentChar, count), [currentChar|tail]) =>
            transform((currentChar, count + 1), tail)
        (tuple, tail) => [tuple|transform(tail)]

Of course, the advantage of this is that you don't need to write functions in order to describe rules with patterns.

Control flow structures

Until now, we showed a lot of declarative features: you are describing what do you want, but not how.

This way of writing programs is usually easier to understand for another person reading the code, and also tends to result in shorter implementations.

However, there may be situations where is probably better to just write and if or a for loop, so Komodo has both of these. Let's get to know them.

if expressions

Let's say we want to know if an integer is even or odd, and display the answer. We can do something like this with pattern matching:

let parityMessage(n: Integer) :=
    case n % 2 do
        0 => String(n) + " is even!"
        1 => String(n) + " is odd!" 

It's fine, but I think it looks too complicated for a problem that should be simpler. Let's use an if expression:

let parityMessage(n: Integer) :=
    if n % 2 = 0 then
        String(n) + " is even!"
    else
        String(n) + " is odd!"

I think this is more explicit, and is less surprising when you read it. A nice thing about ifs in Komodo is that they are expressions themselves, so they return a result. You can do this:

let parityMessage(n: Integer) :=
    let text :=
        if n % 2 = 0 then
            " is even!"
        else
            " is odd!"
    
    String(n) + text

The thing with if expressions in Komodo is that you must write the else part. Always. Not doing it will result in an error when you try to execute the program.

for expressions

We love recursion and array functions, but sometimes loops are just the most convenient way to do things. This is the reason Komodo has for loops.

Let's say you want to print some numbers. You can do this:

let f(n) := 2**n

for k in 0..10 do
    let (k, fk) := (String(k), String(f(k)))
    println("f(" + k + ") = " + f(k))

It would be tiresome to do something like this without loops, and a lot of operations are better with loops.

for loops can also have a single line inside, without an indented block:

for i in 0..10 do println("F" + "U"*i)

for loops are expressions that always return the empty tuple ().

for loops do not have break or continue interruptions... yet.

Mutability

In Komodo, everything is inmutable by default. If you declare something with the let keyword, that's inmutable. Every argument you get in a function body is inmutable. Every imported variable is inmutable. Komodo wants you to write more declarative code, but it does not force you. If you want to declare a mutable variable, you can (with some limitations).

The var keyword

Just declare variables with the var keyword instead of the let keyword. That's it.

For example, you can do this:

var sum := 0

for i in 0..10 do sum := sum + i

println(sum)

The limitations

If you declare a mutable variable outside a function, you can't change its value outside of it. For example, the program

var x := 0

let setX(val) :=
    x := val

setX(5)
println(x)

will fail when you call setX. Functions are a barrier for mutable variables. Even if you pass them as arguments to a functions, its value won't change.

It's clear that mutable state is not our favorite, but we wanted to have some options.

Importing code

You can import any variables you declare in a Komodo file into another Komodo file. For example, if you have a function called foo in a file called foo.komodo in the same directory as the file where your program is, you can do the following:

from "./foo.komodo" import foo

foo()

and it just works! You don't have to define foo as public, or something like that. In general, Komodo does not have explicit mechanisms to define privacy of code.

You can import several names from one module:

from "./foo.komodo" import (foo, bar)

bar(foo())

What you cannot do currently, is to import an entire file:

import foo # this will throw an error!

Imports are specific to code blocks. You can do this:

let f(x) :=
    from "./foo.komodo" import bar
    bar(x)

and bar will not be available outside the definition of f. This is very useful if you want to import something for a very specific purpose.

The standard library

We already saw the builtin functions, functions available everywhere in Komodo programs. These functions are useful, but definitely are not enough. In order to build complex programs, we will probably need a lot of common subroutines. The standard library tries to provide these.

Let's suppose that we want to get the cos function from the math module. We use this syntax:

from math import cos

and the cos function will be available for you in the program. As you can see, the syntax is almost the same as when you want to import a file with code, but you just write the name of the module instead of a string with a path.

The standard library has four modules right now, that we will see briefly.

utils

Utils has some basic utilities for data manipulation that are extremely common. Most of the functions in utils work in lists and sets. utils is entirely written in Komodo. All the functions are here.

The most common example is the map function:

from utils import map

println([1, 3, 4].map(num -> num * 5))
# this will print [5, 15, 20]

math

As the name suggests, math has a lot of math functions. We can split them in the following categories:

• Trigonometric functions: sin, cos, tan, asin, acos, atan.

• Exponential functions: exp, ln, log.

• Roots: sqrt, cbrt.

• Misc: abs, hypot, round, floor, ceil.

time

The time module has two for dealing with time:

• time: Gives you the current Unix time.

• sleep(amount): Freezes the program for amount seconds.

json

The json module allows you to serialize Komodo values as JSON, and parsing JSON into Komodo values.

• parse(str): Parses str as JSON and returns a corresponding Komodo value.

• stringify(val): Interprets val as a JSON object and returns the corresponding JSON string.

Appendix

This chapter contains reference material you may find useful when learning and using Komodo.

Builtin types

Komodo has a few built-in types:

• Integers: Signed, arbitrary precision integers. You can write them in decimal form, or the usual prefixed binary (0x), octal (0o) or hex (0x) form.

• Floats: Signed, arbitrary precision decimal numbers. You can write them in decimal form with a dot.

• Fractions: Signed, arbitrary precision fractions, made with Integers. You can write them like this: 1 // 2.

• Characters: Old-fashioned ASCII characters. You can write them like this: 'x', where x is a representation of some ASCII value. (Support for escaped characters is pretty bad right now!)

• Strings: A bunch of characters, ordered. You can write them like this: "Hello, world!".

  Note: Many programming languages use the built-in list type to define strings. Komodo does not do this. The string type is completely different and defined independently in the interpreter.

• Lists: An ordered collection of anything. You can write them in two ways:

  • By extension: [1, 2, 4, 8]
  • By comprehension: [ 2**k : k in 0..4 ]

  Both of these examples describe the same thing! I should also remind you that the elements of a list can be of different type. This is valid: [1, '2', "3"].

  Note: You probably noticed the 0..4 expression. This is a range, and it behaves exactly like you expect: It goes from 0 to 3 (it always excludes the last number).

• Tuples: An ordered collection of anything. Wait... That's the same as lists! Yes. There are differences, though. You can't do operations with tuples just like you can with lists, and you can't compose them like we did above with lists. You can write them like this: ('1', 11, "111").

• Sets: An unordered and extendable collection of anything. You can write them like this: { 1, 2, 3 }.

• Functions: Pieces of code that receive values and return a value. There are two ways of writing them:

  • Named, with patterns:

  let f(0) := 25
  let f(n) := f(n - 1) + 1
  

  • Anonymously:

  n ->
      let x = n + 2
      x*x
  

  With this syntax, the last expression (i.e x*x) is returned as the result. Of course, this is an expression and you can save it to a value, or execute it in place like this: (x -> x * 2)(1).

  Note: You may have noticed that we used parenthesis to denote a series of steps. This is the only case where something that could be a tuple will be interpreted in another way.

• Dictionaries: A collection of key-value pairs. There are no restrictions on the keys or the values. You can use anything at the same time! You can write them like this: {"a" => 5, [] => 'b'}.

Data structures

Apart from the primitive types, Komodo has three main data structures: Lists, Sets and Dictionaries.

List

Lists are ordered, possibly mutable and non-growable. They can be written exhaustively:

let evens := [0, 2, 4]

Or by comprehension:

let evens := [2*i for i in 0..3]

You can create a new list by putting a new element at the beggining of an existing list:

[5|[1, 2]] = [5, 1, 2]

They can be concatenated with each other:

[1, 2, 3] + [4, 5, 6] = [1, 2, 3, 4, 5, 6]

And multiplied:

[1, 3]*2 = [1, 3, 1, 3]

Set

Sets are unoredered, inmutable and non-growable. They can be written exhaustively:

let Z3 := {0, 1, 2}

Or by comprehension:

let Z3 := {i for i in 0..3}

They can be joined (with the addition operator):

{1, 2} + {1, 3} = {1, 2, 3}

Dictionary

Dictionaries are unordered, inmutable collections of key-value pairs. The pairs can be anything. They can be defined exhaustively:

let dict := {
    5 => 7,
    "1" => 1,
    [] => 0
}

Control flow structures

Komodo includes some control flow structures from imperative languages.

if

These are expressions, and always are complete.

if 5 % 2 = 0 then
    "5 is even"
else
    "5 is odd"

for

Although these are expressions, they are not meant to return anything. They always return an empty tuple ().

for i in 0..5 do
    let x := i*i
    println(x)

Keywords

The following list contains all the keywords that Komodo uses. You can't name anything with them. Komodo is a small language, so it's not that bad of a problem to remember these.

• as: to define aliases of imported modules
• do: part of the for loop syntax
• else: part of if expressions
• false: Boolean false literal
• for: loop over items
• from: for importing some names from modules
• if: for if expressions
• import: for importing modules
• in: operator for membership
• let: declare an inmutable value
• then: part of if expressions
• true: Boolean true literal
• var: declare a mutable value

Operators and symbols

Infix operators

This list contains all the infix operators, an example of how the operator would be used, a short explanation, and its precedence. An operator with a higher precedence will be grouped before an operator with less precedence.

Prefix operators

This list contains all the prefix operators, an example of how the operator would be used, and a short explanation.