Permalink
Browse files

Merge branch 'master' of github.com:scala/scala.github.com

  • Loading branch information...
heathermiller committed Aug 30, 2012
2 parents e30272b + 59afeb1 commit 6e723494f285bd7f75cbf2beb26b76c2ef2df15a
View
@@ -57,6 +57,8 @@ about: Thanks to <a href="http://brenocon.com/">Brendan O'Connor</a>, this cheat
| `for ((x,y) <- xs zip ys) yield x*y` _same as_ <br>`(xs zip ys) map { case (x,y) => x*y }` | for comprehension: destructuring bind |
| `for (x <- xs; y <- ys) yield x*y` _same as_ <br>`xs flatMap {x => ys map {y => x*y}}` | for comprehension: cross product |
| `for (x <- xs; y <- ys) {`<br> `println("%d/%d = %.1f".format(x,y, x*y))`<br>`}` | for comprehension: imperative-ish<br>[sprintf-style](http://java.sun.com/javase/6/docs/api/java/util/Formatter.html#syntax) |
+| `for (i <- 1 to 5) {`<br> `println(i)`<br>`}` | for comprehension: iterate including the upper bound |
+| `for (i <- 1 until 5) {`<br> `println(i)`<br>`}` | for comprehension: iterate omitting the upper bound |
| <h2 id="pattern_matching">pattern matching</h2> | |
| <span class="label success">Good</span> `(xs zip ys) map { case (x,y) => x*y }`<br> <span class="label important">Bad</span> `(xs zip ys) map( (x,y) => x*y )` | use case in function args for pattern matching. |
| <span class="label important">Bad</span><br>`val v42 = 42`<br>`Some(3) match {`<br>` case Some(v42) => println("42")`<br>` case _ => println("Not 42")`<br>`}` | "v42" is interpreted as a name matching any Int value, and "42" is printed. |
@@ -0,0 +1,36 @@
+---
+layout: tutorial
+title: Polymorphe Methoden
+
+disqus: true
+
+tutorial: scala-tour
+num: 21
+language: de
+---
+
+Methoden in Scala können sowohl in deren Parametern als auch in deren Typen parametrisiert werden.
+Wie bei Klassen werden die Parameter von runden Klammern umschlossen, während Typ-Parameter in
+eckigen Klammern deklariert werden. Das folgende Beispiel demonstriert dies:
+
+ object PolyTest extends App {
+ def dup[T](x: T, n: Int): List[T] =
+ if (n == 0)
+ Nil
+ else
+ x :: dup(x, n - 1)
+
+ println(dup[Int](3, 4))
+ println(dup("three", 3))
+ }
+
+Die Methode `dup` des Objektes `PolyTest` ist im Typ `T` sowie den Parametern `x: T` und `n: Int`
+parametrisiert. Wenn die Methode `dup` aufgerufen wird, können Typ-Parameter einerseits explizit
+angegeben werden, wie in Zeile 8, andererseits kann man sie auslassen, wie in Zeile 9, und von
+Scalas Typ-System inferieren lassen. Diese inferierten Typen stammen von den Typen der übergebenen
+Argumente, in obigem Beispiel der Wert `"three"` vom Typ `String`.
+
+Zu bemerken ist, dass der Trait `App` dafür entwickelt worden ist, kurze Testprogramme zu schreiben,
+jedoch für wirklich produktiv gehenden Quellcode der Scala Versionen 2.8.x und früher vermieden
+werden sollte. An dessen Stelle sollte die Methode `main` verwendet werden.
+
@@ -1,6 +1,6 @@
---
layout: overview-large
-title: Configuring Parallel Collections
+title: Configurando las colecciones paralelas
disqus: true
@@ -9,29 +9,28 @@ num: 7
language: es
---
-## Task support
+## "Task support"
-Parallel collections are modular in the way operations are scheduled. Each
-parallel collection is parametrized with a task support object which is
-responsible for scheduling and load-balancing tasks to processors.
+Las colecciones paralelas son modulares respecto al modo en que las operaciones
+son planificadas. Cada colección paralela es planificada con un objeto "task support"
+el cual es responsable de la planificación y el balanceo de las tareas a los
+distintos procesadores.
-The task support object internally keeps a reference to a thread pool
-implementation and decides how and when tasks are split into smaller tasks. To
-learn more about the internals of how exactly this is done, see the tech
-report \[[1][1]\].
+El objeto "task support" mantiene internamente un referencia a un pool de hilos y decide
+cómo y cuando las tareas son divididas en tareas más pequeñas. Para conocer más en detalle
+cómo funciona internamente diríjase al informe técnico \[[1][1]\].
-There are currently a few task support implementations available for parallel
-collections. The `ForkJoinTaskSupport` uses a fork-join pool internally and is
-used by default on JVM 1.6 or greater. The less efficient
-`ThreadPoolTaskSupport` is a fallback for JVM 1.5 and JVMs that do not support
-the fork join pools. The `ExecutionContextTaskSupport` uses the default
-execution context implementation found in `scala.concurrent`, and it reuses
-the thread pool used in `scala.concurrent` (this is either a fork join pool or
-a thread pool executor, depending on the JVM version). The execution context
-task support is set to each parallel collection by default, so parallel
-collections reuse the same fork-join pool as the future API.
+En la actualidad las colecciones paralelas disponen de unas cuantas implementaciones de
+"task support". El `ForkJoinTaskSupport` utiliza internamente un fork-join pool y es utilizado
+por defecto en JVM 1.6 o superiores. `ThreadPoolTaskSupport`, menos eficiente, es utilizado como
+mecanismo de reserva para JVM 1.5 y máquinas virtuales que no soporten los fork join pools. El
+`ExecutionContextTaskSupport` utiliza el contexto de ejecución por defecto que viene definido
+en `scala.concurrent`, y reutiliza el thread pool utilizado en dicho paquete (podrá ser un fork
+join pool o un thread pool executor dependiendo de la versión de la JVM). El "task support" basado
+en el contexto de ejecución es establecido en cada una de las colecciones paralelas por defecto, de modo
+que dichas colecciones reutilizan el mismo fork-join pool del mismo modo que el API de las "futures".
-Here is a way to change the task support of a parallel collection:
+A continuación se muestra cómo se puede modificar el objeto "task support" de una colección paralela:
scala> import scala.collection.parallel._
import scala.collection.parallel._
@@ -45,37 +44,37 @@ Here is a way to change the task support of a parallel collection:
scala> pc map { _ + 1 }
res0: scala.collection.parallel.mutable.ParArray[Int] = ParArray(2, 3, 4)
-The above sets the parallel collection to use a fork-join pool with
-parallelism level 2. To set the parallel collection to use a thread pool
-executor:
+El fragmento de código anterior determina que la colección paralela utilice un fork-join pool con un nivel 2 de
+paralelismo. Para indicar que la colección utilice un thread pool executor tendremos que hacerlo del siguiente modo:
scala> pc.tasksupport = new ThreadPoolTaskSupport()
pc.tasksupport: scala.collection.parallel.TaskSupport = scala.collection.parallel.ThreadPoolTaskSupport@1d914a39
scala> pc map { _ + 1 }
res1: scala.collection.parallel.mutable.ParArray[Int] = ParArray(2, 3, 4)
-When a parallel collection is serialized, the task support field is omitted
-from serialization. When deserializing a parallel collection, the task support
-field is set to the default value-- the execution context task support.
+Cuando una colección paralela es serializada, el atributo que almacena la referencia
+al objeto "task support" es omitido en el proceso de serialización. Cuando una colección
+paralela es deserializada, dicho atributo toma el valor por defecto -- el objeto "task support"
+basado en el contexto de ejecución.
-To implement a custom task support, extend the `TaskSupport` trait and
-implement the following methods:
+Para llevar a cabo una implementación personalizada de un nuevo objeto "task support" necesitamos
+extender del trait `TaskSupport` e implementar los siguientes métodos:
def execute[R, Tp](task: Task[R, Tp]): () => R
def executeAndWaitResult[R, Tp](task: Task[R, Tp]): R
def parallelismLevel: Int
-The `execute` method schedules a task asynchronously and returns a future to
-wait on the result of the computation. The `executeAndWait` method does the
-same, but only returns when the task is completed. The `parallelismLevel`
-simply returns the targeted number of cores that the task support uses to
-schedule tasks.
+El método `execute` planifica una tarea asíncrona y retorna una "future" sobre la que
+esperar el resultado de la computación. El método `executeAndWait` lleva a cabo el mismo
+trabajo, pero retorna única y exclusivamente una vez la tarea haya finalizado. `parallelismLevel`
+simplemente retorna el número de núcleos que el objeto "task support" utiliza para planificar
+las diferentes tareas.
-## References
+## Referencias
1. [On a Generic Parallel Collection Framework, June 2011][1]
@@ -1,68 +1,65 @@
---
layout: overview-large
-title: Parallel Collection Conversions
-
+title: Conversiones en colecciones paralelas
disqus: true
partof: parallel-collections
num: 3
language: es
---
-## Converting between sequential and parallel collections
+## Conversiones entre colecciones secuenciales y paralelas
-Every sequential collection can be converted to its parallel variant
-using the `par` method. Certain sequential collections have a
-direct parallel counterpart. For these collections the conversion is
-efficient-- it occurs in constant time, since both the sequential and
-the parallel collection have the same data-structural representation
-(one exception is mutable hash maps and hash sets which are slightly
-more expensive to convert the first time `par` is called, but
-subsequent invocations of `par` take constant time). It should be
-noted that for mutable collections, changes in the sequential collection are
-visible in its parallel counterpart if they share the underlying data-structure.
+Cada una de las colecciones secuenciales puede convertirse es su versión
+paralela mediante la utilización del método `par`. Determinadas colecciones
+secuenciales disponen de una versión homóloga paralela. Para estas colecciones el
+proceso de conversión es eficiente -- ocurre en tiempo constante dado que ambas
+versiones utilizan la misma estructura de datos interna. Una excepción al caso
+anterior es el caso de los hash maps y hash sets mutables, donde el proceso de
+conversión es un poco más costoso la primera vez que el método `par` es llamado,
+aunque las posteriores invocaciones de dicho método ofrecerán un tiempo de ejecución
+constante. Nótese que en el caso de las colecciones mutables, los cambios en la
+colección secuencial son visibles en su homóloga paralela en el caso de que compartan
+la estructura de datos subyacente.
-| Sequential | Parallel |
+| Secuencial | Paralelo |
| ------------- | -------------- |
| **mutable** | |
| `Array` | `ParArray` |
| `HashMap` | `ParHashMap` |
| `HashSet` | `ParHashSet` |
| `TrieMap` | `ParTrieMap` |
-| **immutable** | |
+| **inmutable** | |
| `Vector` | `ParVector` |
| `Range` | `ParRange` |
| `HashMap` | `ParHashMap` |
| `HashSet` | `ParHashSet` |
-Other collections, such as lists, queues or streams, are inherently sequential
-in the sense that the elements must be accessed one after the other. These
-collections are converted to their parallel variants by copying the elements
-into a similar parallel collection. For example, a functional list is
-converted into a standard immutable parallel sequence, which is a parallel
-vector.
-
-Every parallel collection can be converted to its sequential variant
-using the `seq` method. Converting a parallel collection to a
-sequential collection is always efficient-- it takes constant
-time. Calling `seq` on a mutable parallel collection yields a
-sequential collection which is backed by the same store-- updates to
-one collection will be visible in the other one.
+Otro tipo de colecciones, como las listas, colas o `streams`, son inherentemente
+secuenciales en el sentido de que los elementos deben ser accedidos uno tras otro.
+La versión paralela de estas estructuras se obtiene mediante la copia de los elementos
+en una colección paralela. Por ejemplo, una lista funcional es convertida en una
+secuencia paralela inmutable; un vector paralelo.
+Cada colección paralela puede ser convertida a su variante secuencial mediante el uso
+del método `seq`. La conversión de una colección paralela a su homóloga secuencial es
+siempre un proceso eficiente -- tiempo constante. La invocación del método `seq` sobre
+una colección paralela mutable retorna una colección secuencial cuya representación interna
+es la misma que la de la versión paralela, por lo que posibles actualizaciones en una de las
+colecciones serán visibles en la otra.
-## Converting between different collection types
+## Conversiones entre diferentes tipo de colecciones
-Orthogonal to converting between sequential and parallel collections,
-collections can be converted between different collection types. For
-example, while calling `toSeq` converts a sequential set to a
-sequential sequence, calling `toSeq` on a parallel set converts it to
-a parallel sequence. The general rule is that if there is a
-parallel version of `X`, then the `toX` method converts the collection
-into a `ParX` collection.
+Ortogonal a la conversión entre colecciones secuenciales y paralelas, las colecciones
+pueden convertirse entre diferentes tipos. Por ejemplo, la llamada al método `toSeq`
+convierte un conjunto secuencial en una secuencia secuencial, mientras que si invocamos
+dicho método sobre un conjunto paralelo obtendremos una secuencia paralela. La regla
+general is que si existe una versión paralela de `X`, el método `toX` convierte la colección
+en una colección `ParX`
-Here is a summary of all conversion methods:
+A continuación se muestra un resumen de todos los métodos de conversión:
-| Method | Return Type |
+| método | Tipo de Retorno|
| -------------- | -------------- |
| `toArray` | `Array` |
| `toList` | `List` |
Oops, something went wrong.

0 comments on commit 6e72349

Please sign in to comment.