Actualizada documentacion desfasada.

Author: Araozu

public/textos/es/docs/next/funciones.md

@@ -1,231 +1,5 @@
 # Funciones
 
-## Estructura
+> En diseño
 
-```
-fun nombre param1 param2 =
-    expr
-
-nombre 10 20
-
-// Funcion sin argumentos
-fun devolverHola () = "Hola"
-
-const hola = devolverHola ()
-```
-
-## Parámetros anotados
-
-```
-fun nombreCompleto (nombre: string) (apellido: string) : Txt =
-    nombre <> " " <> Apellido
-
-fun sumarYConvertirAStr n1 n2 : Txt =
-    (n1 <> n2).toString()
-
-```
-
-## Currying / Aplicación parcial
-
-El currying será opcional debido a la forma en la que funcionan las funciones en JavaScript.
-Se usará un símbolo especial (por ejemplo `sumar# 10`)
-
-```
-fun sumar x y z = x + y + z
-
-const sumar10 = sumar# 10
-sumar10 20 30  //: 60
-
-const sumar50 = sumar10# 40
-sumar50 -10  //: 40
-```
-
-## Signatura
-
-```
-// Num -> Num -> Num
-fun sumar x y = x + y
-
-// (Num -> Num) -> Num
-fun aplicar f = f 10 + 20
-
-// Txt -> (Txt -> Txt)
-fun imbuir saludo =
-    fun saludar nombre =
-        saludo <> " " <> nombre
-
-    saludar
-```
-
-## Operadores
-
-```
-fun (<>) s1 s2 = s1.concat s2
-
-"Hola " <> "mundo"  //= Hola mundo
-
-fun (>*>) s1 s2 = s1.concat s2
-
-"Hola " >*> "mundo" //= Hola mundo
-
-// Notacion prefija
-(>*>) "Hola " "mundo"  //= Hola mundo
-
-// Currying
-const saludar = (>*>) "Hola "
-
-saludar "Pedro"  //= Hola Pedro
-saludar "Juan"   //= Hola Juan
-
-// Currying con operadores estilo Haskell
-const sumar2 = (+2)
-sumar2 10  //= 12
-
-const saludar = ("Hola "<>)
-saludar "mundo"  //= "Hola mundo"
-```
-
-## Parametros opcionales
-
-**_Ya que no hay currying automático, es posible cambiar esto._**
-
-En sí, Kan no tiene parámetros opcionales. Para simular ese comportamiento
-se usa un tipo indefinido como parámetro.
-
-```
-// Num -> Num? -> Num
-fun areaCuadrilatero base (altura: Num?) =
-    // Re-definir altura
-    const altura' = if altura? then altura else base
-
-    base * altura'
-
-areaCuadrilatero 10 20  //= 200
-areaCuadrilatero 10 ()  //= 100
-```
-
-## Parámetros por defecto
-
-```
-// Num -> Num
-fun areaCirculo (radio = 1) = Math.PI * radio ** 2
-
-areaCirculo 5  //= 78.539816...
-areaCirculo _  //= 3.141592...
-
-
-fun areaTriangulo (base = 1) altura =
-    (base * altura) / 2
-
-areaTriangulo 2 4  //: 4
-areaTriangulo _ 5  //: 2.5
-
-// Con currying
-const f1 = areaTriangulo# _
-f1 5   //= 2.5
-f1 10  //= 5
-```
-
-## Parámetros nombrados
-
-```
-fun areaTriangulo base altura =
-    (base * altura) / 2
-
-areaTriangulo (~base = 10) 20  //= 100
-areaTriangulo (~base = 10) (~altura = 20) //= 100
-areaTriangulo (~altura = 20) (~base = 10) //= 100
-
-areaTriangulo
-    ~base = 10
-    ~altura = 20
-
-
-// Tener nombres 'publicos' y nombres 'privados'
-fun areaTriangulo b~base h~altura =
-    (b * h) / 2
-
-areaTriangulo (~base = 10) 20
-areaTriangulo
-    ~base = 10
-    20
-```
-
-## Parametros en varias lineas
-
-```
-fun saludar
-| s~saludo = "Hola"
-| n~nombre = ""
-| f~final = ""
-=
-    console.log (s <> " " <> n <> f)
-
-saludar "Bienvenido" "Pedro" "!"  //= Bienvenido Pedro!
-saludar _ _ _    //= Hola
-saludar _ _ "!"  //= Hola!
-```
-
-## Funciones anonimas
-
-```
-const funAnonima = fn x y -> x + y
-
-const funAnonima: Num -> Num -> Num = fn x y -> x + y
-
-const elevarAlCuadrado = fn (x: Num) -> x ** 2
-```
-
-## Conductores
-
-```
-console.log ("El resultado es " <> (10 + 20))
-
-console.log <| "El resultado es " <> (10 + 20)
-
-"El resultado es" <> (10 + 20) |> console.log
-```
-
-## Composicion
-
-```
-// ('A -> 'B) -> ('B -> 'C) -> ('A -> 'C)
-fun (>>) f g = fn x -> g (f x)
-
-sea masDosPorDos = (+2) >> (*2)
-
-masDosPorDos 10  //: 24
-masDosPorDos 23  //: 50
-
-sea porDosMasDos = (*2) >> (+2)
-
-porDosMasDos 10  //: 22
-porDosMasDos 23  //: 48
-
-// Inverso
-// ('A -> 'B) -> ('C -> 'A) -> ('C -> 'B)
-fun (<<) f g = fn x -> f (g x)
-
-sea porDosMasDos = (+2) << (*2)
-sea masDosPorDos = (*2) << (+2)
-```
-
-## Funciones flecha
-
-```
-// Para usar funciones flecha se usa una fun. anonima
-const funFlecha = fn x y => x + y
-```
-
-## Rest/Spread
-
-```
-fun imprimirNombres ...nombres =
-    for (_, nombre) in nombres do
-        console.log nombre
-
-fun imprimirNumeros (...nums: [number]) =
-    for (_, num) in nums do
-        console.log num
-
-```
+Ver los temas en la barra lateral.

public/textos/es/docs/next/funciones/aplicacion-parcial.md

@@ -2,7 +2,7 @@
 
 > En diseño
 
-A diferencia de otros lenguajes funcionales, KS no cuenta con currying automático,
+A diferencia de otros lenguajes funcionales, KS no cuenta con currying,
 debido a que esto entra en conflicto con la semántica de JavaScript.
 
 En JavaScript puedes llamar una función con con cualquier cantidad de parámetros,
@@ -23,78 +23,27 @@ Si quisieramos tener el mismo comportamiento en KS, tendriamos que saber la sign
 todas las funciones y exigir la cantidad exacta de parámetros. Lo primero es imposible y lo
 segundo limita las capacidades de JavaScript.
 
-Por lo tanto, KS no cuenta con Currying, sin embargo, es posible aplicar parcialmente
+Por lo tanto, KS no cuenta con currying, sin embargo, es posible aplicar parcialmente
 una función de forma sencilla.
 
-## Propuesta 1
+## Aplicación parcial
 
 Un operador para aplicar parcialmente una función. Dada una función f con una cantidad desconocida
 de parámetros, se aplicaría parcialmente así:
 
 ```
-const nuevaFun = f* 1 2 3 4
+const nuevaFun = ~f 1 2 3 4
 ```
 
 Esto se compila a:
 
 ```javascript
-const nuevaFun = (...params) => f.call(undefined, 1, 2, 3, 4, ...params);
+const nuevaFun = (...params) => f.call(1, 2, 3, 4, ...params);
 ```
 
 ## Signatura
 
-En KS se usan flechas simples y dobles en la signatura, y ayudan a diferenciar
-los parámetros de una función.
+Debido a que la aplicación parcial es manual, la signatura de la función cambia.
 
-Las flechas simples `->` indican parámetros, y la flecha doble `=>` indica el
-resultado de la función.
-
-A continuación damos varios ejemplos de signaturas.
-
-```
-f: number -> number => number
-```
-
-f toma 2 parámetros de tipo number, y devuelve un number
-
-```
-f: string -> number -> boolean => ()
-```
-
-Toma como parámetros un string, un number, un boolean, y no devuelve nada.
-
-```
-f: () => ()
-```
-
-No toma ningun parámetro, y no devuelve nada.
-
-```
-f: (string -> number -> Array => ()) => ()
-```
-
-Toma 1 parámetro. Este parámetro es una función, y esta toma como parámetros:
-
-- Un string
-- Un number
-- Un Array
-
-y no devuelve nada. Finalmente, f no devuelve nada.
-
-```
-compose: (string => number) -> (number => boolean) => (string => boolean)
-```
-
-La función compose toma 2 funciones, y devuelve una nueva función.
-
-- Función 1
-
-  Toma como parámetro un string y devuelve un number
-  
-- Función 2
-
-  Toma como parámetro un number y devuelve un boolean
-  
-- Función de retorno
-
-  Toma como parámetro un string y devuelve un boolean
+Si la función original es `number number -> number` y se aplica parcialmente el primer parámetro,
+la signatura de la última función será `number -> number`.

public/textos/es/docs/next/funciones/estructura.md

@@ -36,7 +36,7 @@ console.log(10 + 20);  // 30
 Sin embargo, hacer algo parecido en KS da lugar a un error:
 
 ```err
-console.log 10 + 20   //! Error. El operador '+' trabaja con number.
+console.log 10 + 20   // NaN
 ```
 
 Esto se debe a que llamar a una función tiene una menor precedencia que usar un operador. En otras palabras,
@@ -56,9 +56,7 @@ console.log (10 + 20)  // 30
 
 ## Funciones sin parámetros
 
-Tecnicamente, en KS todas las funciones necesitan al menos 1 parámetro. Pero existe una forma de
-crear y llamar funciones 'sin parámetros'. Por ejemplo, la siguiente función imprime "Hola mundo" en
-la consola:
+Una función que no toma parámetros se define así:
 
 ```
 fun imprimirHolaMundo () =
@@ -71,14 +69,5 @@ imprimirHolaMundo ()
 Hola mundo
 ```
 
-En este ejemplo la función `imprimirHolaMundo` toma como primer parámetro una unidad `()`, y luego
-imprime el mensaje. Del mismo modo, al llamar la función pasamos como parámetro una unidad `()`.
-Esa unidad que se pasa como parámetro simplemente se ignora, creando una funcion 'que no toma parámetros'.
-
-
-
-
-
-
-
+Al llamar a la función se coloca `()`.
 

public/textos/es/docs/next/funciones/parametros-nombrados.md

@@ -11,26 +11,5 @@ parámetro:
 ```
 fun sumar {dividendo, divisor} = dividendo / divisor
 
-sumar {dividendo := 20, divisor := 5}
+sumar {dividendo 20, divisor 5}
 ```
-
-## Deprecado
-
-Una sintaxis para tener parametros nombrados.
-
-```
-fun dividir (x~dividendo) (y~divisor) = x / y
-
-dividir (~dividendo = 20) (~divisor = 30)
-dividir (~divisor = 30) (~dividendo = 20)
-dividir
-    ~dividendo = 20
-    ~divisor   = 30
-```
-
-Deprecada por:
-
-1. Hace uso del operador `~` de forma inconsistente, como operador binario y unario.
-2. Requiere que el programador aprenda una nueva sintáxis.
-3. Esta sintaxis requiere que el compilador sepa los nombres y orden de los parámetros.
-4. No funciona con JS existente.