codigos haskell (puntos extra)

Sencillo programa que de una lista de lista de números enteros, muestra en una lista de dos tupla de manera numérica y literal cuantas veces se repiten los elementos de la primera lista. 

rep::Int->[Int]->Int->String
rep _ [] cont="se repite "++show(cont)++" veces"
rep n (x:xs) cont|n==x=rep n xs (cont+1)
     |otherwise=rep n xs cont

conc::[[Int]]->[Int]
conc []=[]
conc (x:xs)=x++conc xs

prin::Int->[[Int]]->(Int,String)
prin n (x:xss)=(n,a)
     where p=conc (x:xss)
     a=rep n p 0

ps::[Int]->[[Int]]->[(Int,String)]
ps [] _=[]
ps (x:xs) xss=k:(ps xs xss)
     where k=prin x xss

pr::[[Int]]->[(Int,String)]
pr (x:xss)=ps x (x:xss) 

Dada una lista de dos tuplas, los cuales serán los elementos "x" e "y" necesarioas para una regresion por mínimos cuadrados la función principal devuelve el número de pares ordenados, la sumatoria de x, sumatoria de y la sumatoria de los cuadrados, la sumatoria del producto de "x" "y", el valor de A y el valor de B de la regresión;

Código fuente

dx::[(Double,Double)]->Double->[Double]
dx [] _=[]
dx (x:xs) n=(k)**n:dx xs n
     where k=fst x

dy::[(Double,Double)]->Double->[Double]
dy [] _=[]
dy (x:xs) n=(k)**n:dy xs n
     where k=snd x

mul::[(Double,Double)]->[Double]
mul []=[]
mul (x:xs)=(k*h):mul xs
     where k=fst x
     h=snd x

regA::Double->Double->Double->Double->Double->Double
regA sx sy sxx sxy n=(sxx*sy-sxy*sx)/(n*sxx-sx*sx)

regB::Double->Double->Double->Double->Double->Double
regB sx sy sxx sxy n=(n*sxy-sx*sy)/(n*sxx-sx*sx)

cn::[(Double,Double)]->Double
cn []=0
cn (x:xs)=1 + cn xs

regresion::[(Double,Double)]->String
regresion (xs)="n="++show(k)++" x="++show(l)++" sum(x)="++show(s)++
     " y="++show(o)++" sum(y)="++show(p)++" x*y="++show(q)++
     " sum(x*y)="++show(r)++" x^2="++show(t)++" sum(x^2)="++show(u)++
      " y^2="++show(v)++" sum(y^2)="++show(w)++" regresion:"++show(a)++
      show(b)
      where k=length xs
      l=dx (xs) 1
      s=sum(l)
      o=dy (xs) 1
      p=sum(o)
      q=mul xs
      r=sum(q)
      t=dx (xs) 2
      u=sum(t)
      v=dy (xs) 2
      w=sum(v)
      z=cn xs
      a=regA s p u r z
      b=regB s p u r z 

Programa que de una lista de listas de números enteros, muestra en una lista de dos tuplas, los coeficientes que se pueden formar, y las raices que se pueden obtener de las ecuaciones cuadrádicas formadas. 

un::[[Float]]->[Float]
un []=[]
un (x:xs)=x++un xs

sep::[Float]->(Float,Float,Float)
sep (x:xs)=(x,y,z)
        where y= head xs
              z= last xs
lis::[Float]->[(Float,Float,Float)]
lis []=[]
lis (xs)|k==3=(sep m):(lis (drop 3 xs))
        |otherwise=[]
           where m=take 3 xs
                 k=length m

sol::(Float,Float,Float)->(Float,Float)
sol (a,b,c)|z>0=(((-b+sqrt(z))/(2*a)),((-b-sqrt(z))/(2*a)))
           |otherwise=(-1999,-1999)
           where z=b^2-4*a*c

prin::[(Float,Float,Float)]->[(Float,Float)]
prin []=[]
prin (x:xs)=(sol x):prin xs

raiz::[[Float]]->String
raiz xs="coeficientes"++show(q)++"resultados"++show(r)
       where p=un xs
             q=lis p
             r=prin q