#python , #ruby : c'est presque pareil

En relisant un tutorial python en francais , j'ai été frappé par la ressemblance entre Ruby et Python.


Exemple en Ruby

#!/usr/bin/ruby
def dupont 
 print "dupont\n"
end
def suite(v) 
 puts v 
end
def encore(param1,param2)
 puts param1,param2 

end
# appel de la fonction
dupont

En Python :

#!/usr/bin/python
def dupond() :
 print "dupond"
 
def suite(chaine) : 
  print chaine

def encore(param1,param2) : 
  print param1,param2 
  
# appel de la fonction
dupond()



L'obligation d'utiliser les parenthèses dans l'appel d'une methode ou fonction Python a des conséquences étonnantes.

En Python , comme en 'c' , il est possible d'assigner une variable à une fonction
ex   :  data= suite   # sans les parenthèses !

Et de demander data('exemple') pour appeler en coulisse la fonction suite avec le parametre 'exemple'.

La même chose en Ruby est plus compliquée à faire :

data= self.method(:suite)
data.call("coucou") 

Ces mécanismes ne doivent pas être confondus avec le currying qui est un  procédé qui permet de
transformer une fonction qui a plusieurs parametre en une fonction qui ne prend qu'un paramètre.

Exemple en Haskell :


module Main where
 prod x y = x * y
 double= prod 2
 triple = prod 3


Prelude> :load currying.hs
[1 of 1] Compiling Main             ( currying.hs, interpreted )
Ok, modules loaded: Main.
*Main> double(6)
12
*Main> triple(4)
12

La signature de la fonction prod reflète ce phénomène
*Main> :t prod
prod :: (Num a) => a -> a -> a

(prod 2)4
Un appel à prod  retourne une fonction lambda \y = 2 * y
Puis un deuxième appel finalise le calcul en remplacant y par 4 => 8

C'est un système extrêmement important en programmation fonctionnelle.