How to Write Code in YAP?

Welcome to the YAP programming language documentation. YAP is designed to be intuitive yet powerful, with a syntax that's both expressive and easy to learn.

1Variables and Data Types

The datatype of the variable must be defined by the user at the time of declaration. You can declare variables using the following types:

• int - Whole numbers
• float - Decimal numbers
• bool - nocap (true) or cap (false)
• string - Text
• int[], float[], bool[], string[] - Arrays
• fn - Functions

Declaring Variables:

int age = 25;
float pi = 3.14;
bool isStudent = nocap;
string name = "Alice";

2Printing Output

Use yap() to display values.

Example: Printing

yap("Hello, world!");
int x = 10;
yap(x);

3Taking User Input

Use spill() to get values from the user.

Example: Input

int age = spill();
yap("Your age is: ", age);

If you enter 20, output will be:

4Operations

5Conditional Statements

Use if, elif, and else for decision-making.

Example: If-Else

int num = spill();
if (num > 0) {
    yap("Positive number");
} elif (num < 0) {
    yap("Negative number");
} else {
    yap("Zero");
}

Input: 5

Example: Nested If-Else

int x = 4;
float y = 7.0;
bool z = nocap;
string msg = "hello";
if (x > 0) {
    if ((y > 2.0) and (z == nocap)) {
        yap("Complex nested condition 1");
        if (msg == "Hello") {
            yap("Deepest nesting");
        } else {
            yap("Deep nest else");
        }
    } else {
        yap("Complex nested condition 2");
    }
} else {
    yap("Outer else");
}

6Loops

YAP supports several types of loops for repeating code execution.

int count = 0;
while (count < 5) {
    yap(count);
    count = count + 1;
}

for (int i = 0; i < 5; i = i + 1) {
    yap(i);
}

for (int i = 0; i < 5; i = i + 1) {
    yap(i);
    if (i==2){
        break;
    }
}

for (int i = 0; i < 5; i = i + 1) {
    if (i==2){
        continue;
    }
    yap(i);
}

7Arrays

Arrays can be defined for any of these types: int[], float[], bool[], string[]. Arrays having elements of different datatypes are not supported.

int[] numbers = [1, 2, 3, 4];
string[] words = ["hello", "world"];

Access array elements:

yap(numbers[2]);

Modify array elements:

numbers[1] = 10;
yap(numbers[1]);

Appending Elements

numbers.append(5);
yap(numbers);

Deleting Elements

Delete takes the index of the element which is to be deleted:

numbers.delete(1);
yap(numbers);

Finding length

yap(numbers.len());

8Functions

A function is defined using def, and parameters are statically typed. The data type for return value is to be specified at the time of function definition, else the function is set to void by default. The keyword 'yeet' is used for returning functions. Functions can only return one value currently.

Note: There are no ';' at the end of 'yeet' statements.

Note: Functions cannot be parsed as parameters to other functions; However, function calls can be parsed.

Function with Parameters

def add(int a, int b) -> int {
    yeet a + b
}
yap(add(5, 3));

Function without Return Value

def greet(string name) {
    yap("Hello, ", name);
}
greet("Alice");

Function with an Array as Input and Output

def double_elements(int[] arr) -> int[] {
    for (int i = 0; i < 4; i = i + 1) {
        arr[i] = arr[i] * 2;
    }
    yeet arr
}
int[] numbers = [1, 2, 3, 4];
int[] result = double_elements(numbers);
yap("Doubled Array:", result);

Recursive Function

def fib(int n) -> int{
    if((n==1) or (n==0) ){
        yeet n
    }
    int x = fib(n-1) + fib(n-2);
    yeet x
}
yap(fib(8));

Functions Calls

def add(int a, int b) -> int {
    yeet a + b
}
def multiply(int x, int y) -> int {
    yeet x * y
}
yap(multiply(add(2, 3), 4));

Functions as First-Class Values

def double(int x) -> int {
    yeet x * 2
}

fn f = double;
yap(f(5));

def return_fn() -> fn {
    def say_hello() -> int {
        yap("hi");
        yeet 0
    }

    yeet say_hello
}

fn greeter = return_fn();
greeter();

Function and Scoping

def changeVar(int x) -> int {
    x = x + 10;
    yeet x
}
int x = 5;
yap(changeVar(x));  # Expected: 15
yap(x);

Explanation: Scoping in YAP

In YAP, function parameters are passed by value. This means that when you call changeVar(x), the function gets a copy of x, not the original variable. Inside the function, the modification x = x + 10; affects only the copy, not the original x. After the function returns, x remains unchanged outside the function.

To modify a variable globally, you would need to return the new value and explicitly reassign it:

int x = 5;
x = changeVar(x);
yap(x);

9Stacks and Queues

Stacks and queues can be declared using stack<type> and queue<type>, where type is the datatype.

stack<int> s;

s.stackPush(3) - pushes 3 into stack
s.stackPop()-pops the top element
s.top() - return the top element

queue<int> q;

q.queuePush(3) - pushes 3 into queue
q.queuePop()-pops the first element
q.first() - return the first element

About YAP Language

YAP is a modern programming language designed for simplicity, readability, and power. Created as an educational project, YAP combines the best features of multiple programming languages to create an experience that's both enjoyable and productive.

Our Mission

Our mission is to create a programming language that's accessible to beginners while still being powerful enough for more complex applications. We believe that learning to code should be fun and intuitive, and YAP was designed with this philosophy in mind.

Connect With Us