Récursives lambdas en F #

Question

Prenez ce code par exemple (l'ignorer étant horriblement inefficace pour le moment)

let listToString (lst:list<'a>) = ;;' prettify fix

    let rec inner (lst:list<'a>) buffer = ;;' prettify fix
        match List.length lst with 
        | 0 -> buffer
        | _ -> inner (List.tl  lst) (buffer + ((List.hd lst).ToString()))

    inner lst ""

Ceci est un modèle commun que je continue à venir à travers en F #, je dois avoir une fonction intérieure qui se récursif sur une certaine valeur - et je ne ai besoin de cette fonction une fois, est-il de toute façon possible d'appeler un lambda à partir de ce auto (certains mot-clé magique ou quelque chose)? Je voudrais que le code pour ressembler à quelque chose comme ceci:

let listToString2 (lst:list<'a>) = ;;' prettify fix

    ( fun 
        (lst:list<'a>) buffer -> match List.length lst with ;;' prettify fix
                                 | 0 -> buffer
                                 | _ -> ##RECURSE## (List.tl lst) (buffer + ((List.hd lst).ToString())) 
    ) lst "" 

Mais comme on pouvait s'y attendre, il n'y a aucun moyen de se référer à la fonction anonyme en lui-même, ce qui est nécessaire où je mets ## RECURSE ##

Answer 1

Oui, il est possible à l'aide que l'on appelle y-combinateur de (ou fixed-point combinators). Ex:

let rec fix f x = f (fix f) x

let fact f = function
 | 0 -> 1
 | x -> x * f (x-1)


let _ = (fix fact) 5 (* evaluates to "120" *)

Je ne sais pas d'articles pour F #, mais cette haskell entrée peut également être utile .

Mais. Je ne les utilise pas s'il y a une solution de rechange - Ils sont très difficiles à comprendre

Votre code (omettez le type d'annotations ici) est une construction standard et beaucoup plus expressive.

let listToString lst =

    let rec loop acc = function
        | []    -> acc
        | x::xs -> loop (acc ^ (string x)) xs

    loop "" lst

Answer 2

Notez que même si vous dites que vous utilisez la fonction qu'une seule fois, techniquement, vous faites référence par son nom deux fois, ce qui explique pourquoi il est logique de lui donner un nom.