12

Is there a good reason for a different argument order in functions getting N-th element of Array, List or Seq:

Array.get source index
List .nth source index
Seq  .nth index  source

I would like to use pipe operator and it seems possible only with Seq:

s |> Seq.nth n

Is there a way to have the same notation with Array or List?

Paul Jurczak
  • 7,008
  • 3
  • 47
  • 72

3 Answers3

15

I don't think of any good reason to define Array.get and List.nth this way. Given that pipeplining is very common in F#, they should have been defined so that the source argument came last.

In case of List.nth, it doesn't change much because you can use Seq.nth and time complexity is still O(n) where n is length of the list:

[1..100] |> Seq.nth 10

It's not a good idea to use Seq.nth on arrays because you lose random access. To keep O(1) running time of Array.get, you can define:

[<RequireQualifiedAccess>]
module Array =
    /// Get n-th element of an array in O(1) running time
    let inline nth index source = Array.get source index

In general, different argument order can be alleviated by using flip function:

let inline flip f x y = f y x

You can use it directly on the functions above:

[1..100] |> flip List.nth 10
[|1..100|] |> flip Array.get 10

    

pad
  • 41,040
  • 7
  • 92
  • 166
7

Just use backward pipe operator:

[1..1000] |> List.nth <| 42

Since both operators are left associative, x |> f <| y is parsed as (x |> f) <| y, and this does the trick.

Backward pipe operator is also useful if you want to remove parentheses: f (very long expression) can be replaced with f <| very long expression.

Be Brave Be Like Ukraine
  • 7,596
  • 3
  • 42
  • 66
  • 3
    It does the trick, but I don't like its readability - very claustrophobic! – Paul Jurczak Mar 04 '13 at 04:20
  • @PaulJurczak Absolutely, it's rather a matter of style. Personally, I love operators, but they naturally have [limitations](http://stackoverflow.com/a/12499093/974789) in F#, so it's a choice between `flip`, extension methods, and `<|`. It seems there's no better idea. – Be Brave Be Like Ukraine Mar 04 '13 at 12:38
  • 2
    +1 `not` and `defaultArg` made me accustomed to using `<|`; it doesn't seem so awkward once you get used to it. – ildjarn Mar 06 '13 at 19:34
5

Since Pad and bytebuster answered your last question I will focus on the why part.

This is based my current knowledge and not historical facts.

Since F# derived from OCaml and OCaml has Array and List but not Seq and F# uses |> for natural pipelining and type checking and OCaml lacks the pipleline operator, the authors of F# made the switch for Seq. But obviously to be backward compatablie with OCaml they did not switch everything.

Community
  • 1
  • 1
Guy Coder
  • 24,501
  • 8
  • 71
  • 136