Feed Aggregator Page 650

Rendered on Fri, 25 Sep 2020 09:03:22 GMT  newer latest older 

Parsers with Error Recovery

via Elm - Latest posts by @jxxcarlson James Carlson on Fri, 25 Sep 2020 04:45:10 GMT

@rupert, I just cloned your parser-recoverable repo and tried the Array example. Beautiful! Am going to study your code and see if I can use it to improve the MiniLaTeX parser. Should give better results than what I have now (chunking as above + error messages using Parser.Advanced).

I should be able to introduce parser-recoveralble gradually so as not to have to rewrite the whole parser before seeing benefits from it.

Accessing values in custom types

via Elm - Latest posts by @meowgorithm Christian Rocha on Thu, 24 Sep 2020 19:21:36 GMT

Exactly what I was looking for — thank you!

Accessing values in custom types

via Elm - Latest posts by @meowgorithm Christian Rocha on Thu, 24 Sep 2020 18:51:43 GMT

I’m wondering if there’s a way to get values out of a custom type, in an example similar to the following, without using a case switch. Wondering if I’m missing something obvious.

type A = A Int Int

getFirst : A -> Int
getFirst a =
    case A of
        A x _ -> x

I know that the above would be better modeled as a tuple, and a record work do as well, but this is just a trite example to help illustrate my question.

Is it compile to

via Elm - Latest posts by @Naserdin Naserdin on Thu, 24 Sep 2020 14:32:04 GMT

Since Elm is compile to js code, is it possible to go svelte’s approach to directly compile to raw dom manipulation, and no vdom?

Getting started with Elm Warrior

via Elm - Latest posts by @system system on Thu, 24 Sep 2020 10:42:57 GMT

This topic was automatically closed 10 days after the last reply. New replies are no longer allowed.

Alexander Artemenko: trivial-timeout

via Planet Lisp by on Wed, 23 Sep 2020 18:15:19 GMT

Today I found that :read-timeout option of the Dexador does not work as expected and remembered about this small but useful library. It provides the only one macro which executes code and limits it's execution to a given number of seconds.

For illustration, I'll use https://httpbin.org This is a service which helps you to test HTTP libraries. If you didn't hear about it, I recommend to look at.

Let's retrieve an URL, which responds in 10 seconds. Even with :read-timeout option, dexador waits 10 seconds:

POFTHEDAY> (time
            (nth-value 1
              (dex:get "https://httpbin.org/delay/10"
                       :read-timeout 2)))
Evaluation took:
  10.692 seconds of real time
  
200

If the site is not responding, a request may hang and block your application. Here is where trivial-timeout comes to the rescue!

POFTHEDAY> (trivial-timeout:with-timeout (2)
             (time
              (nth-value 1
                (dex:get "https://httpbin.org/delay/10"))))
Evaluation took:
  2.003 seconds of real time
  before it was aborted by a non-local transfer of control.
  
; Debugger entered on #<COM.METABANG.TRIVIAL-TIMEOUT:TIMEOUT-ERROR {10055B5373}>

Internally, this library generates the implementation-specific code to interrupt the code execution. Here how our example will look like for SBCL:

(let ((seconds 2))
  (flet ((doti ()
           (progn
             (time (nth-value 1
                     (dexador:get "https://httpbin.org/delay/10"))))))
    (cond
      (seconds
       (handler-case
           (sb-ext:with-timeout seconds
             (doti))
         (sb-ext:timeout (com.metabang.trivial-timeout::c)
           (declare (ignore com.metabang.trivial-timeout::c))
           (error 'com.metabang.trivial-timeout:timeout-error))))
      (t (doti)))))

And this is the same code, expanded on ClozureCL:

(let ((seconds 2))
  (flet ((doit nil
           (progn (time (nth-value 1
                          (dexador:get "https://httpbin.org/delay/10"))))))
    (cond (seconds
           (let* ((semaphore (ccl:make-semaphore))
                  (result)
                  (process
                    (ccl:process-run-function
                     "Timed Process process"
                     (lambda nil
                       (setf result
                             (multiple-value-list (doit)))
                       (ccl:signal-semaphore semaphore)))))
             (cond ((ccl:timed-wait-on-semaphore
                     semaphore
                     seconds)
                    (values-list result))
                   (t
                    (ccl:process-kill process)
                    (error 'com.metabang.trivial-timeout:timeout-error)))))
          (t (doit)))))

Don't know if such running the code in the separate thread can have some side-effects. At least, library's README says that it might be dangerous :)))

Elm-css vendor prefixes

via Elm - Latest posts by @hexedhash Giorgio on Wed, 23 Sep 2020 15:51:38 GMT

Hello!

I’m curious to learn how folks who use elm-css are adding vendor prefixes to their css.

I saw this [seemingly outdated] github thread but don’t quite understand how something like webpack+postcss could add prefixes to dynamically generated css.

Parsers with Error Recovery

via Elm - Latest posts by @rupert Rupert Smith on Wed, 23 Sep 2020 11:39:45 GMT

I found some time at the weekend to look through these. The parsing papers are not really much use when it comes to Elm, as they are all about LR parsers - tree sitter is presumably LR parser based. The Elm parser is a recursive descent parser and so is for LL grammars.

This is why it has backtrackable for situations where you need to parse ahead, realize you are on the wrong branch and then back-up and try a different one. For example in C, you might have a function signature or implementation:

// Signature
void f(int, const char*);

// Implementation
void f(int, const char*)
{
}

You don’t know which you are getting until you hit the ; or {. With an LL parser you either re-design the grammar to be more LL friendly (that is make the void f(int, const char*) bit a production of the grammar that forms part of a sig or implementation), or look ahead.

Googling for “error recovery in LL parser” or “error recovery in recursive descent parser” does turn up some relevant stuff.

From the tree sitter stuff though, this paper is quite fascinating on the topic of incremental tooling, https://www2.eecs.berkeley.edu/Pubs/TechRpts/1997/CSD-97-946.pdf. One thing to note is that written over 20 years ago, computers were a lot slower, I think that a simple chunking strategy might be good enough to keep the problem small enough with the amount of grunt we have at our disposal these days. Also, there seems to be an obsession with reaching the milestone having things fast enough to re-parse on every key stroke. A significant achievement, but I think its not really necessary as most editors implement a delay before offering auto suggests anyway, so fine to do it a few hundred ms after the last keystroke.

Creating Newspaper Columns in elm-ui

via Elm - Latest posts by @evelios Tommy Waters on Tue, 22 Sep 2020 17:54:58 GMT

I am looking to create a newspaper column style format in my app that is using elm-ui. I have been able to figure out a way to create it, but it is not without complications. First off I found that there was already some css properties that control this behavior, mainly column-count.

This works great if you are only using text for the periodical. Here is an example of this in action.
https://ellie-app.com/b3PBXCNL94qa1

textColumn
    [ Element.htmlAttribute 
        <| Html.Attributes.style "column-count" "2"
    , Element.htmlAttribute 
        <| Html.Attributes.style "display" "block" 
        -- Alternatively "inline-block"
    ]
    (...) -- Paragraphs and text elements

However, when you have more than Element.paragraph and Element.text in there, things start to go awry. Changing from using display = flex to display = block has consiquences on any other elements that may be in your content body. It looks like elm-ui makes heavy use of the flex property in for it’s styling

The picutres show what is happening to me because column [] blocks are getting messed up.

Bottom of the first column

Top of the second column

Unfortunately, the best I was able to recreate this issue was with this ellie which doesn’t really show the same problems that I had in my project. This does somewhat capture a problem state if you are willing to horizontally resize the browser carefully, you can see states where the M is shifted down into the text.
https://ellie-app.com/b3Qg7dmWVJPa1

The last thing I’ll say is that I was looking to create more of a book experience where the user would only see the content that is listed on that page, then when they scroll they would get the continuation of the content. If I was to use only basic formatting and stick with what I had in my ellies, the user would have to read the first column all the way down to the bottom and then pick up back up at the top of the page. I haven’t been able to come up with an approach that would break up the content into one viewport worth of information. If there was a way of figuring out that information, then I could do this only in elm-ui and then just use groups of columns that I create myself.

Please let me know what your thoughts are on all of this and if you know of anything I could try to accomplish any of this. It seems like I am stretching the limits of both elm-ui and css in general on this one by adding in the page-break functionality.

Alexander Artemenko: persistent-variables

via Planet Lisp by on Mon, 21 Sep 2020 19:23:46 GMT

This is a simple library which allows to define global variables and save/restore their state to some persistent storage.

For example, we can define variables for database host and password:

;; In real application you should define these
;; variables in the lisp file:

POFTHEDAY> (persistent-variables:defpvar *password*)
POFTHEDAY> (persistent-variables:defpvar *db-host*)

;; Then in the REPL you can setup the app
POFTHEDAY> (setf *password* "Some $ecret")
POFTHEDAY> (setf *db-host* "some-host.internal-to.my-company.com")

;; And save it's state:
POFTHEDAY> (with-open-file (stream "/tmp/app.config"
                                   :if-does-not-exist :create
                                   :if-exists :supersede
                                   :direction :output)
             (persistent-variables:pv-save stream))

;; At startup your app might restore values for these variables:
POFTHEDAY> (with-open-file (stream "/tmp/app.config"
                                   :direction :input)
             (persistent-variables:pv-load stream))

What this system does - it saves all symbols, defined with defpvar into the hash-table. And pv-save/pv-load serializes and deserializes them as sexps:

POFTHEDAY> (rutils:print-ht persistent-variables::*persisted*)
#{
  :DEFAULT '(*DB-HOST* *PASSWORD*)
 } 

POFTHEDAY> (with-output-to-string (s)
             (persistent-variables:pv-save s))
"(\"POFTHEDAY\" \"*DB-HOST*\" \"\\\"some-host.internal-to.my-company.com\\\"\")
(\"POFTHEDAY\" \"*PASSWORD*\" \"\\\"Some $ecret\\\"\")
"

This library can be useful for interactive applications where user can change the settings and they should be restored on restart. You probably also be interested in ubiquitous library which I didn't review yet.

 newer latest older