Skip to content

Commit 5a2d143

Browse files
geovannymcodepivovarit
geovannymcode
authored and
pivovarit
committed
V[0.0.1] documentation translated into Spanish
1 parent 280c24e commit 5a2d143

File tree

4 files changed

+289
-28
lines changed

4 files changed

+289
-28
lines changed

‎src/docs/asciidoc/es/index_es.adoc

+2-2
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,6 @@ include::getting_started_es.adoc[]
1616

1717
include::usage_guide_es.adoc[]
1818

19-
#include::pattern_matching.adoc[]
19+
include::pattern_matching_es.adoc[]
2020

21-
#include::license.adoc[]
21+
include::license_es.adoc[]

‎src/docs/asciidoc/es/license_es.adoc

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
== License
2+
3+
Copyright 2014-2018 Vavr, http://vavr.io
4+
5+
Licenciado bajo la Licencia Apache, Versión 2.0 (la "Licencia");
6+
no puedes usar este archivo excepto en cumplimiento con la Licencia.
7+
Puedes obtener una copia de la Licencia en:
8+
9+
http://www.apache.org/licenses/LICENSE-2.0
10+
11+
A menos que lo exija la ley aplicable o se acuerde por escrito, el software distribuido bajo la Licencia se distribuye "TAL CUAL",
12+
SIN GARANTÍAS O CONDICIONES DE NINGÚN TIPO, ya sean expresas o implícitas.
13+
Consulta la Licencia para conocer los permisos y las limitaciones bajo la Licencia.

‎src/docs/asciidoc/es/pattern_matching_es.adoc

+248
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,248 @@
1+
=== Pattern Matching
2+
3+
SScala tiene coincidencia de patrones (__pattern matching__) nativa, una de las ventajas sobre el Java __**puro**__. The basic syntax is close to Java'sLa sintaxis básica es similar al `switch` de Java:
4+
5+
[source,java]
6+
----
7+
val s = i match {
8+
case 1 => "one"
9+
case 2 => "two"
10+
case _ => "?"
11+
}
12+
----
13+
14+
Notablemente, __match__ es una expresión, lo que significa que produce un resultado. Además, ofrece:
15+
16+
* Parámetros nombrados: ``case i: Int => "Int " + i``
17+
* Desestructuración de objetos: ``case Some(i) => i``
18+
* Condiciones de guarda (guards): ``case Some(i) if i > 0 => "positive " + i``
19+
* Múltiples condiciones: ``case "-h" | "--help" => displayHelp``
20+
* Verificaciones en tiempo de compilación para exhaustividad
21+
22+
El __**Pattern matching**__ es una gran característica que nos ahorra escribir cadenas de ramas `if-then-else`. Reduce la cantidad de código mientras se enfoca en las partes relevantes.
23+
24+
==== Fundamentos de Match para Java
25+
26+
Vavr proporciona una API de coincidencia (__match__) que es similar a la de Scala. Se habilita agregando el siguiente import a nuestra aplicación:
27+
28+
[source,java]
29+
----
30+
import static io.vavr.API.*;
31+
----
32+
33+
Teniendo los métodos estáticos __Match__, __Case__ y los __patrones atómicos (__atomic patterns__)__
34+
35+
* ``$()`` - patrón comodín (__wildcard__)
36+
* ``$(value)`` - patrón de igualdad
37+
* ``$(predicate)`` - patrón condicional
38+
39+
En el alcance, el ejemplo inicial de Scala puede expresarse de esta manera:
40+
41+
[source,java]
42+
----
43+
String s = Match(i).of(
44+
Case($(1), "one"),
45+
Case($(2), "two"),
46+
Case($(), "?")
47+
);
48+
----
49+
50+
⚡ Usamos nombres de métodos en mayúsculas uniformes porque 'case' es una palabra clave en Java. Esto hace que la API sea especial.
51+
52+
===== Exhaustividad (__Exhaustiveness__)
53+
54+
El último patrón comodín (__wildcard__) ``$()`` nos protege de un `MatchError`, que se lanza si ningún caso coincide.
55+
56+
Debido a que no podemos realizar verificaciones de exhaustividad como lo hace el compilador de Scala, ofrecemos la posibilidad de devolver un resultado opcional:
57+
58+
[source,java]
59+
----
60+
Option<String> s = Match(i).option(
61+
Case($(0), "zero")
62+
);
63+
----
64+
65+
===== Syntactic Sugar (__Azúcar Sintáctico__)
66+
67+
Como se mostró anteriormente, ``Case`` permite coincidir con patrones condicionales.
68+
69+
[source,java]
70+
----
71+
Case($(predicate), ...)
72+
----
73+
74+
Vavr ofrece un conjunto de predicados predeterminados.
75+
76+
[source,java]
77+
----
78+
import static io.vavr.Predicates.*;
79+
----
80+
81+
Estos pueden usarse para expresar el ejemplo inicial de Scala de la siguiente manera:
82+
83+
[source,java]
84+
----
85+
String s = Match(i).of(
86+
Case($(is(1)), "one"),
87+
Case($(is(2)), "two"),
88+
Case($(), "?")
89+
);
90+
----
91+
92+
**Condiciones Múltiples**
93+
94+
Usamos el predicado ``isIn`` para verificar múltiples condiciones:
95+
96+
[source,java]
97+
----
98+
Case($(isIn("-h", "--help")), ...)
99+
----
100+
101+
**Realizando Efectos Secundarios**
102+
103+
`Match` actúa como una expresión y produce un valor. Para realizar efectos secundarios (__side-effects__), necesitamos usar la función auxiliar ``run`` que devuelve ``Void``:
104+
105+
[source,java]
106+
----
107+
Match(arg).of(
108+
Case($(isIn("-h", "--help")), o -> run(this::displayHelp)),
109+
Case($(isIn("-v", "--version")), o -> run(this::displayVersion)),
110+
Case($(), o -> run(() -> {
111+
throw new IllegalArgumentException(arg);
112+
}))
113+
);
114+
----
115+
116+
⚡ ``run`` se utiliza para evitar ambigüedades y porque ``void`` no es un valor de retorno válido en Java.
117+
118+
*Precaución:* ``run`` no debe usarse como valor de retorno directo, es decir, fuera del cuerpo de una lambda:
119+
120+
[source,java]
121+
----
122+
// Incorrecto
123+
Case($(isIn("-h", "--help")), run(this::displayHelp))
124+
----
125+
126+
De lo contrario, los `Case` se evaluarán de forma anticipada __antes__ de que los patrones sean comparados, lo que rompe toda la expresión `Match`. En su lugar, se debe usar dentro del cuerpo de una lambda:
127+
128+
[source,java]
129+
----
130+
// Correcto
131+
Case($(isIn("-h", "--help")), o -> run(this::displayHelp))
132+
----
133+
134+
Como podemos ver, ``run`` es propenso a errores si no se usa correctamente. Ten cuidado. Estamos considerando marcarlo como obsoleto en una versión futura y, tal vez, proporcionar una mejor API para realizar efectos secundarios.
135+
136+
===== Parámetros Nombrados
137+
138+
Vavr aprovecha las lambdas para proporcionar parámetros nombrados para los valores coincidentes.
139+
140+
[source,java]
141+
----
142+
Number plusOne = Match(obj).of(
143+
Case($(instanceOf(Integer.class)), i -> i + 1),
144+
Case($(instanceOf(Double.class)), d -> d + 1),
145+
Case($(), o -> { throw new NumberFormatException(); })
146+
);
147+
----
148+
149+
Hasta ahora, hemos coincidido valores directamente utilizando patrones atómicos. Si un patrón atómico coincide, el tipo correcto del objeto coincidente se infiere del contexto del patrón.
150+
151+
A continuación, exploraremos patrones recursivos que pueden coincidir con gráficos de objetos de profundidad (teóricamente) arbitraria.
152+
153+
===== Descomposición de Objetos
154+
155+
En Java usamos constructores para instanciar clases. Entendemos la __descomposición de objetos__ como la destrucción de objetos en sus partes.
156+
157+
Mientras que un constructor es una __función__ que se __aplica__ a los argumentos y devuelve una nueva instancia, un deconstructor es una función que toma una instancia y devuelve sus partes. Decimos que un objeto está __descompuesto__.
158+
159+
La destrucción de objetos no necesariamente es una operación única. Por ejemplo, un `LocalDate` puede descomponerse en:
160+
161+
* Los componentes de año, mes y día.
162+
* El valor `long` que representa los milisegundos desde la época de un `Instant` correspondiente.
163+
* etc.
164+
165+
==== Patrones
166+
167+
En Vavr usamos patrones para definir cómo se deconstruye una instancia de un tipo específico. Estos patrones pueden usarse junto con la API de coincidencia (`Match`).
168+
169+
===== Patrones Predefinidos
170+
171+
Para muchos tipos de Vavr ya existen patrones de coincidencia predefinidos. Estos se importan mediante
172+
173+
[source,java]
174+
----
175+
import static io.vavr.Patterns.*;
176+
----
177+
178+
Por ejemplo, ahora podemos coincidir con el resultado de un `Try`:
179+
180+
[source,java]
181+
----
182+
Match(_try).of(
183+
Case($Success($()), value -> ...),
184+
Case($Failure($()), x -> ...)
185+
);
186+
----
187+
188+
⚡ Un primer prototipo de la API de coincidencia (`Match`) de Vavr permitía extraer una selección definida por el usuario de objetos a partir de un patrón de coincidencia. Sin el soporte adecuado del compilador, esto no es práctico porque el número de métodos generados crecía exponencialmente. La API actual hace un compromiso: todos los patrones se coinciden, pero solo los patrones raíz son __descompuestos__.
189+
190+
[source,java]
191+
----
192+
Match(_try).of(
193+
Case($Success($Tuple2($("a"), $())), tuple2 -> ...),
194+
Case($Failure($(instanceOf(Error.class))), error -> ...)
195+
);
196+
----
197+
198+
Aquí los patrones raíz son `Success` y `Failure`. Estos se descomponen en `Tuple2` y `Error`, teniendo los tipos genéricos correctos.
199+
200+
⚡ Los tipos profundamente anidados se infieren según el argumento de `Match` y __**not**__ según los patrones coincidentes.
201+
202+
===== Patrones Definidos por el Usuario
203+
204+
Es esencial poder descomponer objetos arbitrarios, incluidas las instancias de clases finales. Vavr hace esto de forma declarativa al proporcionar las anotaciones en tiempo de compilación ``@Patterns`` y ``@Unapply``.
205+
206+
Para habilitar el procesador de anotaciones, el artefacto http://search.maven.org/#search%7Cga%7C1%7Cvavr-match[vavr-match] debe añadirse como dependencia del proyecto.
207+
208+
⚡ Nota: Por supuesto, los patrones pueden implementarse directamente sin usar el generador de código. Para más información, consulta el código fuente generado.
209+
210+
[source,java]
211+
----
212+
import io.vavr.match.annotation.*;
213+
214+
@Patterns
215+
class My {
216+
217+
@Unapply
218+
static <T> Tuple1<T> Optional(java.util.Optional<T> optional) {
219+
return Tuple.of(optional.orElse(null));
220+
}
221+
}
222+
----
223+
224+
El procesador de anotaciones coloca un archivo `MyPatterns` en el mismo paquete (por defecto en `target/generated-sources`). También se admiten clases internas. Caso especial: si el nombre de la clase es `$`, el nombre de la clase generada será simplemente `Patterns`, sin prefijo.
225+
226+
===== Guardas (__Guards__)
227+
228+
Ahora podemos coincidir con objetos `Optionals` utilizando __guards__.
229+
230+
[source,java]
231+
----
232+
Match(optional).of(
233+
Case($Optional($(v -> v != null)), "defined"),
234+
Case($Optional($(v -> v == null)), "empty")
235+
);
236+
----
237+
238+
Los predicados podrían simplificarse implementando ``isNull`` y ``isNotNull``.
239+
240+
⚡ ¡Y sí, extraer un `null` es extraño! En lugar de usar el `Optional` de Java, prueba con la `Option` de Vavr.
241+
242+
[source,java]
243+
----
244+
Match(option).of(
245+
Case($Some($()), "defined"),
246+
Case($None(), "empty")
247+
);
248+
----

‎src/docs/asciidoc/es/usage_guide_es.adoc

+26-26
Original file line numberDiff line numberDiff line change
@@ -315,27 +315,27 @@ Ejemplo: Obtenemos los campos `name` y `age` de un formulario web y queremos cre
315315
include::../../../test/java/io/vavr/ValidationDemo.java[tags=validatePerson]
316316
----
317317

318-
A valid value is contained in a `Validation.Valid` instance, a list of validation errors is contained in a `Validation.Invalid` instance.
318+
Un valor válido está contenido en una instancia de `Validation.Valid`, mientras que una lista de errores de validación está contenida en una instancia de `Validation.Invalid`.
319319

320-
The following validator is used to combine different validation results to one `Validation` instance.
320+
El siguiente validador se utiliza para combinar diferentes resultados de validación en una sola instancia de `Validation`.
321321

322322
----
323323
include::../../../test/java/io/vavr/ValidationDemo.java[tags=personValidator]
324324
----
325325

326-
If the validation succeeds, i.e. the input data is valid, then an instance of `Person` is created of the given fields `name` and `age`.
326+
Si la validación tiene éxito, es decir, si los datos de entrada son válidos, entonces se crea una instancia de `Person` con los campos `name` y `age` proporcionados.
327327

328328
----
329-
include::../../test/java/io/vavr/ValidationDemo.java[tags=person]
329+
include::../../../test/java/io/vavr/ValidationDemo.java[tags=person]
330330
----
331331

332-
=== Collections
332+
=== Colecciones
333333

334-
Much effort has been put into designing an all-new collection library for Java which meets the requirements of functional programming, namely immutability.
334+
Se ha dedicado mucho esfuerzo a diseñar una biblioteca de colecciones completamente nueva para Java que cumpla con los requisitos de la programación funcional, especialmente la inmutabilidad.
335335

336-
Java's Stream lifts a computation to a different layer and links to a specific collection in another explicit step. With Vavr we don't need all this additional boilerplate.
336+
El `Stream` de Java eleva una computación a una capa diferente y se vincula a una colección específica en otro paso explícito. Con Vavr, no necesitamos todo este código adicional repetitivo (__boilerplate__).
337337

338-
The new collections are based on http://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html[java.lang.Iterable], so they leverage the sugared iteration style.
338+
Las nuevas colecciones están basadas en http://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html[java.lang.Iterable], lo que permite aprovechar un estilo de iteración simplificado.
339339

340340
[source,java]
341341
----
@@ -345,11 +345,11 @@ for (double random : Stream.continually(Math::random).take(1000)) {
345345
}
346346
----
347347

348-
`TraversableOnce` has a huge amount of useful functions to operate on the collection. Its API is similar to http://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html[java.util.stream.Stream] but more mature.
348+
`TraversableOnce` tiene una gran cantidad de funciones útiles para operar en la colección. Su API es similar a http://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html[java.util.stream.Stream], pero es más madura.
349349

350350
==== List
351351

352-
Vavr's `List` is an immutable linked list. Mutations create new instances. Most operations are performed in linear time. Consequent operations are executed one by one.
352+
La `List` de Vavr es una lista enlazada inmutable. Las mutaciones crean nuevas instancias. La mayoría de las operaciones se realizan en tiempo lineal. Las operaciones consecutivas se ejecutan una por una.
353353

354354
===== Java 8
355355

@@ -373,19 +373,19 @@ List.of(1, 2, 3).sum();
373373

374374
==== Stream
375375

376-
The `io.vavr.collection.Stream` implementation is a lazy linked list. Values are computed only when needed. Because of its laziness, most operations are performed in constant time. Operations are intermediate in general and executed in a single pass.
376+
La implementación de `io.vavr.collection.Stream` es una lista enlazada perezosa (lazy). Los valores se calculan solo cuando se necesitan. Debido a su naturaleza perezosa, la mayoría de las operaciones se realizan en tiempo constante. En general, las operaciones son intermedias y se ejecutan en una sola pasada.
377377

378-
The stunning thing about streams is that we can use them to represent sequences that are (theoretically) infinitely long.
378+
Lo sorprendente de los streams es que podemos usarlos para representar secuencias que son (teóricamente) infinitamente largas.
379379

380380
[source,java]
381381
----
382382
// 2, 4, 6, ...
383383
Stream.from(1).filter(i -> i % 2 == 0);
384384
----
385385

386-
==== Performance Characteristics
386+
==== Características de Rendimiento
387387

388-
.Time Complexity of Sequential Operations
388+
.Complejidad Temporal de las Operaciones Secuenciales
389389
[width="100%",frame="topbot",options="header"]
390390
|====================================================================================================
391391
| | head() | tail() | get(int) | update(int, T) | prepend(T) | append(T)
@@ -399,7 +399,7 @@ Stream.from(1).filter(i -> i % 2 == 0);
399399
| Vector | const^eff^ | const^eff^ | const ^eff^ | const ^eff^ | const ^eff^ | const ^eff^
400400
|====================================================================================================
401401

402-
.Time Complexity of Map/Set Operations
402+
.Complejidad Temporal de las Operaciones en Map/Set
403403
[width="100%",frame="topbot",options="header"]
404404
|=================================================================
405405
| | contains/Key | add/put | remove | min
@@ -412,20 +412,20 @@ Stream.from(1).filter(i -> i % 2 == 0);
412412
| TreeSet | log | log | log | log
413413
|=================================================================
414414

415-
Legend:
415+
Leyenda:
416416

417-
* const &mdash; constant time
418-
* const^a^ &mdash; amortized constant time, few operations may take longer
419-
* const^eff^ &mdash; effectively constant time, depending on assumptions like distribution of hash keys
420-
* const^lazy^ &mdash; lazy constant time, the operation is deferred
421-
* log &mdash; logarithmic time
422-
* linear &mdash; linear time
417+
* const &mdash; tiempo constante.
418+
* const^a^ &mdash; tiempo constante amortizado, algunas operaciones pueden tomar más tiempo.
419+
* const^eff^ &mdash; tiempo efectivamente constante, dependiendo de suposiciones como la distribución de claves hash.
420+
* const^lazy^ &mdash; tiempo constante perezoso (__lazy__), la operación se difiere.
421+
* log &mdash; tiempo logarítmico.
422+
* linear &mdash; tiempo lineal.
423423

424-
=== Property Checking
424+
=== Verificación de Propiedades
425425

426-
Property checking (also known as http://en.wikipedia.org/wiki/Property_testing[property testing]) is a truly powerful way to test properties of our code in a functional way. It is based on generated random data, which is passed to a user defined check function.
426+
La verificación de propiedades (también conocida como http://en.wikipedia.org/wiki/Property_testing[pruebas de propiedades]) es una forma realmente poderosa de probar propiedades de nuestro código de manera funcional. Se basa en la generación de datos aleatorios, que se pasan a una función de verificación definida por el usuario.
427427

428-
Vavr has property testing support in its `io.vavr:vavr-test` module, so make sure to include that in order to use it in your tests.
428+
Vavr admite pruebas de propiedades en su módulo `io.vavr:vavr-test`, por lo que asegúrate de incluirlo para usarlo en tus pruebas.
429429

430430
[source,java]
431431
----
@@ -439,4 +439,4 @@ Property.def("square(int) >= 0")
439439
.assertIsSatisfied();
440440
----
441441

442-
Generators of complex data structures are composed of simple generators.
442+
Los generadores de estructuras de datos complejas se componen de generadores simples.

0 commit comments

Comments
 (0)