auto part1()
{
    return from(foo);
}

auto part2()
{
    return part1().where(foo.id > 17);
}

void test()
{
    for(auto row : part2().select(foo.name))
        print(row.name);
}

var q = db.Table1;

if (a != null)
    q = q.Where(t => t.Field1 == a);

if (b > 3)
    q = q.Where(t => t.Table2.Field2 != 15);
else
    q = q.Where(t => t.Table3.Field7.In("z", "y", "z"));

q.ToList();

IT>var q = db.Table1;

IT>if (a != null)
IT>    q = q.Where(t => t.Field1 == a);

IT>if (b > 3)
IT>    q = q.Where(t => t.Table2.Field2 != 15);
IT>else
IT>    q = q.Where(t => t.Table3.Field7.In("z", "y", "z"));

IT>q.ToList();
IT>

Один из возможных вариантов:

auto q1 = context.Employees;
auto q2 = conditional(!IsNullOrEmpty(lastName), q1.Where(e.LastName = lastName));
auto q3 = conditional(!IsNullOrEmpty(firstName), q2.Where(e.FirstName= firstName));
auto q4 = conditional(HasValue(employmentDateFrom), q3.Where(e.EmploymentDate >= employmentDateFrom.Value));
auto q5 = conditional(HasValue(employmentDateTo)), q4.Where(e.EmploymentDate <= employmentDateTo.Value));

//далее в Presentation Layer (в другом месте)
auto list = await q5.Take(pageSize).Select(/*projection*/).ToListAsync();

При попытке выполнить этот запрос, будет произведено 4 runtime проверки, в результате чего будет выбрана одна из 16 сгенерированных в compile-time версий запроса (причём которые могут кардинально отличаться друг от друга).

Если не нравится экспоненциальное количество запросов в исполняемом файле, то можно добавить динамики. Да, при этом запрос будет частично строится в runtime (с возможным кэшированием), но при этом не будет дорогой runtime reflection — в ней тут нет принципиальной необходимости, достаточно compile-time reflection.

IQueryable<X> F(IQueryable<X> xs, IEnumerable<int> m)
{
    return xs.Where(x => m.Contains(x.y));
}

...
where x.y in (@p1, @p2,...) -- количество значений в in будет зависеть от исходного массива

EP>>Сколько статических по твоим оценкам?
G>По моим оценкам 0.
G>Потому что предикаты в одних функциях, а проекции в других.

auto part2()
{
    return part1().where(foo.id > 17);
}

G>auto part2()
G>{
G>    return part1().where(foo.id > 17);
G>}
G>

// Terminal symbols:
struct From {} from;
struct Select {} select;
struct Where {} where;

// Nonterminal:
template<typename Left, typename Right> struct Pipeline {};

template<typename T, typename U>
auto operator|(T, U)
{
    return Pipeline<T, U>{};
}

// Decomposition:
auto part1()
{
    return from;
}

auto part2()
{
    return part1() | where;
}

auto part3()
{
    return part2() | select;
}

// Utility for print type at compile time:
template<typename T> void type_is(T);

int main()
{
    type_is(part1());
    type_is(part2());
    type_is(part3());
}

undefined reference to `void type_is<From>(From)'
undefined reference to `void type_is<Pipeline<From, Where> >(Pipeline<From, Where>)'
undefined reference to `void type_is<Pipeline<Pipeline<From, Where>, Select> >(Pipeline<Pipeline<From, Where>, Select>)'

IQueryable<User> Active(this IQueryable<User> src) => src.Where(u => u.IsActive)

EP>При попытке выполнить этот запрос, будет произведено 4 runtime проверки, в результате чего будет выбрана одна из 16 сгенерированных в compile-time версий запроса (причём которые могут кардинально отличаться друг от друга).

something.Where(o => o.Visible)

#include <iostream>

using namespace std;

struct Foo
{
    template<typename F>
    void where(F filter)
    {
        struct
        {
            int value;
            bool visible;
        } xs[] = {{1, true}, {2, false}, {3, true}};

        cout << boolalpha;
        for(auto &x : xs)
            if(filter(x))
                cout << x.value << " " << x.visible << endl;
    }
};

/***********************************************************/
struct OnlyVisible {} only_visible;

template<typename T>
auto operator|(T x, OnlyVisible)
{
    return x.where([](auto &x){ return x.visible; });
}

int main()
{
    Foo x;

    cout << "Case #1" << endl;
    x.where([](auto &){ return true; });

    cout << "Case #2" << endl;
    x | only_visible;
}

Case #1
1 true
2 false
3 true
Case #2
1 true
3 true

G>IQueryable<X> F(IQueryable<X> xs, IEnumerable<int> m)
G>{
G>    return xs.Where(x => m.Contains(x.y));
G>}
G>

G>...
G>where x.y in (@p1, @p2,...) -- количество значений в in будет зависеть от исходного массива
G>