       RE: Re: pattern matching quirks

• To: mathgroup at smc.vnet.net
• Subject: [mg29382] RE: [mg29367] Re: [mg29351] pattern matching quirks
• From: "Wolf, Hartmut" <Hartmut.Wolf at t-systems.de>
• Date: Sat, 16 Jun 2001 02:47:53 -0400 (EDT)
• Sender: owner-wri-mathgroup at wolfram.com

```Dear Andrzej,

the problem -- or quirk -- seems to have it's origin at the naming of
patterns, (and possibly it's nothing more than a missing error message).

To repeat your observation in a different way:

In:= g[x] /. g[a : x | y ...] :> its[a]
Out= g[x]
In:= g[y] /. g[a : x | y ...] :> its[a]
Out= its[y]
In:= g[y, y] /. g[a : x | y ...] :> its[a]
Out= its[y, y]
In:= g[] /. g[a : x | y ...] :> its[a]
Out= g[]

We obviously have two missing matches.

Using different names for "incompatible" patterns we get:

In:= g[x] /. g[(a : x) | (b : y ...)] :> its[a, b]
Out= its[x]
In:= g[y] /. g[(a : x) | (b : y ...)] :> its[a, b]
Out= its[y]
In:= g[y, y] /. g[(a : x) | (b : y ...)] :> its[a, b]
Out= its[y, y]
In:= g[] /. g[(a : x) | (b : y ...)] :> its[a, b]
Out= its[]

So far everything fine. But when trying to use the same name:

In:= g[x] /. g[(a : x) | (a : y ...)] :> its[a]
>From In:=
Pattern::"patv": "Name \!\(a\) used for both fixed and variable length \
patterns."
>From In:=
Pattern::"patv": "Name \!\(a\) used for both fixed and variable length \
patterns."
Out= its[x]

an error message ... but we get the result!

So just switch it off !

In:= Off[Pattern::"patv"]

In:= g[x] /. g[(a : x) | (a : y ...)] :> its[a]
Out= its[x]
In:= g[y] /. g[(a : x) | (a : y ...)] :> its[a]
Out= its[y]
In:= g[y, y] /. g[(a : x) | (a : y ...)] :> its[a]
Out= its[y, y]
In:= g[] /. g[(a : x) | (a : y ...)] :> its[a]
Out= its[]

MatchQ just seems to ignore pattern names (since it does no transformation
on it). So we may believe in just a single way matching is done in
Mathematica.

Yours, Hartmut Wolf

> -----Original Message-----
> From: Andrzej Kozlowski [mailto:andrzej at tuins.ac.jp]
To: mathgroup at smc.vnet.net
> Sent: Friday, June 15, 2001 8:24 AM
> To: mathgroup at smc.vnet.net
> Subject: [mg29382] [mg29367] Re: [mg29351] pattern matching quirks
>
>
> That the default value for a pattern in a function definition
> must much a
> pattern seems to me obvious. After all, it is by matching the
> default value
> to the pattern that Mathematica finds out what it should
> return. How else
> could this be accomplished?
>
> As for your problem, it seems to be due to a your use of
> RepeatedNull. It
> can be demonstrated on a simpler example:
>
> In:=
> f[a:Alternatives[x,y...]]:=1
> In:=
> f[x]
> Out=
> f[x]
> In:=
> f[y]
> Out=
> 1
>
>
> But,
>
> In:=
> MatchQ[x,Alternatives[x,y...]]
> Out=
> True
> In:=
> MatchQ[y,Alternatives[x,y...]]
> Out=
> True
>
> The same thing without RepeatedNull (...) works as expected.
>
> On the other hand,
>
> In:=
> Clear[f]
> In:=
> f[x|y...]:=1
> In:=
> f/@{x,y}
> Out=
> {1,1}
>
> so it looks like the problem is with the combination of
> RepeatedNull and
> Pattern. In fact it seems it can be further  reduced to the following
> behaviour:
>
> In:=
> MatchQ[x,a:(x|y...)]
> Out=
> True
> In:=
> MatchQ[g[x],g[a:(x|y...)]]
> Out=
> False
>
> but
>
> In:=
> MatchQ[g[y],g[a:(x|y...)]]
> Out=
> True
>
> and
>
> In:=
> MatchQ[g[x],g[(x|y...)]]
> Out=
> True
>
> I admit that this does seem like a "quirk". On the other hand
> I can't see
> why you should ever need to use a pattern like
> Alternatives[x,RepeatedNull[y]] which ought to be equivalent to simple
> Alternatives[x,y].
>
>
> --
> Andrzej Kozlowski
> Toyama International University
> JAPAN
>
> http://platon.c.u-tokyo.ac.jp/andrzej/
> http://sigma.tuins.ac.jp/~andrzej/
>
>
>
> on 01.6.14 3:27 PM, Michael at michael at science.edu wrote:
>
> > I am trying to write a function which matches only on a
> specific pattern of
> > arguments, some of which can be optional.  The problem I am
> having is that
> > certain complex patterns aren't being matched under
> conditions which should
> > match.
> >
> > For example:
> >
> > In := test[1, inputs : (X["4"] | X[X[_Integer]] ...) :
> X["4"]] := inputs
> >
> > In := test
> > Out := X
> >
> > This is the expected behavior.  However if I redefine the
> function so that
> > the alternatives are collected within a single head, it
> doesn't work:
> >
> > In := Clear[test];
> > test[1, inputs : (X["4" | X[_Integer] ...]) : X["4"]] := inputs
> >
> > In := test
> > Out := test
> >
> > In := MatchQ[X["4"], (X["4" | X[_Integer] ...])]
> > Out := True
> >
> > MatchQ says that my default values matches the given
> pattern.  Through some
> > experimentation I had discovered that the function will NOT
> be called if the
> > default value does not match the pattern for the optional
> argument.  This is
> > annoying (and undocumented I think) because I would like to insert a
> > function call to generate the default value.  This does not
> work right
> > either because the default value appears to be evaluated
> when the function
> > is defined, and wrapping it with Hold causes it to fail the
> above pattern
> > match.  So instead I have to assign it to some inane value
> (hence the
> > alternatives) and then do a rule transformation in the
> function itself (not
> > shown above).
> >
> > So here are my questions:
> > 1. Why does the default value for a pattern have to match
> that pattern?
> > 2. Why is the default value seeming to be evaluated when
> the function is
> > defined?
> > 3. Why do some patterns pass MatchQ but not result in a
> function call?
> > Notably, X[a|b] versus X[a]|X[b]?
> > 4. What other quirks should I be aware of that I haven't
> run into yet? :-)
> >
> > Regards,
> >
> > Michael Schmidt
> > michael at science.edu
> >
> >
> >
> >
> >
>
>

```

• Prev by Date: Re: Re: pattern matching quirks
• Next by Date: How does one write a rule that does integration by parts...in steps ?
• Previous by thread: Re: Re: pattern matching quirks
• Next by thread: Re: pattern matching quirks