lue-bird/elm-linear-direction/8.0.0

linear direction

• foldr, foldl: does foldr mean fold right? A quite unclear name
• no Array.getr/l, setr/l but foldr, foldl?
• negative indices
  • Array.slice 0 -1 is handy! But you can't do slice 2 -0
  • many operations support negative indices, but others don't
  • not explicit → can have unintended side-effects

Better use the Direction as an argument!

import Linear exposing (Direction(..))
import List.Linear
import Array exposing (Array)
import Array.Linear

[ 'l', 'i', 'v', 'e' ]
    |> List.Linear.foldFrom "" Up String.cons
--> "evil"

[ 'l', 'i', 'v', 'e' ]
    |> List.Linear.foldFrom "" Down String.cons
--> "live"

Array.fromList [ 'e', 'v', 'i', 'l' ]
    |> Array.Linear.element ( Down, 0 )
--> Ok 'l'

• → a less cluttered API, e.g.

  • foldFrom instead of foldr, foldl
  • toChunksOf instead of chunksFromLeft/-Right
  • padToLength instead of resizerRepeat, resizelRepeat, resizerIndexed, resizelIndexed

• → deal with both directions at once

  import Linear exposing (DirectionLinear)
  import Array exposing (Array)
  import Array.Linear
  
  alter :
      ( DirectionLinear, Int )
      -> (element -> element)
      -> (Array element -> Array element)
  alter location alter =
      \array ->
          case array |> Array.Linear.element location of
              Err _ ->
                  array
  
              Ok elementAtLocation ->
                  array
                      |> Array.Linear.elementReplace location
                          (\() -> elementAtLocation |> alter)

• → direction is always explicit

Order

Build compare operations for basic types, records, type choices. All without comparable, number, ...

import Order exposing (Ordering)
import Case
import Int.Order
import Char.Order
import String.Order

type User
    = User
        { firstName : String
        , lastName : String
        , age : Int
        }

userOrder : Ordering User
userOrder =
    Order.by (\(User user) -> user)
        (Order.onTieNext
            [ Order.by .lastName
                (String.Order.greaterEarlier (Char.Order.alphabetically Case.lowerUpper))
            , Order.by .firstName
                (String.Order.greaterEarlier (Char.Order.alphabetically Case.lowerUpper))
            , Order.by .age Int.Order.increasing
            ]
        )

[ User { firstName = "Andy", lastName = "Baldwin", age = 90 }
, User { firstName = "Bert", lastName = "Anderson", age = 23 }
, User { firstName = "Alec", lastName = "Anderson", age = 8 }
, User { firstName = "Alec", lastName = "Anderson", age = 100 }
]
    |> List.sortWith userOrder
--> [ { firstName = "Alec", lastName = "Anderson", age = 8 }
--> , { firstName = "Alec", lastName = "Anderson", age = 100 }
--> , { firstName = "Bert", lastName = "Anderson", age = 23 }
--> , { firstName = "Andy", lastName = "Baldwin", age = 90 }
--> ]

↑ other examples

where linear direction is already being used

• emptiness-typed
• typesafe-array
• rosetree-path

suggestions?

→ contribute