A nonempty list which always has exactly one element selected.

Create one using fromLists, fromList or singleton.

A SelectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> selected
    == 4

A SelectList if list has elements.

If empty, Nothing.

fromList [] == Nothing
fromList [2, 3, 4] == Just (fromLists [] 2 [ 3, 4 ])

A SelectList containing exactly one element.

singleton 3 == fromLists [] 3 []

Return a List containing the elements in a SelectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> toList
    == [ 1, 2, 3, 4, 5, 6 ]

Return the selected element.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> selected
    == 4

Return the elements before the selected element.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> before
    == [ 1, 2, 3 ]

Return the elements after the selected element.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> after
    == [ 5, 6 ]

Index of the selected element.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> index
    == 3

Check if the selected element is first element.

fromLists [] 4 [ 5, 6 ]
    |> isHead
    == True

Check if the selected element is last element.

fromLists [ 1, 2, 3 ] 4 []
    |> isLast
    == True

Length of SelectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> length
    == 6

Length of the elements after the selected element

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> afterLength
    == 2

Length of the elements before the selected element

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> beforeLength
    == 3

Attempt to perform action over selectList and return original SelectList in cases where this action returns Nothing.

attempt f selectList =
    f selectList
        |> Maybe.withDefault selectList

Add elements to the end of a SelectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> append [ 7, 8 ]
    |> toList
    == [ 1, 2, 3, 4, 5, 6, 7, 8 ]

Add elements to the beginning of a SelectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> prepend [ 7, 8 ]
    |> toList
    == [ 7, 8, 1, 2, 3, 4, 5, 6 ]

Direction

Modify the selected element using given function.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> modify (\selected -> 2 * selected)
    == fromLists [ 1, 2, 3 ] 8 [ 5, 6 ]

Replace the selected element with new one.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> set 10
    == fromLists [ 1, 2, 3 ] 10 [ 5, 6 ]

Insert the new selected element, then move the old After/Before.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> insert After 8
    == fromLists [ 1, 2, 3 ] 8 [ 4, 5, 6 ]

Delete the selected element, then select After/Before element.

Returns Nothing if list of After/Before elements is empty.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> delete After
    == Just (fromLists [ 1, 2, 3 ] 5 [ 6 ])


fromLists [ 1, 2, 3 ] 4 []
    |> delete After
    == Nothing

A selectList selects a Direction element by a step.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> step After
    == Just (fromLists [ 1, 2, 3, 4 ] 5 [ 6 ])


fromLists [ 1, 2, 3 ] 4 []
    |> step After
    == Nothing

A selectList selects a Direction element by n steps.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> steps After 2
    == Just (fromLists [ 1, 2, 3, 4, 5 ] 6 [])


fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> steps After 3
    == Nothing

A selectList selects the first element of a selectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> moveToHead
    == fromLists [] 1 [ 2, 3, 4, 5, 6 ]

A selectList selects the last element of a selectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> moveToHead
    == fromLists [] 1 [ 2, 3, 4, 5, 6 ]

Change the selected element to the nearest one which passes a predicate function. Find the list after selected element preferentially.

isEven num =
num % 2 == 0


fromLists [ 1, 2 ] 3 [ 4, 5, 6 ]
|> select isEven
== fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]

List of all selectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    == [ fromLists [] 1 [ 2, 3, 4, 5, 6 ]
       , fromLists [ 1 ] 2 [ 3, 4, 5, 6 ]
       , fromLists [ 1, 2 ] 3 [ 4, 5, 6 ]
       , fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
       , fromLists [ 1, 2, 3, 4 ] 5 [ 6 ]
       , fromLists [ 1, 2, 3, 4, 5 ] 6 []
       ]

Transform each element of the SelectList.

fromLists [ 1, 2, 3 ] 4 [ 5, 6 ]
    |> map (\num -> num * 2)
    == fromLists [ 2, 4, 6 ] 8 [ 10, 12 ]

Position is used with mapBy.

Position is Selected if the selected element, BeforeSelected if an element before the selected element, and AfterSelected if an element after the selected element.

Transform each element of the SelectList.

The transform function receives a Position and SelectList which selects a transformed element.

mapBy is the main function in this package. Use mapBy in view.

view : SelectList String -> Html Msg
view selectList =
    ul [] <|
        SelectList.mapBy
            (\position item ->
                li [ onClick (Set item) ]
                    [ text <| toString <| SelectList.index item
                    , toString <| SelectList.selected item
                    ]
            )
            selectList

If you can not use non-empty list, use mapBy_ that receives List instead of SelectList.

This receives List instead of SelectList.