Implement functional programming paradigms
Haskell, many previous byte counts  127 * 0.9 = 114.3 bytes

f#(a:b)=f a:f#b;f#x=x
(f&amp;x)0=x;(f&amp;x)i=f$f&amp;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&gt;b=[]|1&lt;2=f a:f%(a+1,b)


No loops, just recursion.

# is map: (*2) # [1,2,3] -> [2,4,6]

&amp; is nest: ((*2) &amp; 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, &amp; 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-&gt;head, b-&gt;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 &amp; x) 0 = x                -- nesting zero times is x
(f &amp; x) i = f $ f&amp;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-&gt;head, b-&gt;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&gt;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