No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Scala básico

Curso de Scala básico

Carlos Daniel Sanchez

Carlos Daniel Sanchez

Funciones

9/36
Recursos

Aportes 57

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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 😄

<h4>Funciones</h4>

Para definir funciones en scala tenemos dos opciones

  1. def f(x: Any) = // Código ...
  2. 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

Funciones

Hablamos de funciones en su definición matemática.

  • Dominio: Datos de entrada
  • Rango: Datos de salida

f: D → R

Funciones de orden superior

Una función es tratada como un valor más. Esto implica que una función puede recibir y retornar otras funciones.

  • Funciones anónimas (lambdas)
  • Funciones como objetos
  • Funciones como métodos
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

Alguien podría ayudarme a ver donde está el error por favor?:
Según entiendo puedo tener estas dos soluciones y me retornan el Boolean * def greaterT(x: Int)(y: Int) = y > x * def greaterThan(x: Int, y:Int) = x > y Me gusta que las matemáticas están implicitas en el lenguaje.
Mi solución: `def isGreaterThan(compareValue:Int)(value:Int):Boolean = compareValue < value` y ahora simplemente generamos las funciones o ejecutamos directamente: `val isGreaterThan5 = isGreaterThan(5)` `isGreaterThan5(3) // false` `isGreaterThan5(6) // true` `isGreaterThan(10)(7) // false`
Solucion: `val evaluaSiEsMayor = (paramIngresado: Int, paramExistente: Int) => if(paramExistente > paramIngresado) "El numero existenete es mayor al ingresado" else "El numero existente es menor o igual al numero ingresado"` `def evaluadorNumero21(h:(Int, Int) => String)(x:Int) = h(x,21)` lo ejecutaria asi `evaluadorNumero21(evaluaSiEsMayor)(21)` la solucion seria algo asi `val res17: String = El numero existente es menor o igual al numero ingresado`
Listo aqui mi aporte: def calcula\_Si\_Numero\_Es\_Mayor(a : Int, b : Int): String = { val resultado = if (a > b) "El primer numero es mayor" else "El segundo numero es mayor" resultado } println(calcula\_Si\_Numero\_Es\_Mayor(550, 6))
A mi me quedo asi: `def is_greater_than(n1: Int): Int=>Boolean = (n2:Int) => n2> n1` `val f=is_greater_than(3)` `f(4)`
Reto: def functionFactory = (x: Int) => if(5 > x) "Es mayor" else "es menor"
def isGreater (j:Int => if(J>5) "Es Mayor que 5" else "No Es Mayor que 5" ) = J(25)

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))