Haskell - consultez dernier élément de la liste

Question

Je dois vérifier si le dernier élément de la liste est en majuscules Par exemple "abc"-False, "abC"-True

C'est ce que j'ai essayé

checkLast :: [a] -> Bool 
checkLast [] = False 
checkLast [x] = if isUpper x then True else False 
checkLast (x:xs) = if isUpper last then True else False 

Answer 1

Think récursivement. checkLast (x:xs) est en train de vérifier checkLast xs:

checkLast :: [Char] -> Bool 
checkLast [] = False 
checkLast [x] = isUpper x 
checkLast (x:xs) = checkLast xs 

Notez que puisque vous utilisez isUpper pour vérifier les chaînes, il est plus logique que le type devrait être [Char], pas [a].

Answer 2

Une version fixe avec des commentaires:

import Data.Char (isUpper) 

checkLast :: [Char] -> Bool  -- it cannot be [a]: use of isUpper already limits possible type to [Char] 
checkLast [] = False 
checkLast [x] = isUpper x  -- the if .. can be shorter 
checkLast (x:xs) = checkLast xs -- drop first char and look at rest of string 

Answer 3

Vous pouvez utiliser récursion comme les autres réponses démontrent. Mais vous pouvez aussi utiliser des builtins pour construire une telle fonction.

Deux fonctions pertinentes ici sont null :: [a] -> Bool qui vérifie si une liste est vide, et last :: [a] -> a qui obtient le dernier élément.

Alors maintenant, nous pouvons construire une fonction:

import Data.Char(isUpper) 

checkLast :: [Char] -> Bool 
checkLast l = not (null l) && isUpper (last l) 

Nous voici donc affirmer que checkLast est True si la liste l n'est pas vide (not (null l)); et le dernier élément est un caractère majuscule isUpper (last l).

Cela sera probablement un peu plus rapide que les fonctions récursives, puisque nous ne testons le cas [] qu'une seule fois (dans null). last vérifie seulement deux cas: [x] et (x:xs) donc nous économisons sur [] contrôles.

Bien sûr, ces fonctions fonctionnent avec récursion, mais il est parfois utile de chercher des fonctions d'aide telles qu'une fonction est presque auto expliquer: ici les fonctions dit: "Une liste l est checkLast si elle est pas vide, et le dernier élément est une majuscule ".

Answer 4

Vous pouvez également procéder comme suit sans récursion

import Data.Char 

checkLast :: String -> Bool 
checkLast = (&&) <$> not . null <*> isUpper . head . reverse 

L'opérateur applicatif, <*> est un outil idéal pour alimenter un paramètre commun (la chaîne d'entrée ici) à deux fonctions différentes comme not . null et isUpper . head . reverse puis pour effectuer une opération (&&) sur leur résultat.

Selon le commentaire de @ dfeuer, je voudrais juste ajouter la solution suivante pour une meilleure performance. Vous n'avez pas besoin d'importer tout autre paquet que Data.Char

import Data.Char 

checkLast :: String -> Bool 
checkLast [] = False 
checkLast cs = isUpper $ foldr1 seq cs 

Answer 5

La façon la plus simple d'éviter la récursivité explicite, si vous souhaitez le faire, est probablement d'utiliser un pli:

lastMay :: [a] -> Maybe a 
lastMay = foldl' (\_ x -> Just x) Nothing 

checkLast = maybe True isUpper . lastMay