Question

I am trying to write a general function in F# that would return all the permutations of a list. I was trying to accomplish this using a recursive algorithm inspired by the java version here

But on the final line of the recursive function, I get the error given in the comments. I am guessing this is something to do with collating the output produced when the recursive loop exits (the output of if(Array.length <= 1) then being executed) with the rest Array.Map function.

I would greatly appreciate it if someone could give an explanation of why this error is happening and how I can go about fixing it.

let GetPermutationsOfList inputList =

let rec innerLoop firstPart secondPart =
    if (Array.length secondPart) <= 1 then
        [| Array.append firstPart secondPart |]
    else
        let SliceAtMarkerElement m =
           let currentMarkerElement = secondPart.[m] 
           let everythingBeforeMarkerElement = secondPart.[0 .. m - 1]
           let everythingAfterMarkerElement = secondPart.[m+1 .. ]
           let newSecondPartList = Array.append everythingBeforeMarkerElement everythingAfterMarkerElement
           let newFirstPartList = Array.append firstPart [|currentMarkerElement|]
           (newFirstPartList, newSecondPartList)

        [|for i in 0 .. ((Array.length secondPart) - 1) -> i|] |> 
        Array.map(fun c -> SliceAtMarkerElement c) |>
        // The following line gives the error 
        // "Type Mismatch. Expecting a 'a but given a 'a[] The resulting type would be infinite when unifying "a' and "a[]"
        Array.map(fun d -> innerLoop (fst d) (snd d))

innerLoop Array.empty (List.toArray inputList)

Answer 1

Assume that your function’s indentation is correct, the error message is quite informative. In the innerLoop function, Array.append firstPart secondPart should return 'b []. However, the last line Array.map(fun d -> innerLoop (fst d) (snd d)) forces it to return 'b [] [], which couldn’t be unified with 'b [].

I think you would like calculate permutations in each innerLoop and concatenate these results afterwards. You have to use Array.collect instead of Array.map:

[|for i in 0 .. (Array.length secondPart)-1 -> i|] 
|> Array.map (fun c -> SliceAtMarkerElement c) 
|> Array.collect (fun d -> innerLoop (fst d) (snd d))

The above fragment is employing two temporary arrays, which is wasteful. You can eliminate these extra arrays by using computation expression only:

[| for i in 0 .. (Array.length secondPart)-1 do
      let first, second = SliceAtMarkerElement i
      yield! innerLoop first second (* concatenating results *)
    |]

UPDATE:

As clarified in the comment, you want to return an array of arrays where each array is a permutation. So your change would work and map operations should be:

[| for i in 0 .. (Array.length secondPart)-1 do
          let first, second = SliceAtMarkerElement i
          yield innerLoop first second (* returning each array as a permutation *)
        |]