Funkcje bez argumentów, z jednostką jako argumentem w scala

Question

def foo(x:Int, f:Unit=>Int) = println(f()) 

foo(2, {Unit => 3+4} 

//case1 
def loop:Int = 7 
foo(2, loop) //does not compile 

changing loop to 
//case 2 
def loop():Int = 7 
foo(2, loop) // does not compile 

changing loop to 
//case 3 
def loop(x:Unit): Int = 7 //changing according to Don's Comments 
foo(2,loop) // compiles and works fine 

should'nt case 1 and case 2 also work? dlaczego oni nie działają?

definiowania foo jako

def foo(x:Int, y:()=>Int) 

wówczas przypadek 2 działa, ale nie Przypadek 1.

Arent wszyscy powinni pracować, definiowanie funkcji w obu kierunkach.

// również myślę() => Int in foo to zły styl, y: => Int nie działa, komentarze ??

Answer 1

Scala rozróżnia następujące rzeczy:

• Funkcje/metod z żadne listy parametrów ("przez -name parametr”jeśli funkcja)
• Funkcje z jeden pustej listy parametrów
• Funkcje z jeden parametr typu jednostki

Żaden z nich nie są równoważne, chociaż jako udogodnienie pozwala Scala aby wymazać puste listy parametrów. (Nawiasem mówiąc, dwie listy pusty parametrów nie są również takie same.)

Więc chociaż Unit napisano (), to nie samo jako argument funkcji parens () dla funkcji lub metody. Zamiast tego pomyśl o () jako o Tuple0.

Więc, jeśli powiesz f: Unit => Int, co masz na myśli to „f przyjmuje jeden parametr, ale jest to naprawdę nudny parametr ponieważ jest Unit, które zawsze muszą być takie same nudne Tuple0 wartość ()”. To, co piszesz, jest naprawdę krótkie dla f: (Unit) => Int.

Jeśli powiesz f:() => Int, to znaczy, że „f przyjmuje żadnych parametrów i wytwarza Int”.

Jeśli powiesz f: => Int, to znaczy, że „opóźnić wykonanie cokolwiek oświadczenie generuje wartość Int aż używamy go w tym kodzie (i ponownie ocenić go za każdym razem).” Funkcjonalnie kończy się to w zasadzie takim samym, jak f:() => Int (i wewnętrznie jest konwertowany na tę samą klasę Function0), ale ma inne zastosowanie, prawdopodobnie w celu uzyskania bardziej zwartej formy zamknięć (zawsze pomijasz kod => w kodzie wywołującym).

Answer 2

() => int Function0 [Int] Chociaż jednostka => int Function1 [jednostka, Int]

scala> val function0:() => Int =() => 5 
function0:() => Int = <function0> 

scala> val function1: Unit => Int = u => 5 
function1: (Unit) => Int = <function1> 

scala> function0() 
res0: Int = 5 

scala> function1("anything") 
res1: Int = 5 

scala> function1(100) 
res2: Int = 5 

scala> 

Należy również zauważyć, że() jest przedmiotem jednostki

scala> function1(()) 
res11: Int = 5 

scala> function1() 
res12: Int = 5 

scala> function1() 
res13: Int = 5 

scala> val unit =() 
unit: Unit =() 


scala> function1(unit) 
res15: Int = 5 

scala> function1 apply unit 
res16: Int = 5 

scala> 

Answer 3

W przypadku 1 i 2 powyżej, wartość zwracana pętla zamiast pętli sam jest typem sprawdzana dla drugiego argumentu foo a nie: Int = jednostka => Int

Zmiana na pętla ma błąd literowy.