A partial function is a function that is not defined for all possible arguments of the specified type. The first one is an empty list, the seconds one is a list that contains one empty list, the third one is a list that contains three empty lists. and you see that one of the constructors (the empty list ) does not use the type parameter a.There are types, where none of the constructors refers to the type parameter and these types are very useful, e.g. ... tail takes a list and returns its tail. Also, lists with literal elements like [1,2,3], or even "abc" (which is equivalent to ['a','b','c']) can be used for pattern matching as well, since these forms are only syntactic sugar for the (:) constructor. Therefore, once it has gotten to the end of the list, the only tail remaining is the empty list, , which should … Extract the possibly-empty tail of the stream. In Haskell, there are no looping constructs. Instead, there are two alternatives: there are list iteration constructs (like foldl which we've seen before), and tail recursion. Instead you can use pattern matching to get the head and tail of a list: unicodeValueList (x:xs) = getLetterUnicodeValue x : unicodeValueList xs total (x:xs) = x + total xs This way x and xs will only be available when the list is non-empty and it is guaranteed that you never accidentally access the head or tail of an empty list. I don't see any loop here except a recursive call passing the same y to ys. The recursive portion is passing the tail of the list to the elem' function, not the same list. bytestring Data.ByteString Data.ByteString.Char8. O(1) Extract the elements after the head of a ByteString, which must be non-empty. Well, anyway, list cells and the empty list partition the list type, and the 'tail' and 'init' functions operate only on list cells, which is the way it should be. Examples in the Haskell standard library are: head, tail: undefined for empty lists): undefined if the index is at least as big as the list length div: undefined if the divisor is zero; The opposite is a total function. In other words, it chops off a list's head. You should strive to avoid partial functions and instead write total ones. for defining numbers with type-checked physical dimensions. headとtailはそれぞれリストの最初の要素と残りのリストを取得する．schemeでいうcarとcdr． Prelude> head [1, 2, 3] 1 Prelude> head  *** Exception: Prelude.head: empty list Prelude> tail [1, 2, 3] [2,3] Prelude> tail  *** Exception: Prelude.tail: empty list. tail:: ByteString -> ByteString. Think about how we'd represent a two-dimensional vector in Haskell… haskell.org tail. A pattern like x: xs will bind the head of the list to x and the rest of it to xs, even if there’s only one element so xs ends up being an empty list. @Ashwin the term tails' xs without the brackets is already a list of lists, i.e., of type [[a]]. We can match with the empty list [ ] or any pattern that involves: and the empty list, but since [1, 2, 3] is just syntactic sugar for 1: 2 : 3 : [ ], we can also use this pattern. In Haskell, the cons operation is written as a colon (:), and in scheme and other lisps, it is called cons. headの定義 If it helps, think of tail as "part after the first element" and init as "part before the last element." It's a little confusing because the function is recursive, but if you look at the type you declared, it reads tails' takes a list and returns a list of lists; since xs is a list, applying it to tails' yields a list of lists. In many languages, lists are built up from two primitives: either the list is the empty list, commonly called nil, or it is a list constructed by appending an element to the start of some other list, which we call a cons. will evaluate to False for the  list, to True if the list has 0 as first element and a non-empty tail and to False in all other cases. Extract the elements after the head of a list, which must be non-empty.