Different Map for Selected Item

[cjduncana]

I propose to add a new function to NonEmptyArray to map different functions depending on if an item in the list is selected or not. You can find the function definition below.

I am currently creating an interface inspired by Gmail's tablet interface: a list view on the left, and a detail view on the right. The user would select an item from the list, and the app would display its details in the view to the right. The design asks for the selected item to be visually distinct from the rest of the items.

Whenever I want to select or modify one element in a list without knowing beforehand its position in the list, I reach for Array and its get and set functions. Other users solve this problem using List and its indexedMap and foldl functions by checking if the index matches the one given. I avoid this since these functions traverse the whole list, which is always going to be slower compared to Array especially as the list grows longer. NonEmptyArray benefits the app since I know that there is always going to be at least an item, so I can use getSelected without dealing with Maybe.

I created two functions Int -> Item -> Html Msg, one for when the item is selected and the other for the other items. I also created a function that maps the items with these two functions:

indexedMapSelected : { selected : Int -> a -> b, other : Int -> a -> b } -> NonEmptyArray a -> NonEmptyArray b
indexedMapSelected { selected, other } array =
    let
        choose index =
            if index == NonEmptyArray.selectedIndex array then
                selected index
            else
                other index
    in
    NonEmptyArray.indexedMap choose array

Yesterday, I mentioned to this package owner the List.Selection.mapSelected function as inspiration for the function I created, but that was before I realize I need the index in the Array to pass in a Msg.

mapSelected : { selected : a -> b, other : a -> b } -> NonEmptyArray a -> NonEmptyArray b
mapSelected { selected, other } array =
    let
        choose index =
            if index == NonEmptyArray.selectedIndex array then
                selected
            else
                other
    in
    NonEmptyArray.indexedMap choose array

[basti1302]

This looks good to me and I would be willing to add the two functions.

Here is one thing I would like to discuss: I'm not sure about the benefit of using a record type in the type signatures of the functions. If I had written the functions I would have written them like this:

mapSelected : ( a -> b ) -> ( a -> b ) -> NonEmptyArray a -> NonEmptyArray b
mapSelected selectedFn otherFn array =
   ...

indexedMapSelected : ( Int -> a -> b ) -> ( Int -> a -> b ) -> NonEmptyArray a -> NonEmptyArray b
indexedMapSelected selectedFn otherFn array =
   ...

That's also how most library functions would be defined for similar use cases. I would prefer this way unless there are very good reasons for using the record type.

So, if you want to prepare a PR for this (including documentation and tests) I will merge it. Note that almost all functions have executable examples in their doc comments, so I would appreciate if the two new functions also have those (see tests and elm-verify-examples)

Aside: When you mentioned the idea on the Elm slack and cited List.Selection.map as an inspiration I thought that this new function should also support multiple selected elements which would not be a good fit for Array.NonEmpty but with only one selected element it fits in nicely.

[cjduncana]

I can prepare that PR.

Using a record as an input: The problem I see is that the compiler can't distinguish between the function to map the selected item and the function to map the other items, because they share the same type. That means that a programmer can accidentally place the two functions in the wrong spot in the arguments. The solution implemented by List.Selection.mapSelected is to have a record, so that the keys of the record provide some meaning to the functions used as its values. Another possibility is to create types for the two spots and export them in the library. Besides that it's a little heavy-handed, the compiler will now have the information to distinguish between the two functions, but then we just moved the problem from the function to the creation of the types. What do you think?

Aside to your aside: I corrected the link in the original issue for List.Selection.mapSelected. Both this and List.Selection has only one selected item.

[basti1302]

I think I would still prefer just two functions, accepting that the client code has the responsibility to pass the functions in the right order. However, I do not really have a strong opinion here and I see your point. If you want to go with the record type, that's also fine.

Aside to your aside to my aside: I though you were talking about http://package.elm-lang.org/packages/TheSeamau5/selection-list/latest.

[cjduncana]

I actually prefer the API from the link you provided: http://package.elm-lang.org/packages/TheSeamau5/selection-list/1.0.0/SelectionList#selectedMap

What do you think? Add a Bool argument to the beginning of the functions that is True when the item is selected? It would make the function type shorter and the user can compose this function using the other two functions that they have.

[basti1302]

So it would become something like this:

mapSelected : (Bool -> a -> b) -> NonEmptyArray a -> NonEmptyArray b
mapSelected function array =
    let
        innerFn index =
            function (index == NonEmptyArray.selectedIndex array) 
    in
    NonEmptyArray.indexedMap innerFn array

Yes, I like that! Let's go with that.