Non-exhaustive patterns, Haskell

Question

I am trying to write the function tails, which converts a string into a list of strings in the following way:

tails "abc" = ["abc", "bc", "c", ""]

Here is my implementation:

tails :: [Char] -> [[Char]]
tails (x:xs)
  | length (x:xs) == 0 = [""]
  | otherwise = (x:xs) : tails xs

As the title suggests, there are non-exhaustive patterns in this function. Unfortunately, I don't see how so.

I am new to Haskell... Any help would be appreciated!

`(x:xs)` assumes the list is not empty. – Stéphane Laurent Mar 24 '18 at 07:54 — Stéphane Laurent, Mar 24 '18 at 07:54
Turning on warning with `-Wall` would spot the issue. – chi Mar 24 '18 at 08:23 — chi, Mar 24 '18 at 08:23

Dannyu NDos · Accepted Answer · 2018-04-12T02:58:15.727

3

The pattern is non-exhaustive because it can't accept []. A list has form of either [] or a:as, where a is the leading element and as is the list of the trailing elements. So the pattern x:xs matches only if the list has a leading element. Fixing that gives:

tails :: [Char] -> [[Char]]
tails xs
    | length xs == 0 = [""]
    | otherwise = let (_:xs') = xs in xs : tails xs'

And then xs accepts the list regardless of its form. But this is inefficient due to length, and doesn't work for infinite lists.

This should fully work, which directly does pattern mathing:

tails :: [Char] -> [[Char]]
tails [] = [""]
tails xs@(_:xs') = xs : tails xs'

edited Apr 12 '18 at 02:58

answered Mar 24 '18 at 07:54

Dannyu NDos

2,458
13
32

I see! Thanks for the explanation! However, I don't think your code works as in the recursive case, tails takes the same parameter. But this can easily fixed using case with pattern matching. – user376127 Mar 24 '18 at 08:00
Ah, sorry. Fixed. – Dannyu NDos Mar 24 '18 at 08:02
I also added a simper version. – Dannyu NDos Mar 24 '18 at 08:04
The first version given should be removed. Computing `length xs == 0` will run down the entire list when you only need to look at the very top, and will also not work for infinite lists. It is also unidiomatic. The second version is the correct one. – HTNW Apr 12 '18 at 01:54
@HTNW Fixed. Thank you. – Dannyu NDos Apr 12 '18 at 02:58

fp_mora · Answer 2 · 2018-04-15T23:37:55.690

What about trying this or at least get some logic from it. It works well. It's got a helper function to convert the string into a list of separate characters, for example "abc" becomes ["a","b","c"]. It is just less complicated to process them like that and it becomes necessary to collect distinct strings in the result list. There are two functions in the function set and a third is warranted to call the primary function with one parameter. The primary function is on one line but uses guards.

ca = [[c] | c <- "abcdef"]
f (l1,ls) | null ls = l1++[[]] | True = f ( l1 ++ [concat ls], (tail ls))
f ([],ca)
["abcdef","bcdef","cdef","def","ef","f",""]

Edit 4/4/2018 I was wrong. The list parameter does not have to be made into a list before hand. By not doing so, the function becomes simpler by removing the concat function and changing the parameter list from tuple to individual removed lots or parentheses.

fs l1 ls = if null ls then l1++[""] else fs (l1++[ls]) (tail ls)

It is invoked differently, too.

fs [] "Hello!"

This, by itself, produced the right results.

Edit/add 4/11/2018

What keeps recurring (no pun) is dependence on tail when Haskell splits up input into head and tail with (x:xs) they are ready to use. Here is a basic recursive function that uses (x:xs) only for head and tail. I produces all tails of input list including null.

t [] = [""]; t (x:xs) = [x:xs] ++ t xs

And yet another that takes a list as the only parameter.

t ls = [drop n ls|n<-[0..length ls - 1]]

Non-exhaustive patterns, Haskell

2 Answers2