Learn you a Haskell for great good problems in Lux

quintus
New Member

Posts: 2

Learn you a Haskell for great good problems in Lux Apr 28, 2018 17:51:43 GMT

Quote

Post by quintus on Apr 28, 2018 17:51:43 GMT

Hello, I'm currently solving the problems in the LYAH book in Lux as an exercise. As a matter of fact though, I'm stuck on the RPN reader.
Here it is in Hs: learnyouahaskell.com/functionally-solving-problems

In Lux:

(;module: {#;doc "DOC"}

  lux

  lux/type/auto

  (lux (codata io)

       (control monad

                monoid

                functor

                applicative

                ord

                eq

                codec)

       (data [text Eq<Text> "Text/" Monoid<Text>])

       (data [sum])

       (data ["E" error])

       (data [number Codec<Text,Real>])

       (data/struct [list #* Fold<List> Monoid<List>])

       [cli #+ program:])

  utils)

(def: (solve-RPN expr)

  (All [a] (-> Text (Maybe (Number a))))

  (|> expr

      (utils;words)

      (fold folding-func #;Nil)

      (head)))

(def: (folding-func stack item)

  (All [a] (-> (List Real) Text (List Real)))

  (case stack

    (^ (list x y ys))

    (let [x_ (E;assume (decode x))

          y_ (E;assume (decode y))]


      (case item

       "+" (#;Cons (+ x_ y_) ys)

       "-" (#;Cons (- x_ y_) ys)

       "*" (#;Cons (* x_ y_) ys)

       _   (list& (%r _) stack)))



    _ (list& (%r) item)))

I hope someone can help me understand how to solve this pickle: inside folding-func, I need to convert from Text to number, so I'm using Codec<Text,Real>.
The thing is, decode doesn't return a Real but a Error<Real>, and I have no idea how to get out of this... I've looked in the Lux stdlib and I found a function that looks like what I need:

(def: #export (assume error)

  (All [a] (-> (Error a) a))

  (case error

    (#Success value)

    value



    (#Error message)

    (error! message)))

But apparently I can't import it?

I also tried this:

"+" (do Monad<Error>

       [x_ (|> x decode)

        y_ (|> y decode)
       (wrap (#;Cons (+ x y)))])

So, uhm, how do I do this?
In case there is an embarrassing mistake I have to admit that I'm still not that comfortable with Monad and Applicative in Lux...

Last Edit: Apr 28, 2018 18:04:03 GMT by quintus

Eduardo Julian
Administrator

Benevolent Dictator For Life

Posts: 27

Learn you a Haskell for great good problems in Lux Apr 29, 2018 0:42:14 GMT

Quote

Post by Eduardo Julian on Apr 29, 2018 0:42:14 GMT

Hello quintus.

I tried this program, and it works properly:

(;module:
  lux
  (lux [cli #+ program:]
       (control [monad])
       (codata [io #+ io])
       (data ["e" error]
             [number #* "int/" Codec<Text,Int> "real/" Codec<Text,Real>]
             [text]
             text/format
             (struct [list "list/" Functor<List>]))
       ))

(type: Stack (List Real))

(def: empty Stack #;Nil)

(def: (push value stack)
  (-> Real Stack Stack)
  (#;Cons value stack))

(def: (compute arg stack)
  (-> Text Stack (e;Error Stack))
  (case (real/decode arg)
    (#e;Success value)
    (#e;Success (push value stack))
    
    (#e;Error _)
    (case (int/decode arg)
      (#e;Success value)
      (#e;Success (push (int-to-real value) stack))
      
      (#e;Error _)
      (case [arg stack]
        (^template [<op> <func>]
          (^ [<op> (list& y x stack')])
          (#e;Success (push (<func> y x) stack')))
        (["+" r.+]
         ["-" r.-]
         ["*" r.*]
         ["/" r./]
         ["%" r.%])
        
        _
        (#e;Error (format "Invalid operation: " arg))))))

(def: (stack-representation stack)
  (-> Stack Text)
  (|> stack
      (list/map real/encode)
      list;reverse
      (text;join-with " ")
      (text;enclose ["[" "]"])))

(program: args
  (let [input (text;join-with " " args)
        output (case (monad;foldM e;Monad<Error> compute empty args)
                 (#e;Success stack)
                 (stack-representation stack)
                 
                 (#e;Error error)
                 error)]
    (io (log! (format " input = " input "\n"
                      "output = " output "\n")))))

Ran it with this:
java -jar target/jvm/program.jar 10 4 3 + 2 \* -

Got this output:

 input = 10 4 3 + 2 * -
output = [-4.0]

Last Edit: Apr 29, 2018 0:54:10 GMT by Eduardo Julian

Eduardo Julian
Administrator

Benevolent Dictator For Life

Posts: 27

Learn you a Haskell for great good problems in Lux Apr 29, 2018 0:52:38 GMT

Quote

Post by Eduardo Julian on Apr 29, 2018 0:52:38 GMT

To put things into perspective:

The thing is, decode doesn't return a Real but a Error<Real>, and I have no idea how to get out of this... I've looked in the Lux stdlib and I found a function that looks like what I need:

The assume function you mention exists in v0.6 (currently work-in-progress), but not in v0.5, which is the version of Lux you're using.
That is why you can't import it.
Remember that when you check the source code as it appears in the Lux repo, you're checking out the current in-progress version of the v0.6 code.

In case there is an embarrassing mistake I have to admit that I'm still not that comfortable with Monad and Applicative in Lux...

Don't worry about that. The sample code I wrote can work fine with just pattern-matching.
Though, I do a monadic fold, to handle the fact that computing over the inputs being received can fail if either the command is unknown, or there aren't enough parameters for it.

Also, the sample code I wrote corrects several syntactic and structural mistakes in your code that would get it to fail the type-checker.

Best regards.

quintus
New Member

Posts: 2

Learn you a Haskell for great good problems in Lux May 3, 2018 9:01:01 GMT

Quote

Post by quintus on May 3, 2018 9:01:01 GMT

Hello, thanks for your help.

I see that instead of trying to "escape" the Error monad I should have just adapted my computation around it. It's quite elegant!

Also thank for that ^template example, will be useful for me

The Lux Programming Language

Learn you a Haskell for great good problems in Lux

Post by quintus on Apr 28, 2018 17:51:43 GMT

Post by Eduardo Julian on Apr 29, 2018 0:42:14 GMT

Post by Eduardo Julian on Apr 29, 2018 0:52:38 GMT

Post by quintus on May 3, 2018 9:01:01 GMT

Quick Reply