CLRS Kit

clrs-kit is a Visual Studio Code extension designed to support a pseudocode language heavily inspired by the syntax used in the book Introduction to Algorithms (CLRS).

💻 Getting started in VS Code

⚙️ Current status (version 1.0.1)

• Full CLRS parser built with Chevrotain.
• Automatic Abstract Syntax Tree (AST) generation.
• CLRS-to-JavaScript transpiler.
• Execution of CLRS programs directly from Visual Studio Code.
• JavaScript code generation without execution.
• Syntax highlighting via a TextMate grammar.
• Language configuration with automatic indentation and code folding.
• Built-in snippets for CLRS syntax.
• Standard library for handling files, strings, arrays, and mathematical functions.
• Syntax and runtime error reporting.
• Support for functions, arrays, expressions, conditionals, loops, and input/output operations.
• CodeLens support for run and build buttons.

📖 Language Philosophy

The language is designed based on the following principles:

• Simple pseudocode syntax close to english.
• Educational and academic focus.
• Simplicity for beginners.
• Similarity to CLRS pseudocode.
• Use case focused on algorithm design and learning.

🛠️ Requirements

• Visual Studio Code
• Node.js (for execution)

🧑‍💻 Author

Project developed by j-hernandez-dev as an open educational tool.

📜 License (GPLv2)

This project is open source. It may be freely modified and extended, provided that attribution to the original author is maintained.

⚠️ Known issues

• There is no support for semantic analysis. Consequently, everything is handled during JavaScript analysis without specifying the error location.
• Certain code may be generated incorrectly by the transpiler.

🧮 Language Features

Comments

CLRS only supports single-line comments using //.

// Simple comment

Variables

Variables are dynamically and weakly typed. They can store values of different types and change their type during execution through implicit type conversions when necessary.

variable1 <- 10
variable2 <- "text"
variable1 <- variable2

Variables are always mutable; the language does not support constants. Their scope is local to the function in which they are defined, and assignment is performed using the <- operator.

variable1 <- 10
variable1 <- 2
variable1 <- 4

Variables must be initialized when they are created. Standalone declarations without an initial value are not allowed. Supported value types are numeric, string, and boolean.

variable1 <- 10
variable2 <- "text"
variable3 <- TRUE

Arrays

Arrays are dynamic. Their size and number of dimensions are determined automatically as new positions are accessed.

array[0] <- 10
matrix[2][2] <- 10

A complete array can be assigned to a variable, and a variable can also be assigned to an array. In both cases, the corresponding values are copied.

variable1 <- array
matrix <- variable2

Input and Output

The print statement writes data to the console. It can print individual values, multiple values separated by commas, concatenated expressions, and entire arrays.

print variable1
print array
print variable1, variable2, variable3
print variable1 + variable2 + variable3

The scan statement reads input from the console. One or more variables can be read in a single statement. The type of the input value is determined automatically.

scan variable1
scan variable1, variable2, variable3

Selection Statements

The only selection structure is if, together with its else if and else variants. Code blocks are defined by indentation, so consistent indentation is required.

if variable3 or TRUE
    print "a"
else if variable1 > 3
    print "b"
else if variable2 = "text"
    print "c"
else
    print "d"

Operators

CLRS provides logical, relational, and arithmetic operators similar to those found in most programming languages. Equality comparison uses the = operator.

if TRUE and TRUE
    print "a"

if FALSE or TRUE
    print "b"

if 10 > 20
    print "c"

if 20 < 10
    print "d"

if 10 = 10
    print "e"

if 20 != 10
    print "f"

for Loop

The for loop supports two variants.

The to variant automatically increments the loop variable until it reaches the specified end expression.

for i <- 0 to 5
    print i

The downto variant automatically decrements the loop variable until it reaches the specified end expression.

for j <- 5 downto 0
    print j

while Loop

The while loop repeatedly executes a block of code as long as the specified condition evaluates to TRUE.

while variable3 and FALSE
    print "This code is never executed"

Functions

Functions are defined by an identifier, a parameter list, and an indented code block.

helloWorld()
    print "Hello, world!"

Function calls use the same syntax as their definitions. Be careful not to indent code immediately after a function call, as it may be interpreted as the body of a new function definition.

helloWorld()

Functions can receive any number of parameters and return a value using the return statement.

sum(a, b)
    return a + b

Functions can also receive arrays as parameters. Only the number of dimensions needs to be specified.

sum2(a, b[])
    return a + b[0]

Function calls can be used as part of any expression. Arrays are passed simply by using their identifier.

variable1 <- sum(1, 2)
print sum(1, 2)

variable1 <- sum2(1, array)
print sum2(1, array)

A function named main can be used as the program entry point. It is invoked automatically, so it does not need to be called explicitly.

main()
    print "Hello, world!"

main() // Not required; this would execute it twice.

Example

Complete Bubble Sort implementation.

array[0] <- 5
array[1] <- 2
array[2] <- 9
array[3] <- 1
array[4] <- 6

n <- LENGTH(array)

print n

i <- 0
j <- 0

for i <- 0 to n - 1
    for j <- 0 to n - i - 2
        if array[j] > array[j + 1]
            temp <- array[j]
            array[j] <- array[j + 1]
            array[j + 1] <- temp

print array

📚 CLRS Standard Library

The CLRS Standard Library provides built-in functions for file handling, mathematical operations, strings, and arrays.

📁 Files

🔢 Mathematics

🔤 Strings

📦 Arrays