a polymorphic splitting function that splits until the increase of accuracy of splitting again is below some threshold

Split.elm

module Geometry.Split exposing (..)


type alias Config a =
    { length : a -> Float
    , split : Float -> a -> ( a, a )
    , percentageError : Float
    }


splitIntoChunks : Config a -> a -> List a
splitIntoChunks config curve =
    helper config [ curve ] []


{-| make the split function tail-recursive

-}
helper : Config a -> List a -> List a -> List a
helper config remaining accum =
    case remaining of
        [] ->
            accum

        curve :: rest ->
            let
                ( left, right ) =
                    config.split 0.5 curve

                lessAccurate =
                    config.length curve

                moreAccurate =
                    config.length left + config.length right

                average =
                    (lessAccurate + moreAccurate) / 2
            in
                if (average - lessAccurate) / average > config.percentageError then
                    helper config (right :: left :: rest) accum
                else
                    helper config rest (left :: right :: accum)