And

The And programming language is a very peculiar esoteric language by User:Rdococ.

Structure

And takes advantage of lazy evaluation so that you can do this:

((x < 3 || y > 2 || z[3] = 1) && input = 'a') && (x := y + 1 && y := 0 && print "Hello guys!")

In that snippet of And code, if x < 3 or y > 2 or the fourth entry of z = 1, and your input is the letter a, then x will become y + 1 and y will become 0, and then the user will see the words, "Hello guys!", and then the instruction pointer will return to the top, asking for another input. The reason this stuff happens is because of lazy evaluation - which allows a chain of and operators like that to work like a conditional.

And code is essentially lines upon lines of chained && and || operations that are repeatedly evaluated over and over again, asking the user for input every time. Who needs conditionals?!

Oh and a few more things. The exit statement - when evaluated - will end the program. The print statement - when evaluated - will print a message. And stuff like assignment and printing always return true.

Computational class

And is Turing complete.

Proof

The following program interprets a BF program (reading the program on the first line of input):

state = 0 && (
    input != '\n' && code[rp] := input && rp := rp + 1
    || state := 1
)
|| state = 1 && (
    code[ip] = '+' && data[dp] := (data[dp] + 1) % 256 && ip := ip + 1
    || code[ip] = '-' && data[dp] := (data[dp] + 255) % 256 && ip := ip + 1
    || code[ip] = '>' && dp := dp + 1 && ip := ip + 1
    || code[ip] = '<' && dp := dp - 1 && ip := ip + 1
    || code[ip] = ',' && data[dp] := (input % 256 + 256) % 256 && ip := ip + 1
    || code[ip] = '.' && print data[dp] && ip := ip + 1
    || code[ip] = '[' && (
        data[dp] = 0 && state := 2
        || ip := ip + 1
    )
    || code[ip] = ']' && state := 3
    || code[ip] = 0 && exit
    || ip := ip + 1
)
|| state = 2 && (
        code[ip] = '[' && depth := depth + 1
        || code[ip] = ']' && depth := depth - 1
        || true
    ) &&
    ip := ip + 1 &&
    depth = 0 && state := 1
|| state = 3 && (
        code[ip] = ']' && depth := depth + 1
        || code[ip] = '[' && depth := depth - 1
        || true
    ) &&
    ip := ip - 1 &&
    depth = 0 && ip := ip + 1 && state := 1

Examples

Hello World

print "Hello World!" && exit

Cat program

This is a bit restricted because the user can only input one character at a time.

print input

99 bottles of beer

This version adds a new line every time it is evaluated. It goes from 99 to 0 and then repeats, and it handles grammar correctly.

s = 0 && (n := 99 && s := 1) || (
(n = 0 && (print "No more bottles of beer on the wall, no more bottles of beer. Go to the store and buy some more, 99 bottles of beer on the wall." && n := 99)) ||
(n = 1 && (print "One bottle of beer on the wall. One bottle of beer. Take one down and pass it around, no more bottles of beer on the wall." && n := n - 1)) ||
(n = 2 && (print "Two bottles of beer on the wall. Two bottles of beer. Take one down and pass it around, one bottle of beer on the wall." && n := n - 1)) ||
(n > 2 && (print n + " bottles of beer on the wall. " + n + " bottles of beer. Take one down and pass it around, " + (n - 1) + " bottles of beer on the wall." && n := n - 1)))

External resources

• Interpreter in Python 3