Qu'est-ce que le système de type "puissant" de Scala?

Question

Lorsque Scala est discuté, le système de type est toujours mentionné comme l'une des principales fonctionnalités. Il est considéré comme puissant et la principale raison du surnom de langue (Scala étant l'abréviation de "langage évolutif"). Quelqu'un pourrait-il expliquer comment fonctionne la saisie Scala / pourquoi est-ce unique et comment cela contribue-t-il à rendre la langue évolutive?

Answer 1

Je ne pense pas que les questions / réponses sont appropriées. Scala a beaucoup de commodités, mais ils ne sont pas liés au type de système puissant juste parce qu'ils se rapportent à des types. En effet, l'inférence de type est en conflit direct avec la puissance du système de type -- ont été moins puissant, on pourrait avoir la pleine inférence de type (comme en Haskell).

Donc,

• Scala a des classes avec les membres. (Évident, mais je vais essayer d'être exhaustif ici.)
• Méthode ("def") les membres de la scala de classe peut avoir zéro, un ou plusieurs listes de paramètres, dont chacun peut avoir zéro, un ou plusieurs paramètres, dont le dernier peut-être un vararg.
• Les paramètres peuvent être passés par valeur ou par nom.
• Les paramètres ont des noms et peuvent avoir des valeurs par défaut.
• Scala a "var" et "val" membres (qui sont, dans la pratique, également d'autres méthodes).
• Scala a "paresseux val" les membres.
• Scala a "type" des membres (type d'emprunt), qui peut être spécifié comme des types fixes ou type de limites.
• Scala a les classes abstraites et les membres (tous les membres ci-dessus mentionnés peuvent être abstrait).
• Scala a intérieur de la classe, les traits et les objets (Scala intérieure de la classe sont différents de Java).
• Scala membres, plus intérieure trucs, peut être surchargée.
• Scala a le type d'héritage.
• Scala a des traits de caractère, offrant de multiples-l'héritage avec le type de linéarisation.
• Scala de traits de la méthode de membres de l'abstrait remplacer (empilables, d'aspect comme override).
• Scala a singleton types.
• Scala a compagnon de classe/objets (liées à portée).
• Scala a private, protected et public étendues pour les classes, les traits, les singletons et les membres.
• Scala privé et protégé champs d'application peut être limité à un ancêtre package, classe, trait ou d'un singleton, plus "présent".
• Scala a auto types.
• Scala a des paramètres de type.
• Scala type de paramètres peuvent être co - et contra-variante, ainsi que de l'invariant.
• Scala a le type des constructeurs.
• Scala a d'ordre supérieur types.
• Scala a existentielle types.
• Scala a des types structuraux.
• Scala a paramètres implicites.
• Scala a des types de fonction, bien que, depuis qu'ils sont tout simplement une classe plus sucre syntaxique, je ne pense pas qu'il appartient à cette liste. D'autre part, des types de fonction font partie de la vue de limites, alors peut-être qu'il fait.
• Scala a un haut (comme presque tout le monde) et un fond (comme d'autres statiquement typé fp langues).
• Scala "unité" est un type avec une valeur (par opposition à "vide" d'ailleurs).

Ensuite, il y a des fonctionnalités liées à la Scala, à la implicites, qui est ce que mérite leur inclusion ci-dessus.

• Scala a vue de limites, un paramètre implicite qui agit comme un autre type liés.
• Scala a contexte counds, un paramètre implicite qui agit comme un autre lié.
• Généralement parlant, les paramètres implicites et l'inférence de type peuvent être combinés pour construire complexe arbitraire des preuves sur les paramètres de type.

Rapport au dernier commentaire, implicites et de l'inférence de type, ensemble, faire de la Scala de type du système de turing. Qui est, vous codifier des programmes arbitraires comme des types, qui seront "run" au moment de la compilation par le compilateur. La preuve ici, par voie de SKI de Calcul, avec un "buggy" boucle infinie dans les types est plus à démontrer.

La liste des fonctionnalités ci-dessus est assez grand et impressionnant sur de nombreux points. Il est, cependant, la façon dont Scala combine implicites et l'inférence de type pour produire de la statique des épreuves au moment de la compilation (comme voir les limites et le contexte de limites) qui font de la Scala, du type de système unique. Autant que je sache, il n'y a pas d'autre langue de faire qui, si il y a certainement d'autres langues, en fournissant la preuve des capacités par d'autres moyens.

Answer 2

Quelques avantages de la Scala, le système de types de cours Java:

1. Les Types peuvent être déduites dans de nombreux cas, au lieu d'être spécifié explicitement. C'est plus une commodité, mais il favorise les à l'aide des types complexes.

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

   au lieu de

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

2. Les fonctions peuvent être exprimées simplement dans le système de type. Si vous voulez voir comment cette puissante est, considère que la goyave bibliothèque comme un travail autour de Java . Il est incroyablement limité et détaillé (mais toujours utile).

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

   au lieu de (à l'aide de Goyave)

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

3. Les Tuples sont un type de Scala, le contournement de Java problème de pouvoir retourner une seule valeur.

4. Scala prend en charge le type des Écarts de sorte que vous pouvez spécifier que SomeObject est un sous-type de SomeObject quand le Chat est un sous-type de la Chose (ou quand la marche arrière rapport de titulaire). En java, les génériques ne sont pas covariante, ce qui est souvent problématique.

5. Scala prend en charge une forme limitée de multiples-l'héritage à l'aide de traits. Contrairement aux interfaces (dont plusieurs peuvent être mises en œuvre en Java), les traits peuvent définir des méthodes et des variables.

6. Les tableaux sont de manière transparente gérée comme n'importe quelle autre classe.

7. Vous pouvez ajouter des méthodes dans les classes existantes par le biais implicite définitions. Par exemple, vous pouvez ajouter une "somme" de la méthode à des Tableaux d'Entiers.

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

C'est une autre bonne ressource pour certaines des questions ci-dessus: http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-5

Answer 3

En plus de schmmd excellente réponse, Scala type de système a même des caractéristiques les plus importantes:

• objects sont une alternative propre à static membre de variables et de méthodes en Java, par exemple, un object a son propre type et peut être passé en argument
• type déclarations: vous pouvez définir des alias pour les types complexes, comme type FactorMap[A] = Map[A, Set[Int]]
• type abstrait membres comme alternative générique-types de style
• auto types
• types de construction
• plusieurs listes d'arguments pour lancer
• paramètres implicites et les conversions, en collaboration avec vue les limites. Cela conduit à la "pimp my library" modèle et peut être utilisé pour simuler Haskell-style typeclasses
• les types d'ordre supérieur

Le dernier point est l'un de mes favoris. E. g. vous ne pouvez pas écrire un simple général foncteur interface en Java. Vous auriez besoin...

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

Cela fonctionne si vous le remplacer par un type de béton comme List au lieu de C. En Java, vous pouvez résumé sur le contenu d'un containter (par exemple, en écrivant " la Liste), mais vous ne pouvez pas abstraite sur le conteneur lui-même. Faites-moi confiance, j'ai essayé de trouver des échappatoires (le résultat a été ce). En Scala, c'est un jeu d'enfant:

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

Answer 4

Tout système de type dans lequel vous pouvez coder HList, TList et HOF pour les types est assez puissant à mon humble avis. Voir http://apocalisp.wordpress.com/2010/06/08/type-level-programming-in-scala/ pour plus d'informations.

Answer 5

Je ne sais pas si vous connaissez Java, mais imaginez le système de type de Scala comme ceci:

• Supprimez les limitations artificielles de Java de ce que vous pouvez faire avec les types et les génériques
• Ajoutez-y les caractéristiques communes des langages fonctionnels
• Innover sur le front oop / héritage

j'adorerais plus, bu mon clavier cassé, désolé!