workspace
stringclasses 4
values | channel
stringclasses 4
values | text
stringlengths 1
3.93k
| ts
stringlengths 26
26
| user
stringlengths 2
11
|
|---|---|---|---|---|
elmlang | general | but not just that, you could create a generic "optional" function, like my `nodeIf` example, but which returned `[]` if False, so it'd work on all lists! | 2019-01-29T12:16:31.264400 | Nana |
elmlang | general | Like `(::) : a -> List a -> List a` we could have a `(:?) : Maybe a -> List a -> List a` for example. | 2019-01-29T12:16:39.264700 | Antonette |
elmlang | general | They already work like how <@Nana> suggests except that you need to wrap the lists in a node | 2019-01-29T12:17:27.266100 | Carman |
elmlang | general | I guess it doesn't flatten though | 2019-01-29T12:18:19.266900 | Carman |
elmlang | general | so you could then write:
```
[ a
, b
, c
, ... optional condition [x, y]
]
``` | 2019-01-29T12:18:56.267200 | Nana |
elmlang | general | (`optional` being a function that returns `[]` if the first argument is `False`, otherwise returns the second argument) | 2019-01-29T12:19:36.268200 | Nana |
elmlang | general | (there's probably a better name though) | 2019-01-29T12:20:11.269300 | Nana |
elmlang | general | I was thinking something along the lines of:
```
a
:: b
:: c
:? Just d -- will be appended
:? Nothing -- won't count
:? optionallyC -- optionallyC being a Maybe of the right type
:: []
``` | 2019-01-29T12:20:29.269900 | Antonette |
elmlang | general | You _could_ have something like
```
conditionalList
[ hardcoded a
, hardcoded b
, hardcoded c
, optional condition [x y]
]
``` | 2019-01-29T12:22:01.271100 | Carman |
elmlang | general | That's not very different from `Maybe.Extra.values`, is it <@Carman>? | 2019-01-29T12:22:31.272000 | Antonette |
elmlang | general | here you're basically creating many lists (one for each row). i'm not sure if there are some optimizations that could happen at runtime | 2019-01-29T12:22:47.272100 | Lilli |
elmlang | general | Oh, no. | 2019-01-29T12:22:58.272300 | Antonette |
elmlang | general | Each element in this list is an item of the list (since `(::) : a -> List a -> List a` it just appends an item to the list). | 2019-01-29T12:23:36.273000 | Antonette |
elmlang | general | `(:?) : Maybe a -> List a -> List a` is different in that it takes a `Maybe a` and only appends to the list if it's a `Just` and not a `Nothing`. | 2019-01-29T12:24:12.274200 | Antonette |
elmlang | general | yes if you use a `Maybe` under the hood. | 2019-01-29T12:24:30.274800 | Carman |
elmlang | general | what's nice about the spread operator though is that you wouldn't have to use `filterMap` or whatever on the list afterwards | 2019-01-29T12:24:33.275000 | Nana |
elmlang | general | yea, but lists are immutable in elm. when you append to a list, you're actually creating a new list with 1 more item in the end | 2019-01-29T12:24:59.276200 | Lilli |
elmlang | general | to allow multiple items you'd probably want `List` under the hood in which case `conditionalList` is `List.concat` | 2019-01-29T12:25:01.276400 | Carman |
elmlang | general | Same with something like the `(:?)` idea. | 2019-01-29T12:25:14.276900 | Antonette |
elmlang | general | I feel like first constructing a list and then filtermapping it to a different type of list becomes kind of indirect | 2019-01-29T12:25:18.277100 | Nana |
elmlang | general | Needing to do logic inline in a list like that is a bit of a smell IMO. It's not _bad_ but when I see that I pause to see if I can move that elsewhere. | 2019-01-29T12:26:37.278600 | Carman |
elmlang | general | Sure ; it's an idea for cases where these are not very long lists though. | 2019-01-29T12:26:46.278900 | Antonette |
elmlang | general | Many conditionals can be pushed up higher in the decision tree | 2019-01-29T12:26:48.279200 | Carman |
elmlang | general | (and it's only the case because Elm doesn't do optimization like in Haskell, in which `a : b : c` is the same as `[a, b, c]`, memory serves) | 2019-01-29T12:28:00.280700 | Antonette |
elmlang | general | <@Carman> I think it makes sense for html nodes / attributes though
it's nice to have "linear" code where you don't have to jump around to read it | 2019-01-29T12:28:51.282000 | Nana |
elmlang | general | which I think is a bit of a problem with moving the logic elsewhere | 2019-01-29T12:29:21.282800 | Nana |
elmlang | general | Plus, you can use names to push the specifics up in a `let` rather than putting the condition in the list itself. | 2019-01-29T12:29:25.283000 | Antonette |
elmlang | general | I agree but that leads me to the opposite conclusion :smile:. Having "linear" code in your view is why I like moving the logic up | 2019-01-29T12:30:04.283900 | Carman |
elmlang | general | I guess it's just because I'm so used to writing HTML templates :thinking_face: so I try to write Elm node lists in the same way | 2019-01-29T12:31:40.284700 | Nana |
elmlang | general | (also, <@Nana>, you're entitled to your preferences as long as it fits your teams' :wink:) | 2019-01-29T12:33:44.286300 | Antonette |
elmlang | general | I'm a big fan of the idea of separating conditional logic from the implementation of each path. This is especially powerful if you start repeating conditionals. For example:
```
message : Bool -> Html a
message condition =
div (if condition then [class "active"] else [])
(if condition then [ text "true" ] else [ text "false" ])
```
is much easier to read if we separate the conditional logic from the branches
```
message : Bool -> Html a
message condition =
if condition then
activeMessage
else
inactiveMessage
activeMessage : Html a
activeMessage =
div [class "active"] [ text "true" ]
inactiveMessage : Html a
inactiveMessage =
div [ ] [ text "false" ]
``` | 2019-01-29T12:38:55.292700 | Carman |
elmlang | general | I guess this is related to the idea of keeping code in a function at a single level of abstraction | 2019-01-29T12:40:11.294100 | Carman |
elmlang | general | On a side note, beware, `nodeIf/viewIf` can be devastating for performance if it is used for a complex node (for example a full page with `elm-css` styling). Be sure to use a lazy version like <https://package.elm-lang.org/packages/elm-community/html-extra/latest/Html-Extra#viewIfLazy> for example when you want to avoid evaluating the node. | 2019-01-29T12:41:06.294800 | Velia |
elmlang | general | I take a similar approach to case statements:
```
case maybe of
Nothing -> emptyState
Just item -> viewItem item
``` | 2019-01-29T12:43:07.296600 | Carman |
elmlang | general | Turns out doing this is super powerful, not just for views. Moving the conditional up in the decision tree removes a lot of the pain around working with Maybe | 2019-01-29T12:43:57.297600 | Carman |
elmlang | general | Tinkering with these ideas led to this article: <https://robots.thoughtbot.com/problem-solving-with-maybe> and this ElmEurope talk <https://www.youtube.com/watch?v=43eM4kNbb6c> :slightly_smiling_face: | 2019-01-29T12:45:06.298400 | Carman |
elmlang | general | <@Antonette> I'm the only frontend dev :grin: | 2019-01-29T12:48:26.299100 | Nana |
elmlang | general | Good point! | 2019-01-29T12:53:21.299300 | Nana |
elmlang | general | <@Antonette> elm-ui, which I am in the process of switching to, actually has `Element.none` | 2019-01-29T13:40:47.300800 | Nana |
elmlang | general | Yay for them :grin::+1: | 2019-01-29T13:41:15.301000 | Antonette |
elmlang | general | (I should have suggested we use elm-ui on my company's app) | 2019-01-29T13:41:45.301200 | Antonette |
elmlang | general | yeah it's really nice | 2019-01-29T13:42:31.301400 | Nana |
elmlang | general | makes so much more sense than CSS | 2019-01-29T13:43:02.301600 | Nana |
elmlang | general | It can look a bit nicer if you hide the if/else behind a function and use List.concat to keep it all lined up
```
List.concat
[ [a, b, c]
, optionalItems
, moreOptionals
]
``` | 2019-01-29T13:52:06.301900 | Lorilee |
elmlang | general | <@Lorilee> good idea! might try that :slightly_smiling_face: | 2019-01-29T13:55:10.302100 | Nana |
elmlang | general | can I call `elm make` from another directory? I just get `It looks like you are starting a new Elm project. elm init` message … I can’t discover any flags :confused: | 2019-01-29T14:00:40.303300 | Elliot |
elmlang | general | You can make files at an arbitrary path but `elm make` must be run from the directory that contains the project's `elm.json` | 2019-01-29T14:02:00.304300 | Carman |
elmlang | general | okay! thank you for confirming that :blush: | 2019-01-29T14:02:47.304900 | Elliot |
elmlang | general | I've got another question related to splitting things up. I had a giant `Main.elm`. It's an app for letting a user search and then displaying those search results. The seam I split the file apart on was on my SearchResults type. There are a bunch of types that it included in it and it's a nicely contained part of the app. The only place where there is some leakage is in my `getSearchResults` method. The signature for it is `getSearchResults : SearchQuery -> Cmd Msg`. `Msg` is defined in `Main.elm`. I'm not crazy about needing to pull `Msg` out into its own file to prevent circular dependencies. So, I think I have two options, leave `getSearchResults` in `Main.elm` or use a type placeholder for `Msg`. Any recommendations? | 2019-01-29T18:13:14.309200 | Marcus |
elmlang | general | Side note, I just tried the type placeholder approach and I'm still picking compiler errors out of my forehead. | 2019-01-29T18:13:40.309700 | Marcus |
elmlang | general | You could try doing something like `getSearchResults : SearchQuery -> (SearchResults -> msg) -> Cmd msg`. Not sure if that's what you meant by 'type placeholder', but it seems like a decent API | 2019-01-29T18:21:42.312800 | Huong |
elmlang | general | "Type variable" is what I meant. | 2019-01-29T18:24:30.313100 | Marcus |
elmlang | general | That does look like a good API. So, is the second param a function that takes a `SearchResults` and returns a message? | 2019-01-29T18:25:30.314100 | Marcus |
elmlang | general | Ah, I got it to work, although I don't understand the syntax entirely. | 2019-01-29T18:42:09.314700 | Marcus |
elmlang | general | Which part? | 2019-01-29T18:42:34.314900 | Kris |
elmlang | general | Hullo all - I'm implementing drag-and-drop that should interoperate with other software. In the past, I've used something like `onDragStart(e) => e.dataTransfer.setData("custom/mime-type", value)` and `val = dataTransfer.getData("custom/mime-type")` over in the receiver but this is feeling pretty janky in Elm right now. Has anyone else solved this problem? | 2019-01-29T18:53:08.316800 | Elvis |
elmlang | general | In particular, I've noticed that I can use a gross manual HTML attribute to "shell out" and set the custom data on the dragStart event but it's not clear to me how I could decode the data out of the event on the flip side. Advice or links are welcome! | 2019-01-29T18:54:19.317000 | Elvis |
elmlang | general | <@Kris> The type definition. The definition of the method in my module is this:
```
getSearchResults : SearchQuery -> (Result Http.Error SearchResults -> msg) -> Cmd msg
```
and the way I call it is:
```
getSearchResults model.searchQuery NewResults
``
The second parameter of the method is tripping me up a bit. | 2019-01-29T19:12:38.317200 | Marcus |
elmlang | general | It's just a function `Result Http.Error SearchResults -> msg` like you said | 2019-01-29T19:13:35.318200 | Kris |
elmlang | general | Yeah, I just haven't internalized that syntax. I can give the definition of what it is doing, but can't give a nuanced explanation. It will come. | 2019-01-29T19:18:42.321300 | Marcus |
elmlang | general | anyone know why I would be getting this compile error?
```
-- NAMING ERROR -------- ./src/ui/src/elm/Conversion/ClickEnergy/Validations.elm
Module `Char` does not expose `isAlpha`
3| import Char exposing (isDigit, isAlpha)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
``` | 2019-01-29T20:18:13.321900 | Son |
elmlang | general | AFAIK, `Char` _does_ expose `isAlpha`… | 2019-01-29T20:18:36.322300 | Son |
elmlang | general | <@Son> `isAlpha` was added in Elm 0.19 | 2019-01-29T20:27:50.323000 | Earlean |
elmlang | general | it looks like you're using Elm 0.18 | 2019-01-29T20:28:45.323700 | Earlean |
elmlang | general | <@Earlean> ah, no equivalent in 0.18? | 2019-01-29T20:31:13.324000 | Son |
elmlang | general | will I just have to use a range? | 2019-01-29T20:31:18.324200 | Son |
elmlang | general | ```
isAlpha : Char -> Bool
isAlpha char =
Char.isLower char || Char.isUpper char
``` | 2019-01-29T20:33:56.324800 | Earlean |
elmlang | general | Nice tip. Adding this and a variation with two Maybe values really helped clean up my code. | 2019-01-30T02:10:50.325500 | Annika |
elmlang | general | ```maybeView2 : (a -> b -> Html msg) -> Maybe a -> Maybe b -> Html msg
maybeView2 f maybeA maybeB =
case ( maybeA, maybeB ) of
( Just a, Just b ) ->
f a b
_ ->
div [] []``` | 2019-01-30T02:18:06.325700 | Annika |
elmlang | general | Which I guess is equivalent to: | 2019-01-30T02:42:03.326000 | Annika |
elmlang | general | ```maybeView2 : (a -> b -> Html msg) -> Maybe a -> Maybe b -> Html msg
maybeView2 f maybeA maybeB =
Maybe.map2 f maybeA maybeB
|> Maybe.withDefault (div [] [])``` | 2019-01-30T02:42:07.326200 | Annika |
elmlang | general | Does anyone know which github repository the Debugger code is defined in? | 2019-01-30T03:11:46.327200 | Norris |
elmlang | general | <@Norris> <https://github.com/elm/browser/tree/master/src/Debugger> | 2019-01-30T03:14:56.327600 | Earlean |
elmlang | general | and <https://github.com/elm/browser/blob/master/src/Elm/Kernel/Debugger.js> | 2019-01-30T03:15:59.327800 | Earlean |
elmlang | general | ah thank you! I'm looking for it because there is an issue with the `File.Select.file` code on certain browsers (e.g. safari on iOS), and it appears the issue can be mitigated by temporarily appending an input element to the DOM and then removing it. I noticed that this is exactly what the Debugger kernel code does. | 2019-01-30T03:17:55.329700 | Norris |
elmlang | general | Here's the `elm/file` issue I'm referencing, which I just posted my quick-and-dirty fix in: <https://github.com/elm/file/issues/4> | 2019-01-30T03:18:27.330400 | Norris |
elmlang | general | is `text ""` even added to the dom? | 2019-01-30T03:40:36.330500 | Saran |
elmlang | general | I heard there were plans to make the compiler detect functions and give a type error if you try to compare them? Could that also mean that all types which don't contain functions would be moved into `comparable`? :slightly_smiling_face: | 2019-01-30T03:57:42.332400 | Nana |
elmlang | general | That's a good question <@Saran> and I'm not sure. Still, I prefer having an `Element.none` that says it's no element than a `text ""` that's a little bit less clear on why it's here. | 2019-01-30T03:58:25.332800 | Antonette |
elmlang | general | So then we could have native any-dicts! | 2019-01-30T03:58:39.333200 | Nana |
elmlang | general | <@Antonette> I actually considered defining `none = text ""` for myself hehe | 2019-01-30T03:59:57.333300 | Nana |
elmlang | general | yeah, it should be a zero element | 2019-01-30T04:00:53.333500 | Saran |
elmlang | general | `comparable` is kind of a confusing name. It's types where `<` and `>` and `==` are defined | 2019-01-30T04:02:36.335100 | Earlean |
elmlang | general | <@Earlean> indeed, but if you know there are no functions, you could use an internal function like `Debug.toString` and then maybe put it through a hashing function | 2019-01-30T04:03:53.336800 | Nana |
elmlang | general | or would it be too "weird" that users could use `>` and `<` on random types? | 2019-01-30T04:05:31.337900 | Nana |
elmlang | general | `comparable` required ordering, and custom types don't have an order, unless the compiler assumes the order is the one in which they are defined, e.g. `type Custom = First | Second | Third`, and then `First < Second` | 2019-01-30T04:06:35.339400 | Norris |
elmlang | general | off the top of my head, that's how Haskell works if you define a custom data type with the `Ord` typeclass | 2019-01-30T04:07:19.340200 | Norris |
elmlang | general | <@Norris> I was thinking it would just be an arbitrary ordering, only really used for performance in data structures | 2019-01-30T04:08:16.340700 | Nana |
elmlang | general | maybe it could have an alternate API instead of `>` and `<` though | 2019-01-30T04:09:07.341300 | Nana |
elmlang | general | then you just want equality | 2019-01-30T04:09:15.341500 | Norris |
elmlang | general | not orderability | 2019-01-30T04:09:21.341700 | Norris |
elmlang | general | which Elm doesn't have | 2019-01-30T04:09:24.341900 | Norris |
elmlang | general | again to go back to Haskell, there's `Eq` and there's `Ord` | 2019-01-30T04:09:38.342300 | Norris |
elmlang | general | one gives you `==`, the other gives you `>` and `<` | 2019-01-30T04:09:58.342700 | Norris |
elmlang | general | but `Ord` requires `Eq` | 2019-01-30T04:10:02.343000 | Norris |
elmlang | general | <@Norris> but orderability can give you better performance for lookups
example: <https://github.com/pzp1997/assoc-list/blob/master/Performance.md> | 2019-01-30T04:10:45.344000 | Nana |
elmlang | general | I think it is generally hard (if not impossible) to come with both fast and reliable hashing function for arbitrary data | 2019-01-30T04:27:53.345700 | Lynne |
elmlang | general | If you convert elements to string and use, say, md5 hash (or whatever else out there without collisions), creation and insertion will be a major bottleneck | 2019-01-30T04:29:28.346800 | Lynne |
elmlang | general | <@Lynne> yeah that may be true | 2019-01-30T04:31:03.347100 | Nana |
elmlang | general | Not to mention that comparing large strings is not that efficient | 2019-01-30T04:31:42.347500 | Lynne |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.