Statements

| Statements |

## Lazy statements

The primitives and composite building blocks presented before are sufficiently powerful to construct quite elaborate structures and facilities. We have presented lazy-functions and lazy-operators. How about lazy-statements? First, an appetizer:

Print all odd-numbered contents of an STL container using std::for_each (sample4.cpp):

`

        for_each(c.begin(), c.end(),
            if_(arg1 % 2 == 1)
            [
                cout << arg1 << ' '
            ]
        );

`

Huh? Is that valid C++? Read on...

Yes, it is valid C++. The sample code above is as close as you can get to the syntax of C++. This stylized C++ syntax differs from actual C++ code. First, the if has a trailing underscore. Second, the block uses square brackets instead of the familiar curly braces {}.

Here are more examples with annotations. The code almost speaks for itself.

1) block statement:

`

        statement,
        statement,
        ....
        statement

`

Basically, these are comma separated statements. Take note that unlike the C/C++ semicolon, the comma is a separator put *in-between* statements. This is like Pascal's semicolon separator, rather than C/C++'s semicolon terminator. For example:

`

        statement,
        statement,
        statement,     //  ERROR!

`

Is an error. The last statement should not have a comma. Block statements can be grouped using the parentheses. Again, the last statement in a group should not have a trailing comma.

`

        statement,
        statement,
        (
            statement,
            statement
        ),
        statement

`

Outside the square brackets, block statements should be grouped. For example:

`

        for_each(c.begin(), c.end(),
            (
                do_this(arg1),
                do_that(arg1)
            )
        );

`

2) if_ statement:

We have seen the if_ statement. The syntax is:

`

        if_(conditional_expression)
        [
            sequenced_statements
        ]

`

3) if_ else_ statement:

The syntax is

`

        if_(conditional_expression)
        [
            sequenced_statements
        ]
        .else_
        [
            sequenced_statements
        ]

`

Take note that else has a prefix dot and a trailing underscore: .else_

Example: This code prints out all the elements and appends " > 5", " == 5" or " < 5" depending on the element's actual value:

`

        for_each(c.begin(), c.end(),
            if_(arg1 > 5)
            [
                cout << arg1 << " > 5\n"
            ]
            .else_
            [
                if_(arg1 == 5)
                [
                    cout << arg1 << " == 5\n"
                ]
                .else_
                [
                    cout << arg1 << " < 5\n"
                ]
            ]
        );

`

Notice how the if_ else_ statement is nested.

4) while_ statement:

The syntax is:

`

        while_(conditional_expression)
        [
            sequenced_statements
        ]

`

Example: This code decrements each element until it reaches zero and prints out the number at each step. A newline terminates the printout of each value.

`

        for_each(c.begin(), c.end(),
            (
                while_(arg1--)
                [
                    cout << arg1 << ", "
                ],
                cout << val("\n")
            )
        );

`

5) do_ while_ statement:

The syntax is:

`

        do_
        [
            sequenced_statements
        ]
        .while_(conditional_expression)

`

Again, take note that while has a prefix dot and a trailing underscore: .while_

Example: This code is almost the same as the previous example above with a slight twist in logic.

`

        for_each(c.begin(), c.end(),
            (
                do_
                [
                    cout << arg1 << ", "
                ]
                .while_(arg1--),
                cout << val("\n")
            )
        );

`

6) for_ statement:

The syntax is:

`

        for_(init_statement, conditional_expression, step_statement)
        [
            sequenced_statements
        ]

`

It is again almost similar to C++ for statement. Take note that the init_statement, conditional_expression and step_statement are separated by the comma instead of the semi- colon and each must be present (i.e. for_(,,) is invalid).

Example: This code prints each element N times where N is the element's value. A newline terminates the printout of each value.

`

        int iii;
        for_each(c.begin(), c.end(),
            (
                for_(var(iii) = 0, var(iii) < arg1, ++var(iii))
                [
                    cout << arg1 << ", "
                ],
                cout << val("\n")
            )
        );

`

As before, all these are lazily evaluated. The result of such statements are in fact composites that are passed on to STL's for_each function. In the viewpoint of for_each, what was passed is just a functor, no more, no less.

Unlike lazy functions and lazy operators, lazy statements always return void.

Copyright © 2001-2002 Joel de Guzman
Use, modification and distribution is subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)