In Clojure:

(defn f [s] (reduce #(+ (- (int %2) 96) (* %1 26)) 0 s))

def intToNBase(base : Int)(n : Int) : List[Int] = {
def inner(ntemp : Int, res : List[Int]) : List[Int] = {
if(ntemp == 0) res
else if (ntemp == 1) 1::res
else inner(ntemp/base, ntemp%base::res)
}
inner(n,List())
}

def intToBinary(n : Int) = intToNBase(2)(n)

def NtoIntBase(base: Int)(n : List[Int]) : Int = {
def inner(tempN : List[Int], res : Int) : Int = tempN match {
case Nil => res
case x::xs => inner(xs, x+base*res)//x +base*(inner(xs))
}
inner(n,0)
}

def f(x : String) = NtoIntBase(26)(x.toLowerCase.toList.map(_ - ‘a’+1))

import Data.Char(ord, isAsciiLower)

f :: [Char] -> Int
f [] = 0
f s | isAsciiLower (head s) =
(ord(head s) - ord(’a') + 1) * (26 ^ ((length s) - 1)) + (f (tail s))

Here is another explanation:

There are 26 data constructors for one type (a-z)
There are 10 data constructors for another type (0-9)
There is some bijective and total function between these two types.
This function (by implication) is converting between a base 26 and base 10 system — you can call the data constructors anything.
- QED

We can post formatted code using <code> tags and   I think.
(http://codex.wordpress.org/Writing_Code_in_Your_Posts)

Test:

public long raf (String s26)
{
  long res = 0L;
  for (int i = 0; i

Now in base-26.
The empty string is not a number.
a is 0.
b is 1.
etc
aa is 0.
aaa is 0.

This is not to say that there is no challenge in your puzzle. It’s just not base-26.

reduce(lambda x, y: x * 26 + (ord(y) - 96), “aza”, 0)

or a bit longer:

reduce(lambda x, y: x * 26 + y, map(lambda x: ord(x) - 96, “aza”))

or in Haskell:

foldl (\x y -> x * 26 + Char.ord(y) - 96) 0 “aza”