In Go language, the Boolean type represents logical values, which can be either true or false. The bool keyword is used to declare a variable as a Boolean type.

Syntax & Examples:

The syntax to declare a variable with a Boolean type in Go is:

var myBoolean bool = true

Here, "myBoolean" is the name of the variable, "bool" is the data type, and "true" is the assigned value.

We can also declare a variable without initializing it. In such cases, Go will assign the default value for the Boolean type, which is "false".

var myBoolean bool

In Go language, Boolean values are often used in decision-making statements such as if conditions, switch statements, and loops. For example:

package main

import "fmt"

func main() {
    var isTrue bool = true

    if isTrue {
        fmt.Println("This statement is true.")
    } else {
        fmt.Println("This statement is false.")
    }
}

The above code declares a Boolean variable named "isTrue" and assigns the value "true". Then, it checks whether the variable is true or false using an if condition, and prints the appropriate message.

Output:

This statement is true.

Operators

Boolean operators are used to perform logical operations on Boolean values. In programming, there are three main Boolean operators: AND (&&), OR (||), and NOT (!).

Sure! Here's a table that enumerates the Boolean operators in Go along with their Unicode symbols and a brief description of each:

Note:

In Go, we use two characters (II and &&) to represent the logical OR and AND operators, though they correspond to a single Unicode symbol each. Operator ! = (bang) is single and is unary operator.

Table of truth:

Here's a table of truth showing the result of Boolean operations using Go using operators AND and OR for all possible combinations of the operand values.

In this table, A and B represent the two operands of a Boolean operation. The result of the logical NOT operation (!) require a single operant and is not demonstrated in this table of truth.

• ! true = fals

• ! false = true

AND (&&) Operator:

This operator returns true if both the operands are true. If any of the operands are false, then it returns false.

Example:

package main

import "fmt"

func main() {
    var x bool = true
    var y bool = false

    fmt.Println(x && y) // Output: false
    fmt.Println(x && x) // Output: true
}

OR (||) Operator:

This operator returns true if either of the operands is true. If both operands are false, then it returns false.

Example:

package main

import "fmt"

func main() {
    var x bool = true
    var y bool = false

    fmt.Println(x || y) // Output: true
    fmt.Println(y || y) // Output: false
}

NOT (!) Operator:

This operator inverts the Boolean value of its operand.Example:

package main

import "fmt"

func main() {
    var x bool = true

    fmt.Println(!x) // Output: false
}

Note:

It is important to note that Boolean operators always return Boolean values. They are commonly used in decision-making statements such as if conditions, loops, and switch statements.

Morgan's law is a fundamental concept in Boolean algebra that deals with the negations of compound propositions. It offers two equivalent ways to express a proposition that is the negation of a conjunction (AND) or disjunction (OR).

---

Morgan's Laws

1. The complement of the conjunction of two statements is logically equivalent to the disjunction of the negations of those two statements.

   !(A && B) == !A || !B

2. The complement of the disjunction of two statements is logically equivalent to the conjunction of the negations of those two statements.

   !(A || B) == !A && !B

Examples

Next examples demonstrate the principle of Morgan's Law in action in the Go programming language.

package main

import "fmt"

func main() {
    // initialize two boolean variables
    a, b := true, false

    // using the && (AND) operator
    result1 := !(a && b) == (!a || !b)
    fmt.Println(result1) // prints true

    // using the || (OR) operator
    result2 := !(a || b) == (!a && !b)
    fmt.Println(result2) // prints true
}

Notes:

In the example above, we first initialize two boolean variables a and b. We then use the && and || operators to demonstrate Morgan's Laws.

For the AND operator, we negate the conjunction of a and b using the first equation of Morgan's Law. We compare this with the disjunction of the negations of a and b. Since both sides of the equation evaluate to true, result1 is set to true.

For the OR operator, we negate the disjunction of a and b using the second equation of Morgan's Law. We compare this with the conjunction of the negations of a and b. Since both sides of the equation evaluate to true, result2 is set to true.

---

Commutativity

Boolean operators exhibit commutativity, which means that the order of operands does not affect the outcome of the expression.

Example:

For example, in the case of the logical AND (&&) operator, the order of operands does not matter. The expression would be evaluated to the same result, whether the first or the second operand comes first.

package main

import "fmt"

func main() {
    a := true
    b := false

    if a && b {
        fmt.Println("Both are true") 
        // Not executed as a && b is false
    } else {
        fmt.Println("At least one is false") 
        // This is executed
    }

    if b && a {
        fmt.Println("Both are true") 
        // Not executed as b && a is false
    } else {
        fmt.Println("At least one is false")
        // This is executed
    }
}

Note:

In the above code, the logical AND operator is used twice. In the first if statement, a && b is evaluated, which returns false because b is false. In the second if statement, b && a is evaluated, which also returns false because both a and b are not true. Thus, the order of operands does not matter in this case, and the results are the same.

---

Relation Operators

In Boolean algebra, relation operators are a set of logical operators that compare two values, expressions, or variables and return a Boolean value of true or false. The most common relation operators in Boolean algebra are:

In Boolean algebra, the relation operators are often used in conjunction with logical operators such as AND, OR, and NOT to form complex logical expressions. For example, you can use the AND operator along with the greater than (>) operator to check if two values are both greater than a certain number.

Here's an example Boolean expression that uses relation operators in conjunction with other logical operators:

(x > 5) && (y < 10)

In the above expression, we're checking if variable x is greater than 5 AND variable y is less than 10. The > and < operators are relation operators that compare two values, while the AND operator is a logical operator that returns true only if both operands are true.

The relational operators in Go are primarily used for comparisons between values. Based on the comparison, a boolean value of true or false is returned.

Here's an example using relational operators in Go:

package main

import "fmt"

func main() {
    a := 5
    b := 10

    // Using relational operators in if statements
    if a < b {
        fmt.Println("a is smaller than b")
    }

    if a == 5 {
        fmt.Println("a is equal to 5")
    }

    // Using relational operators in a for loop
    for i := 0; i <= 10; i++ {
        if i%2 == 0 {
            fmt.Println(i, "is even")
        }
    }
}

Note

In the above code, the if statements use the less than (<) and equal to (==) relational operators to compare values. The for loop also uses the equal to (==) relational operator, along with the modulo operator (%), to filter even numbers.

Use Cases

Relational operators are widely used, especially when comparing values or processing data based on conditions. They play a major role in control flow statements such as if, for, while, etc.

The use of relation operators in Boolean algebra is essential in programming and computer science, as they play a vital role in control flow and logical operations.

---

Conclusion:

In this article I have used multiple prompts to create a comprehensive tutorial for beginners to understand esentials of Logic used in programming with Go language. If you like this article encourage me to write more. Buy me a coffee and Join my community on Discord to work with my team on real projects. If you find any errors, blaim ChatGPT and drop me a comment below to fix what we can.

---

Thank you for reading. Have fun, live long and prosper 🍀🖖🏼