Lisplog

Feed Aggregator Page 674

Rendered on Thu, 25 Nov 2021 18:33:57 GMT  newer latest older 

Conditional JSON decoder with optional fields

via Elm - Latest posts by @ben-t on Wed, 24 Nov 2021 13:57:22 GMT

Hi all,

I have some JSON from a 3rd party API that can take a few different forms. For each response, there are

• Shared fields which are present in every response (id, timestamp, etc)
• There is a field type (present in every response) whose value is another JSON object with id and name keys
• There is an additional key whose name is is the name of the type object. Some types don’t actually have any additional metadata (and thus have no extra key in the response JSON).

For example:

{
  "id": 1,
  "timestamp": "etc",
  "type": {"id": 1, "name": "chair"},
  "chair": {
    // (Chair metadata goes here)
  }
}

Or...

{
  "id": 2,
  "timestamp": "etc",
  "type": {"id": 4, "name": "bed"},
  "bed": {
    // (Bed metadata goes here)
  }
}

Or...

{
  "id": 2,
  "timestamp": "etc",
  "type": {"id": 4, "name": "stool"},
  // (no metadata)
}

Where the metadata for each type has a different shape.

This is complicated by the fact that
I could naively decode this into an Elm record with lots of optional fields:

type alias NaiveRecord =
    { id : Int
    , timestamp : Timestamp
    , recordType : NaiveRecordType
    , chair : Maybe ChairMetadata
    , bed : Maybe ChairMetadata
    , table : Maybe TableMetadata
    -- and so on...
    }

type alias NaiveRecordType =
    { id : Int,
    , name : String 
    }

However, this seems bad for a couple of reasons:

• It makes (theoretically) impossible states possible. The relevant metadata field for each record’s type should be Just a if and only if the recordType is the corresponding one.
• Any production code using this type will result in unnecessarily getting any metadata in/out of Maybes when we know that the value is present (or rather, if the value isn’t present, something has gone very wrong and we would like to handle that case differently!)

So, I would rather use a type like:

type Record =
    { id : Int
    , timestamp : Timestamp
    , recordType : RecordType
    }

type RecordType
    = Chair ChairMetadata
    | Bed BedMetadata
    | Table TableMetadata
    | Stool      -- Has no additional metadata
    | Bookcase   -- Has no additional metadata
    -- And so on

However, I’m not sure quite how to decode this from the JSON, as it requires checking the type's name field, and then (possibly) nesting the top level metadata field within the RecordType.

My current best guess is to use the “naive” type as an intermediate type. For example:

decodeNaiveRecord : Decoder NaiveRecord
-- i.e. relatively cookiecutter decoder with Decode.mapN or similar

fromNaiveRecord : NaiveRecord -> Decoder Record
-- i.e. succeed if "type" matches the metadata field, fail otherwise

decodeRecord : Decoder Record
decodeRecord =
    Decode.andThen fromNaiveRecord decodeNaiveRecord

I have 2 main questions that I would like help with:

• Is my “target” type (Record) a good design for this problem or is there a better solution/pattern I should be aware of
• If it is an acceptable design, then what is the best approach to decode the JSON into it? Is there any clear and elegant way to do so without going via an intermediate data type?

Thanks!

Working with folders

via Elm - Latest posts by @hrnxm Harun Muderizovic on Wed, 24 Nov 2021 07:10:43 GMT

As wolfadex said, your best bet is to read it as a list of files. Here is a very very rough example of what we’re doing.

'let' best practices

via Elm - Latest posts by @mje on Tue, 23 Nov 2021 15:47:59 GMT

SPJ’s book is mostly about non-strict languages, whereas Elm is strict, so you can’t always apply lessons from the book to Elm.

Even if that section of the book is strictness agnostic, another aspect is that the book describes translating source code to an enhanced lambda calculus where there are no temporary variables. So even if there is such a translation step in Elm, with referential transparency, f model and newModel are interchangeable, and a good compiler ought to be able recognize repeated expression and optimize them away.

'let' best practices

via Elm - Latest posts by @dkodaj Daniel Kodaj on Tue, 23 Nov 2021 15:13:06 GMT

I don’t know why you would think that newModel is computed twice.

Section 3.2 of The Implementation of Functional Languages by Peyton Jones seems to imply that you evaluate f newModel (using the let definition from the first example above) by calculating f (complicatedTransformationOf model). I never checked how Elm actually does it.

Thanks!

'let' best practices

via Elm - Latest posts by @dkodaj Daniel Kodaj on Tue, 23 Nov 2021 12:24:32 GMT

This is probably a highly complicated question (possibly answered elsewhere), but I find myself wondering about it a lot – what are the main performance-improving pro tips for let expressions? I’m thinking of cases like the following:

update msg model =
    let
        newModel =
            complicatedTransformationOf model

        cmd =
            someFunctionOf newModel
    in
    ( newModel, cmd )

Is newModel calculated here twice? If it is, then is it more performant to write this instead?

update msg model =
    let
        f x =
            complicatedTransformationOf x

        cmd x =
            someFunctionOf x

        g x =
            (x, someFunctionOf x)
    in
    g (f model)

Working with folders

via Elm - Latest posts by @jaruji on Tue, 23 Nov 2021 11:41:30 GMT

Hey everyone,
I was wondering if someone here has some experience/idea about how to upload entire folders into an Elm app. As far as I know, this option is not supported nowhere in the File package. It is possible to upload folders with HTML input element, but they get stored somewhere in the DOM if I understand correctly (specifically at the id of the input). I would love to be able to:

1. Get a JSON schema of the uploaded folder structure
2. Have all the files stored in Elm be it as a List File or List String (I’m mainly interested in their content)

Would love to hear you suggestions, Thank you!

Error in Elm Guide

via Elm - Latest posts by @system system on Tue, 23 Nov 2021 09:04:59 GMT

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

Updating a deeply nested array?

via Elm - Latest posts by @pit Pit Capitain on Tue, 23 Nov 2021 06:42:58 GMT

If you are always editing one node at a time, you could use a tree zipper to focus on the currently edited node. Then most of the work would be spent on moving the focus, but not on editing the current node. Maybe this is better in your use case?

Introducing Elm Editor - a web-based IDE for Elm programs

via Elm - Latest posts by @Viir Michael Rätzel on Mon, 22 Nov 2021 20:11:25 GMT

I implemented this at Expand loading from git repositories to support links to repository root · elm-fullstack/elm-fullstack@6c5d806 · GitHub

You can now use the link to the repository. The loading from git now also works for the URL you find in the address bar on the repository homepage. In this case, Elm Editor uses the HEAD reference from the git repository to determine the default branch.

(Meanwhile I also updated the demo instance to integrate that change)

Updating a deeply nested array?

via Elm - Latest posts by @Snaker on Mon, 22 Nov 2021 16:36:55 GMT

This looks great. I can’t imagine it helping performance much but at least should make the task much easier.

Oh that is exactly how I implemented variables, nice to see I am on the right track. I did leave out this part though for simplicity sake.

No, I explicitly want to modify the NumberLiteral and that is just the start. I need to be able to do all sorts of complex modifications to the AST in real time, deleting and moving nodes and so on. (If you need to know, it is similar to what the editor of the Roc programming language does, allowing you to edit the language directly in AST form. At least from what I can tell from the videos.)

I think it might be better to think about me wanting to writer an editor for a complex ToDo List with child elements or something like this, which would require similar solutions.

 newer latest older