text:
Implement functional programming paradigms
Your company is just getting started on a project, and for the first time you decided to go use a functional programming code-style. However your boss is really diffident and doesn't want to use built-in functions, and requires you to implement yourself the main functions. In particular you need to write the functions: Map, Nest, Apply, Range, Fold and Table in a language on your choice. The boss is a really busy man, and he wants to have the programs as short as possible, so he doesn't waste time reading. He also would like not for you to use loops, therefore you will have a 10% reduction on the byte count for not using loops.
The detailed requirements of the functions are below:
Map
The Map function takes two parameters: f and list where f is a function and list is a list of values. It should return the f applied to each element of list. Therefore it will work as such:
Map(f,{a,b,c})

returns
{ f(a), f(b), f(c) }

and
Map(f, {{a,b},{b,c}})

returns
{ f({a,b}), f({b,c})}

Nest
The Nest function takes three parameters as well: f, arg, times where f is a function, arg is its starting argument, and times is how many times the function is applied. It should return an expression with f applied times times to arg. Therefore it will work as such:
Nest(f, x, 3)

returns
f(f(f(x)))

and
Nest(f, {a,b}, 3)

returns
f(f(f({a,b})))

Apply
The Apply function takes two parameters: f and args where f is a function and args a list. It should apply f to the args. Therefore:
Apply(f, {a,b,c})

returns
f(a,b,c)

Range
The Range function takes one integerr and outputs the integers up to that number. Therefore:
Range(5)

returns
{ 1, 2, 3, 4, 5}

Fold
The Fold function takes three parameters f, arg, others where f is a function, arg is simple parameter, and others a list. It will work as such:
Fold(f, x, {a, b, c, d})

returns
f(f(f(f(x,a),b),c),d)

Table
The table functions should take a function f, and a parameter called iterator in the form: {iMin, iMax} where iMin and iMax are integers. You should apply f over the range specified. Therefore:
Table(f, {0, 5})

returns
{f(0), f(1), f(2), f(3), f(4), f(5)}

I've used the definition of these functions from the Mathematica functional programming page, so head there if you need any more guidance. Note that you will not need to implement all the version of the functions shown in that page, but only those written in this post.
Standard Loopholes are disallowed as usual.
In case your language does not allow functions to be passed as arguments, you need to implement this capability, and add it into your answer. However the byte-count of this operation will not be added to the total.
This is code golf so the shortest code wins. Good luck!!!

This is awesome! +1 However, I don't really get how Table works here. Is your example supposed to be Table(f, {x, 0, 5})? I also don't get the purpose of x at all, since it just applies the function to the range.

@kirbyfan64sos Thank you! Yes that was a typo, I left x in as a reference to mathematica, which uses it as symbolic feauture, however I think I can get it out

One more question: how do we name the functions? Do we have to give them the exact same names? Single-letter?

@kirbyfan64sos Since it is code-golf, I'll allow single letter names, however in your answer put a heading over each function so that we know which one it is. Also do not use colliding letters.

Could you be more specific about what counts as a loop?

@xnor no you can't, what I'm really interested in is the implementation of the features. As what counts for loop I think for and while loops, and the use of gotos to emulate them

By the way, that's the wrong fold for languages that offer infinite lists. Those languages really want f(a, f(b, f(c, f(d, x)))).

Is the 10% bonus per function, i.e. a total of 60% for the whole code if no function uses loops?

@nimi originally I was going for that approach, but I think the 10% if no loops are used in all code is more adapt

You use Map(f, {{a,b},{b,c}}) resulting in { f(a, b), f(b, c) } - is that f taking a single argument, the list {a, b}? Or is it f taking in two distinct arguments a and b?

@Dannnno it is f taking a single argument, a list, I wrote it wrongly, well spotted

I assume the same for the other ones?

@Dannnno where exactly? As a reference I used this page, https://reference.wolfram.com/language/guide/FunctionalProgramming.html, so it should reflect those

Range is for positive integers only?  What happens with 0 or with a negative number?

For example, Nest.  I would expect Nest(f, {a,b}, 3) to give me f(f(f({a, b}))) but you have f(f(f(a, b)))

@Dannnno Range is for positive integers indeed, Nest follows the same rule as well, so you're right

May I use one of the functions to implement another?

@edc65 yes of course, just define it before its usage :)

My language has built-in functionality for all these, so may I just assign your names to cover-functions?

@NBZ  the challenge states that built-ins are not allowed

What means "returns an expression"? Does this mean we should return something which needs to be evaluated later, or can we evaluate it immediately and return the result of that evaluation?

@PaŭloEbermann, it can be evaluated immediately, see other answers as guidlines, I think that the Haskell one is quite indicative.

@dfeuer I think you got it wrong – your version would need to iterate the whole list before starting to evaluate f, while the version in the question evaluates f during each step.

If some of the functions use loops and the others not, do these others still get the 10% reduction?

@PaŭloEbermann no, to be elegible for the bonus there needs to be no looping in general

@Paŭlo Ebermann, I was referring to lazy lists. A lazy function passed to a right fold can be productive on an infinite list. It's possible to implement left folds in terms of right ones but not (in the infinite case) the other way around.

@dfeuer so you would have not just a lazy list, but also a lazy fold (i.e. f(a, f(b, ...)) would only calculate the second parameter of the first when (an if) actually needed by f's implementation? I guess that works. I was thinking about a non-lazy fold (maybe with side effects), i.e. an endless loop for an infinite list, which wouldn't work with right-folding.

@PaŭloEbermann, take a look at how it's done in Haskell. In the latest library version, the left fold is actually defined in terms of the right: foldl f b0 xs = foldr (\x r b -> r (f b x)) id xs b0

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

I'm new to haskell, it looks quite good, however could you please add an explanation to what you are doing?

@WizardOfMenlo: added some comments

Just realized how elegant Haskell is, real good!

Ignoring infinite lists and efficiency, m#q=reverse$f((:).m)[]q. This is the same length as yours, but much harder to read.

You can shorten ! by making it a name instead of an operator: i f=f.

Now that you have i, you can use it in the definition of r for another byte.

n and f can both be defined as infix, but you need parentheses: (f&x)1=f x;(f&x)i=f$f&x$i-1 for n, and similarly for f. Also, swapping the cases of # and doing f#x=x for the empty list saves 2 bytes.

To save 3 more bytes: swap the definitions of ? and do (g?x)y=x for empty lists, and do (f&x)0=x for the base case of &.

@Zgarb: thanks again

@nimi I've removen the accepted answer just to draw a bit more attention to the question, I will put it back again soon :) (Unless someone beats you)

Python 2, 305.1 bytes (-10% 376 369 366 349 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!

My boss will have my head on his desk :) Could you add a brief explanation as well please?

How about r=lambda i:[]if i<1 else r(i-1)+[i]? No loops, only recursion.

Sure, I'll take that for now but the boss needs more eval to show them how for loops aren't so bad :)

Ha! Another version using e=eval: r=lambda i:e("r(i-1)+"*(i>1)+"[i]")

can you change it from the 60% bonus to a 10% please? I revised the question specification, so to make it fairer

Might want to make an alias to replace: R=str.replace. Then instead of s.replace(x,y) you can do R(s,x,y).

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.

Wanna know my philosophy? "If it's cheap, buy it." It doesn't say in the specs that you can't use builtins (yet), so use them!

Julia, 181 bytes
No bonus for me; I used loops liberally. Sorry boss, but loops in Julia are efficient!
M(f,x)=[f(i...)for i=x]
N(f,x,n)=(for i=1:n x=f(x...)end;x)
A(f,x)=f(x...)
R(n)=(i=0;x={};while i<n push!(x,i+=1)end;x)
F(f,x,a)=(for b=a x=f(x,b)end;x)
T(f,i)=[f(j)for j=i[1]:i[2]]

Adding the ellipses after an argument to a function breaks an array, tuple, or what have you into regular function arguments. Otherwise the function will think you're trying to pass an array (or tuple, etc.). It has no effect for single arguments.
Function names:

Map: M
Nest: N
Apply: A
Range: R
Fold: F
Table: T

Python 3, 218 bytes
The unreadable version:
exec("P!:[f(_)for _ in x];Y!,z:Y(f,f(x),z-1)if z else x;T!:f(*x);H!=0:(H(f-1)if~-f else[])+[f];O!,z:O(f,f(x,z[0]),z[1:])if z else x;N!:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]".replace("!","=lambda f,x"))

The (more) readable version:
P=lambda f,x:[f(_)for _ in x]
Y=lambda f,x,z:Y(f,f(x),z-1)if z else x
T=lambda f,x:f(*x)
H=lambda f,x=0:(H(f-1)if~-f else[])+[f]
O=lambda f,x,z:O(f,f(x,z[0]),z[1:])if z else x
N=lambda f,x:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]

Going though it one lambda at a time:
Map function P
P=lambda f,x:[f(_)for _ in x]
Just a simple iterator. Not much to say here.
Nest function Y
Y=lambda f,x,z:Y(f,f(x),z-1)if z else x
Recursing until z hits zero, applying f every time. The if clause at the end feels clunky; perhaps there is a better way to end the recursion.
Apply function T
T=lambda f,x:f(*x)
Python has a nice expansion operator to do all of the heavy lifting for me.
Range function H
H=lambda f,x=0:(H(f-1)if~-f else[])+[f]
This one was harder than I was expecting. Ended up taking a recursive approach. Again, the if-else construction takes up a lot of bytes, and I feel it can be improved. Why does it have a dummy x=0, you ask? It's so that when I compress it with the exec, I can replace =lambda f,x instead of just =lambda f.
Fold function O
O=lambda f,x,z:O(f,f(x,z[0]),z[1:])if z else x
Pretty happy with this one. Just lops off the first element of the array every time it recurses, until there's nothing left.
Table function N
N=lambda f,x:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]
This one is horrible and I'm sure there's room for improvement. Tried to use the range and map functions previously defined for a map(f,range(x,y)) sort of construction, but without much success. Ended up doing a terrible recursive approach which shares some similarity to the range function.
All the lambdas are wrapped up in an exec with a replace to shorten the byte count significantly.

I was about to comment that [f(_)for _ in x] could be shortened to map(f,x), but then I remembered what the challenge was

tinylisp, 325 * 0.9 = 292.5
The language is newer than the question, but it's not going to win anyway.
(d @(q(a a)))(d Q(q((l)(i l(c(@(q q)(h l))(Q(t l)))l))))(d A(q((f a)(v(c(q f)(Q a))))))(d M(q((f l)(i l(c(A f(@(h l)))(M f(t l)))l))))(d N(q((f a x)(i x(A f(@(N f a(s x 1))))a))))(d ,(q((m a b)(i(l b a)m(,(c b m)a(s b 1))))))(d R(q((a)(,()1 a))))(d T(q((f r)(M f(A ,(c()r))))))(d F(q((f a l)(i l(F f(A f(@ a(h l)))(t l))a))))

Defines the functions A (apply), M (map), N (nest), R (range), T (table), and F (fold), along with a couple helper functions. T expects a list of two integers for its second argument.
Tinylisp doesn't even have any loop constructs; everything is accomplished using recursion. Several of these functions are not tail-recursive, so if you call them on large lists they will probably blow the call stack. They could all be implemented with tail recursion... but it would take more bytes, and this is code golf.
Here's an expanded version with whitespace and real words for names, which should be pretty readable if you're familiar with Lisp. (I've aliased most of the tinylisp builtins except for q (quote) and i (if).)
(d define d)
(define cons c)
(define car h)
(define cdr t)
(define subtract s)
(define less l)
(define eval v)

(define lambda
  (q (()
      (arglist expr)
      (list arglist expr))))

(define list (lambda args args))

(define quote-all
  (lambda (lyst)
    (i lyst
       (cons
         (list (q q) (car lyst))
         (quote-all (cdr lyst)))
       lyst)))

(define Apply
  (lambda (func arglist)
    (eval (cons (q func) (quote-all arglist)))))

(define Map
  (lambda (func lyst)
    (i lyst
       (cons
         (Apply func (list (car lyst)))
         (Map func (cdr lyst)))
       lyst)))

(define Nest
  (lambda (func arg times)
    (i times
       (Apply func
              (list (Nest func arg (subtract times 1))))
       arg)))

(define range*
  (lambda (accumulator a b)
    (i (less b a)
       accumulator
       (range* (cons b accumulator) a (subtract b 1)))))

(define Range
  (lambda (x)
    (range* 1 x)))

(define Table
  (lambda (func iterator)
    (Map func
         (Apply range* (cons () iterator)))))

(define Fold
  (lambda (func arg lyst)
    (i lyst
       (Fold func
             (Apply func (list arg (car lyst)))
             (cdr lyst))
       arg)))

Further explanation available upon request.
Sample output
Uses the REPL environment from my reference implementation. I used q (quote) for the unary function and s (subtract) as the binary function for these examples, as well as the function @ (defined in this code) which returns a list of its arguments.
tl> [line of definitions goes here]
@
Q
A
M
N
,
R
T
F
tl> (A s (@ 10 7))
3
tl> (M q (@ 1 2 3 4))
((q 1) (q 2) (q 3) (q 4))
tl> (N q 123 4)
(q (q (q (q 123))))
tl> (R 5)
(1 2 3 4 5)
tl> (T q (@ 3 7))
((q 3) (q 4) (q 5) (q 6) (q 7))
tl> (F s 10 (@ 4 3 2))
1

Python 2.x: 450.6 bytes (493 bytes before 10% discount)
Golfed answer:
y=len
z=lambda a,b:a.append(b)
_=lambda a:a if a is not None else[]
def M(a,b,c=None):
 c=_(c);d=y(b)
 if d:z(c,A(a,b[0]))
 return M(a,b[1:],c)if d else c
def N(a,b,c):d=A(a,b);return N(a,d,c-1)if c>1 else d
A=lambda a,b:a(*b)if type(b)is list else a(b)
def R(a,b=None):b=_(b);b.insert(0,a);return b if a<=1 else R(a-1,b)
def F(a,b,c):d=a(b,c[0]);return F(a,d,c[1:])if y(c)>1 else d
def T(a,b,c=None,d=None):
 if c is None:c=b[0];d=[]
 z(d,a(c));return T(a,b,c+1,d)if c<b[1]else d

This question was fun.  I decided to write my functions without using the Python equivalents (though that may have been a valid loophole) and to write the functions as though Python supports tail recursion.  To make this work, I used a lot of optional parameters that allow the required calls to still work.
Below I have ungolfed listings for each function.
Apply:
A = lambda function, arguments: function(*arguments) if type(arguments) is list else function(arguments)

Map:
def M(function, arguments, result=None):
    result = result if result is not None else []
    length = len(arguments)
    if length != 0:
        result.append(A(function, arguments[0]))
    return M(function, arguments[1:], result) if length != 0 else result

Nest:
def N(function, arguments, times):
    result = A(function, arguments)
    return N(function, result, times - 1) if times > 1 else result

Note that this function requires that the passed function be able to represent multiple arguments variably.  Another approach would have been to enforce that the function always received a single list, but that would have required that the passed functions be able to interpret argument lists.  There were assumptions either way, so I chose the one that fit the rest of the system better.
Range:
def R(ceiling, result=None):
    result = result if result is not None else []
    result.insert(0, ceiling)
    return result if ceiling <= 1 else R(ceiling - 1, result)

Fold:
def F(function, initial, rest):
    result = function(initial, rest[0])
    return F(function, result, rest[1:] if len(rest) > 1 else result

Table:
def T(function, iterator, current=None, result=None):
    if current is None:
        current = iterator[0]
        result = []
    result.append(function(current))
    return T(function, iterator, current + 1, result) if current < iterator[1] else result

Here is sample output using the following helper functions:
square = lambda x: x * x
def add(*args):
    addTwo = lambda a, b: a + b
    if len(args) == 1 and type(args[0]) is list:
        return F(addTwo, 0, args[0])
    else:
        return F(addTwo, 0, args)

>>> M(square, R(10))
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> M(add, [R(i) for i in R(10)])
[1, 3, 6, 10, 15, 21, 28, 36, 45, 55]
>>> T(square, [0, 10])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> N(square, 2, 4)
65536
>>> N(lambda *args: F(lambda a, b: a * b, 1, args) if len(args) > 1 else str(args[0]) + 'a', R(5), 10)
'120aaaaaaaaa'

Wow, looks really good!

That seems like a skewed sense of aesthetics ; )  I always find it amusing to see golfed Python since the first Python book I read talked about how Python enforces readability.

I do indeed have a skewed sense of aesthetics :)

I am confused by other people's scores.  I took 10% of the score of each of the required functions which did not use a loop (which was all of them), but other people took 10% of the whole score for each function that did not use a loop (which can be up to 60% off).  Which is the correct approach?

Yours is the correct way to go, I had an unrealistic expectation and so initially I had in mind the 60% approach, but now I think the 10% will be more stimulating and the righter between the two

Ceylon, 370 * 0.9 = 333 364 * 0.9 = 327.4
Most of those functions are already available in Ceylon's language package (though sometimes with a bit different signature), but we are defining them here like requested in the question.
alias I=>Integer;R[]m<A,R>(R(A)g,A[]l)=>f((R[]x,A y)=>x.append([g(y)]),[],l);A n<A>(A(A)g,A a,I t)=>f((A x,I y)=>g(x),a,r(t));R y<A,R>(Callable<R,A>g,A v)given A satisfies Anything[]=>g(*v);I[]r(I i)=>t((j)=>j,[1,i]);A f<A,O>(A(A,O)g,A a,O[]o)=>if(nonempty o)then f(g,g(a,o[0]),o.rest)else a;R[]t<R>(R(I)g,[I,I]i)=>i[1]<i[0]then[]else[g(i[0]),*t(g,[i[0]+1,i[1]])];

Actually only two of the functions (t and f) are actually using recursion (over lists and integers, respectively), the other ones are based on these. (Apply is a bit of an outlier, it doesn't really relate to the others.)
I interpret "List" as Ceylon's Sequential type, which is an immutable ordered (possibly empty) sequence of elements. [R*] stands for Sequential<R> – for some reason we can also write it R[], which is one byte shorter.
A function type is Callable<R, A>, where A is a tuple type for the arguments, like [X, Y, Z] (i.e. some subtype of Anything[]). As a shortcut we can write R(X,Y,Z) instead of Callable<R,[X,Y,Z]>.
I aliased Integer as I to save some bytes.
Here is a formatted (and slightly commented) version:
// implement functional paradigms
//
// Question: http://codegolf.stackexchange.com/q/58588/2338
// My Answer: http://codegolf.stackexchange.com/a/64515/2338

alias I => Integer;

// map – based on fold.
R[] m<A, R>(R(A) g, A[] l) =>
        f((R[]x,A y) => x.append([g(y)]), [], l);

// nest – based on fold + range, throwing away the second
//        argument in a proxy function.
A n<A>(A(A) g, A a, I t) =>
        f((A x, I y) => g(x), a, r(t));

// apply – this looks quite heavy due to type safety.
//         This uses the "spread operator" *.
R y<A, R>(Callable<R,A> g, A v)
        given A satisfies Anything[] =>
        g(*v);

// range – based on table (using the identity function)
I[] r(I i) =>
        t((j) => j, [1, i]);

// fold – a plain list recursion.
A f<A, O>(A(A, O) g, A a, O[] o) =>
        if (nonempty o) then f(g, g(a, o[0]), o.rest) else a;

// table – an integer recursion.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        i[1] < i[0] then [] else [g(i[0]), *t(g, [i[0] + 1, i[1]])];

Using "loops"
Table and Map can be implemented shorter using loops (actually, an sequence comprehension):
// map – using a sequence comprehension:
R[] m<A, R>(R(A) g, A[] l) =>
        [for(a in l) g(a)];

// table – map with an integer range.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        m(g, i[0]..i[1]);

Though I'm not sure if the use of the .. operator for the integer range counts as using a built-in function. If this is allowed, the resulting code is this here, length 312:
alias I=>Integer;R[]m<A,R>(R(A)g,A[]l)=>[for(a in l)g(a)];A n<A>(A(A)g,A a,I t)=>f((A x,I y)=>g(x),a,r(t));R y<A,R>(Callable<R,A>g,A v)given A satisfies Anything[]=>g(*v);I[]r(I i)=>t((j)=>j,[1,i]);A f<A,O>(A(A,O)g,A a,O[]o)=>if(nonempty o)then f(g,g(a,o[0]),o.rest)else a;R[]t<R>(R(I)g,[I,I]i)=>m(g,i[0]..i[1]);

(It could be made even shorter by defining r(I i) => 1..i, resulting in score 301. Though that looks even more like cheating.)
If .. is not allowed, we'll have to implement it again. We can use these implementations for r and t (with the m above):
// range – based two-limit range
I[] r(I i) =>
        q(1, i);

// two-limit range implemented recursively
I[] q(I i, I j) =>
        j < i then [] else [i, *q(i + 1, j)];

// table – map with an integer range.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        m(g, q(i[0], i[1]));

This results in 348 bytes, better than the completely recursive version, but not after applying the bonus.

Scala 3 (compile-time), 403 * 0.9 = 362.7 bytes
This works using compiletime black magic.
import compiletime.S
type T=Tuple
type E=EmptyTuple
type^[F[_],X<:T]<:T=X match{case h*:t=>F[h]*:(F^t)case _=>X}
type N[F[_],X,T]=T match{case 0=>X case S[t]=>N[F,F[X],t]}
type%[F[_],X]=F[X]
type>[A<:T,X]=X match{case 0=>A case S[e]=>X*:A>e}
type R[X]=E>X
type F[G[_,_],X,L]=L match{case h*:t=>F[G,G[X,h],t]case _=>X}
type-[F[_],I]<:T=I match{case(b,e)=>S[e]match{case`b`=>E case _=>F[b]*:(F-(S[b],e))}}

Try it in Scastie

^ is Map.
N is Nest.
% is Apply.
R is Range.
F is Fold.
- is Table. NB there is a compiler bug so most functions (type constructors) don't work with my implementation of Table, and only the identity function seems to work.

The first 3 lines are just so long names aren't repeated. T and E are typealiases we'll need later, and S is a type that gives the successor of a singleton type, e.g. S[1] becomes 2. S is extremely useful here, as it can not only add 1, but also subtract 1 using match types.
import compiletime.S
type T=Tuple
type E=EmptyTuple

Map
type ^[F[_], X <: T] <: T = X match {
  case h *: t => F[h] *: (F ^ t)
  case _ => E
}

Here, we declare a type ^ that takes 2 parameters, F and X. The [_] after F means that F is a type constructor of 1 argument, which we'll treat as a function taking a single parameter. X <: T means that X is a subtype of T, which is an alias for Tuple. The second <: T means that ^ returns a tuple (this is necessary because ^ is recursive).
The body of ^ is a match type. The first case if X has at least one element (tuples can be uncons-ed in Scala 3). If so, X is destructured into a head h and a tail t. F[h] applies F to h, and we join that using *: to the result of mapping the result of the tuple (F ^ t is equivalent to ^[F, t]). The second case will be reached if X is empty, in which case we return E, the empty tuple (or rather, the type of an empty tuple).
Nest
type N[F[_], X, T] = T match {
  case 0 => X
  case S[t] => N[F, F[X], t]
}

This is more interesting. Here, F is the function to repeatedly apply, X is the starting argument, and T is how many times to apply F. If T is 0, we simply return X. Otherwise, we see if it is the successor of some type t. If T is a literal type extending Int, t will be T - 1, so the second case is basically calling N(F, F(X), T - 1).
Apply
type %[F[_], X] = F[X]

This is boring. It just takes a function F and another argument X and applies F to X.
Range
type >[A <: T, X] = X match {
  case 0 => A
  case S[e] => X *: A > e
}
type R[X] = E > X

R is the Range function, but >, a tail-recursive type, does all the heavy-lifting. > takes an accumulator tuple A and an integer X. When X reaches 0, it's time to return the accumulator. Otherwise, we use S to find an e that is X - 1. X is prepended to the accumulator and > is called again with e. R just calls > with an empty tuple as the accumulator to start it off.
Fold
type F[G[_, _], X, L] = L match{
  case h *: t => F[G, G[X, h], t]
  case _ => X
}

Here, G is a function/type constructor that takes two parameters (like F[_] above). X is the starting argument, and L is the tuple to fold over. If L is not empty, the first case will be matched, so we call F again with the same function G, but with X as the result of applying G on X and the first element of L, and with L as L's tail.
Table
type -[F[_], I] <: T = I match{
  case (b, e) => S[e] match{
    case `b` => E
    case _ => F[b] *: ( F - (S[b],e) )
  }
}

This got a little hairy because of how the second parameter is taken, and it's also affected by a compiler bug (mentioned above). First, we destructure the iterator I to get the start and end (here, b and e). If b is greater than e, we return an empty tuple (E). To test that, we find e + 1 (S[e]) and check if that matches b. Otherwise (case _), we apply F to Imin/b and prepend that to the result of calling Table with b + 1 (S[b]) as the new beginning.

Go, 489 bytes, int only
func M(f func(int)int,L[]int)(Q[]int){for _,e:=range L{Q=append(Q,f(e))};return}
func N(f func(int)int,s,t int)int{if t<1{return s};return f(N(f,s,t-1))}
func A(f func(...int)int,L[]int)int{return f(L...)}
func R(r int)(O[]int){for i:=1;i<=r;i++{O=append(O,i)};return}
func F(f func(int,int)int,x int,o[]int)int{l:=len(o)-1;if len(o)<2{return f(x,o[l])}else{return f(F(f,x,o[:l]),o[l])}}
func T(f func(int)int,k...int)(O[]int){if len(k)>1{for i:=k[0];i<=k[1];i++{O=append(O,f(i))}};return}

Attempt This Online!
Golang is really not designed for concise functional programming. This solution works on ints only.
Go, 492 bytes, generic
func M[I,O any](f func(I)O,L[]I)(Q[]O){for _,e:=range L{Q=append(Q,f(e))};return}
func N[I any](f func(I)I,s I,t int)I{if t<1{return s};return f(N(f,s,t-1))}
func A[I,O any](f func(...I)O,L[]I)O{return f(L...)}
func R(r int)(O[]int){for i:=1;i<=r;i++{O=append(O,i)};return}
func F[I any](f func(I,I)I,x I,o[]I)I{l:=len(o)-1;if len(o)<2{return f(x,o[l])}else{return f(F(f,x,o[:l]),o[l])}}
func T[K any](f func(int)K,k...int)(O[]K){if len(k)>1{for i:=k[0];i<=k[1];i++{O=append(O,f(i))}};return}

Attempt This Online!

Groovy (146 Bytes) (146*90%=131.4)
P.S. I don't know what you're considering as a 'loop' in this context, I only applied the bonus after I was told to in the comments by OP and will remove if 2-3 additional users say these collection functions and iterators are loops and that I don't deserve the bonus. Also, if you want to call me out on my use of 1..it, please do so and I will rework it / update my bytecount.
m={f,l->l.collect{f(it)}}            // Map
n={f,x,n->n.times{x=f(x)};x}         // Nest
a={f,l->f(l)}                        // Apply
r={1..it}                            // Range (Is this cheating?)
f={f,x,l->l.each{x=f(x,it)};x}       // Fold
t={f,l->(l[0]..l[1]).collect{f(it)}} // Table

Example Input/Output
f1={2*it}
f2={a,b,c,d,e->a*b*c*d*e}
f3={a,b->a*b}
l=[1,2,3,4,5]
l2=[1,9]
y=5
x=1
println m(f1,l)
println n(f1,x,y)
println a(f2,l)
println r(y)
println f(f3,x,l)
println t(f1,l2)

Output
MAP:   [2, 4, 6, 8, 10]
NEST:  32
APPLY: 120
RANGE: [1, 2, 3, 4, 5]
FOLD:  120
TABLE: [2, 4, 6, 8, 10, 12, 14, 16, 18]

Try it yourself:
https://groovyconsole.appspot.com/edit/5203951758606336

This technically does not use loops, so remember the bonus! Else, great answer!

Technically no loops?! Really?!
.each{} .times{} .collect{} are iterators.


text:
Heterograms, Palindromes, oh my!
(First challenge, please let me know if there are any problems with it.)
A heterogram is a word where no letter of the alphabet occurs more than once, and a palindrome is a phrase that is the same backwards and forwards.
The challenge here is to write a piece of code that takes in a word (just letters) as input, and outputs whether or not it is a heterogram (truthy/falsy). The catch is that the program must be a palindrome -- reads the same backwards and forwards. Capitalization doesn't matter here, so for the heterogram to be valid it can't have both q and Q, for instance.  No comments are allowed, and you cannot place strings that contain your code (or a significant part of your code) to try to make the palindrome part easy :P
This is code-golf, so shortest code wins. Good luck!
EDIT: Parens, brackets or other symbols that have left and right forms must be reversed approriately for the palindrome part. So (helloolleh) is a palindrome, but (helloolleh( is not. Apparently this is called a convenient palindrome.
EDIT 2: You won't get any empty input, input with multiple words or input with characters other than letters. So don't worry about that :)

Are brackets considered to be equivalent for palindromicity? That is, is (hellolleh) a valid palindrome? Similar for [], {}, and <> (where appropriate).

Yes. Sorry, I should have explained that.

What about new lines, will asdsa be considered equal to asd\nsa?

No, they would not be equivalent.

I believe it's called a convenient palindrome.

Pyth - 11 bytes
(Trailing and leading spaces necessary and counted).
 z.{ z }.z

Test Suite.
<space>        Suppress print
 z             Input (for palindromness)
.{             Unique - actually does testing
  z            Input
<space>        Suppress print
  }            In operator
   .z          Cached input list
   <space>     At end of program makes empty tuple

Mike's Pyth answer converts to lowercase before doing .{, are you sure you don't need to do that too?

Pyth, 17 bytes
 Z.{rzZ.q.Zzr}.Z

Try it online here.
The leading space is necessary. I have counted it and the trailing space in the byte count.
Here's the breakdown:
     z            z is initialized to the input
    r Z           Z is initialized to 0, and r(string)0 converts the string to lowercase
  .{              .{ is pyth's builtin uniqueness test
       .q         .q terminates the program
         .Zzr}    This is just the program mirrored
              .Z  . requires a number to immediately follow it
                  If left blank the parser would throw an error
 Z                This is just mirrored from the end
                  The leading space suppresses the automatic printing of this 0
                  The trailing space mirrors the leading space

Jeez, and I was worried that this would be too hard... Nice job!

You have a .q in your comments, but a .w in your program.

@JamesWebster Thanks for pointing that out. It should be .q

Python 3, 125
The main problem is to make the reverse of the code parsable. Then we can let it error out from undefined identifiers.
w=[str.lower][0]((input)())
(print)((max)((map)(w.count,w))<2)
(2>((w,tnuoc.w)(pam))(xam))(tnirp)
(()(tupni))[0][rewol.rts]=w

Very minor point, but from the rules you should change the second < into a >!

Perl, 43 bytes
print+m:^(?!.*(.).*\1|1/*.(.)*.!?)^:m+tnirp

Usage example:
echo "abcde" | perl -n entry.pl

Wow, that's amazing. Nice job!

><>, 137 131 Bytes
When I saw this challenge, I thought ><> might finally be a good choice of language since using it you can mostly ignore palindromes; it is simple to make sure the pointer only stays where it should. While this is true, ><> unfortunately makes golfing conditionals excruciating (or just golfing in general). I hope to use some weird tricks I thought of to compensate for this, but here's a "quick" (not actually, both program-wise and creation-wise) answer. You can try it online here.
i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
  ;n1<^  -*48<   .00~<  ;n-10<01-n;  >~00.   >84*-  ^>1n;
<.0e&$v?=@:}:&v?)1:-1lv?("Z":<v?)0:i

Returns 1 for true and -1 for false (I could change it to 0 but the length would stay the same, unfortunately)
As always, let me know if this doesn't work and if you have any ideas on how to golf it down. I tested it against a few test cases, but there always could be an exception.
Here's another version, one that I think is a bit more clever, but alas is ten bytes more. Truthy/falsey values this time are 1 and an error (something smells fishy...):
>i:0(?v>:"Z")?vl: 2(?v&{:@$:@=01-*2.
 < ;n1<^  -*48<f6+0.0<
 &1-:1)e*1.1*e(1:-1&
>0.0+6f>84*-  ^>1n; >
.2*-10=@:$@:}&v?)2 :lv?("Z":<v?)0:i<

Explanation:
Here's the code without the part added to make it a palindrome. This one doesn't use the "more clever" tricks I attempted to use for the alternate version, so it's a bit easier to explain (if anyone is interested in an explanation for the "tricks," I'd be happy to give one, though).
i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
  ;n1<^  -*48<   .00~<  ;n-10<

Line 1:
i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
i:0(?v                                 #Pushes input and directs down if negative
      >:"Z")?v                         #Directs down if input is greater than "Z"
                                       #(reduces lowercase input to uppercase)
              l                        #Pushes length

                                       #Main loop begins
               1-:1(?v                 #Decrements top, and then directs down if less than 1
                      &                #Pushes top of stack onto register (length minus 1)
                       :{              #Duplicates top, shifts stack to the left
                         :@            #Duplicates top, shifts top three values of the stack to the right

                           =?v         #If top two values are equal, directs down
                              $        #Swaps top two values of the stack
                               &       #Pushes register onto stack
                                e0.    #Jumps back to the "1" after "?vl"
                                       #Main loop ends

                                   >   #Makes sure when the pointer jumps back to i it goes the right way

Here's how the convoluted swapping (:{:@=?v$) works -- I'll use a test case of this stack: [5,1,8,1] where the last character is the top.
:{ The top of the stack is duplicated: [5,1,8,1,1], and the stack shifted to the left: [1,8,1,1,5]
:@ The top is duplicated: [1,8,1,1,5,5], then the top three values are shifted to the right: [1,8,1,5,1,5]
=?v Unnecessary for this part of explanation
$ The top value is swapped once more yielding [1,8,1,5], which, if you'll note, is the original stack shifted over once (as if { had been the only command).

So what this does in English ("Thank God, he's actually explaining things") is check the entire stack against the top value and move to a point in the second line if any value equals the top. This checking is done proportionate to how many values there are in the stack (l - 1, where l is the length of the stack) so that all values are checked against each other.
Line 2:
  ;n1<^  -*48<   .00~<  ;n-10<
   n1<                          #If input is less than 0 (i.e. there is none), print 1
  ;                             #and terminate

             <                  #If redirected because input is greater than "Z"
         -*48                   #Push 32, subtract (reducing lowercase to uppercase, numerically)
      ^                         #And move back to the portion that tests if input
                                #is uppercase (which it will pass now)

                     <          #If counter is less than 1 (for main loop)
                 .00~           #Pop the counter and jump to the beginning (i)

                             <  #If any two values in the stack are equal
                          -10   #Push -1 (subtract 1 from 0)
                        ;n      #Print and terminate

Glad to see a ><> answer :)

Also, ><> is a palindrome itself (just not a convenient one)

PHP, 126 Bytes
You need to run this with the short_tags ini directive turned off in 5.4 or above.
First golf ever. Two copies, the first prints a whole bunch of garbage with the falsy/truthy result:
<?=var_dump(max(array_count_values(str_split(end($argv))))<2)?><?(2>((((vgra$)dne)tilps_rts)seulav_tnuoc_yarra)xam)pmud_rav=?>

This version will not print any jargon (162 bytes):
<?=var_dump(max(array_count_values(str_split(end($argv))))<2);__halt_compiler()?><?()relipmoc_tlah__;(2>((((vgra$)dne)tilps_rts)seulav_tnuoc_yarra)xam)pmud_rav=?>

Run from the command line with
php -f golf.php heterogram

Probably can be golfed a bit further

Clever, though pushing limits of validness. Maybe for the sport think of a solution with comments

Instead of ?><?, you can use //\\. That should remove that requirement. And instead of __halt_compiler() use return;

Disregard it. You can't use comments. But the return; is still valid.

05AB1E, 9 bytes
lDÙQqQÙDl

Try it online.
*insert something about going all the way back to my very first challenge*
Non-competing since 05AB1E was made after this challenge.
Explanation
lDÙQqQÙDl
l           Take input and lowercase it.
 DÙ         Duplicate and uniquify.
   Q        Compare the two strings.
    q       Immediately exit.
     QÙDl   The rest of the program is ignored.

"Non-competing since 05AB1E was made before this challenge." Perhaps you meant after this challenge? ;)

Brachylog, 3 bytes, language postdates challenge
DdD

Try it online!
This is one of the very few programs that works in both Brachylog 1 and Brachylog 2. The TIO link is to Brachylog 1 for old times' sake. Also unsually for Brachylog, this is a full program, not a function. (Full programs in Brachylog implicitly output booleans, which is just what we want for this question.)
The general principle here is that placing a predicate between a pair of identical uppercase letters is an assertion that the current value is invariant under that predicate. So you often see things like AoA for "is sorted" ("invariant under sorting"); A↔A would (in Brachylog 2) mean "is a palindrome" ("invariant under reversal"), and so on. This program is "invariant under removing duplicates", i.e. "doesn't contain duplicates". It's really convenient that this method of specifying invariance happens to be a palindrome.

Brachylog, 3 bytes
≠ụ≠

Try it online!
The predicate succeeds if the input is a heterogram and fails if it is not.
≠      The characters of the input are all distinct,
 ụ     and when converted to upper case,
  ≠    are still all distinct.

MATL, 7 bytes
tuX=Xut

Try it online!
Returns list [1, 1] if the input is a heterogram and [0, 0] if not.
Explanation:
t       % duplicate the input
u       % remove duplicates from the original
X=      % check the two lists are equal
Xu      % unique rows (does nothing as we now have a boolean)
t       % duplicate the result
        % (implicit) convert to string and display

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Dependency Graph Visualization
The goal of this challenge is to write a program that visualizes a dependency graph in the form of a tree.
While "dependency graph" in this context means nothing more than a directed graph, the visualization method described here works best for graphs describing some dependency relation (as an exercise, after you've read the challenge, try to reverse the direction of one of the sample graphs, and see if the result is as useful.)
The input to the program consists of one or more target definitions, which are lines of the form
Target DirectDependency1 DirectDependency2 ...

, defining a target, and its associated direct dependencies, if any.
Targets and their dependencies are collectively called objects.
If an object appears only as a dependency, and not as a target, it has no dependencies.
The set of all objects that appear in the input is called Γ.
(See the Input and Output section for more details about the input format.)
For any pair of objects, A and B, we say that:

A depends on B (equivalently, B is required by A), if A directly depends on B, or if A directly depends on B', and B' depends on B, for some object B';
A properly depends on B (equivalently, B is properly required by A), if A depends on B, and B does not depend on A.

We define a contrived object, ʀooᴛ, not in Γ, such that ʀooᴛ is not directly required by any object, and such that, for all objects A, ʀooᴛ directly depends on A if and only if A is in Γ, and A is not properly required by any object in Γ (in other words, ʀooᴛ directly depends on A if no other object depends on A, or if all objects that depend on A are also required by A.)
Output Tree
We construct a tree, whose root node is ʀooᴛ, and such that the children of each node are its direct dependencies.
For example, given the input
Bread Dough Yeast
Dough Flour Water
Butter Milk

, the resulting tree is

, or, in ASCII form,
ʀooᴛ
+-Bread
| +-Dough
| | +-Flour
| | +-Water
| +-Yeast
+-Butter
  +-Milk

.
The program's output is the above-defined tree, printed without the ʀooᴛ node.
So, for example, the corresponding output for the above input is
Bread
+-Dough
| +-Flour
| +-Water
+-Yeast
Butter
+-Milk

.
A detailed description of the layout of the output tree is given later.
Node Order
The child nodes of a given parent node, P, should be sorted, such that, for all child nodes A and B of P, A appears before B if and only if

there exists a child node C of P, such that A is properly required by C, and C precedes, or equals to, B, according to the same order; or,
A alphabetically precedes B (more preceisely, A precedes B using ASCII collation,) and there exists no child node C of P, such that B is properly required by C, and C precedes, or equals to, A, according to the same order.

(People looking for a mathematical challenge might want to show that this relation is well defined, and that it's, in fact, a strict total order. Don't forget that Γ is finite!)
For example, given the input
X D C B A
B D
C A

, the output should be
X
+-A
+-D
+-B
| +-D
+-C
  +-A

.
A appears before B, and B appears before C, due to their alphabetical order;
D appears before B, since it is properly required by it, and after A, since it alphabetically follows it;
B and C do not appear before D, even though they precede it alphabetically, since there exists a node, namely, B, that properly requires D, and that equals to B (i.e., itself), and preceeds C, according to the same rules.
Repetitions
The same object, A, may appear more than once in the output, if, for example, it is required by more than one object.
If A has no dependencies of its own, no special handling is required in this case.
Otherwise, in order to minimize the verbosity of the output, and to avoid infinite recursion due to circular dependencies, the dependencies of A are listed only on its first occurrence for which none of the ancestors are siblings of another A node;
any other occurrence of A should have no children, and should appear followed by a space and an ellipsis, as in A....
For example, given the input
IP Ethernet
TCP IP
UDP IP
WebRTC TCP UDP

, the output should be
WebRTC
+-TCP
| +-IP
|   +-Ethernet
+-UDP
  +-IP ...

.
As another example, featuring both circular dependency and ancestry considerations,
Rock Scissors
Paper Rock
Scissors Paper

, should result in
Paper
+-Rock ...
Rock
+-Scissors ...
Scissors
+-Paper ...

.
Note that, for example, the first occurrence of Rock does not list its dependencies, since its parent, Paper, is a sibling of another Rock node.
The parent of the second Rock node, ʀooᴛ (which doesn't appear in the output), doesn't have Rock as a sibling, so the dependencies of Rock are listed on this node.
Output Tree Layout
I'm sure you got the hang of how the tree should be represented as ASCII art (and feel free to skip this section if you have,) but for the sake of completeness...
The child nodes of ʀooᴛ are printed on separate lines, without any indentation, in order.
Each node is immediately followed by its children, if any, printed in the same fashion, recursively, indented by two characters to the right.
For each node that has children, a vertical line, consisting of | (pipe) characters, extends down from the character directly below the first character of the node, until the row of its last child node, not including the last child node's children.
If the indentation of a node is nonzero, it is preceded by +- (on the same indentation level as its parent), overwriting the vertical line described above.
Input and Output
You may read the input through STDIN, or using an equivalent method.
You may assume that there are no empty lines, and you may require that the last line ends, or doesn't end, in a newline character.
You may assume that object names consists of printable ASCII characters (not including space).
You may assume that objects in a target definition are separated by a single space character, and that there are no leading or trailing spaces.
You may assume that each target is defined at most once, and that there are no repetitions in its dependency list.
You may write the output to STDOUT, or use an equivalent method.
All output lines, except for the longest, may include trailing spaces.
The last output line may, or may not, end in a newline character.
Score
This is code-golf.
The shortest answer, in bytes, wins.
Test Cases
Your program should process each of the following test cases in a reasonable amount of time.

Input
Depender Dependee
Independent

Output
Depender
+-Dependee
Independent

Input
Earth Turtle
Turtle Turtle

Output
Earth
+-Turtle
  +-Turtle ...

Input
F A C B D I
A B
B A C
D E H
C
G F
J H G C E I
E D
H D
I G

Output
J
+-C
+-E
| +-D
|   +-E ...
|   +-H ...
+-H
| +-D ...
+-G
| +-F
|   +-C
|   +-A
|   | +-B ...
|   +-B
|   | +-C
|   | +-A ...
|   +-D ...
|   +-I ...
+-I
  +-G ...

Civilization V Technology Tree
Input

Pottery Agriculture
AnimalHusbandry Agriculture
Archery Agriculture
Mining Agriculture
Sailing Pottery
Calendar Pottery
Writing Pottery
Trapping AnimalHusbandry
TheWheel AnimalHusbandry
Masonry Mining
BronzeWorking Mining
Optics Sailing
Philosophy Writing
HorsebackRiding TheWheel
Mathematics TheWheel Archery
Construction Masonry
IronWorking BronzeWorking
Theology Calendar Philosophy
CivilService Philosophy Trapping
Currency Mathematics
Engineering Mathematics Construction
MetalCasting Construction IronWorking
Compass Optics
Education Theology CivilService
Chivalry CivilService HorsebackRiding Currency
Machinery Engineering
Physics Engineering MetalCasting
Steel MetalCasting
Astronomy Compass Education
Acoustics Education Chivalry
Banking Chivalry
PrintingPress Machinery Phyisics
Gunpowder Physics Steel
Navigation Astronomy
Economics Banking PrintingPress
Chemistry Gunpowder
Metallurgy Gunpowder
Archaeology Navigation
ScientificTheory Navigation Acoustics Economics
MilitaryScience Economics Chemistry
Fertilizer Chemistry
Rifling Metallurgy
Biology Archaeology ScientificTheory
SteamPower ScientificTheory MilitaryScience
Dynamite MilitaryScience Fertilizer Rifling
Electricity Biology SteamPower
ReplaceableParts SteamPower
Railroad SteamPower Dynamite
Refrigeration Electricity
Telegraph Electricity
Radio Electricity
Flight ReplaceableParts
Combustion ReplaceableParts Railroad
Penicillin Refrigeration
Plastics Refrigeration
Electronics Telegraph
MassMedia Radio
Radar Radio Flight Combustion
AtomicTheory Combustion
Ecology Penicillin Plastics
Computers Electronics MassMedia Radar
Rocketry Radar
Lasers Radar
NuclearFission AtomicTheory
Globalization Ecology Computers
Robotics Computers
Satellites Rocketry
Stealth Lasers
AdvancedBallistics Lasers NuclearFission
ParticlePhysics Robotics Satellites
NuclearFusion Satellites Stealth AdvancedBallistics
Nanotechnology ParticlePhysics
FutureTech Globalization Nanotechnology NuclearFusion

Output

FutureTech
+-Globalization
| +-Computers
| | +-Electronics
| | | +-Telegraph
| | |   +-Electricity
| | |     +-Biology
| | |     | +-Archaeology
| | |     | | +-Navigation
| | |     | |   +-Astronomy
| | |     | |     +-Compass
| | |     | |     | +-Optics
| | |     | |     |   +-Sailing
| | |     | |     |     +-Pottery
| | |     | |     |       +-Agriculture
| | |     | |     +-Education
| | |     | |       +-CivilService
| | |     | |       | +-Philosophy
| | |     | |       | | +-Writing
| | |     | |       | |   +-Pottery ...
| | |     | |       | +-Trapping
| | |     | |       |   +-AnimalHusbandry
| | |     | |       |     +-Agriculture
| | |     | |       +-Theology
| | |     | |         +-Calendar
| | |     | |         | +-Pottery ...
| | |     | |         +-Philosophy ...
| | |     | +-ScientificTheory
| | |     |   +-Acoustics
| | |     |   | +-Chivalry
| | |     |   | | +-CivilService ...
| | |     |   | | +-Currency
| | |     |   | | | +-Mathematics
| | |     |   | | |   +-Archery
| | |     |   | | |   | +-Agriculture
| | |     |   | | |   +-TheWheel
| | |     |   | | |     +-AnimalHusbandry ...
| | |     |   | | +-HorsebackRiding
| | |     |   | |   +-TheWheel ...
| | |     |   | +-Education ...
| | |     |   +-Economics
| | |     |   | +-Banking
| | |     |   | | +-Chivalry ...
| | |     |   | +-PrintingPress
| | |     |   |   +-Machinery
| | |     |   |   | +-Engineering
| | |     |   |   |   +-Construction
| | |     |   |   |   | +-Masonry
| | |     |   |   |   |   +-Mining
| | |     |   |   |   |     +-Agriculture
| | |     |   |   |   +-Mathematics ...
| | |     |   |   +-Phyisics
| | |     |   +-Navigation ...
| | |     +-SteamPower
| | |       +-MilitaryScience
| | |       | +-Chemistry
| | |       | | +-Gunpowder
| | |       | |   +-Physics
| | |       | |   | +-Engineering ...
| | |       | |   | +-MetalCasting
| | |       | |   |   +-Construction ...
| | |       | |   |   +-IronWorking
| | |       | |   |     +-BronzeWorking
| | |       | |   |       +-Mining ...
| | |       | |   +-Steel
| | |       | |     +-MetalCasting ...
| | |       | +-Economics ...
| | |       +-ScientificTheory ...
| | +-MassMedia
| | | +-Radio
| | |   +-Electricity ...
| | +-Radar
| |   +-Combustion
| |   | +-Railroad
| |   | | +-Dynamite
| |   | | | +-Fertilizer
| |   | | | | +-Chemistry ...
| |   | | | +-MilitaryScience ...
| |   | | | +-Rifling
| |   | | |   +-Metallurgy
| |   | | |     +-Gunpowder ...
| |   | | +-SteamPower ...
| |   | +-ReplaceableParts
| |   |   +-SteamPower ...
| |   +-Flight
| |   | +-ReplaceableParts ...
| |   +-Radio ...
| +-Ecology
|   +-Penicillin
|   | +-Refrigeration
|   |   +-Electricity ...
|   +-Plastics
|     +-Refrigeration ...
+-Nanotechnology
| +-ParticlePhysics
|   +-Robotics
|   | +-Computers ...
|   +-Satellites
|     +-Rocketry
|       +-Radar ...
+-NuclearFusion
  +-AdvancedBallistics
  | +-Lasers
  | | +-Radar ...
  | +-NuclearFission
  |   +-AtomicTheory
  |     +-Combustion ...
  +-Satellites ...
  +-Stealth
    +-Lasers ...

Cygwin syslog-ng Package Dependency Graph
Input

p11-kit-trust cygwin libtasn1_6
libtasn1_6 cygwin
libp11-kit0 cygwin libffi6 libintl8
libopenssl100 cygwin libgcc1 zlib0 ca-certificates
gsettings-desktop-schemas libglib2.0_0
p11-kit cygwin libp11-kit0 libtasn1_6
zlib0 libgcc1
libpcre1 cygwin
libfam0 gamin
shared-mime-info cygwin libglib2.0_0 libxml2
coreutils cygwin libattr1 libgcc1 libgmp10 libiconv2 libintl8 tzcode _update-info-dir
syslog-ng bash gawk libevtlog0 libgcc1 libglib2.0_0 libopenssl100 libpcre1 libwrap0 tzcode
libxml2 libiconv2 libreadline7 zlib0
cygwin base-cygwin
ca-certificates bash p11-kit p11-kit-trust cygwin
libintl8 cygwin libiconv2
libncursesw10 cygwin libgcc1 libstdc++6 terminfo
libstdc++6 libgcc1
bash coreutils cygwin libgcc1 libiconv2 libintl8 libncursesw10 libreadline7 _update-info-dir
libmpfr4 libgcc1 libgmp10
tzcode bash cygwin libgcc1
_update-info-dir cygwin
libreadline7 libncursesw10
gawk bash cygwin libgcc1 libgmp10 libintl8 libmpfr4 libreadline7
gamin libglib2.0_0
libglib2.0_0 libfam0 libffi6 libgcc1 libiconv2 libintl8 libpcre1 zlib0 gsettings-desktop-schemas shared-mime-info tzcode

Output

syslog-ng
+-libgcc1
+-bash
| +-cygwin
| | +-base-cygwin
| +-_update-info-dir
| | +-cygwin ...
| +-libgcc1
| +-libiconv2
| +-libintl8
| | +-cygwin ...
| | +-libiconv2
| +-libncursesw10
| | +-cygwin ...
| | +-libgcc1
| | +-libstdc++6
| | | +-libgcc1
| | +-terminfo
| +-libreadline7
| | +-libncursesw10 ...
| +-coreutils
|   +-cygwin ...
|   +-_update-info-dir ...
|   +-libattr1
|   +-libgcc1
|   +-libgmp10
|   +-libiconv2
|   +-libintl8 ...
|   +-tzcode ...
+-tzcode
| +-cygwin ...
| +-libgcc1
| +-bash ...
+-gawk
| +-cygwin ...
| +-libgcc1
| +-libgmp10
| +-libintl8 ...
| +-libreadline7 ...
| +-bash ...
| +-libmpfr4
|   +-libgcc1
|   +-libgmp10
+-libevtlog0
+-libpcre1
| +-cygwin ...
+-libglib2.0_0
| +-libffi6
| +-libgcc1
| +-libiconv2
| +-libintl8 ...
| +-libpcre1 ...
| +-tzcode ...
| +-zlib0
| | +-libgcc1
| +-gsettings-desktop-schemas
| | +-libglib2.0_0 ...
| +-libfam0
| | +-gamin
| |   +-libglib2.0_0 ...
| +-shared-mime-info
|   +-cygwin ...
|   +-libxml2
|   | +-libiconv2
|   | +-libreadline7 ...
|   | +-zlib0 ...
|   +-libglib2.0_0 ...
+-libopenssl100
| +-cygwin ...
| +-libgcc1
| +-ca-certificates
| | +-cygwin ...
| | +-bash ...
| | +-p11-kit
| | | +-cygwin ...
| | | +-libp11-kit0
| | | | +-cygwin ...
| | | | +-libffi6
| | | | +-libintl8 ...
| | | +-libtasn1_6
| | |   +-cygwin ...
| | +-p11-kit-trust
| |   +-cygwin ...
| |   +-libtasn1_6 ...
| +-zlib0 ...
+-libwrap0

GNU grep regex.c Call Graph
Input

check_dst_limits_calc_pos_1 check_dst_limits_calc_pos_1
re_string_destruct
match_ctx_add_sublast
build_charclass bitset_set
match_ctx_init
rpl_re_set_syntax
link_nfa_nodes re_node_set_init_1 re_node_set_init_2
re_node_set_init_union re_node_set_init_copy
register_state re_node_set_insert_last re_node_set_alloc
rpl_re_search re_search_stub
re_node_set_init_2
re_search_2_stub re_search_stub
merge_state_array re_acquire_state re_node_set_init_union
calc_eclosure calc_eclosure_iter
create_token_tree
create_tree create_token_tree
pop_fail_stack
re_compile_fastmap_iter
rpl_regcomp rpl_re_compile_fastmap re_compile_internal
check_arrival_expand_ecl find_subexp_node check_arrival_expand_ecl_sub re_node_set_merge re_node_set_alloc
clean_state_log_if_needed extend_buffers
lower_subexps lower_subexp
duplicate_node re_dfa_add_node
re_node_set_merge
build_equiv_class bitset_set
create_initial_state re_acquire_state_context re_node_set_merge re_node_set_init_copy re_node_set_contains
rpl_regfree free_dfa_content
check_halt_state_context check_halt_node_context re_string_context_at
check_dst_limits search_cur_bkref_entry check_dst_limits_calc_pos
re_node_set_insert re_node_set_init_1
transit_state_bkref transit_state_bkref check_subexp_matching_top get_subexp re_string_context_at re_node_set_init_union re_acquire_state_context
get_subexp_sub match_ctx_add_entry clean_state_log_if_needed check_arrival
free_tree free_token
parse_reg_exp free_tree parse_branch fetch_token postorder create_tree
re_string_skip_chars
match_ctx_clean
re_copy_regs
parse_expression parse_dup_op parse_sub_exp build_charclass_op parse_expression init_word_char create_tree free_tree create_token_tree fetch_token parse_bracket_exp postorder
init_dfa
re_acquire_state_context calc_state_hash re_node_set_compare create_cd_newstate
re_node_set_add_intersect
merge_state_with_log transit_state_bkref check_subexp_matching_top re_acquire_state_context re_string_context_at re_node_set_init_union
free_fail_stack_return
check_subexp_limits sub_epsilon_src_nodes re_node_set_contains
build_charclass_op create_tree bitset_not bitset_set build_charclass create_token_tree bitset_mask free_charset
re_node_set_alloc
check_arrival_add_next_nodes check_node_accept_bytes re_acquire_state re_node_set_merge check_node_accept re_node_set_insert
check_node_accept_bytes re_string_char_size_at re_string_wchar_at re_string_elem_size_at
re_string_allocate re_string_construct_common re_string_realloc_buffers
lower_subexp create_tree
parse_branch parse_expression create_tree postorder free_tree
rpl_regexec re_search_internal
free_state
expand_bkref_cache re_node_set_init_1 re_node_set_insert search_cur_bkref_entry re_node_set_merge re_node_set_init_copy check_arrival_expand_ecl re_node_set_contains re_acquire_state
peek_token re_string_peek_byte_case re_string_wchar_at peek_token
re_string_construct build_wcs_upper_buffer re_string_construct_common build_upper_buffer re_string_translate_buffer re_string_realloc_buffers build_wcs_buffer
re_string_realloc_buffers
calc_inveclosure re_node_set_insert_last
sub_epsilon_src_nodes re_node_set_add_intersect re_node_set_contains re_node_set_remove_at
sift_ctx_init
re_string_fetch_byte_case re_string_char_size_at
find_recover_state merge_state_with_log
sift_states_iter_mb check_node_accept_bytes re_node_set_contains
group_nodes_into_DFAstates bitset_set_all bitset_copy bitset_set re_node_set_init_1 re_node_set_insert re_node_set_init_copy bitset_merge bitset_clear bitset_contain bitset_empty
push_fail_stack re_node_set_init_copy
check_node_accept bitset_contain re_string_context_at
match_ctx_free match_ctx_clean
build_wcs_upper_buffer
rpl_regerror
sift_states_backward re_node_set_init_1 update_cur_sifted_state build_sifted_states
build_sifted_states re_node_set_insert sift_states_iter_mb check_dst_limits check_node_accept re_node_set_contains
transit_state_mb check_node_accept_bytes re_acquire_state_context re_string_context_at re_node_set_init_union clean_state_log_if_needed
optimize_utf8
build_collating_symbol bitset_set
re_search_stub rpl_re_compile_fastmap re_search_internal re_copy_regs
check_matching merge_state_with_log find_recover_state re_acquire_state_context transit_state check_subexp_matching_top transit_state_bkref extend_buffers check_halt_state_context re_string_context_at
extend_buffers build_wcs_upper_buffer re_string_translate_buffer re_string_realloc_buffers build_wcs_buffer build_upper_buffer
check_arrival re_node_set_init_1 re_string_context_at expand_bkref_cache re_node_set_merge re_node_set_init_copy re_node_set_contains check_arrival_expand_ecl check_arrival_add_next_nodes re_acquire_state_context
free_workarea_compile
match_ctx_add_entry
parse_bracket_symbol re_string_fetch_byte_case
free_charset
build_trtable re_node_set_merge re_node_set_alloc group_nodes_into_DFAstates re_acquire_state_context bitset_merge bitset_contain bitset_empty
re_node_set_init_copy
duplicate_node_closure duplicate_node_closure re_node_set_insert duplicate_node search_duplicated_node
parse_bracket_exp build_equiv_class bitset_not bitset_set parse_bracket_element build_range_exp free_charset peek_token_bracket bitset_mask build_charclass create_tree build_collating_symbol create_token_tree
parse_bracket_element peek_token_bracket re_string_wchar_at parse_bracket_symbol re_string_char_size_at
re_search_internal re_string_destruct re_string_allocate match_ctx_init match_ctx_free check_matching check_halt_state_context re_string_reconstruct match_ctx_clean set_regs prune_impossible_nodes
set_regs free_fail_stack_return update_regs pop_fail_stack proceed_next_node
prune_impossible_nodes sift_ctx_init check_halt_state_context sift_states_backward merge_state_array
check_arrival_expand_ecl_sub re_node_set_insert re_node_set_contains check_arrival_expand_ecl_sub
re_acquire_state re_node_set_compare create_ci_newstate calc_state_hash
build_wcs_buffer
rpl_re_compile_pattern re_compile_internal
free_dfa_content free_token free_state
get_subexp match_ctx_add_sublast get_subexp_sub clean_state_log_if_needed extend_buffers search_cur_bkref_entry find_subexp_node check_arrival
analyze calc_first optimize_subexps postorder lower_subexps calc_eclosure preorder link_nfa_nodes calc_inveclosure calc_next
re_node_set_init_1
duplicate_tree create_token_tree
calc_eclosure_iter duplicate_node_closure calc_eclosure_iter re_node_set_alloc re_node_set_insert re_node_set_merge
bitset_empty
free_token free_charset
bitset_copy
parse_dup_op fetch_token mark_opt_subexp fetch_number create_tree postorder duplicate_tree free_tree
rpl_re_compile_fastmap re_compile_fastmap_iter
re_dfa_add_node
re_node_set_insert_last
sift_states_bkref re_node_set_remove_at sift_states_backward search_cur_bkref_entry re_node_set_insert check_dst_limits merge_state_array re_node_set_init_copy re_node_set_contains
fetch_number fetch_token
match_ctx_add_subtop
fetch_token peek_token
bitset_set_all
re_string_reconstruct build_wcs_buffer re_string_translate_buffer re_string_skip_chars bitset_contain build_upper_buffer build_wcs_upper_buffer re_string_context_at
rpl_re_match_2 re_search_2_stub
create_cd_newstate re_node_set_init_copy re_node_set_remove_at free_state register_state
check_subexp_matching_top match_ctx_add_subtop
proceed_next_node check_node_accept re_node_set_contains push_fail_stack check_node_accept_bytes re_node_set_insert
rpl_re_match re_search_stub
build_range_exp bitset_set
add_epsilon_src_nodes re_node_set_add_intersect re_node_set_merge re_acquire_state re_node_set_alloc
update_regs
rpl_re_search_2 re_search_2_stub
transit_state re_string_context_at build_trtable transit_state_mb
check_dst_limits_calc_pos check_dst_limits_calc_pos_1
build_upper_buffer
calc_first re_dfa_add_node
re_compile_internal optimize_utf8 re_string_destruct init_dfa free_workarea_compile parse create_initial_state analyze free_dfa_content re_string_construct
parse_sub_exp postorder create_tree fetch_token free_tree parse_reg_exp
re_string_context_at bitset_contain
init_word_char
create_ci_newstate register_state free_state re_node_set_init_copy
update_cur_sifted_state check_subexp_limits re_acquire_state sift_states_bkref add_epsilon_src_nodes
parse fetch_token create_tree parse_reg_exp
rpl_re_set_syntax
rpl_re_set_registers
rpl_regerror

Output (Whoops! Too long for SE to handle.)

Well-specified!

The self-reference in the Node order section makes my head hurt.

Haskell, 512 bytes
import Data.List
r=reverse
n j|let(w,s)#p|let a?b=or[q!b<GT|(q,r)<-i,a==r,elem q(h p)>elem(a,q)i];a!b|a==b=EQ|a?b||(a<b)>b?a=LT;_!_=GT;l=nub.sortBy(!)$h p;m(v,s)q|h q==[]=(v,[q]:s)|elem q w=(v,[q++" ..."]:s)|(w,x:y)<-(v,[])#q=(w,(q:(u"| "=<<r y)++u"  "x):s)=foldl m(l++w,[])l;c(p,q)=z$p:q:h q;y=z=<<j;i=iterate(nub.sort.(c=<<))y!!length j;h""=[p|p<-id=<<j,and[elem(p,r)i|(r,q)<-i,p==q]];h p=[r|(q,r)<-y,p==q]=unlines=<<r(snd$mempty#"")
u s(x:y)=("+-"++x):map(s++)y
z(x:y)=(,)x<$>y
main=interact$n.map words.lines

Run online at Ideone

Congrats. Very nice!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
A Perplexing Puzzle
The Challenge
Create a program or function that takes no input, and outputs (or returns):
I'm a programming paradox — no I'm not.

Without using a character twice in any string, or digit twice in any integer.

Rules

You may not use any character twice within a string. For example, the word "test" would violate this rule.
You may not use any character twice between strings. For example, if somewhere in your code you have the string "hi", no other strings may contain the substring "h" or "i".
You may not use a digits more than once within an integer. For example, the integer 200 would not be acceptable.
You may not use a digit more than once between integers. For example, if you have the integer 40 in your code, you may  not have the integer 304.
The above rules do not apply between data types. You could, for example, have the string "9" and the integer 9 in your code.
An uppercase letter is considered a separate character from the lowercase.
You may only use printable ASCII characters in your strings.
You may not set variables to each character and add them together.

Example
Here is an example, written in Python 2, of what the same challenge might look like with the string "Hello, World!" instead.
print"He"+"l"*2+"o, "+"W"+chr(int("1"*3))+"r"+chr(108)+"d!"

Note: For those wondering why I chose this particular string; I chose it because it has several repeated characters and a repeated word. It has no greater significance or meaning.

Does the repeated rule only apply to strings, and not the rest of the code?

Correct. It only applies to strings and integers. @ASCIIThenANSI

Does this apply to format strings? For example, using printf("%s%s") in C?

Yep. @TobErnack

I don't like that you added a rule to rule out a posted answer. It's not fair to ETHproductions that they figured out a solution but don't get to use it because you don't like it. Also, I don't think saving chars to variables is any more cheap than using character codes as in your example.

What if I mash together characters without setting variables to them?

I suppose that's alright. @dfeuer

-1 for changing the rules.

The dash in the text "I'm a programming paradox — no I'm not." you posted is not ASCII 39 "-"

It's not clear to me whether when you say string you mean string literal, and similarly for integer vs integer literal.

Javascript (ES6), 89 86 84 Bytes
`${y=>I0m3a3programming3paradox313no3I0m3not2}`.slice(3).replace(/\d/g,m=>"'—. "[m])

Python 2, 186 155 139 138 126 109 98 bytes
I don't know if this is a loophole...
OKDLPLGHFBHPDDCEBLGPHPAFJLMLEFLOKDLEFIN=0
print list(locals())[3].translate("adgimnoprtx' -.I"*16)

don't think I can golf more than this...

Very nicely done!

This seems to use 3 twice in integers 35 and 39. You could always use 42-7 for 35 or something similar though.

chr(39) can be replaced with "'" and chr(35) with "#". Saves you bytes and puts you in the rules. Also, you can do r=replace and save a ton of bytes. You're also calling list twice.

r=replace is not valid syntax in Python. @MorganThrapp

@ZachGates Right, forgot that was a method of str.

@MorganThrapp You can do r=str.replace though. This requires some other changes so idk if it helps golf here, but just an fyi :)

@FryAmTheEggman Yeah, I spent a bit trying to work with that, but I couldn't make it work.

@MorganThrapp you have to call r like this: r("My String", "My", "A") which returns "A String".

@FryAmTheEggman Right, duh, I forget when you call it as a class method you have to pass in the instance.
@Max I0m_a_programming_paradox_3_no_I0m_not1="#";r=str.replace print r(r(r(r(list(locals().iteritems())[4][-2],'0',chr(39)),"_"," "),"1","."),"3","-") saves you 10 bytes.

@ETHproductions the little step in previous edit that gave me 1 byte led to the last result of 126 bytes...

Javascript (ES6), 142 105 98 96 bytes
[a="I'm","a",`${y=>programming}`.slice(3),`${no=>paradox}`.slice(4),'-',x="no",a,x+"t."].join` `

Another possible rule-breaker, but it was fun, anyway. :)
Original version:
[a="I'm",(''+(b=>a)).substr(3),(''+(is=>programming)).substr(4),(''+(Fermi=>paradox)).substr(7),'-',(''+(yes=>no)).substr(5),a,'not.'].join` `

I don't know ES6 but.... googling i found thath is=>programming is like: function f(is){return programming} right? I don't understand why this should return the string "programming"?

@Max Yes, you are correct about the fat arrow function declaration. ...`${y=>programming}`... is the same as ...(''+(y=>programming))..., (or ...(''+(function(y){return programming;}))...) which returns "y=>programming", and a substring is taken off of that. Not sure if this is allowed or not.

does the string concatenation "generate" automagically a string representation of the function?

@Max Yep. Javascript's type conversion can be ridiculous sometimes.

C++14, 327 bytes
#include <iostream>
#define x(y) <<(y)[s]
std::string s[]={"I'"," ","a","p","r","o","g","m","n","i","d","x","—","t","."};enum{J,S,A,P,R,O,G,M,N,I,D,X,W,T,Z};[]{std::cout x(J)x(M)x(S)x(A)x(S)x(P)x(R)x(O)x(G)x(R)x(A)x(M)x(M)x(I)x(N)x(G)x(S)x(P)x(A)x(R)x(A)x(D)x(O)x(X)x(S)x(W)x(S)x(N)x(O)x(S)x(J)x(M)x(S)x(N)x(O)x(T)x(Z);}();

I'm defining a macro which returns a string to the << operator, mapping the necessary characters in a string array and access them with an enum

I don't think I can golf this particular solution any more, but tips are always welcome!

Haskell, 320 bytes
import Data.Char

data Letter = A|D|I|I'm|MM|P|R|G|N|O|X|Y|S|T deriving Show

transform :: Letter -> String
transform S = " "
transform Y = "—"
transform I'm = "I'm"
transform x = map toLower $ show x

main :: IO ()
main = print $ transform =<<
   [I'm,S,A,S,P,R,O,G,R,A,MM,I,N,G,S,P,A,R,A,D,O,X,S,Y,S,N,O,S,I'm,S,N,O,T]

What language is this?

This is Haskell I believe.