# Haskell, <s>many previous byte counts</s>  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