LudolfC Programming Language

LudolfC is a simple programming language for learning concepts of structured, object-oriented and functional programming.

Created to support the textbook Computer Science for Kids (editions: English, German, Czech)

The internationalization of keywords and the standard library provides worldwide language support.

Check it out in action at ludolfc.github.io

Language Overview

Assignment

name := value

Variable names can contain all word characters, digits and underscore _. A varible name must not start with a digit.

Unicode characters ěščřžťďýáíéúůüöäňñĚŠČŘŽŤĎÝÁÍÉÚŮÜÖÄŇÑß are allowed.

Variable names are case-sensitive.

Data types

LudolfC is a dynamically-typed language. The type of a variable can differ with each assignment.

Numbers

integer := 123
decimal := 123.45

four  := 5 + 4 / 2 + -3
three := -0.5 + 1.25 + 2.25

| Feature | Operation | Return type | Example | | --------- | -------------- | ----------- | ----------------- | | plus | addition | Number | 1.plus(2) = 3 | | minus | subtraction | Number | 2.minus(1) = 1 | | mult | multiplication | Number | 2.mult(3) = 6 | | div | division | Number | 4.div(2) = 2 | | mod | modulo | Number | 5.mod(3) = 2 | | neg | negation | Number | 1.neg() = -1 | | sum | sum | Number | 1.sum(2, 3) = 6 | | round | rounding | Number | 1.5.round() = 2 | | floor | floor | Number | 1.5.floor() = 1 | | ceil | ceiling | Number | 1.2.ceil() = 2 |

Strings

string1 := "Hello World!"
string2 := 'Hello World!'
string3 := “Hello World!”

empty := ""
abcde1 := "ab" + 'c' + 1

| Feature | Operation | Return type | Example | | --------- | -------------- | ----------- | ---------------------------- | | concat | concatenation | String | "ab".concat("c") = "abc" | | charAt | char at index | String | "abc".charAt(1) = "b" | | sub | substring | String | "abc".sub(1,2) = "b" |

| Property | Value | Data type | Example | | --------- | -------------- | ----------- | ---------------- | | size | size | Number | "abc".size = 3 |

Boolean

t := true | false
f := true & false

t := 1 <= 2
t := 1 != 2

| Feature | Operation | Return type | Example | | --------- | --------------------- | ----------- | --------------------------- | | neg | logical negation | Boolean | true.neg() = false | | and | logical conjunction | Boolean | true.and(false) = false | | or | logical disjunction | Boolean | true.or(false) = true | | xor | exclusive disjunction | Boolean | true.xor(true) = false | | nand | alternative denial | Boolean | true.nand(true) = false |

Void

Void is a special data type with an empty value. Void is a result of statement executions or calls of empty functions.

Comments

Any text starting with two slashes // will be ignored until the end of the line.

Arrays

Arrays are heterogeneous collections of indexed elements whose index starts at zero.

arr := []
arr := [1]
arr := [1, 2, 3]
arr := [1, [2, 3]]
arr := [[1], [2, 3]]
arr := [1, "x", true]

// [1, 123, true]
arr[1] := 123

// [1, [123], true]
arr[1] := [123]

// [1, [999], true]
arr[1,0] := 999

// 3
arr.size

// 1
arr[1].size

// true
[1,2] = [1,2]

// false
[1,2] = [2,1]

// true
[1] + [2,3] = [1,2,3]

| Feature | Operation | Return type | Example | | --------- | -------------- | ----------- | ------------------------------- | | concat | concatenation | Array | [1,2].concat([3]) = [1,2,3] |

| Property | Value | Data type | Example | | --------- | -------------- | ----------- | ------------------ | | size | size | Number | [1,2,3].size = 3 |

Conditionals

Conditionals are boolean-condition-controlled branches of the program.

if condition {
    // body for condition is true
}

if condition {
    // body for condition is true
} else {
    // body for condition is false
}

if condition1 {
    // body for condition1 is true
} else if condition2 {
    // body for condition2 is true
} else if condition3 {
    // body for condition3 is true
} else {
    // body for conditions are false
}

Conditions must be of type Boolean:

if true {}
if false {} else {}

The body of conditionals is a sequence of instructions:

a := 0
b := 0

if a <= 0 {
    a := a + 1
    b := 1
} 

if a <= 0 {
    a := a + 1
    b := 2
}
else {
    a := a - 1
    b := 3
}

// 3
a + b

Variables created inside a body are scoped to the life time of that body.

Loops

Loops are sequences of instructions that are continually repeated while a condition is met.

while condition {
    // body to repeat
}

i := 1
while i <= 10 {
    i := i * 2
}
// i = 16

Variables created inside a body are scoped to the life time of that body.

Functions

Functions are callable sub-programs with zero or more named parameters.

The last statement is returned as a result of the function call.

empty := (){}
void := empty()

identity := (x){x}
one := identity(1)

addition := (x,y){ x + y }
three := addition(1,2)

Variables created inside a function are scoped to the life time of that function:

func := (x,y){
    res := x + y
    res * 2
}
six := func(1,2)
// 'res' does not exist here

Functions are first-class citizens:

f := (){(){1}}
f()()

x := 1
f := (a){(){x+a()}}
g := f((){x})
g()

makeCounter := (init) {
  i := init
  (){
    i := i + 1
    i
  }
}
counter := makeCounter(100)
counter()   // 101
counter()   // 102

Objects

Object are heterogeneous structures of named attributes.

obj := {}
obj := { a: 1 }
obj := { a: 1, b: "B" }
obj := { a: 1, b: "B", t: true }
obj := { a: 1, b: "B", t: true, arr: [1,2,3] }
obj := { a: 1, b: "B", t: true, arr: [1,2,3], f: (x){x*2} }
obj := { a: 1, b: "B", t: true, arr: [1,2,3], f: (x){x*2}, o:{a:5} }

// 1
obj.a

// 2
obj.arr[1]

// 246
obj.f(123)

// 5
obj.o.a

Object's attributes are available inside member functions:

a := 0
obj := {
    a: 1,
    f: (){ a + 1 }
}

// 2
obj.f()

Everything is an object:

1.plus(2)

"Hello".concat("World")

false.or(true)

[1,2].eq([1,2])

Self reference

Inside an object, a built-in attribute $ can be used to access the object itself.

o := {
    a: 1,
    setA: (a) {
        $.a := a
    }
}

o.setA(2)

o.a   // 2

Constructor functions

Objects do not contain any special constructors, but can be constructed via functions that return objects:

Robot := (name, sernum, x, y) {{
  name: name,
  sernum: sernum,
  position: { x: x, y: y },

  move: (x, y) {
    position.x := x
    position.y := y
  }
}}

ludolf := Robot('Ludolf', 'A001', 0, 0)
euler := Robot('Euler', 'A002', 10, 20)

Explicit separators

Newlines are implicit separators of statements. The semicolon ; can be used as an explicit separator.

x := 1; y := x

// is the same as

x := 1
y := x

Keywords

All keywords are case-insensitive!

true, false, if, else, while

Internationalization

In order to be used in different native languages, LudolfC has several mutations of keywords and standard attributes. Other mutations are forseen in the future.

| Keyword | German (de) | Czech (cs) | | --------- | ----------- | ---------- | | true | wahr | pravda | | false | falsch | nepravda | | if | falls | pokud | | else | sonst | jinak | | while | solange | dokud |

| Propery | German (de) | Czech (cs) | | ----------- | ----------- | ------------- | | [].size | [].größe | [].velikost |

Interpreter

LudolfC comes along with a JavaScript interpreter:

npm i ludolfc

import {LudolfC, lang} from 'ludolfc'

var imports = {
    inc: new lang.NativeFunction(x => new lang.Number(x.value + 1)),
    dec: new lang.NativeFunction(x => new lang.Number(x.value - 1)),
}

var ludolfC = new LudolfC(imports)

var result = ludolfC.execute(`
    i := 1
    a := inc(i)
    b := dec(i)
    i + a + b
`)

console.log(result.value)   // 3

A web-based interpreter is to be found in dist/.

Examples

insertionSort := (arr) {
  n := arr.size
  i := 1
  while i < n {
    c := arr[i]
    j := i - 1 
    while j > -1 & c < arr[j] {
      arr[j + 1] := arr[j]
      j := j - 1
    }
    arr[j + 1] := c
    i := i + 1
  }
  arr
}

insertionSort([5,3,2,1,4])

o := 1
(o){(o){o}((o){o})}(o)(o)

Build

npm run build

License

GPL-3.0