Conditional structures: Difference between revisions

=={{header|Ol}}==

if-then, the simplest conditional primitive.

<lang scheme>

(if (= (* 2 2) 4) (print "if-then: equal"))

(if (= (* 2 2) 6) (print "if-then: non equal"))

; ==> if-then: equal

</lang>

if-then-else, the full conditional 'if' primitive.

<lang scheme>

(if (= (* 2 2) 4) (print "if-then-else: equal") (print "if-then-else: non equal"))

(if (= (* 2 2) 6) (print "if-then-else: non equal") (print "if-then-else: i don't know"))

; ==> if-then-else: equal

; ==> if-then-else: i don't know

</lang>

unless, the opposite for 'if'.

<lang scheme>

(unless (= (* 2 2) 4) (print "unless: non equal"))

(unless (= (* 2 2) 6) (print "unless: i don't know"))

(unless (= (* 2 2) 4) (print "unless: non equal") (print "unless: equal"))

(unless (= (* 2 2) 6) (print "unless: i don't know") (print "unless: non equal"))

; ==> unless: i don't know

; ==> unless: equal

; ==> unless: i don't know

</lang>

case, the sequence of comparing values.

<lang scheme>

(case (* 2 2)

(3

(print "case: 3"))

(4

(print "case: 4"))

((5 6 7)

(print "case: 5 or 6 or 7"))

(else

(print "case: i don't know")))

; ==> case: 4

</lang>

cond, the sequnce of comparators.

<lang scheme>

(cond

((= (* 2 2) 4)

(print "cond: equal"))

((= (* 2 2) 6)

(print "cond: not equal"))

(else

(print "cond: i don't know")))

; ==> cond: equal

</lang>

tuple-case, smart tuple comparer with variables filling.

<lang scheme>

(tuple-case (tuple 'selector 1 2 3)

((case1 x y)

(print "tuple-case: case1 " x ", " y))

((selector x y z)

(print "tuple-case: selector " x ", " y ", " z))

(else

(print "tuple-case: i don't know")))

; ==> tuple-case: selector 1, 2, 3

</lang>

case-lambda, selecting the lambda based on arguments count.

<lang scheme>

(define smart (case-lambda

((x)

(print x ", -, -"))

((x y)

(print x ", " y ", -"))

((x y z)

(print x ", " y ", " z))))

(smart 1) ; ==> 1, -, -

(smart 1 2) ; ==> 1, 2, -

(smart 1 2 3) ; ==> 1, 2, 3

</lang>