Scheme - IF w/ several operations for an outcome - if-statement

Question

I am very briefly looking into Scheme and wondering if there is a way to do the following: add several operations to each outcome (#t and #f).
(if (something)
Do something //true, #t
Do one thing AND another thing)) //false, #t
As an example, given a defined procedure that takes an integer x. If it is greater than five --> print out a message. If it is less than five --> print out message AND set x to zero:
(if (> x 5)
"Greater than five"
"Less than or equal to 5", (= x 0))
To rephrase: I am looking for a mechanism that allows me to do the following (expressed in Java syntax):
if (cond) { //true
//Do this
}
else { //false
//Do this
//AND this
}

Answer 1

Just make it up as you go !
OK, so say you we're really stuck, you at least know if gives you two branches.
(if #t "a" "b") ; => "a"
(if #f "a" "b") ; => "b"
Well "a" and "b" could be anything, right? What if they were procedures instead?
(define (a) "10")
(define (b) "20")
(if #t (a) (b)) ; => "10"
(if #f (a) (b)) ; => "20"
OK and we know procedure bodies can evaluate any number of expressions in sequence. So we could expand a and b to something like
(define (a) (print "a is ") (print "10") (newline))
(define (b) (print "b is ") (print "20") (newline))
(if #t (a) (b)) ; "a is 10\n"
(if #f (a) (b)) ; "b is 20\n"
OK so maybe that's a little cumbersome to define a procedure every time you want a logic branch that needs to eval multiple expressions, but at least it works. You could then inline the procedures with lambdas to make your life a little easier
((if #t
(λ ()
(print "a")
(print "b")
(newline))
(λ ()
(print "c")
(print "d")
(newline)))) ; "ab\n"
((if #f
(λ ()
(print "a")
(print "b")
(newline))
(λ ()
(print "c")
(print "d")
(newline)))) ; "cd\n"
Well now you can't really say you're stuck anymore. Things may not look exactly the same way they do in Java (thankfully), but at least things are behaving as expected.
As you continue to learn the language and common idioms, you might stumble across cond and begin. They might make your life easier, but you have to understand there's nothing magical about them. You could've just have easily implemented these yourself.
You can make up everything as you go. This is one of the reasons I love scheme/racket. Next to nothing is holy/sacred and you can essentially implement anything you can imagine.

Answer 2

Here's the thing though, if in scheme is a lot different from if in the algol family. If in algol derivatives is a branch or conditional jump instruction; if directly alters the flow of the code. In scheme/lisps every if returns a value. It isn't quite a full function is lisps due to the limitation of the internal structure of the interpreter or compiler, but for most purposes you can treat it as just another function.
(if (something)
Do something //true, #t
Do one thing AND another thing)) //false, #t
Is wrong, what is really going on.
(if condition
(return value of this first exp) //true value
(return value or this second exp)) //false value
In scheme, when you want a function to have a side-effect, that is mutate state you have to be very explicit and it's a good idea to mark function that mutate state with a "!" at the end of the function name.
Procedures like set! vector-set! and the like return an unspecified value. If you want a side effect and a specific value or more than one side effect in a particular sequence, you have to wrap the whole thing up with begin. Additionally if you just (set! x 0) you only change the value of x in the local scope, which may not be what you wanted to do . Whatever bound symbol you used to pass x into the function still carries it's old value.(set-car, vector-set! and set-cell-contents! do modify the underlying state of the data structure called across lexical boundaries) Explicit recursion or hiding a value in a closure is often appropriate.
The syntax for begin is (begin exp1 ... expN). Begin evaluates each expression in turn, and returns the value of the last expression. The only was this is useful is if all expressions before the last create side effects (mutate state or perform I/O). Also keep in mind both define and each clause of a cond contain and implicit begin.
In Java the procedure that prints a string creates side effect. If is not the same as simply returning a string, which is what your first branch of the (if (> x 5) .. is doing.
So to simplify things, we will keep the string printing as a side effect, and the next or new value of x as the return value of the statment.
(cond ((> x 5) (display "Greater than five") (newline) x)
(else (display "Less than or equal to 5") (newline) 0))
or the nearly equivalent
(if (> x 5)
(begin (display "Greater than five") (newline) x)
(begin (display "Less than or equal to 5") (newline) 0))

Answer 3

Just use begin, which is pretty similar to a λ expression:
(if #t
(begin (displayln "Hello, world!") (displayln "wtf"))
(displayln "stdio.h"))
You can wrap pretty much anything you like into a begin expression. They are usually used for flow control, because everything within a begin is evaluated first, but since if is a macro (Created with define-syntax instead of define) it treats begin as just another expression.