sábado, 16 de diciembre de 2017

Primeros pasos con F#

Si bien hemos hablado de F# en el blog nunca hice un post del lenguaje en si, bueno vamos a cambiar eso.

Si vamos a la pagina de F# nos dira que es un lenguaje open source, multiplataforma y funcional. Capaz de resolver problemas complejos de forma simple.

Por que utilizar o aprender F#?

  • Concisión. F # no está lleno de "ruido" de codificación, como llaves, punto y coma, etc. Casi nunca tiene que especificar el tipo de un objeto, gracias a un potente sistema de inferencia de tipo. Y generalmente requiere menos líneas de código para resolver el mismo problema.
  • Conveniente. Muchas tareas de programación comunes son mucho más simples en F#. Esto incluye cosas como crear y usar definiciones de tipos complejos, hacer el procesamiento de listas, comparación e igualdad, máquinas de estado y mucho más. Y debido a que las funciones son objetos de primera clase, es muy fácil crear código poderoso y reutilizable creando funciones que tienen otras funciones como parámetros, o que combinan funciones existentes para crear nuevas funcionalidades.
  • Exactitud. F# tiene un sistema de tipo muy poderoso que evita muchos errores comunes, como las excepciones de referencia nula. Además, a menudo puede codificar la lógica de negocios utilizando el sistema de tipo en sí, de modo que es realmente imposible escribir código incorrecto, porque se detecta en tiempo de compilación como un error de tipo.
  • Concurrencia: F# tiene una serie de herramientas y bibliotecas integradas para ayudar con los sistemas de programación cuando ocurre más de una cosa a la vez. La programación asincrónica es directamente compatible, como lo es el paralelismo. F# también tiene un sistema de cola de mensajes y un excelente soporte para el manejo de eventos y programación reactiva. Y debido a que las estructuras de datos son inmutables por defecto, compartir estado y evitar bloqueos es mucho más fácil.
  • Completo. Aunque F # es un lenguaje funcional de corazón, admite otros estilos que no son 100% puros, lo que facilita mucho la interacción con el mundo no puro de sitios web, bases de datos, otras aplicaciones, etc. En particular, F# está diseñado como un lenguaje híbrido funcional / OO, por lo que puede hacer casi todo lo que C# puede hacer también. Por supuesto, F# se integra sin problemas con el ecosistema .NET, que le da acceso a todas las herramientas y bibliotecas .NET de terceros. Finalmente, es parte de Visual Studio, lo que significa que obtiene un buen editor con soporte IntelliSense, un depurador y muchos complementos para pruebas unitarias, control de código fuente y otras tareas de desarrollo.


Aquí hay una descripción general muy rápida sobre cómo leer el código F# para los recién llegados que no estén familiarizados con la sintaxis. La sintaxis F# es muy clara y directa cuando te acostumbras. En muchos sentidos, es más simple que la sintaxis C#, con menos palabras clave y casos especiales.

El siguiente código de ejemplo es un script sencillo de F # que muestra la mayoría de los conceptos que necesita de forma regular.

// single line comments use a double slash
(* multi line comments use (* . . . *) pair -end of multi line comment- *)

// ======== "Variables" (but not really) ==========
// The "let" keyword defines an (immutable) value
let myInt = 5
let myFloat = 3.14
let myString = "hello" //note that no types needed

// ======== Lists ============
let twoToFive = [2;3;4;5]        // Square brackets create a list with
                                 // semicolon delimiters.
let oneToFive = 1 :: twoToFive   // :: creates list with new 1st element
// The result is [1;2;3;4;5]
let zeroToFive = [0;1] @ twoToFive   // @ concats two lists

// IMPORTANT: commas are never used as delimiters, only semicolons!

// ======== Functions ========
// The "let" keyword also defines a named function.
let square x = x * x          // Note that no parens are used.
square 3                      // Now run the function. Again, no parens.

let add x y = x + y           // don't use add (x,y)! It means something
                              // completely different.
add 2 3                       // Now run the function.

// to define a multiline function, just use indents. No semicolons needed.
let evens list =
   let isEven x = x%2 = 0     // Define "isEven" as an inner ("nested") function
   List.filter isEven list    // List.filter is a library function
                              // with two parameters: a boolean function
                              // and a list to work on

evens oneToFive               // Now run the function

// You can use parens to clarify precedence. In this example,
// do "map" first, with two args, then do "sum" on the result.
// Without the parens, "List.map" would be passed as an arg to List.sum
let sumOfSquaresTo100 =
   List.sum ( List.map square [1..100] )

// You can pipe the output of one operation to the next using "|>"
// Here is the same sumOfSquares function written using pipes
let sumOfSquaresTo100piped =
   [1..100] |> List.map square |> List.sum  // "square" was defined earlier

// you can define lambdas (anonymous functions) using the "fun" keyword
let sumOfSquaresTo100withFun =
   [1..100] |> List.map (fun x->x*x) |> List.sum

// In F# returns are implicit -- no "return" needed. A function always
// returns the value of the last expression used.

// ======== Pattern Matching ========
// Match..with.. is a supercharged case/switch statement.
let simplePatternMatch =
   let x = "a"
   match x with
    | "a" -> printfn "x is a"
    | "b" -> printfn "x is b"
    | _ -> printfn "x is something else"   // underscore matches anything

// Some(..) and None are roughly analogous to Nullable wrappers
let validValue = Some(99)
let invalidValue = None

// In this example, match..with matches the "Some" and the "None",
// and also unpacks the value in the "Some" at the same time.
let optionPatternMatch input =
   match input with
    | Some i -> printfn "input is an int=%d" i
    | None -> printfn "input is missing"

optionPatternMatch validValue
optionPatternMatch invalidValue

// ========= Complex Data Types =========

// Tuple types are pairs, triples, etc. Tuples use commas.
let twoTuple = 1,2
let threeTuple = "a",2,true

// Record types have named fields. Semicolons are separators.
type Person = {First:string; Last:string}
let person1 = {First="john"; Last="Doe"}

// Union types have choices. Vertical bars are separators.
type Temp =
| DegreesC of float
| DegreesF of float
let temp = DegreesF 98.6

// Types can be combined recursively in complex ways.
// E.g. here is a union type that contains a list of the same type:
type Employee =
  | Worker of Person
  | Manager of Employee list
let jdoe = {First="John";Last="Doe"}
let worker = Worker jdoe

// ========= Printing =========
// The printf/printfn functions are similar to the
// Console.Write/WriteLine functions in C#.
printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
printfn "A string %s, and something generic %A" "hello" [1;2;3;4]

// all complex types have pretty printing built in
printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
         twoTuple person1 temp worker

// There are also sprintf/sprintfn functions for formatting data
// into a string, similar to String.Format.


Dejo link:




miércoles, 13 de diciembre de 2017

Entrando en .NET Core con the Windows Compatibility Pack


Una de las mayores diferencias entre .net y .net core es que este ultimo corre en Linux. Pero para aplicaciones de grandes empresas, realizar una migración en un solo paso no es factible. Por este motivo, Microsoft recomienda una transición incremental:

Migrar a ASP.NET Core
Migrar a .NET Core
Migrar a Linux
Y luego Migrar a Azure (host en linux)

Si bien eso suena bien en teoría, si falta una API crítica los proyectos no llegarán ni al paso 2. En este caso es donde entra en juego he Windows Compatibility Pack para .NET Core. Abarcando 20,000 APIs, esta colección de paquetes .net tiene como objetivo abordar las necesidades de la librerías para los desarrolladores de aplicaciones web.

Las API recientemente portadas se dividen aproximadamente en dos categorías: solo Windows y multiplataforma. Las API solo de Windows incluyen:

  • Active directory
  • Criptografia
  • Registros de eventos y contadores de rendimiento
  • File system security
  • Named pipes
  • Registry Access
  • Windows Services


En su mayor parte, están relacionados con el sistema operativo Windows, y los equivalentes de Linux a menudo tienen un diseño diferente.

Las bibliotecas multiplataforma incluyen:

  • Caching
  • ConfigurationManager 
  • DatasetExtensions (usado para acceso a base de datos sin un ORM) 
  • ODBC database access
  • System.Configuration.ConfigurationManager (MEF v1)
  • System.Drawing
  • System.IO.Packaging 
  • System.ServiceModel (i.e. WCF)
Cabe señalar que estas API se están omitiendo intencionalmente de la distribución .NET Core completa. 



lunes, 11 de diciembre de 2017

Un resumen de Scala for the Impatient, parte 33

Self type


Cuando un trait extiende de una clase, hay una garantía de que la superclase está presente en cualquier clase que se mezcle con el trait. Scala tiene un mecanismo alternativo para garantizar esto,  se denomina self type.

Cuando un trait comienza con :

this: Type =>

entonces solo se puede mezclar en una subclase del tipo dado.

trait LoggedException extends ConsoleLogger {
    this: Exception =>
    def log() { log(getMessage()) }
}

Note que el trait no extiende de Exception, en cambio, tiene un tipo propio Excepción. Eso significa que solo se puede mezclar en subclases de Excepción.

En los métodos del rasgo, podemos llamar a cualquier método del self type. Por ejemplo, la llamada a getMessage() en el método de registro es válida, ya que sabemos que debe ser un trait extendido por una excepción.

Como se puede suponer si una clase que no sea una Excepción quiere utilizar LoggedException eso no va a compilar.

También se puede utilizar type self con un método determinado, sin especificar una clase.

trait LoggedException extends ConsoleLogger {
    this: { def getMessage() : String } =>
        def log() { log(getMessage()) }
}

Por lo tanto este trait podrá mezclarse con cualquier clase que implemente getMessage() .

Que pasa en la jvm?

Scala necesita pasar un trait a una clase o interfaz java para que esto pueda ser comprendido por la JVM. Y es muy útil entender como trabajan los traits.

Un trait con todos los métodos abstractos es convertido a una interfaz. Un trait con un método es como una interfaz con un método por defecto:

trait ConsoleLogger {
    def log(msg: String) { println(msg) }
}

Se convierte:

public interface ConsoleLogger {
    default void log(String msg) { ... }
}

Si un trait tiene campos, es transformado a una interfaz con los métodos getters y setters:

trait ShortLogger extends Logger {
    val maxLength = 15 // A concrete field
    ...
}

es transformado a:

public interface ShortLogger extends Logger {
    int maxLength();
    void weird_prefix$maxLength_$eq(int);
    default void log(String msg) { ... } // Calls maxLength()
    default void $init$() { weird_prefix$maxLength_$eq(15); }
}

Por supuesto las interfaces en java no tienen campos, por lo que llama a los metodos getters o setters cuando quiera acceder o cambiar este valor. El setter es necesario tambien para inicializar el campo. Esto sucede en el método $init$.

Cuando el rasgo se mezcla en una clase, la clase obtiene un campo maxLength, y el getter y el setter se definen para obtener y establecer el campo. Los constructores de esa clase invocan el método $init$ del trait. Por ejemplo:

class SavingsAccount extends Account with ConsoleLogger with ShortLogger

seria en java:

public class SavingsAccount extends Account
 implements ConsoleLogger, ShortLogger {
   private int maxLength;
   public int maxLength() { return maxLength; }
   public void weird_prefix$maxLength_$eq(int arg) { maxLength = arg; }
 
   public SavingsAccount() {
      super();
      ConsoleLogger.$init$();
      ShortLogger.$init$();
   }
...
}

jueves, 7 de diciembre de 2017

Top 5 de libros sobre c++


Encontré un buen post sobre libros de c++, y yo justo necesito por lo tanto vamos a pegarle un repaso:

  • The C++ Programming Language, 4th Edition : Escrito por Bjarne Stroustrup es la biblia de c++ y la edición 4, nos enseña C++ 11
  • C++ Primer Plus (6th Edition) (Developer's Library) :Este libro es también uno de los libros populares de C ++, escrito por Stephen Prata. Es beneficioso tanto para estudiantes o programadores. 
  • Starting Out with C++ from Control Structures to Objects (9th Edition): Este libro es el mejor para los principiantes, está escrito por Tony Gaddis. El autor describe el concepto fundamental de una manera clara y fácil que hace que este libro sea amigable para los estudiantes.
  • Effective Modern C++ : Este es un excelente libro para el experimentado programador de C ++. El autor describe muy bien cómo escribir un software realmente genial usando C ++ 11 y C ++ 14 (C ++ moderno).
  • Accelerated C++: Practical Programming by Example: El libro es sorprendentemente pequeño, en menos de 300 páginas, los autores cubren muchas de las cosas. Cubre un alcance mucho más amplio de la programación C ++ que otros libros introductorios que he visto, y en un formato sorprendentemente compacto.


Dejo link: https://aticleworld.com/best-c-books/#.WicYcwOnLlE.google_plusone_share

miércoles, 6 de diciembre de 2017

Libros de algoritmos gratuitos


Quiero compartir este link donde se pueden bajar muchos libros de algoritmos estan todos en ingles pero son muy completos. Hay de todo, aprovechen!!

Dejo link: http://www.improgrammer.net/free-algorithm-books-for-download/

martes, 5 de diciembre de 2017

Un resumen de Scala for the Impatient, parte 32

Orden de construcción de trait

Como las clases, los traits pueden ser construidos y estos pueden construir sus propiedades y ejecutar métodos:

trait FileLogger extends Logger {
val out = new PrintWriter("app.log") // Part of the trait’s constructor
out.println(s"# ${java.time.Instant.now()}") // Also part of the constructor
def log(msg: String) { out.println(msg); out.flush() }
}


Esto se ejecutara en el constructor de cualquier objeto que incorpore este Trait.

El orden sera el siguiente: 
  1. El constructor de la super clase se ejecutara primero. 
  2. Luego el constructor de los traits, de izquierda a derecha. 
  3. Por cada traits, el constructor del padre (si lo tuviera) primero. 
  4. Si los traits tienen un constructor común, no ejecuta 2 veces el mismo constructor. 
  5. Luego de que todos los traits son construidos, la subclase es construida. 

Por ejemplo: 

class SavingsAccount extends Account with FileLogger with ShortLogger

El orden de construcción sería: 
  1. Account
  2. Logger (padre de FileLogger)
  3. FileLogger
  4. ShortLogger (tiene el padre en comun con FileLogger pero no vuelve a construirlo)
  5. SavingsAccount

Inicializando campos en los Traits

Los traits no pueden tener constructores con parámetros. Cada trait tiene un constructor sin parámetros. Esta limitación puede ser un problema para traits que necesitan ser adaptados para ser útiles. Por ejemplo el trait FileLogger seria útil poder definir el nombre del archivo.

val acct = new SavingsAccount with FileLogger("myapp.log")

Una posible solución es que el nombre de archivo sea un campo abstracto.

trait FileLogger extends Logger {
val filename: String
val out = new PrintStream(filename)
def log(msg: String) { out.println(msg); out.flush() }
}

La clase puede sobreescribir el filename pero el problema es que el constructor del trait se ejecuta antes por lo tanto no va funcionar. Esto se puede resolver con lo que se indico en el siguiente post

Aplicando esto nuestra clase sería:

val acct = new { // Early definition block after new
val filename = "myapp.log"
} with SavingsAccount with FileLogger

Otra alternativa es hacer que out sea lazy (es decir que se llame al constructor de out la primera vez que se utilice)

trait FileLogger extends Logger {
val filename: String
lazy val out = new PrintStream(filename)
def log(msg: String) { out.println(msg) } // No override needed
}

Cuando se llame al constructor de out el campo filename ya va estar seteado. Pero los valores lazy son un poco más ineficientes dado que se deben chequear al ser utilizados.

 Traits que extienden clases :

Como se puede ver un trait puede extender otro trait de esta manera podremos tener nuestra jerarquía de traits. Menos común un traits puede extender una clase. Esa clase se convierte en una superclase de cualquier clase que se mezcle con el trait.

Veamos un ejemplo: 

trait LoggedException extends Exception with ConsoleLogger {
    def log() { log(getMessage()) }
}

Una LoggerException tiene un método log que logea el mensaje. Por lo que vemos puede acceder al método getMessage que es de la clase Exception. 

Ahora podemos mix esto con el trait: 

class UnhappyException extends LoggedException { // This class extends a trait
    override def getMessage() = "arggh!"
}

¿Qué pasa si nuestra clase ya extiende otra clase? Eso está bien, siempre que sea una subclase de la superclase del trait. Por ejemplo,

class UnhappyException extends IOException with LoggedException

Pero si nuestra clase extiende de otra clase que no es hija o no es la clase padre del trait, esta clase no puede mezclarse con este trait. Por ejemplo: 

class UnhappyFrame extends JFrame with LoggedException
// Error: Unrelated superclasses

La clase no puede extender de Jframe y de Exception. 

lunes, 4 de diciembre de 2017

Juego de Serie en C# y mono!!

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en C# y mono :

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

using System;
using System.Collections.Generic;

namespace SecuenciaCSharep
{
public abstract class Secuencia
{
protected IList<int> values = new List<int>();

protected abstract void generate();

public Secuencia ()
{
this.generate();
}

public IList<int> getValues(){
return values;
}

}
}

Ahora vamos a ver las implementaciones de secuencia:

using System;

namespace SecuenciaCSharep
{
public class SecuenciaPar : Secuencia
{
protected override void generate () {
int semilla = new Random ().Next (99);
for (int i = 0; i<4; i++) {
this.values.Add (semilla * i * 2);
}
}

public SecuenciaPar ()
{
}
}
}

Y ahora la secuencia Impar: 

using System;

namespace SecuenciaCSharep
{
public class SecuenciaInPar : Secuencia
{
protected override void generate () {
int semilla = new Random ().Next (99);
for (int i = 0; i<4; i++) {
this.values.Add ((semilla * i * 2) + 1);
}  

}

public SecuenciaInPar ()
{
}
}
}

Ahora vamos a ver el juego, este tiene la responsabilidad de verificar si el usuario acertó y tambien debe llevar los puntos: 

using System;

namespace SecuenciaCSharep
{
public class Juego
{
private Secuencia secuencia;

private int puntaje = 0;

public void generar() {
int i = new Random ().Next (2);

switch (i) {
case 0:
secuencia = new SecuenciaPar ();
break;
default: 
secuencia = new SecuenciaInPar ();
break;
}
}

public Juego ()
{
this.puntaje = 0;
generar ();
}

public int getValue0() {
return secuencia.getValues()[0];
}

public int getValue1() {
return secuencia.getValues()[1];
}

private int getValue2() {
return secuencia.getValues()[2];
}

public int getValue3() {
return secuencia.getValues()[3];
}

public int getPuntaje() {
return this.puntaje;
}

public bool isOK(int n) {
if (this.getValue2 () == n) {
this.puntaje++;
this.generar ();
return true;
}
this.puntaje --;
this.generar ();
return false;
}

}
}

Ahora programemos la interfaz en este caso utilizaremos mono+Gtk:

using System;
using Gtk;
using SecuenciaCSharep;

public partial class MainWindow: Gtk.Window
{
private Juego juego;

public MainWindow (): base (Gtk.WindowType.Toplevel)
{
Build ();
juego = new Juego ();
this.regenerate ();
}

protected void OnDeleteEvent (object sender, DeleteEventArgs a)
{
Application.Quit ();
a.RetVal = true;
}

protected void OnButton1Clicked (object sender, EventArgs e)
{
int n = (int)this.spinbutton2.Value;
MessageDialog msd; 
if (juego.isOK (n)) {
msd = new MessageDialog (this, DialogFlags.Modal, MessageType.Info, ButtonsType.None, "Ganaste!! Puntaje : " + juego.getPuntaje());
} else {
msd = new MessageDialog (this, DialogFlags.Modal, MessageType.Info, ButtonsType.None, "Perdiste  Puntaje : " + juego.getPuntaje());
}
msd.Show ();
this.regenerate ();
}

private void regenerate() {
this.label1.Text = juego.getValue0 ().ToString();
this.label2.Text = juego.getValue1 ().ToString();
this.label3.Text = juego.getValue3 ().ToString();
this.spinbutton2.Value = 0;
}
}

Y eso es todo!11 a jugar se a dicho!!

Dejo el repositorio git: 

sábado, 2 de diciembre de 2017

Kotlin 1.2 introduce el proyecto multiplataforma


Kotlin se va para arriba y en su ultima versión permite compartir codigo desde la JVM a una plataforma javascript usando el proyecto multiplataforma. Además, incluye una serie de mejoras en el lenguaje y la biblioteca, y un mejor rendimiento del compilador.

Kotlin ahora ofrece a los desarrolladores la posibilidad de administrar fácilmente los proyectos destinados a ejecutarse tanto en la JVM como en las plataformas de JavaScript. En un futuro no muy lejano, el soporte nativo gracias a Kotlin Native.

El proyectos multiplataforma organiza sus módulos en un conjunto de módulos comunes y específicos para cada plataforma. Los módulos específicos de la plataforma contienen código que se ejecuta en la JVM o en JavaScript y puede acceder libremente a las bibliotecas específicas de la plataforma donde se ejecutan. Para cada módulo específico de la plataforma, debe existir un módulo común que proporcione las denominadas "declaraciones esperadas", es decir, declaraciones que deben implementarse en el módulo específico de la plataforma. Gracias a este mecanismo, puede llamar al código específico de la plataforma desde un código independiente de la plataforma. Mientras que los módulos comunes solo pueden contener el código de Kotlin y usar bibliotecas de Kotlin, los módulos de plataforma también pueden contener código en Java o JavaScript y se compilan en un formato específico.

Veamos un ejemplo:

// Common module

package org.jetbrains.foo

expect class Foo(bar: String) {
    fun frob()
}

fun main(args: Array<String>) {
    Foo("Hello").frob()
}

// JVM module

package org.jetbrains.foo

actual class Foo actual constructor(val bar: String) {
    actual fun frob() {
        println("Frobbing the $bar")
    }
}

En un futuro Kotlin sera capaz de expresar el comportamiento en módulos comunes en un conjunto de bibliotecas multiplataforma, que incluyen una biblioteca de serialización, una biblioteca de pruebas y una biblioteca isomórfica HTML. Esto debería reducir la necesidad de recurrir a módulos de plataforma.

Además, el compilador de Kotlin se ha vuelto significativamente más rápido en la versión 1.2, superando a Kotlin 1.1 en un 25%. Se planea una mejora adicional para futuros lanzamientos menores de 1.2.

Dejo link: https://blog.jetbrains.com/kotlin/2017/11/kotlin-1-2-released/
http://kotlinlang.org/docs/reference/whatsnew12.html
http://kotlin.es/2017/11/1.2.0/

jueves, 30 de noviembre de 2017

Llega Linux Mint 18.3

Como saben soy fanático de linux Mint y ya está disponible su versión 18.3 en sus dos ediciones: Linux Mint Cinnamon y Linux Mint MATE. Se trata de una versión de soporte extendido que será mantenida hasta el año 2021, así que es un excelente momento para actualizar.

Linux Mint 18.3 Sylvia viene con muchas novedades, entre las que podemos nombrar un nuevo centro de software con muchas aplicaciones populares como Spotify y WhatsApp al alcance de un click, soporte para Flatpak, y nuevas herramientas de respaldo.

El centro de software  ha sido remodelado por completo, ahora es más moderno, rápido y ofrece una mejor experiencia de uso. Mira:



A mi entender la novedad más importante es que Linux Mint ahora soporta Flatpak, pero que es Flatpak? es una herramienta para que podamos instalar aplicaciones incluso si sus dependencias no son compatibles con Linux Mint. Es decir todo el software del mundo libre!!!

Más adelante tendremos su versión kde y Xfce.

Dejo link: https://www.linuxmint.com/release.php?id=31
https://linuxmint.com/rel_sylvia_cinnamon.php


Ebook Gratuitos


Quiero compartir una pagina donde orelly publica todos sus e-books gratuitos. Se puede encontrar libros de cualquier variedad.

Un archivo de todos los libros electrónicos de O'Reilly para su descarga gratuita. Sumérgete en lo último en ciencia de datos y big data, compilado por editores, autores y ponentes de O'Reilly.

Dejo el link :
http://www.oreilly.com/data/free/archive.html

domingo, 26 de noviembre de 2017

Inferencia de tipos


Leyendo en infoQ sobre las nuevas características que podría tener Java 10, me entere que estan pensando agregar inferencia de tipos. Básicamente esto se esta discutiendo en el marco de la JEP 286.  Hasta hay una posible síntaxis: 

var list = new ArrayList<String>();  // infers ArrayList<String>

var stream = list.stream();          // infers Stream<String>

Pero, que es la inferencia de tipos? Porque puede ser beneficiosa? 

Primero, las inferencia de tipos es una característica predominante de los lenguajes de programación funcionales tales como ML, Haskell y Ocaml. También lo tiene C# y scala. 

Si vamos a la wikipedia: "La inferencia de tipos asigna automáticamente un tipo de datos a una función sin necesidad de que el programador lo escriba. El tipo de las funciones es reconstruido a partir de un análisis estático del programa realizado por el compilador o intérprete del lenguaje, a partir de las definiciones previas y del uso de las variables en el cuerpo de las funciones." 

Por lo tanto si escribimos :

int i = 5;

Estamos diciendo 2 veces que i es de tipo entero, uno en su declaración y otra en la asignación de 5 que es entero. Por lo que el compilador podria inferir que si le asignamos un entero, la variable debería ser entera.

De esta manera, por ejemplo en scala podemos hacer lo siguiente:

var i = 5;

Y i va ser de tipo entero.

Tanto lio para solo no escribir el tipo, no? En realidad con compiladores más inteligentes la inferencia de tipos puede ser de gran ayuda. Por ejemplo en scala, si hacemos :

1 to 20

Esto retornara un rango, entre 1 y 20. Si vemos bien to es un método de 1 peroo, de que tipo es 1? En este caso 1 no es Int porque Int no tiene el método to, sino que es de tipo RichInt que si lo tiene. Como podemos ver el compilador tomo el tipo no solo porque se parece a un Int sino que tuvo en cuenta que metodo llamábamos. Haciéndonos más fácil la vida.



jueves, 23 de noviembre de 2017

Clase Fracción en scala


Supongamos que debemos representar valores en forma de fracciones, es scala.

Veamos como podemos diseñarlo. Primero podemos utilizar el patrón ValueObject,  que describe Martin Fowler.

Estas estructuras deben devolver una copia de ellos mismos si desean devolver un resultado pero nunca deben cambiar su valor interno.

Dado que es ilogico pensar que un valor determinado cambie su valor. Estas son estructuras inmutables.

En java y scala hay muchas estructuras inmutables podemos pensar en los String, Integer, BigDecimal or BigInteger.

Estas estructuras representan datos que sería impensable que cambie su estado interno. Es decir son objetos que representan un valor. Estas estructuras deben devolver una copia de ellos mismos si desean devolver un resultado pero nunca deben cambiar su valor interno.

Otra decisión que podemos tomar es que estando en Scala, podemos sobre escribir lo operadores, esto es muy fácil. Y otra decisión es trabajar con las fracciones siempre simplificadas:

package utils


/**
 * En matemáticas, una fracción, número fraccionario, (del vocablo latín frāctus,
 * fractĭo -ōnis, roto, o quebrado)1 es la expresión de una cantidad dividida
 * entre otra cantidad; es decir que representa un cociente no efectuado de
 * números. Por razones históricas también se les llama fracción común, fracción
 * vulgar o fracción decimal. El conjunto matemático que contiene a las fracciones
 * es el conjunto de los números racionales, denotado ℚ.
 */
class Fraccion(val numerador:Int, val denominador:Int) {
  require(denominador != 0, "El denominador no puede ser 0")

  def this(numerador:Int) = this(numerador, 1)

  /**
   * En matemáticas, se define el máximo común divisor(MCD) de dos o más números
   * enteros al mayor número entero que los divide sin dejar resto.
   * El algoritmo de Euclides, que utiliza el algoritmo de la división junto
   * al hecho que el MCD de dos números también divide al resto obtenido de
   * dividir el mayor entre el más pequeño.
   */
  def mcd () : Int =
  {
    if(this.abs().numerador>denominador)
    {
      if (this.abs().numerador%denominador==0) denominador
      else new Fraccion(denominador,this.abs().numerador%denominador).mcd()
    }
    else if (denominador%this.abs().numerador==0) numerador
    else (new Fraccion(this.abs().numerador,denominador%this.abs().numerador)).mcd()
 
  }

  def abs() : Fraccion=
    if(numerador<0) new Fraccion(numerador*(-1),denominador)
    else new Fraccion(numerador,denominador)

  def simplificar () : Fraccion =
  {
    if(this.mcd()!=1)new Fraccion(numerador/this.mcd(),denominador/this.mcd())
    else new Fraccion(numerador,denominador)
   
  }

  /*
   *
   *   a   +   c   =       ad + bc     (se multiplica cruzado y los productos de suman)
   *  --       --         --------
   *   b       d             bd        (se multiplican los denominadores)
   *
   */
  def + (otro : Fraccion) : Fraccion =
  {
    new Fraccion((otro.denominador*this.numerador+otro.numerador*this.denominador),otro.denominador*this.denominador).simplificar()
  }

  def - (otro : Fraccion) : Fraccion = new Fraccion((otro.denominador*this.numerador-otro.numerador*this.denominador),otro.denominador*this.denominador).simplificar()


  /*
   * Para multiplicar dos fracciones, el procedimiento es muy simple. Solo es necesario
   * hacerlo horizontalmente, es decir, multiplicar ambos numeradores y luego ambos denominadores.
   */
  def * (otro : Fraccion) : Fraccion = new Fraccion(this.numerador*otro.numerador, this.denominador*otro.denominador)

  def / (otro : Fraccion) : Fraccion = new Fraccion(this.numerador*otro.denominador,this.denominador*otro.numerador)

  def == (otro : Fraccion) : Boolean =
  {
    (otro.simplificar().numerador==this.simplificar().numerador && otro.simplificar().denominador==this.simplificar().denominador)
  }

  def < (otro : Fraccion) : Boolean = (numerador.toFloat/denominador.toFloat < otro.numerador.toFloat/otro.denominador.toFloat )

  def > (otro : Fraccion) : Boolean = (numerador.toFloat/denominador.toFloat > otro.numerador.toFloat/otro.denominador.toFloat )

  def unary_- : Fraccion = new Fraccion(numerador*(-1),denominador)

  override def toString() : String = numerador.toString()+"\n--\n"+denominador.toString()
}