What to use instead of a list comprehension

Question

I'm just getting started with Haskell and finished a nice exercise to make a Caesar cipher.

One of the first steps was to make a function that will take a letter and turn it into a number. I know that chr and ord can do this already but part of the exercise was to write your own.

let2num c = head [ b | (a,b) <- zip ['a'..'z'] [0..25], a==c]

I'm new to the Haskell syntax and one of the first things I learned was list comprehensions, so that has become my hammer. I'm very curious though, what is another (likely better) way to write this function?

If you're curious the rest of the cipher is in a gist.

EDIT

I'm also interested in other ways to translate back from numbers to letters.

num2let d = head [ a | (a,b) <- zip ['a'..'z'] [0..25], b==(d `mod` 26)]

Answer 1

My solution:

import Data.List
let2num c = let (Just n) = elemIndex c ['a'..'z'] in n

Or:

import Data.List
import Data.Maybe
let2num c = fromJust $ elemIndex c ['a'..'z']

Or in pointless style:

import Data.List
import Data.Maybe
let2num = fromJust . (flip elemIndex) ['a'..'z']

The function elemIndex returns the index of the first element in the given list which is equal (by ==) to the query element, or Nothing if there is no such element.

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The function fromJust extracts the element out of a Just.