def mymap(funct, iterable):
    return [ funct(x)  for x in iterable ]

def mymap_gen(funct, iterable):
    for x in iterable:
        yield funct(x)

def myreduce(funct, iterable, initiale=None):
    if initiale is None:
        iterable, initiale = iterable[1:], iterable[0]
    for x in iterable:
        initiale = funct(initiale, x)
    return initiale

def mymap2(funct, iterable):
    def f(a, b):
        return a + [funct(b)]
    return myreduce(f, iterable, [])

def compose1(funct1, funct2):
    def f(x):
        return funct2(funct1(x))
    return f

def compose2(*functs):
    def f(x):
        return x
    return myreduce(compose1, functs, f)

# -*- coding: utf-8 -*-

"""
Les exemples qui suivent sont des implémentations en Python de plusieurs
routines classiques en programmation fonctionnelle.

"""


def mymap_it(fn, lst):
    """ Implémentation de 'map' de façon itérative. """
    res = list()
    for elt in lst:
        res.append(fn(elt))
    return res
    
# Implémentation de 'map' au moyen d'une list comprehension.
mymap = lambda fn, lst: [fn(x) for x in lst]

# Implémentation de 'map' au moyen d'une expression génératrice.
mymap_gen = lambda fn, lst: (fn(x) for x in lst)


def myreduce(fn, lst, acc = None):
    """ Implémentation de 'reduce' de façon itérative. """
    if acc is None:
        acc, lst = lst[0], lst[1:]
    for elt in lst:
        acc = fn(acc, elt)
    return acc

def mymap2(fn, lst):
    """ Formulation de 'map' en fonction de 'reduce'. """
    acc_fn = lambda acc, elt: acc + [fn(elt)]
    return myreduce(acc_fn, lst, [])

# One-liner pour mymap2
mymap3 = lambda fn, lst: myreduce(lambda acc, elt: acc + [fn(elt)], lst, [])


def comp(f, g):
    """ Composition de 2 fonctions. """
    def c(x): 
        return g(f(x))
    return c


# Version one-liner de la composition.
comp1 = lambda f, g: lambda x: g(f(x))


def compose_naive(*args):
    """ Version 'naïve' de la composition de n fonctions. """
    def c(x):
        acc = x             # accumulateur de résultats
        for fn in args:
            acc = fn(acc)   # application successive des fonctions
        return acc          
    return c

# Ça ressemble furieusement à une application de 'reduce', non ?

def compose_naive_reduce(*args):
    """ 
    Version 'naïve' de la composition de n fonctions exprimée en fonction
    de 'reduce'.
    
    """
    applique = lambda acc, fn: fn(acc)
    return lambda x: myreduce(applique, args, x)


def compose(*args):
    """ 
    Composition d'un nombre arbitraire de fonctions exprimée en fonction de la
    composition de 2 fonctions.
    
    """
    acc = lambda t: t       # accumulateur: fonction identité
    for fn in args:
        acc = comp(acc, fn) # fct d'accumulation: composition
    return acc

# La même, en une seule instruction
compose_lambda = lambda *args: myreduce(comp, args, lambda t: t)

def compose2(*args):
    def inter(x):
        acc = args[0]
        for f in args[1:-1]:
            acc = f(acc(x))
        acc = args[-1](acc)
        return acc
    return inter