Comment faites-vous une fonction récursive F # qui renvoie le caractère de la liste?

Je suggère que votre fonction fait quelque chose comme ceci:

1) Appelez lui-même (la partie récursive) pour trouver le meilleur candidat à la queue de la liste.

2) Comparez le meilleur candidat de l'étape 1 à la tête de la liste et ...

3) Si la tête de la liste est une meilleure solution que celle du candidat de la queue, utilisez la tête, utilisez sinon le candidat queue.

Un peu délicat à itérer sur la "liste" fournie
J'aurais besoin de papier dur les éléments tuples
Que je puisse avoir fait à la fin pour en faire une liste

Contrairement à l'échantillon fourni p> xxx pré>

un tuple de la liste des tuples avec seulement 1 élément p>

et étant donné que tous les éléments sont du même "type"
Je l'ai généralisé sous forme de p> xxx pré>

beaucoup plus facile à itérer et à morsez plus générique p> xxx pré>

it sortit p> xxx pré>

aux questions supplémentaires ... p>

Le plus simple et plus générique est la non récursive (trouver)
(Find1) est plus traditionnel et moins générique de
(Find2) La récursive de Scott, est plus idiomatique
Le tout fait de même, comparer et retourner un sous-produit P>

let list =
    [ (0.1, '*')
      (0.5, '@')
      (1.0, '!') ]

/// non-recursive
let find test map list =
    match list |> List.tryFind test with
    | None -> map None
    | x -> Some(x).Value |> map

/// iterates
let rec find1 test result index (lst: 'a list) =
    if index < list.Length then
        match lst.[index] with
        | x when test x -> Some(x) |> result
        | _ -> find1 test result (index + 1) lst
    else
        result None

/// iterates , idiomatically
let rec find2 test result index lst =
    match lst with
    | [] -> result None
    | head :: tail ->
        if test head then Some(head) |> result
        else find2 test result index tail

let greaterThanIndex index = fun (value, _) -> value > index

let map x =
    match x with
    | None -> '\000'
    | Some(_, chr) -> chr

printf "ctrl+c to quit!\n"

// the 'input function'?
match System.Console.ReadLine() with
| input ->
    match System.Double.TryParse input with
    | false, _ ->
        printf "%s: NaN! \n" input
    | _, index ->
        list
        |> find (greaterThanIndex index) map
        |> printf "find: %2.2f in %A = %c\n" index list
        // ...
        list
        |> find1 (greaterThanIndex index) map 0
        |> printf "find1: %2.2f in %A = %c\n" index list
        // ...
        list
        |> find2 (greaterThanIndex index) map index
        |> printf "find2: %2.2f in %A = %c\n" index list

let list =
    [ (0.1, '*')
      (0.5, '@')
      (1.0, '!') ]

let rec something index lst =
        match lst with
        | [] -> '\000'
        | h :: t -> 
            let value, chr = h
            if index <= value
            then chr
            else something index t

list 
|> List.sortBy fst // only needed if not already sorted by value
|> something 2.0