insertAt en F # plus simple et/ou mieux

Question

Je voudrais commencer quelques questions sur la simplification des différentes expressions en F #. Tout le monde a des idées pour une implémentation meilleure et/ou plus simple de insertAt (les paramètres peuvent aussi être réordonnés). Des listes ou des séquences pourraient être utilisées.

Voici une implémentation de départ:

let insertAt x xs n = Seq.concat [Seq.take n xs; seq [x]; Seq.skip n xs] 

Answer 1

Le dannyasher de mise en œuvre affichée est un non tail-recursive un. Afin de rendre la fonction plus efficace, nous devons introduire un paramètre d'accumulateur explicite qui rend la fonction récursive et permet au compilateur d'optimiser les frais généraux de récursion loin:

let insertAt = 
    let rec insertAtRec acc n e list = 
     match n, list with 
     | 0, _  -> (List.rev acc) @ [e] @ list 
     | _, x::xs -> insertAtRec (x::acc) (n - 1) e xs 
     | _  -> failwith "Index out of range" 

    insertAtRec [] 

Answer 2

De Haskell Wiki - http://www.haskell.org/haskellwiki/99_questions/21_to_28

insertAt :: a -> [a] -> Int -> [a] 
insertAt x ys  1 = x:ys 
insertAt x (y:ys) n = y:insertAt x ys (n-1) 

Je ne suis pas un F # programmeur donc je ne connais pas la syntaxe équivalente pour F #, mais cela est une belle définition récursive pour insertAt

Answer 3

Voici une implémentation F # de l'insertion de la liste Haskell:

let rec insertAt x ys n = 
    match n, ys with 
    | 1, _  
    | _, []  -> x::ys 
    | _, y::ys -> y::insertAt x ys (n-1) 

let a = [1 .. 5] 
let b = insertAt 0 a 3 
let c = insertAt 0 [] 3 

> 
val a : int list = [1; 2; 3; 4; 5] 
val b : int list = [1; 2; 0; 3; 4; 5] 
val c : int list = [0] 

Mon Haskell n'est pas assez bon pour savoir si le cas de passer une liste vide est correctement pris en charge dans la fonction Haskell. En F #, nous prenons explicitement en compte la liste vide dans le second cas de match.

Danny

Answer 4

Pour le cas où vous voulez vraiment travailler avec la séquence:

let insertAt x ys n = 
    let i = ref n 
    seq { 
    for y in ys do 
    decr i 
    if !i = 0 then yield x 
    yield y 
    } 

Pour tous les autres cas, la réponse de dannyasher est définitivement plus agréable et plus rapide.

Answer 5

SEQS utilisant récursive:

let rec insertAt = function 
    | 0, x, xs -> seq { yield x; yield! xs } 
    | n, x, xs -> seq { yield Seq.hd xs; yield! insertAt (n-1, x, Seq.skip 1 xs) }