Generic Constexpr Lookup Table C++11

I'm trying to construct a generic lookup table that takes a generator function and creates the table at compile time.Here is the code for the table and generation:

#ifndef CONSTEXPR_LOOKUPTABLE_H
#define CONSTEXPR_LOOKUPTABLE_H

#include <cstddef>

/* Generate a range */
template <std::size_t... Is>
struct seq{};

template <std::size_t N, std::size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...>{};

template <std::size_t... Is>
struct gen_seq<0, Is...> : seq<Is...>{};

/*
    The lookup table consisting of values to be 
    computed at compile-time
*/
template<std::size_t N, class T>
struct LookUpTable{
    std::size_t indexes[N];
    T values[N];

    static constexpr std::size_t length = N;
};

/*
   Generate the table from a generator function
*/
template <class Lambda, std::size_t... Is>
constexpr auto LookUpTableGenerator(seq<Is...>, Lambda f) ->
LookUpTable<sizeof...(Is), decltype(f(Is)...)>
{
    return {{ Is... }, { f(Is)... }};
}

template <std::size_t N, class Lambda>
constexpr auto LookUpTableGenerator(Lambda f) ->
decltype(LookUpTableGenerator(gen_seq<N>{}, f))
{
    return LookUpTableGenerator(gen_seq<N>{}, f);
}

#endif

Here is the main function:

#include <iostream>
#include <memory>
#include <vector>
#include <string>
#include "ConstExprLookupTable.h"

typedef unsigned short ushort;
typedef unsigned char byte;

/*
    There are only 10 digits (0 - 9)
*/
static constexpr ushort DIGITS = 10;
/*
   A table to prevent repeated division calculation:
        table[i][j] = (i + j) / 10;
*/
static constexpr ushort carry_table[DIGITS][DIGITS] = \
{ 
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
    {0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
    {0, 0, 0, 0, 0, 0, 0, 1, 1, 1},
    {0, 0, 0, 0, 0, 0, 1, 1, 1, 1},
    {0, 0, 0, 0, 0, 1, 1, 1, 1, 1},
    {0, 0, 0, 0, 1, 1, 1, 1, 1, 1},
    {0, 0, 0, 1, 1, 1, 1, 1, 1, 1},
    {0, 0, 1, 1, 1, 1, 1, 1, 1, 1},
    {0, 1, 1, 1, 1, 1, 1, 1, 1, 1}
};

static constexpr double myFunc(double x)
{
    return x / DIGITS;
}

int main()
{
    constexpr std::size_t length = 100;
    auto table = LookUpTableGenerator<length>(myFunc);
    for (auto v : table.values){
        std::cout << v << " ";
    }
    std::cout << "\n";
}

However, this generates the following compile-time errors:

ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
 LookUpTable<sizeof...(Is), decltype(f(Is)...)>
                                              ^
ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
ConstExprLookupTable.h:33:46: error: template argument 2 is invalid
ConstExprLookupTable.h:33:1: error: invalid use of template-name ‘LookUpTable’ without an argument list
 LookUpTable<sizeof...(Is), decltype(f(Is)...)>
 ^
ConstExprLookupTable.h:33:12: error: expected initializer before ‘<’ token
 LookUpTable<sizeof...(Is), decltype(f(Is)...)>
            ^
virt.cpp: In function ‘int main()’:
virt.cpp:88:53: error: no matching function for call to ‘LookUpTableGenerator(double (&)(double))’
     auto table = LookUpTableGenerator<length>(myFunc);

My questions are (finally!): 1) Is this possible to do? When I replace the class T parameter of the lookup table with a concrete type (like a double), the code compiles fine. 2) I think the error is here:

template <class Lambda, std::size_t... Is>
    constexpr auto LookUpTableGenerator(seq<Is...>, Lambda f) ->
    LookUpTable<sizeof...(Is), decltype(f(Is)...)>
    {
        return {{ Is... }, { f(Is)... }};
    }

It seems to not like the decltype. What should the decltype be in this case?