/ / Jaki jest "potężny" system typu Scala? - scala, typy

Co to jest "potężny" system Scali? - scala, typy

Kiedy omawiany jest Scala, typem systemu jestzawsze wspomniane jako jedna z głównych cech. Jest on określany jako potężny i główny powód dla monikera języka (Scala jest skrótem od "języka skalowalnego"). Czy mógłby ktoś wyjaśnić, jak działa pisanie Scala / dlaczego to wyjątkowe i jak to wpływa na skalowalność języka?

Odpowiedzi:

46 dla odpowiedzi № 1

Nie sądzę, że istnieją odpowiedziwłaściwy. Scala ma wiele udogodnień, ale nie są one związane z systemem typu, który jest potężny tylko dlatego, że odnoszą się do typów. W rzeczywistości, wnioskowanie typu jest w bezpośrednim konflikcie z mocą systemu typu - gdyby było mniej potężne, można mieć pełne wnioskowanie typu (jak w Haskell).

Więc,

  • Scala ma zajęcia z członkami. (Oczywiste, ale staram się być wyczerpujący.)
  • Metoda ("def") członków klasy scala może mieć zero lub więcej list parametrów, z których każda może mieć zero lub więcej parametrów, z których ostatnia może być zmienną.
  • Parametry mogą być przekazywane według wartości lub według nazwy.
  • Parametry mają nazwy i mogą mieć wartości domyślne.
  • Scala ma członków "var" i "val" (które są w praktyce również metodami).
  • Scala ma członków "lazy val".
  • Scala ma "typ" członków (aliasy typów), które mogą być określone jako typy stałe lub jako granice typów.
  • Scala ma klasy abstrakcyjne i członków (wszyscy wyżej wymienieni członkowie mogą być abstrakcyjni).
  • Scala ma wewnętrzną klasę, cechy i obiekty (klasa wewnętrzna Scali jest inna niż Java).
  • Członkowie Scala, plus rzeczy wewnętrzne, mogą zostać zmienione.
  • Scala ma dziedziczenie typu.
  • Scala ma cechy, zapewniające wielokrotne dziedziczenie z linearyzacją typu.
  • Członkowie metody cech Scaly mogą mieć abstrakcyjne zastąpienie (ustawianie w stosy, podobne do aspektu).
  • Scala ma typy singleton.
  • Scala ma klasę / obiekty towarzyszące (związane z zakresem).
  • Scala ma prywatne, chronione i publiczne zakresy dla klas, cech, singletonów i członków.
  • Prywatne i chronione zakresy Scala mogą być ograniczone do dowolnego pakietu, klasy, cechy lub singletona, plus "to".
  • Scala ma własne typy.
  • Scala ma parametry typu.
  • Parametry typu Scala mogą być co- i przeciw-wariancyjne, jak również niezmienne.
  • Scala ma konstruktorów typów.
  • Scala ma typy wyższego rzędu.
  • Scala ma typy egzystencjalne.
  • Scala ma typy strukturalne.
  • Scala ma ukryte parametry.
  • Scala ma jednak typy funkcji, ponieważ sąpo prostu klasa plus cukier syntaktyczny, nie sądzę, że należy ona do tej listy, z drugiej strony, typy funkcji są częścią granic widoku, więc może tak jest.
  • Scala ma górę (jak prawie wszyscy) i spód (podobnie jak inne statycznie wpisane języki fp).
  • Jednostka "Scala" to typ o wartości (w przeciwieństwie do "void" w innym miejscu).

Następnie są funkcje związane z implikacjami Scali, co zasługuje na ich włączenie powyżej.

  • Scala ma ograniczenia widoku, niejawny parametr, który działa jak inny związany typ.
  • Scala ma counds kontekstu, niejawny parametr, który działa jak inna granica.
  • Ogólnie rzecz biorąc, niejawne parametry i typy wnioskowania mogą być łączone w celu konstruowania dowolnych złożonych dowodów na parametrach typu.

Powiązane z ostatnim komentarzem, implicite i typem inferencji tworzą razem system typu Scala ukończenie. Oznacza to, że kodyfikujesz dowolne programy jako typy, które zostaną "uruchomione" w czasie kompilacji przez kompilator. Dowód tutaj, za pomocą SKI Calculus, z "buggy" nieskończoną pętlą w typach jako dalszą demonstrację.

Lista powyższych funkcji jest dość duża iimponujące w wielu punktach. Jest to jednak sposób, w jaki Scala łączy implikacje i wnioskowanie typu, aby wytworzyć statyczne dowody w czasie kompilacji (takie jak granice widoku i granice kontekstu), które czynią system Scala wyjątkowym .AFAIK, nie ma innego języka, który to robi, chociaż są z pewnością inne języki, które zapewniają dowody za pomocą innych środków.


20 dla odpowiedzi nr 2

Kilka zalet systemu typu Scala nad Javą:

  1. Typy można wywnioskować w wielu przypadkach, zamiast być wyraźnie określone. Jest to raczej wygoda, ale promuje używanie skomplikowanych typów.

    val map = new Map[String, (String, String)]()

    zamiast

    Map<String, Tuple<String, String>> map = new HashMap<String, Tuple<String, String>>()

  2. Funkcje można wyrazić po prostu w typiesystem. Jeśli chcesz zobaczyć, jak jest to potężne, rozważ bibliotekę guawy jako obejście dla Javy. Jest niewiarygodnie ograniczony i gadatliwy (ale nadal przydatny).

    val double = (x: Int) => x * 2

    zamiast (używając Guava)

    Function<Integer, Integer> double = new Function<Integer, Integer>() { @Override public Integer apply(Integer value) { return value * 2; }}

  3. Krotki są typem w Scali, omijającym problem Javy, który jest w stanie zwrócić pojedynczą wartość.

  4. Scala obsługuje typ Warianty więc możesz określić, że SomeObject jest podtypem SomeObject, gdy Cat jest podtypem Thing (lub gdy zachowana jest relacja odwrotna). W języku Java, leki generyczne nie są kowariantne, co często jest problematyczne.

  5. Scala obsługuje ograniczoną formę wielokrotnego dziedziczenia przy użyciu cechy. W przeciwieństwie do interfejsów (z których wiele może być zaimplementowanych w Javie), cechy mogą definiować metody i zmienne.

  6. Tablice są przezroczyście obsługiwane jak każda inna klasa.

  7. Możesz dodać metody do istniejących klas poprzez ukryte definicje. Na przykład możesz dodać metodę "sum" do Array of Integers.

    class IntArray(value: Array[Int]) { def sumIt = value.reduceRight(_+_) }
    implicit def pimpArray(xs: Array[Int]) = new IntArray(xs)
    Array(1,2,3).sumIt
    

Jest to kolejne dobre źródło niektórych z powyższych tematów: http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-5


6 dla odpowiedzi nr 3

Oprócz doskonałej odpowiedzi schmmd, system typu Scala ma jeszcze ważniejsze cechy:

  • objects są czystą alternatywą dla static zmienne składowe i metody w języku Java, np. na object ma własny typ i może być przekazywany jako argument
  • type deklaracje: możesz zdefiniować aliasy dla typów złożonych, takich jak type FactorMap[A] = Map[A, Set[Int]]
  • członkowie typu abstrakcyjnego jako alternatywa dla typów typu generycznego
  • typy własne
  • typy strukturalne
  • wiele list argumentów dla curry
  • niejawne parametry i konwersje, a także ograniczenia widoku. Prowadzi to do wzoru "pimp my library" i może być użyte do symulacji typów znaków w stylu Haskella
  • typy wyższego rzędu

Ostatni punkt jest jednym z moich ulubionych. Na przykład. nie możesz napisać prostego interfejsu ogólnego funktora w Javie potrzeba...

public interface Function<A,B> {
public B apply(A a);
}

//not valid Java
public interface Functor<C> {
public <A,B> C<B> map(Function<A,B> fn, C<A> ca);
}

Działa, jeśli zastąpisz konkretny typ List zamiast C. W Javie można streścić zawartość kontenera (np. Wpisując `List), ale nie można go pominąć sam pojemnik. Zaufaj mi, próbowałem znaleźć luki (wynik był to). W Scali jest bardzo proste:

trait Functor[C[_]] {
def map[A,B](fn: A => B, ca: C[A]):C[B]
}

object ListFunctor extends Functor[List] {
def map[A,B](fn: A => B, ca: List[A]):List[B] = ca.map(fn)
}

3 dla odpowiedzi № 4

Dowolny system typów, w którym można kodować HList, TList i HOF dla typów, jest bardzo silnym IMHO. Widzieć http://apocalisp.wordpress.com/2010/06/08/type-level-programming-in-scala/ po więcej informacji.


0 dla odpowiedzi № 5

Nie wiem, czy znasz Javę, ale wyobraź sobie system typu Scala, taki jak ten:

  • Usuń sztuczne ograniczenia Javy, co możesz zrobić z typami i rodzajami
  • Dodaj do niego wspólne cechy języków funkcyjnych
  • Wprowadzaj innowacje na frontach związanych z dziedziczeniem

Chciałbym jeszcze więcej napisać, moja klawiatura pękła, przepraszam!