Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
    Salvador Fandiño
    @salva
    Any idea about what I am doing wrong?
    Paul Snively
    @paul-snively
    Turning an HList of Parsers and a function whose arguments are of the Parsers' types into a function taking a String to an Either of Throwable or the function's result type:
    
    import cats._, implicits._                // Be very Cats-centric
    import cats.sequence._
    
    import shapeless.{ HList, HNil }          // Only what we need from Shapeless
    import shapeless.ops.function.FnToProduct
    import shapeless.ops.hlist.IsHCons
    import shapeless.UnaryTCConstraint._
    
    import atto._, Atto._
    
    object command {
      implicit class Command[P <: HList : IsHCons : *->*[Parser]#λ](parsers: P) {
        def command[InF, InL <: HList, R](f: InF)
          (implicit
            fntop: FnToProduct.Aux[InF, InL => R],
            seq:   Sequencer.Aux[P, Parser, InL]
          ): String => Either[Throwable, R] = { s =>
            val parser = parsers.sequence
            val args   = parser.parseOnly(s).either.leftMap(s => new RuntimeException(s))
            args.map(a => fntop(f)(a))
          }
      }
    
      def describe(name: String, age: Int, height: Double) = {
        println(s"name: $name")
        println(s"age: $age")
        println(s"height: $height")
        42
      }
    
      val descCommand = (token(stringOf1(letter)) :: token(int) :: token(double) :: HNil).command(describe _)
    
      def main(args: Array[String]): Unit = descCommand("Paul 55 6.25").fold(_ => (), _ => ())
    }
    Thanks to Atto and Kittens.
    @salva: That gives me a 404.
    Rob Norris
    @tpolecat
    neato :-)
    Paul Snively
    @paul-snively
    I hadn’t encountered FnToProduct before. Kinda blows my mind that we can say “I’d like the argument list and result type of an arbitrary function, please.”
    And Kittens gives us Cats typeclasses for HList. Bam!
    “It has been 0 days since the answer was traverse/sequence.”
    Rob Norris
    @tpolecat
    :-)
    Christopher Davenport
    @ChristopherDavenport
    At some point I want to do this for some ridiculous tracing context, but don't have the time.
    Paul Snively
    @paul-snively
    Right? Arbitrary transformations of arbitrary Kleislis...
    Ryan Heins
    @RyanHeins

    Hello, I'm new here. I have a question about atto, and I already know the answer is traverse, but traverse doesn't seem to be defined. What I want is

    val myParser: Parser[MyType] = ???
    
    val myThings: ParseResult[List[MyType]] = List("thing1", "thing2").traverse(myParser.parse)

    Since I have a list of strings to parse and not just a single string I can't get sequence to work for me.

    Christopher Davenport
    @ChristopherDavenport
    Do you have cats.implicits._ in scope?
    Ryan Heins
    @RyanHeins
    I do
    Christopher Davenport
    @ChristopherDavenport
    Ah,m ParseResult only ofrms a functor, not an applicative.
    Rob Norris
    @tpolecat
    yeah
    Christopher Davenport
    @ChristopherDavenport
    Try, .traverse(a => myParser.parse(a).either)
    Rob Norris
    @tpolecat
    yeah
    @ List("1","2","3").traverse(int.parseOnly(_).either) 
    res4: Either[String, List[Int]] = Right(List(1, 2, 3))
    
    @ List("1","woozle","3").traverse(int.parseOnly(_).either) 
    res5: Either[String, List[Int]] = Left("Failure reading:bigInt")
    Ryan Heins
    @RyanHeins
    That worked, thanks!
    Christopher Davenport
    @ChristopherDavenport
    Pure is easy, but Not sure how youd implement ap over Partials
    Actually you do both in terms of partial that way you could feed.
    def pure(a: A): ParseReseult[A] = Partial(k: String => Done(k, a))
    def ap(ff: ParseResult[A => B], fa: ParseResult[A] ): ParseResult[B] = case (ff, fa) match {
        case (e@Fail(_,_,_), _) => e
        case (_, e@Fail(_,_,_) => e
        case (Done(s1, f), Done(s2, a) => Done(???, f(a))
        case (Partial(f1), _) => ???
        case (_, Partial(_)) =>  ???
    Christopher Davenport
    @ChristopherDavenport
    Thats tricky, I see why you went with functor
    Wojtek Pituła
    @Krever
    Hey, did anyone of you have a need for a more generic version of atto, where parser abstract over input (so Parser[In, Out])?
    Christopher Davenport
    @ChristopherDavenport
    I have one, gato-parsec. @Krever
    Wojtek Pituła
    @Krever
    Of course you have @ChristopherDavenport , why haven't I checked :D Thanks a lot, will check it out.
    Christopher Davenport
    @ChristopherDavenport
    It's pretty bare-bones, but you should be able to build off it
    Wojtek Pituła
    @Krever
    You didn't want to migrate/have char/string/numbers-specific parsers there? Or it just needs to be done?