-- попытка раз
someKeyword = string "someKeyword"
identifier  = many1 letter
someExpr    = someKeyword <|> identifier -- сломается на "someIdentifier"

-- попытка два
someKeyword = string "someKeyword"
identifier  = many1 letter
someExpr    = try someKeyword <|> identifier -- на "someIdentifier" пройдёт identifier.

spaces = skipMany space <?> "white space"

VD>На предложение создать реальный (простенький) пример мне было заявлено, что на это нет времени, так как иначе будет некогда отвечать на мои сообщения. Почему-то мне кажется, что время на создание теста должно было бы уйти куда меньше.

Имеем: x := alpha * p + omega * s;


Разворачивается в:

for(i = 0; i < x.Length; i++)
{
    x[i] = alpha * p[i] + omega * s[i];
}

#include <cmath>
#include <iostream>
#include <vector>

typedef std::vector< float > vector_t;

class vector_element_extractor_t
    {
    public :
        virtual float
        operator[]( unsigned int index ) const = 0;

        virtual unsigned int
        size() const = 0;
    };

class delayed_scalar_by_vector_multiply_t
    :    public vector_element_extractor_t
    {
    public :
        delayed_scalar_by_vector_multiply_t(
            float a,
            const vector_t & b )
            :    a_( a )
            ,    b_( b )
            {}

        virtual float
        operator[]( unsigned int index ) const
            {
                return b_[ index ] * a_;
            }
        virtual unsigned int
        size() const
            {
                return b_.size();
            }

    private :
        float a_;
        const vector_t & b_;
    };

delayed_scalar_by_vector_multiply_t
operator*(
    float a,
    const vector_t & b )
    {
        return delayed_scalar_by_vector_multiply_t( a, b );
    }

class delayed_vector_by_scalar_div_t
    :    public vector_element_extractor_t
    {
    public :
        delayed_vector_by_scalar_div_t(
            const vector_t & a,
            float b )
            :    a_( a )
            ,    b_( b )
            {
                if( fabs( b ) < 0.00000000001 )
                    throw std::invalid_argument( "devider is 0" );
            }

        virtual float
        operator[]( unsigned int index ) const
            {
                return a_[ index ] / b_;
            }
        virtual unsigned int
        size() const
            {
                return a_.size();
            }

    private :
        const vector_t & a_;
        float b_;
    };

delayed_vector_by_scalar_div_t
operator/(
    const vector_t & a,
    float b )
    {
        return delayed_vector_by_scalar_div_t( a, b );
    }

class delayed_sum_of_vectors_t
    :    public vector_element_extractor_t
    {
    public :
        delayed_sum_of_vectors_t(
            const vector_element_extractor_t & a,
            const vector_element_extractor_t & b )
            :    a_( a )
            ,    b_( b )
            {
                if( a.size() != b.size() )
                    throw std::invalid_argument(
                            "vectors sizes must be the same" );
            }

        virtual float
        operator[]( unsigned int index ) const
            {
                return a_[ index ] + b_[ index ];
            }
        virtual unsigned int
        size() const
            {
                return a_.size();
            }

    private :
        const vector_element_extractor_t & a_;
        const vector_element_extractor_t & b_;
    };

delayed_sum_of_vectors_t
operator+(
    const vector_element_extractor_t & a,
    const vector_element_extractor_t & b )
    {
        return delayed_sum_of_vectors_t( a, b );
    }

class delayed_sub_of_vectors_t
    :    public vector_element_extractor_t
    {
    public :
        delayed_sub_of_vectors_t(
            const vector_element_extractor_t & a,
            const vector_element_extractor_t & b )
            :    a_( a )
            ,    b_( b )
            {
                if( a.size() != b.size() )
                    throw std::invalid_argument(
                            "vectors sizes must be the same" );
            }

        virtual float
        operator[]( unsigned int index ) const
            {
                return a_[ index ] - b_[ index ];
            }
        virtual unsigned int
        size() const
            {
                return a_.size();
            }

    private :
        const vector_element_extractor_t & a_;
        const vector_element_extractor_t & b_;
    };

delayed_sub_of_vectors_t
operator-(
    const vector_element_extractor_t & a,
    const vector_element_extractor_t & b )
    {
        return delayed_sub_of_vectors_t( a, b );
    }

vector_t &
operator<<(
    vector_t & receiver,
    const vector_element_extractor_t & extractor )
    {
        receiver.clear();
        receiver.reserve( extractor.size() );

        for( unsigned int i = 0, i_max = extractor.size();
                i != i_max;
                ++i )
            receiver.push_back( extractor[ i ] );

        return receiver;
    }

std::ostream &
operator<<(
    std::ostream & to,
    const vector_t & v )
    {
        for( unsigned int i = 0, i_max = v.size(); i != i_max; ++i )
            {
                if( i )
                    to << " ";
                to << v[ i ];
            }
        return to;
    }

void
main()
    {
        const int vector_size = 5;
        float a_src[ vector_size ] = { 1, 2, 3, 4, 5 };
        float b_src[ vector_size ] = { 0.5, 1.5, 2.5, 3.5, 4.5 };

        vector_t a( a_src, a_src + vector_size );
        vector_t b( b_src, b_src + vector_size );
        vector_t d( b_src, b_src + vector_size );
        vector_t c;

        c << 0.0 * a + 2.0 * b - 1 * d + b / 0.2;

        std::cout << c << std::endl;
    }

((a1 * v + a2 * v2)/0.5 - (a3*v3 - a4*v4)*2) * 0.75;

Modifiers      := "public" | "private" | "protected";
Method         := Modifiers ident "(" [ ident (", " ident)* ] ")" "{" ... "}"
AbstractMethod := Modifiers ident "(" [ ident (", " ident)* ] ")" ";"

L>spaces = skipMany space <?> "white space"
L>

variable = do
    x <- identifier
        return (Var x)

variable = liftM Var identifier