¿Cómo "Aplicar" para los resultados de una función sin parámetros

Esto funciona:¿Cómo "Aplicar" para los resultados de una función sin parámetros

List(3, 1, 2).sorted apply 1 
res1: Int = 2

y esto funciona:

var x = List(3, 1, 2).sorted 
x: List[Int] = List(1, 2, 3) 
x(1) 
res2: Int = 2

pero esto no lo hace:

List(3, 1, 2).sorted (1) 

error: type mismatch; 
found : Int(1) 
required: Ordering[?] 
     List(3, 1, 2).sorted (1) 
          ^

Y hasta paréntesis no muestran el analizador en lo que quiero:

(List(3, 1, 2).sorted)(1) 

error: type mismatch; 
found : Int(1) 
required: Ordering[?] 
     (List(3, 1, 2).sorted)(1)

Parece una expresión natural. ¿Qué estoy haciendo mal?

Fuente

2011-01-22 Malvolio

'ordenados' no tiene parámetros: se necesita un parámetro implícito, que puede omitirse. Ese es el problema: su (1) se interpreta como un parámetro explícito para 'sorted' y no como un parámetro para el método apply de su valor de retorno, como en' List (1, 2, 3) .tail (0) ', que funciona bien. Lamentablemente, no sé si hay alguna solución. –

¿Has probado 'List (3, 1, 2) .sorted() (1)'? – Madoc

@Madoc: eso no funciona, no se puede omitir lo implícito al proporcionar una lista de parámetros vacía, el compilador se queja de un parámetro no especificado. –

Esto funciona:

(Listed(3, 1, 2).sorted _)(1),

pero no estoy seguro de si es mucho más cómodo de usar que:

Listed(3, 1, 2).sorted apply 1.

Me gustaría ir por el último de todos modos.

Fuente

2011-01-22 17:58:11 Saew

En realidad, mi plan es asignarlo a una variable, es * legible *, donde 'aplicar' es simplemente peculiar. – Malvolio

Creo que debe mantener la aplicación. La razón es que ordenadas no es "sin parámetros", se define como

def sorted [B >: A] (implicit ord: Ordering[B]) : List[A]

Como se trata de un parámetro implícito, el Ordenamiento [Int] se proporciona normalmente de forma automática, pero si se utiliza parens, el compilador piensa desea especificar otro pedido [Int] (digamos al revés).

Fuente

2011-01-22 17:35:45 Landei

¿Entonces está diciendo que estoy jodido? ¿Por qué no fue útil envolverlo en parientes? – Malvolio

Porque los parens no cambian nada aquí. Considera '(math.abs) (- 1)': Los primeros parens no evitan que los abdominales reciban su argumento. Lo mismo es cierto para 'sorted', por lo que solo espera una arg para su lista de argumentos con lo implícito. Buena solución de Saew, por cierto. – Landei

El parámetro requerido se puede proporcionar de esta manera:

List(3, 1, 2).sorted(implicitly[Ordering[Int]])(1)

Aunque el uso de aplicar() se ve más corta y menos miedo.

Fuente

2011-01-22 17:49:08

El más corto que podría hacer - no sin una pequeña penalización en el rendimiento, sin embargo - es

class Allow_\[A](a: A) { def \ = a } 
implicit def allowEveryone[A](a: A) = new Allow_\[A](a) 

scala> List(1,3,2).sorted\(1) 
res0: Int = 2

Si usted puede aceptar otro personaje, esto podría ser más agradable: <> ve como parens de todos modos, y puede debe leerse como "complete los parámetros implícitos como de costumbre":

class Allow_<>[A](a: A) { def <> = a } 
implicit def allowEveryone[A](a: A) = new Allow_<>[A](a) 

scala> List(1,3,2).sorted<>(1) 
res0: Int = 2

Fuente

2011-01-22 23:25:34

¿Cómo "Aplicar" para los resultados de una función sin parámetros

Respuesta

Cuestiones relacionadas