"intersperse" not very beginner friendly

[matthid]

It is used here: https://github.com/SAFE-Stack/SAFE-template/blob/master/Content/src/Client/Client.fs#L121
And defined here: https://github.com/SAFE-Stack/SAFE-template/blob/master/Content/src/Client/Client.fs#L94-L97

I feel like we should get rid of it?

[isaacabraham]

Oh, this. I thought it was something in the docs!! Happy to rename this to something more meaningful or refactor etc. @theimowski thoughts?

[theimowski]

Yes, I'm all in for making this one easier to comprehand - open for ideas

[theprash]

The name List.join would be analogous to String.join, and it should take a list as the separator: List.join [ str ", " ]. It could maybe be placed in another file. Or added to F# core 😃

[matthid]

Honestly even the implementation is really hard to gasp for newcomers, a lambda returning a lambda ;).

[vasily-kirichenko]

Let's search such signature on hoogle :)

[vasily-kirichenko]

https://www.haskell.org/hoogle/?hoogle=a+-%3E+%5Ba%5D+-%3E+%5Ba%5D which gives us intersperse...

[isaacabraham]

let insertSeparator sep items =
    match items with
    | [] -> []
    | head :: tail ->
        head :: (tail |> List.collect(fun item -> [ sep; item ]))

Is that any better?

[theprash]

Maybe this as a more understandable implementation:

module List =
    let join sep xs =
        match xs with
        | [] -> []
        | head :: tail ->
            [ yield head
              for x in tail do
                yield! sep
                yield x ]

I think it's more important for the name to be consistent with F# than with Haskell.

[matthid]

join signature is 'a -> 'a list -> 'a while this is 'a -> 'a list -> 'a list
(@theprash I think you mean yield instead of yield! otherwise the signature doesn't match)

[matthid]

Here are some other suggestions:

let rec intersperseRec sep xs =
    match xs with
    | [] -> []
    | [ head ] ->
        [ head ]
    | head :: tail ->
        head :: sep :: intersperseRec sep tail
let intersperse2 sep xs =
    let rec intersperseRec result sep xs =
        match xs, result with
        | [], result -> List.rev result
        | head :: tail, [] -> intersperseRec [head] sep tail
        | head :: tail, result ->
            intersperseRec (head :: sep :: result) sep tail
    intersperseRec [] sep xs

[vasily-kirichenko]

@isaacabraham no :)

[isaacabraham]

@vasily-kirichenko how about this?

let second sep items =
    match items with
    | [] -> []
    | items ->
        [ for item in items do yield! [ sep; item ] ]
        |> List.skip 1

[theimowski]

Actually I'm thinking this code is used only for safe components credits - one probably deletes that at some point. IMO It's yet another example of something that shouldn't be in the sources, but probably referenced (yet another next to extracting common build functions in #123)