Preserving string matching

[mihneagogu]

The <::> and <~> operators are quite useful, in that regard, I've seen a very similar operator which is missing (or I can't seem to have found it). Is there any equivalent operator for string concatenation?
what I would like to write is
val ays: Parsley[String] = "a" <++> "ys" and mean "match 'a' and 'ys' and retain both strings in the result" I know string concatenation is expensive, yet it would be very handy to have something like this rather than write

val ays: Parsley[String] = "a" <**> ("ys" <#> concat) where concat = (ys: String) => (xs: String) => xs.concat(ys)
Is there any reason for this not being present in the API?

[j-mie6]

The more idiomatic way would be lift2(_ ++ _, "a", "ys").

The reason it's not in the API is because it's not usually something you do very often, you can ask the same question for a lot of different operators. That being said, <+:> is in the API for a generalised collection cons, so if it can be done for general sequences nicely then I'm happy to put it in. That would make it work for Lists, Maps, Sets, etc. See #46

[j-mie6]

Of course, there is nothing to stop you defining it yourself! Defining an implicit class somewhere in your project will allow you to use the operator (it's the exact same mechanism which Parsley uses to make all the other operators... See parsley.Parsley.LazyParsley. This is part of the fun when working with parser combinators, you can make your own combinators to suit your own needs.

import parsley.Parsley
import parsley.lift.lift2

object ParsleyExtensions {
  implicit final class StringAppend[P](p: =>P)(implicit con: P => Parsley[String]) {
    def <++>(q: =>Parsley[String]): Parsley[String] = lift2[String, String, String](_ ++ _, p, q)
  }
}

[mihneagogu]

Thank you, that's a prefectly reasonable answer. What I needed wasn't it necessarily to add it to the API but to be able to use it easily without explicitly calling lift2. Implicits would do that for me, definitely

[j-mie6]

Scala's number one feature for me is implicits, for this very reason. Extension methods are seriously useful. But definitely, I think this is a good thing to include, so I'll probably add it soon enough (keep an eye out for new Parsley releases basically). I just need to be careful that whatever I do works with both Scala 2.12 and 2.13, since the collections had a huge overhaul between the two!