LENGUAJES FUNCIONALES

EN LOS LENGUAJES FUNCIONALES DECIDI UTILIZAR HASKELL
ES UN POCO COMPLICADO LA VERDADA SU CODIFICACION
PERO LES PRESENTO LA SERIE GEOMETRICA UNA DE LAS PROGRECIONES MATEMATICAS
La Serie Geometrica está constituida por una secuencia de elementos en la que cada uno de ellos se obtiene multiplicando el anterior por una constante denominada razón o factor de la progresión. Se suele reservar el término progresión cuando la secuencia tiene una cantidad finita de términos mientras que se usa sucesión cuando hay una cantidad infinita de términos, si bien, esta distinción no es estricta.
Así,  es una progresión geométrica con razón igual a 3, porque:
15 = 5 × 3
45 = 15 × 3
135 = 45 × 3
405 = 135 × 3
y así sucesivamente.

El codigo en Haskell seria el siguiente:
module Geometric (geo, geo') where
import qualified Data.Ratio as R
data Geo = Geo Rational deriving (Eq, Ord, Show)
instance Num Geo where 
(+)    (Geo a) (Geo b)    = Geo (a + b) 
(*)    (Geo a) (Geo b)    = Geo (a * b) 
(-)    (Geo a) (Geo b)    = Geo (a - b) 
abs    (Geo a)            = Geo (abs a) 
signum (Geo a)            = Geo (signum a) 
fromInteger               = Geo . toRational
instance Real Geo where  toRational (Geo a)= toRational a
instance Fractional Geo where 
(/)    (Geo a) (Geo b)    = Geo (a / b) 
fromRational              = Geo
instance RealFrac Geo where 
properFraction (Geo a)    = case properFraction a of (i, f) -> (i, Geo f)
tmap2 :: (a -> b) -> (a, a) -> (b, b)
tmap2 f (x, y) = (f x, f y)
geo :: (Fractional n) => [Geo] -> [n]
geo = map (fromRational . toRational)
geo' :: (Integral n) => [Geo] -> [n]
geo' = map truncate . geo
def_factor = 2
instance Enum Geo where 
succ           (Geo n)  = Geo $ succ n 
pred           (Geo n)  = Geo $ pred n 
toEnum                  = Geo . toEnum 
fromEnum       (Geo n)  = fromEnum n 
enumFrom       n        = enumFromThen n (n * def_factor) 
enumFromThen   n n'     = let q = n' / n in iterate (* q) n 
enumFromTo     n end    = enumFromThenTo n (n * def_factor) end 
enumFromThenTo n n' end   
| n  > end             = []  
| n' > end             = [n]   
| otherwise            = takeWhile (<= end) $ enumFromThen n n'

La otra serie que tome fue la del Fcatorial en Perl
En este lenguaje es mas sencillo, almenos no se aplican tantas funciones
Su codigo es el siguiente
#factorial

$input=<>;
sub factorial
{
$s=1;
$r=1;
 while ($s <= $input)
 {
   $r *= $s;
   $s++;
 }
if($input == 0)
{
 $r=0;
}
return $r;
}
print "The result is".$r;
ESPERO LES HAYA GUSTADO!!! ESPERO COMENTARIOS

CORRIGIENDO EL LENGUAJE A LISP EL FACTORIAL SERIA:

(defun factorial (n)

    (if (= n 0)

    1

    (* n (factorial (- n 1)))
    )
)