Expressions
Expressions are a core concept in ApLang. They represent values or computations that produce values. In ApLang, you can use expressions to perform arithmetic operations, manipulate strings and lists, call functions, and evaluate logical conditions. This chapter will introduce you to the different types of expressions available in ApLang and how to use them effectively.
Arithmetic Expressions
Arithmetic expressions in ApLang allow you to perform basic mathematical operations. ApLang supports the following arithmetic operators:
+
(addition)-
(subtraction)*
(multiplication)/
(division)MOD
(modulo)
Example: Arithmetic Operations
// Addition
sum <- 5 + 3
DISPLAY(sum) // Output: 8
// Subtraction
difference <- 10 - 4
DISPLAY(difference) // Output: 6
// Multiplication
product <- 7 * 2
DISPLAY(product) // Output: 14
// Division
quotient <- 8 / 2
DISPLAY(quotient) // Output: 4
// Modulo (remainder of division)
remainder <- 9 MOD 4
DISPLAY(remainder) // Output: 1
In these examples, each expression calculates a result using arithmetic operators and assigns the result to a variable.
String and List Concatenation
ApLang supports string and list concatenation using the +
operator. Concatenation combines two strings or two lists into one.
Example: String Concatenation
greeting <- "Hello, "
name <- "World!"
full_greeting <- greeting + name
DISPLAY(full_greeting) // Output: "Hello, World!"
Example: List Concatenation
list1 <- [1, 2, 3]
list2 <- [4, 5, 6]
combined_list <- list1 + list2
DISPLAY(combined_list) // Output: [1, 2, 3, 4, 5, 6]
These examples show how the +
operator can be used to concatenate strings and lists, creating a new string or list that combines the contents of both operands.
Function Calls as Expressions
Function calls in ApLang are expressions that evaluate to the return value of the function. You can use function calls wherever expressions are allowed.
Example: Using Function Calls
PROCEDURE square(x) {
RETURN x * x
}
result <- square(4)
DISPLAY(result) // Output: 16
In this example, square(4)
is an expression that calls the square
function with the argument 4
and returns the result.
Logical Expressions
Logical expressions evaluate to boolean values (TRUE
or FALSE
) and are used to make decisions in your programs. ApLang supports several logical operators:
NOT
(logical negation)AND
(logical conjunction)OR
(logical disjunction)
Example: Logical Operations
a <- TRUE
b <- FALSE
// Logical NOT
not_a <- NOT a
DISPLAY(not_a) // Output: FALSE
// Logical AND
and_result <- a AND b
DISPLAY(and_result) // Output: FALSE
// Logical OR
or_result <- a OR b
DISPLAY(or_result) // Output: TRUE
Logical expressions are crucial for controlling the flow of your program using conditional statements.
Comparison Expressions
Comparison expressions are used to compare values and produce boolean results. ApLang supports the following comparison operators:
==
(equal to)!=
(not equal to)>
(greater than)<
(less than)>=
(greater than or equal to)<=
(less than or equal to)
Example: Comparison Operations
x <- 5
y <- 10
DISPLAY(x == y) // Output: FALSE
DISPLAY(x != y) // Output: TRUE
DISPLAY(x > y) // Output: FALSE
DISPLAY(x < y) // Output: TRUE
DISPLAY(x >= y) // Output: FALSE
DISPLAY(x <= y) // Output: TRUE
These expressions evaluate to TRUE
or FALSE
based on the comparison of x
and y
.
Combined Expressions
Expressions in ApLang can be combined to perform more complex calculations or evaluations. By using parentheses ()
to group expressions, you can control the order of operations.
Example: Combining Expressions
a <- 2
b <- 3
c <- 4
result <- (a + b) * c // Parentheses change the order of operations
DISPLAY(result) // Output: 20
In this example, the expression (a + b)
is evaluated first, followed by multiplication by c
, resulting in 20
.
Conclusion
Expressions are a powerful tool in ApLang, enabling you to perform a wide range of operations and calculations. By mastering arithmetic, string, list, logical, and comparison expressions, you can create more dynamic and efficient programs. Remember to use parentheses to control the order of operations to ensure your expressions evaluate as intended.