Según entiendo sería algo así 🤯
def isGreater(a: Int) = (b: Int) => a < b
println(isGreater(10)(20))
Introducción a Scala y configuración del entorno de desarrollo
Introducción al curso y presentación de los objetivos
Scala en la historia
Instalando JVM, SBT y editores
Instalación de las herramientas
¡Hola, Mundo!
Fundamentos de Programación Funcional
Tipos de datos básicos
Inmutabilidad
Expresiones
Funciones
Colecciones: Secuencias, Conjuntos y Mapas
Tuplas y Objetos
La función de copy y el concepto de Lences
Conceptos básicos de Programación Funcional
Pattern Matching
Tail recursion
Agregación
Fundamentos teoricos
Funciones totales y parciales
Razonamiento inductivo
Razonamiento con tipos
Traits
Tipos genéricos
Tipos de datos algebraicos
Evaluación peresoza (Lazy)
Disyunciones: Option
Disyunciones: Either, try
Proyecto de Backend
Introducción e iniciación del proyecto
Modelo por Actores
Modelo de datos
Configuración de Slick
Controladores: Cómo obtener información de la base de datos
Controladores: Crear, actualizar y eliminar información de la base de datos
Computación paralela, asíncrona y concurrente
Serialización
Validación
Manejo de errores en el proyecto
Exportación del proyecto
Conclusiones
Clase final
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 57
Preguntas 1
Según entiendo sería algo así 🤯
def isGreater(a: Int) = (b: Int) => a < b
println(isGreater(10)(20))
Hola!
def isGreather(x: Int, y: Int):Boolean = {
x > y
}
val isGreatherObj = isGreather _
def comparar(fx: (Int, Int) => Boolean, a: Int, b: Int): Boolean = fx(a,b)
comparar(isGreatherObj, 3, 1)
Mi solucion es generar una funcion que retorne una funcion anonima y en la funcion anonima se “fija” el parametro pasado a la funcion padre. El concepto puede ser dificil de explica, pero si miras el codigo seguro lo entiendes.
// Funcion que genera funciones
def isGreaterGenerator(ref: Int): Int => Boolean = {
(x:Int) => ref < x
}
// Usando el generador de funciones
val isGreaterThanTen = isGreaterGenerator(10)
// Usando la funcion generada
isGreaterThanTen(11) // true
isGreaterThanTen(1) // false
isGreaterThanTen(10) // false
Hola, quiero felicitarte tienes una buena facilidad para explicar las cosas, me parece que eres un muy buen profesor.
Pero me gustaría que ahondes un poco en eso del apply, por lo que me parece y se de Java, creo el compilador de Scala interpreta esta función anónima:
(x: Int) => x * x
Como un objeto que interpreta la interfaz funcional https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html
es por eso que puedes ejecutar la función con apply, sin embargo si la función no recibe ningún parámetro y produce una salida, eso del apply no funciona y tal vez en vez de apply se utilizaría get (https://docs.oracle.com/javase/8/docs/api/java/util/function/Supplier.html) o si hablamos de que se recibe algo y no se produce nada usaríamos accept (https://docs.oracle.com/javase/8/docs/api/java/util/function/Consumer.html)
Es una duda que tengo, gracias.
Yo no le tengo miedo a las mates 😄
Para definir funciones en scala tenemos dos opciones
def f(x: Any) = // Código ...
a = (x: Any) => // Código ...
La segunda siendo una función lambda la cual se comporta como un objeto y podemos usar el metodo apply. Podemos pasar de una funciún común a un obeto usando la siguiente expresión
val c = f _
Lo cual deja c como una función lambda basada en f. Para definir funciones que reciben funciones como parametros usamos la siguiente expresión
def g(h: Any => Any) = // Código ...
def k(h: Any => Any)(x: Any) = // Código ...
La segunda notación nos permiten pasar dos parametros a la función k, en primer lugar otra función y en segundo lugar una variable.
<h5>Funciones como metodos</h5>object Util {
def metodo (x: Int) = x+x
val a = metodo _
}
Tengo dos soluciones pero entonces no se cual seria la que mejor da la repsuesta al reto:
SOLUCION 1:
scala> def calcMayorQue(x:Int,y:Int) = {
| if (x>y){
| "El numero " + x + " es mayor al numero " + y}
| else{
| "El numero " + x + " es menor al numero " + y}}
calcMayorQue: (x: Int, y: Int)String
scala> calcMayorQue(5,8)
res1: String = El numero 5 es menor al numero 8
SOLUCION 2:
scala> def calcMayorQue(x:Int,y:Int) = {
| val resComp = x > y
| def MayorQue(bool: Boolean) = {
| if (bool){
| "El numero " + x + " es mayor al numero " + y}
| else{
| "El numero " + x + " es menor al numero " + y}}
| MayorQue(resComp)}
calcMayorQue: (x: Int, y: Int)String
scala> calcMayorQue(5,1)
res2: String = El numero 5 es mayor al numero 1
Quedo atento a sus comentarios
Hablamos de funciones en su definición matemática.
f: D → R
Una función es tratada como un valor más. Esto implica que una función puede recibir y retornar otras funciones.
def f(x: Int) = x * x
// f: (x: Int)Int
f(2)
//res0: Int = 4
f(2)
//res1: Int = 16
// Función anónima
(x; Int) => x*x
// res2: Int => Int = $$Lambda$$770/123467@333f5f6
val a = (x; Int) => x*x
//a: Int => Int = $$Lambda$$770/123467@333f5f6
a(2)
//res3: Int = 4
a(4)
//res4: Int = 16
// a es un objeto y f es una función
f.apply(2) // error
a.apply(2) ////res4: Int = 4
// convertir f en objeto
val c = f _
// c: Int => Int = $$Lambda$$770/123467@333f5f6
c.apply(2)
//res7: Int = 4
def g(h: Int => Int) = h(3)
//g: h: Int => Int)Int
g(f)
//res10: Int =9
def k(h: Int => Int)(x: Int) = h(x)
// k: (h: Int => Int)(x: Int)Int
k(f)(3)
//res11: Int = 9
k(f)(4)
//res12: Int = 16
// Funciones como métodos
object Util {
def metodo(x: Int) = x+x
val a = metodo _
}
Util.metodo(3)
//res5: Int = 6
Util.a(3)
//res6: Int = 6
En mi caso si me funciono f.apply() sobre
def f(x: Int) = x * x
😮
scala> val otraFunction = (parametro: Int) => ((x: Int) => x > parametro)
otraFunction: Int => (Int => Boolean) = $$Lambda$992/0x00000008010dc040@53c1f4ae
scala> otraFunction(10)(5)
res18: Boolean = false
scala> otraFunction(10)(13)
res19: Boolean = true
Hola, yo encounter otra manera para pasar los paramteros de las funciones
// Definicion de la function suma para hacer el llamado se ejecuta como fx_suma(3,4)
def fx_suma (x:Int, y:Int):Int ={
x+y
}
// Convertir la function en un objeto
val obj_fx_suma = fx_suma _
def fx_multi(x:Int, y:Int):Int ={
x*y
}
// Definicion de una funcion de orden superior
def fx_orden_superior ( fx:(Int,Int)=> Int,x:Int, y:Int):Int = {
fx(x,y)
}
// Llamado con la funcion como objeto
fx_orden_superior(obj_fx_suma,3,5)
fx_orden_superior(fx_suma,3,5)
fx_orden_superior(fx_multi,3,5)
me dio mucha risa cuando dijiste: existe una **vaina **que se llama el apply jaja
Scala 3
@main def hello(): Unit =
def isGreater(a: Int): Int => String = (b: Int) =>
if (a > b) s"El primer parametro a=$a es mayor que el segundo parametro b=$b"
else s"El primer parametro a=$a es menor que el segundo parametro b=$b"
println(isGreater(15)(8))
Podría ser que en Scala 3.2.1 ya apliquen las funciones como objetos?
object Main {
def main(args: Array[String]): Unit = {
val res = isGreater(10)
println(res)
}
def isGreater(num1:Int):Int => Boolean = {
(num2:Int) => num1 < num2
}
}
Comparto por aca mi solucion al reto:
object Util{
def metodo(x:Int,e:Int) =
if (x>e) {
println("Primero mayor a segundo")
} else if (x<e) {
println("Segundo mayor a primero")
}
else {
println("Son iguales")
}
}
scala> def es_Mayor(x: Int, z: Int) = (if x > z then "El numero X es mayor que Z" else "El numero X es menor que Z")
def es_Mayor(x: Int, z: Int): String
scala> es_Mayor(10,5)
val res1: String = El numero X es mayor que Z
scala> es_Mayor(5,15)
val res2: String = El numero X es menor que Z
Creo que podría ser algo así:
def g(x: Int) = (a: Int) => a>x
Esta creo que es la solución del problema y mas abajo esta una pequeña utilidad que se le puede hacer a dicha función.
def isGreater(num : Int) = (num2 : Int) => num2 > num
val isGreaterThan3 = isGreater(3)
isGreaterThan3(5)
Creo un objeto que recibe la función devuelta por la primera función, la cual se le pasa como parámetro el número 3, lo que nos permite que el objeto no devuelva un booleano si el número que se le pasa por parámetros es mayor o no.
Solución al reto
def calculateHigherInt(base:Int) = (judged:Int) => judged > base
def calculateHigherIntOfFive = calculateHigherInt(5)
calculateHigherIntOfFive(10)
def f (x : Int)(a : Int) = {
if(x>a) "x es mayor al parámetro a"
else “no es mayor”
}
object Calcular {
def mayor_menor(x: Int, y : Int) = if(x > y)
println( x + " es mayor que " + y)
else
println( x + " no es mayor que " + y)
val validar = mayor_menor _
}
Calcular.mayor_menor(1, 4)
Mi solución:
def isGreater(a:Int, b:Int)= if(a>b)
"A is greater" else if(a.equals(b)) "Are similar" else "B is greater"
def comparar(f:(Int,Int)=>String)(a:Int,b:Int)
= f(a,b)
comparar(isGreater)(4,2)
object Test{
def calcular(valor:Int, val2:Int)= if(valor>val2) valor else val2
val parametro= calcular _
}
// Test.calcular(2,4)
Test.parametro(2,4)
solución del reto
object Util {
def calcular(a: Int, b: Int): String = {
if (a > b) "Es mayor" else "Es menor"
}
}
println (Util.calcular(6,5))
def GreaterThan(x: Int) = (y: Int) => (y > x)
GreaterThan(5)(2)
Seria algo asi:
def mayor(x:int) = (x2: int) => x<x2
println(mayor(4)(5))
Ésta es mi solución
def isGreater(x: Int) : (Int => Boolean) ={
(y: Int) => {x>y}
}
Buenas noches, este es mi aporte
def may(x: Int,y: Int): Boolean = x<y
may: (x: Int, y: Int)Boolean
may(10,10)
res0: Boolean = false
may(10,101)
res1: Boolean = true
may(1000,101)
res2: Boolean = false
Gracias.
Mi solución fue esta:
Object Mayor {
def validar(x:Int) = if ( x > 10) “El numero “+x+” es mayor a 10” else "El numero “+x+” es menor a 10"
Val m = validar _
}
Mayor.a(11)
Val res0: String = El numero 11 es mayor a 10
object comparador {
def comparar( a: Int ) = {
( b: Int ) => println( a < b )
}
}
comparador.comparar(10)(20)
Easy!
def m(x: Int) = (y: Int) => x > y
O eso creo!!! Jajaj
Mi solución quedo así, según entendí
// Con una función simple
def a(x: Int)(y: Int) = x > y
println(a(1)(2))
// Una función que resuelve el problema acorde al enunciado
def a(y: Int) = 6 > y
println(a(2))
// Agregando la parte de una función que genera una función
def a(x: Int) = { def y(x: Int) = 6 < x; y(x); }
println(a(2))
no me quedo muy claro lode funciona anónimamente, no me dio el msj de Lambda.
scala> val a = (x: Int ) => x*x
a: Int => Int = <function1>
scala> def Mayor(p: Int) = if(p > 10) "Es Mayor" else "Es Menor o Igual"
Mayor: (p: Int)String
scala> def MayorQue(funcionBase: Int => String)(p: Int) = funcionBase(p)
MayorQue: (funcionBase: Int => String)(p: Int)String
scala> MayorQue(Mayor)(2)
res0: String = Es Menor o Igual
scala> MayorQue(Mayor)(10)
res1: String = Es Menor o Igual
scala> MayorQue(Mayor)(11)
res2: String = Es Mayor
Para el ejercicio he realizado varios intentos el mas simplificado es el siguiente
def validator(param:Int) = if (param >= scala.util.Random.nextInt(10)) "Es mayor o igual" else "Es menor o igual"
Sin embargo quisiera saber porque no funciona el siguiente Código:
def fx_identify_parameter(param: Int) = {
def validator ():String ={
val num_aleatorio = scala.util.Random.nextInt(10)
if (num_aleatorio > param) {
"El parametro es mayor al numero aleatorio"
} else if (num_aleatorio < param) {
"El parametro es menor al numero aleatorio"
} else {
"El parametro es igual al numero aleatorio"
}
}
}```
val calc = (x:Int) => ((y:Int) => x > y)
def f(x: (Int, Int) => Int)(y: Int, z: Int) = x(y,z)
def x(a: Int, b: Int) = if(a>b) a else b
def functionFactory(num: Int): Int => Boolean = { (param: Int) => num > param }
val test = functionFactory(10)
test(20)
test(5)
Si entendí bien debería ser así
def function(a:Int): (Int) => Boolean = (b:Int) => a > b
Qué tal, comparto mi ejercicio:
![]()
object ChallengeOne extends App {
def generatorChallenge = (x: Int) => if (x > 10) "Is greater than" else "Is less than"
val result = generatorChallenge
println(result(15))
println(result(7))
}
Acorde a lo que yo entendí esta es mi propuesta
def isGreater(num: Int) = (param : Int) => num > param
isGreater(4)(2)
val res0: Boolean = True
isGreater(4)(5)
val res1: Boolean = False
Lo logreee!!
-Según comprendí el enunciado y mis conocimientos actuales en scala
Abierto a sugerencias y correcciones
Creo que sería algo así:
scala> val compara = (a:Int,b:Int) => a>b
compara: (Int, Int) => Boolean = <function2>
scala> def esMayor(f: (Int,Int) => Boolean)(x:Int)(y:Int) = f(x,y)
esMayor: (f: (Int, Int) => Boolean)(x: Int)(y: Int)Boolean
scala> esMayor(compara)(5)(4)
res7: Boolean = true
scala> esMayor(compara)(5)(7)
res8: Boolean = false
scala> esMayor(compara)(5)(5)
res9: Boolean = false
def g(h: Int => Int)(x: Int) = h(x) > x
La respuesta que yo propongo es
def genera3(b: Int): Int => Boolean = (c: Int)=> if(b<c)true else false
println("El resultado es: " + genera3(4)(6))
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?