Elm snippet to highlight text for when searching

Highlight.elm

module Highlight exposing (highlight, interweave)


type Html msg
    = Mark (List (Html msg))
    | Text String


mark _ children =
    Mark children


text =
    Text


{-| Alternative implementation for interweave using map2 and concatMap but it
    cannot handle lists of different lengths.

  concatMap2 : (a -> b -> List c) -> List a -> List b -> List c
  concatMap2 mapper xs ys =
    List.map2 mapper xs ys |> List.concat

  interweave : List a -> List a -> List a
  interweave =
    concatMap2 (\x y -> [ x, y ])
-}

{-| not tail recursive yet
interweave [1, 3, 5][2, 4, 6] == [1, 2, 3, 4, 5, 6].
Can handle lists of different length.
-}
interweave : List a -> List a -> List a
interweave xs ys =
    case xs of
        [] ->
            ys

        headX :: tailX ->
            case ys of
                [] ->
                    xs

                headY :: tailY ->
                    headX :: headY :: interweave tailX tailY


partitionByTerm : String -> String -> ( List String, List String )
partitionByTerm term content =
    let
        revPositions =
            String.indexes
                (String.toLower term)
                (String.toLower content)
                |> List.reverse
    in
    partitionByTermHelp revPositions term content ( [], [] )


partitionByTermHelp : List Int -> String -> String -> ( List String, List String ) -> ( List String, List String )
partitionByTermHelp revPositions term content ( misses, matches ) =
    case revPositions of
        [] ->
            ( content :: misses, matches )

        pos :: rest ->
            let
                end =
                    pos + String.length term

                miss =
                    String.dropLeft end content

                match =
                    String.slice pos end content

                newContent =
                    String.dropRight (String.length miss + String.length match) content
            in
            partitionByTermHelp rest term newContent ( miss :: misses, match :: matches )


highlight : String -> String -> List (Html msg)
highlight term content =
    partitionByTerm term content
        |> Tuple.mapBoth (List.map text) (List.map (text >> List.singleton >> mark []))
        |> (\( texts, marks ) -> interweave texts marks)

Nice solution 👍

What about publishing an elm-package of this?

Usage:

...
import Html.Highlighter exposing (highlight)
...