## Haskell, many previous byte counts 127 * 0.9 = 114.3 bytes

f#(a:b)=f a:f#b;f#x=x
(f&x)0=x;(f&x)i=f$f&x$i-1
i=id
r x=i%(1,x)
(g?x)(a:b)=g(g?x$b)a;(g?x)y=x f%(a,b)|a>b=[]|1<2=f a:f%(a+1,b)  No loops, just recursion. # is map: (*2) # [1,2,3] -> [2,4,6] & is nest: ((*2) & 3) 4 -> 48 i is apply: i (*2) 7 -> 14 r is range: r 4 -> [1,2,3,4] ? is fold: ((+) ? 0) [1,2,3,4] -> 10 % is table: (*2) % (2,4) -> [4,6,8] As requested an ungolfed version with comments. Note, & and ? are ternary infix operators, which require additional parentheses when called or pattern matched. f # (a:b) = f a : f#b -- map on a list (a->head, b->tail) is f a in front of mapping f to b f # x = x -- map on the empty list is the empty list -- (non empty lists are caught in the line before) (f & x) 0 = x -- nesting zero times is x (f & x) i = f$ f&x $i-1 -- nesting i times is f (nesting one time less) i=id -- apply in Haskell is just the identity function r x = i % (1,x) -- defined via the "table" of the identity function from 1 to x (g ? x) (a:b) = g (g?x$b) a  -- folding g into a list (a->head, b->tail) is g applied to (folding g into b) and a
(g ? x) y     = x             -- folding the empty list is x
--  again, y must be the empty list, else it would have been handled by the previous line

f % (a,b)
|a>b       = []                -- if iMin is greater than iMax, the table is empty
|otherwise = f a : f%(a+1,b)   --  otherwise f a in front of the table with iMin increased by one


Thanks to @dfeuer and @Zgarb for some useful hints

## Python 2, 305.1 bytes (-10% 376369366349 339 bytes)

exec'e=eval;q=len;m=@,l:e("["+"f(l.pop()),"*q(l)+"][::-1]");n=@,x,l:e("f("*l+"*x"+")"*l);r=@:e("r(f-1)+"*(f>1)+"[f]");a=@,a:e("f(a["+r(q(a))[1:-1]$",","-1],a[")+"-1])");f=@,x,l:e("f("*q(l)+"x,["+r(q(l))[1:-1]$",","-1]),l[")+"-1])");t=@,n,x:e("[f("+r(x)[n-1:]$",","),f(")[1:-1]+")]")'.replace("@","lambda f").replace("$",".replace(")


When expanded, equivalent to:

e=eval;q=len
m=lambda f,l:e("["+"f(l.pop()),"*q(l)+"][::-1]")
n=lambda f,x,l:e("f("*l+"*x"+")"*l)
r=lambda i:e("r(i-1)+"*(i>1)+"[i]")
a=lambda f,a:e("f(a["+r(q(a))[1:-1].replace(",","-1],a[")+"-1])")
f=lambda f,x,l:e("f("*q(l)+"x,["+r(q(l))[1:-1].replace(",","-1]),l[")+"-1])")
t=lambda f,n,x:e("[f("+r(x)[n-1:].replace(",","),f(")[1:-1]+")]")


No loops!

Well, it does a lot of evaling and if your boss can't stand loops, then they'll HATE eval. But, they're going to have to put up with it

A way to do range in a lambda is appreciated so I don't have to do any functions (Shudder.).

Explanations:

• m=lambda f,l:eval("["+"f(l.pop()),"*len(l)+"][::-1]")
• Create a string that pops elements from the list, wrap it into a list, reverse it and finally eval it!
• n=lambda f,x,l:eval("f("*l+"*x"+")"*l)
• Manually create the string with the nesting, and eval it!
• r=lambda i:e("r(i-1)+"*(i>1)+"[i]")
• Create a string that when evaled, either returns [0] or uses recursion to get the previous results and adds the current index to the list. Evals it.
• a=lambda f,a:eval("f(a["+r(len(a))[1:-1].replace(",","-1],a[")+"-1])")
• Uses the range function to get the indexes 1-len(list). Replaces the commas in the list stringified with a way to get the correct index of the list a. Evals it!
• f=lambda f,x,l:eval("f("*len(l)+"x,["+r(len(l))[1:-1].replace(",","-1]),l[")+"-1])")
• Same as apply except replaces the commas with closing brackets, commas and starting the list index.
• t=lambda f,n,x:eval("[f("+r(x)[n-1:].replace(",","),f(")[1:-1]+")]")
• Same as apply and fold except replaces with ending the function and calling the new one. Evals it!

Map, nest, range, apply, fold, table.

Thanks @Zgarb for a lambda for range!

## Javascript ES6, 197 * 0.9 = 177.3 bytes

M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)
N=(f,x,n)=>f(--n?N(f,x,n):x)
A=(f,l)=>f(...l)
R=n=>n--?[...R(n),n+1]:[]
F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x
T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))


### Map (M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)):

Uses Fold to concat the results of f applied to every member of l onto an empty list. Using built-in functions reduces the this to M=(f,l)=>l.map(f) (didn't use it because it seems cheap...?).

### Nest (N=(f,x,n)=>f(--n?N(f,x,n):x)):

Apply f recursively until n is decremented to 0.

### Apply (A=(f,l)=>f(...l)):

Uses the spread (...) operator to apply l onto f.

### Range (R=n=>n--?[...R(n),n+1]:[]):

Concat n to recursive call of Range until n is decremented to 0.

### Fold (F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x):

Applies the recursive call of Fold and the n'th element of l to f until n is decremented to 0. Using built-in functions reduces this to F=(f,x,l)=>l.reduce(f,x) (again, seemed cheap...).

### Table (T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))):

First initializes n and x to iMin and iMax using destructuring ([n,x]=i), then uses Range to construct the table of values from iMin to iMax. f is then applied over the table using Map and the result is returned.