Ruby:

square = lambda {|x| puts x ** 2} 
power = lambda {|x, y| puts x ** y} 

square.call(2) # => 4
power.call(2, 4) # => 16 

Erlang:

-module(power).

 -compile(export_all).

 sqaure(X) -> X * X.

 pow(X, 0) -> 1;
 pow(X, Y) -> X * pow(X, Y-1).

 geometric_pow(_, 0, Acc) -> Acc;
 % It’s interesting that if 1 and 2 aren’t “unrolled”,
 % the linear implementation beats geometric_pow.
 geometric_pow(Square, 1, Acc) -> Square*Acc;
 geometric_pow(Square, 2, Acc) -> Square*Square*Acc;
 geometric_pow(Square, 3, Acc) -> Square*Square*Square*Acc;
 geometric_pow(Square, 4, Acc) -> Square*Square*Square*Square*Acc;
 geometric_pow(Square, Exp, Acc) ->
   geometric_pow(Square*Square, Exp div 2, ((Exp rem 2)*(Square-1)*Acc + Acc)).

 geometric_pow(Base, Exponent) -> geometric_pow(Base,Exponent,1).

power:geometric_pow(2, 2). and power:pow(2,2) return the same, geometric_pow however is recursive.