The English and Persian glossary

One program, two languages

These two programs are the same, and produce the same output:

func fibonacci(n: int): int:
    if n < 2:
        ret n
    end
    ret fibonacci(n - 1) + fibonacci(n - 2)
end

func main:
    repeat 10 in i:
        print fibonacci(i), ""
    end
    println ""
end

تابع فیبوناچی(ن: صحیح): صحیح:
    اگر ن < ۲:
        برگشت ن
    پایان
    برگشت فیبوناچی(ن - ۱) + فیبوناچی(ن - ۲)
پایان

تابع ریشه:
    تکرار ۱۰ در ک:
        چاپ فیبوناچی(ک), ""
    پایان
    سرچاپ ""
پایان

salam translate fa program.salam turns English code into Persian, and salam translate en goes the other way. It rewrites keywords, types, the entry function and the built-in methods. The compiler decides which language a file is in from its keywords, and a file uses one language throughout: in a Persian file the English spelling of a built-in name is an error, and the message names the Persian one.

Keywords

The comparison words eq, neq, lt, gt, lte and gte stand for ==, !=, <, >, <= and >=, and both forms work in both languages. In Persian, تا is until at the start of a statement and to inside a repeat header, and هر is each at the start of a statement and the step by inside a repeat header. main is not a keyword but the name of the entry function, which a Persian program calls ریشه.

Context words

These words are keywords only in one position, so they can still be used as names elsewhere:

static appears in static func and in link static. Persian پویا has two jobs: after پیوند it means dynamic, and in front of an interface type it means dyn. defined(NAME) belongs to conditional compilation.

Types

Watch the floating-point types in Persian: اعشار on its own is the 32-bit float, and a literal such as ۲.۵ is an اعشار۶۴. The digits in a type name can be Persian or ASCII, so صحیح۶۴ and صحیح64 are the same type.

Built-in functions

A handful of functions need no import. A Persian program must use their Persian names:

Most of them appear in earlier lessons: len on arrays and strings, spawn and join in Concurrency. sizeof takes a type, char_code gives the code of the first letter of a string, and lang() tells a program which language its own source is written in. This example uses several of them, with a few built-in methods:

func main:
    word := "salam"
    println lang(), len(word), sizeof(i64)
    println char_code("A"), char_from_code(66), strcmp("ab", "ac") < 0

    mut names := Vector {} as Vector<str>
    defer names.free()
    names.push("sara")
    names.push("reza")
    println names.len(), names.get(1), names.pop()

    mut ages := HashMap {} as HashMap<str, int>
    defer ages.free()
    ages.put("sara", 31)
    println ages.has("sara"), ages.get("sara"), ages.size()

    text := "  hello world  ".trim()
    println text.starts_with("hello"), text.find("world"), text.substr(0, 5)
    println "سلام".len(), "سلام".char_count()
end

Built-in methods

Strings, vectors, maps, files and map iterators have methods built into the language, and they have a Persian spelling as well:

Two of the names count bytes, not letters: len and find work on the bytes of a string, so "سلام".len() is 8. Use char_count, char_at and char_find to work letter by letter, as the last line of the example above shows.

Compile-time constants

The constants of conditional compilation have Persian names too, and a Persian program must use them:

SALAM_JS exists only when the program is compiled to JavaScript, so ask defined(SALAM_JS) rather than testing it directly. SALAM_GIT_DIRTY is text, "-dirty" for a compiler built from uncommitted sources.