Comment faire une voiture et cadr contre une liste?

Question

Supposons que j'ai un code:

let listB = [ 1; 2; 3 ] 

En utilisant la notation Lisp, comment dois-je faire une car et cadr contre cette liste? Je connais par contre ::.

Ou dans le schéma, first et rest?

Answer 1

List.head: Renvoie le premier élément d'une liste non vide (La tête de la liste).

List.tail: renvoie tous les éléments d'une liste non vide, à l'exception de la première (La queue ou de repos de la liste).

Exemple (en utilisant F # Interactive Console):

> let sample = [1;2;3;4];; 

val sample : int list 

> List.head sample;; 

val it : int = 1 

> List.tail sample;; 

val it : int list = [2; 3; 4] 

Answer 2

List.hd et List.tl fera ce que vous voulez - mais en F #, vous trouverez que les listes sont généralement déconstruits en utilisant la correspondance de motif. Par exemple, dans la fonction suivante x correspond à la tête et xs correspond à la queue de la liste transmise à la fonction:

let list = [1;2;3] 

let rec f = function 
    | [] -> 1 
    | (x::xs) -> x * (f xs) 

f list; 

Answer 3

Je vais devoir être d'accord avec simonuk. Bien que, comme CMS a mentionné, hd et tl sont les fonctions correctes, il n'y a plus alors à l'argument que. Lorsque vous utilisez la correspondance de formes, vous pouvez exploiter la capacité des compilateurs à attraper les cas (de base) que vous avez peut-être manqués (par exemple lorsque la liste est vide). Vous pouvez certainement attraper ou continuer à lancer cette exception, mais vous n'êtes pas obligé de le faire et vous pourriez introduire des bogues si cette attente ne se produit pas souvent. Donc, prendre l'habitude d'exploiter le pattern matching est une bonne pratique de programmation. Pour toutes fins utiles la fonction réelle est appliquée lors de l'appel hd/tl IS correspondant à un modèle. En fait, en OCaml, c'est un échec:

let hd = function [] -> failwith "hd" | a::l -> a 
let tl = function [] -> failwith "tl" | a::l -> l 

À titre d'exemple, au lieu d'utiliser des exceptions/échecs que nous pourrions trouver plus satisfaisant d'utiliser options:

> let car = function | hd::tl -> Some hd | _ -> None 
> let cdr = function | hd::[] -> None | hd :: tl -> Some tl | _ -> None 

Aussi, méfiez-vous d'utiliser _ pour correspondre à n'importe quoi. Ça fait plus mal dans les types de variantes quand vous décidez d'ajouter un autre type ... opps!