HTML + javascript + Haskell = ELM, parte 2

Seguimos con el post anteriro. 

elm provee el if tradicional :

 if x < 0 then "too small" else "ok"
"ok" : String

Similar al if de Ruby o al case de otros lengujes podemos escribir lo siguiente :

> x = 5
5 : number
> if | x < 0 -> "too small" \
|      | x > 0 -> "too big" \
|      | otherwise -> "just right"
"too big" : String

La barra invertida es porque estoy usando el RELP y tengo que avisarle de los enteres que no tienen sentido

Este if es muy similar a pattern matchinig pero Elm tiene pattern matching :

> list = [1, 2, 3]
[1,2,3] : [number]
> case list of \
| head::tail -> tail \
| [] -> []
[2,3] : [number]

Esta sentencia devuelve el final de una lista, si existe, las vacia, de otro modo. Se puede ver el uso de pattern matching.

La belleza y el poder de un sistema de tipos se ve cuando constrimos nuestros propios tipos de datos complejos. Veamos un ejemplo, una pieza de ajedrez tiene un tipo y un color. Lo que podemos hacer es lo siguiente :

> type Color = Black | White
> type Piece = Pawn | Knight | Bishop | Rook | Queen | King
> type ChessPiece = CP Color Piece
> piece = CP Black Queen
CP Black Queen : ChessPiece

Un constructor de tipos nos permite construir nuevas instancias de un tipo. Nuestro tipo ChessPiece consta de los caracteres CP, nuestro constructor de tipos, seguido de un Color y una Pieza. Ahora, podemos usar la combinación de mayúsculas y minúsculas para separar la pieza, así:

> color = case piece of \

| CP White _ -> White \

| CP Black _ -> Black

Black : Color

Crearemos un tipo que funcione como Lista. Para esto debe saber que Cons construye una lista, dado un elemento y otra lista :

type List = Nil | Cons Int List

Esta es una definición recursiva, una lista es una lista vacia o una construcción de un elemento y una lista. 

Ese tipo de datos es interesante, pero podemos hacerlo mejor. Podemos definir una lista abstracta, una que pueda contener cualquier tipo de datos, como este: 

type List a = Empty | Cons a (List a)

Es igual que la definición anterior pero con tipo generico a. 

Si desea saber cómo se evalúa una lista en Elm, observe el tipo de datos. Puede representar el tipo para la lista [1, 2] como Cons 1 (Cons 2 Empty).

Ahora, cuando te digo que puedes combinar el encabezado de una lista con la cola, tiene sentido. Cons funciona en tipos en tiempo de compilación. La contraparte en tiempo de ejecución del operador Cons que trabaja con datos es ::, y funciona así :

> 1 :: 2 :: 3 :: []

[1,2,3] : [number]

Por ahora vamos bien, pero seguimos en otro post... 

eBook "C++17 IN DETAIL - Part 1"

Me llego el siguiente mail de Embarcadero, y como es un libro gratuito lo comparto con ustedes :

Download your copy of the eBook "C++17 IN DETAIL - Part 1"   Learn the Exciting Features of the New C++ Standard!     Get your eBook

What you will learn: ● What was removed from the language and what is deprecated ● How the language is more precise: for example, thanks to expression evaluation order guarantees ● What the new features of templates are, like if constexpr or fold expressions ● What the new standard attributes are ● How you can write cleaner and more expressive code thanks to structured binding, inline variables, compile-time if or template argument deduction for classes

This eBook is offered to you by:

Embarcadero is the creator of the C++Builder, the powerful C++ IDE for multi-platform development focusing on database access and excellent UI design for all your platforms. Try C++Builder Whole Tomato is the creator of Visual Assist, an extension that improves Visual C# and Visual C++with a multitude of productivity features above those provided in the default IDE. Try Visual Assist

Happy programming from all of us at Embarcadero and Whole Tomato!

HTML + javascript + Haskell = ELM

Supongamos que tenemos que hacer un juego en Html, css y javascript. Ante esta idea, viene otra muy rápidamente relacionada con el suicidio.

Por suerte existe ELM, que es un lenguaje inspirado en Haskell el cual esta orientado a sistemas reactivos y compila a HTML y javascript.

Antes de comenzar debemos instalar ELM. ELM cuenta con 2 herramientas, una es el RELP y otra es le server. Por ahora vamos a utilizar el RELP.

Para instalar el RELP, vamos a : https://guide.elm-lang.org/install/elm.html
O podemos utilizar el try : https://elm-lang.org/try

Instalado el RELP, vamos a ver expresiones en ELM y literales : 

 > 4

4 : number

> "String"

"String" : String

> 5 < 4

False : Bool

Todo retorna un valor y ese valor tiene un tipo. ELM es de tipado estático y su tipado es muy poderoso pero algo quisquilloso :

> [1, "2"]

[1 of 1] Compiling Repl

 ( repl-temp-000.elm )

The 2nd element of this list is an unexpected type of value.

3|

 [1, "2"]

^^^

...

> 4 + "4"

[1 of 1] Compiling Repl

...

( repl-temp-000.elm )

As I infer the type of values flowing through your program, I see a conflict

between these two types: number String

> "4" ++ "4"

"44" : String

> 4 ++ 4

[1 of 1] Compiling Repl

...

Expected Type: appendable

...

> [1, 2] ++ [3, 4]

[1,2,3,4] : [number]

( repl-temp-000.elm ) 

Por lo visto, ELM es de tipado fuerte y estático.  ELM esta influenciado por el sistema de tipos de Haskell y ML. Su sistema de tipo contiene type classes. Esto se puede ver como las interfaces de Java. Es decir, un tipo implementa estas interfaces y todas las funciones que trabajan con este data type, puede ser utilizados con el tipo.

Por ejemplo tanto las listas como los Strings son appendable por lo tanto toda función que necesitan un appendable pueden ser utilizadas con listas o String por ejemplo ++.

A la vez ELM infiere el tipo, no es necesario indicar le tipo dado que este es inferido por el compilador : 

> a = [1, 2, 3]

[1,2,3] : [number]

A la vez cuenta con un sistema de tipos polimorfico, lo que significa que puede tratar los tipos que heredan de la misma type class de la misma manera. Verá que Elm aprovecha al máximo su herencia de ML y Haskell para construir uno de los mejores sistemas de tipos del mundo.

> a[1] = 2

[1 of 1] Compiling Repl ( repl-temp-000.elm )

> a[1] = 2

<function> : List number -> number'

Elm es un lenguaje de tipado estático, y muy estricto, aunque en REPL, puede redefinir valores primitivos por conveniencia. Elm es como Elixir a este aspecto. : List number -> number'

Creo que por este post estamos, continuará ...

Dejo link :  https://elm-lang.org/

Ballerina un lenguaje pensado para la nube, Parte 2

En el post anterior me quede con muchas ganas de ver código. Pero, si llegaste acá y no sabés de que estoy hablando o no sabés que es Ballerina ve esto: https://emanuelpeg.blogspot.com/2020/02/ballerina-un-lenguaje-pensado-para-la.html

Si queres probar el código que vamos dejando, pueden hacerlo acá : https://play.ballerina.io/

Veamos un poco de código en Ballerina y empecemos con un hola mundo:

import ballerina/io;

public function main() {
    io:println("Hello, World!");
}

Lindo pero, ahora vamos hacerlo en paralelo :

import ballerina/io;

public function main() {

    worker w1 {
        io:println("Hello, World! #m");
    }    worker w2 {
        io:println("Hello, World! #n");
    }    worker w3 {
        io:println("Hello, World! #k");
    }
}

veamos el mismo código en un servidor :

import ballerina/http;
import ballerina/log;

service hello on new http:Listener(9090) {
    resource function sayHello(http:Caller caller, http:Request req) {
        var result = caller->respond("Hello, World!");
        if (result is error) {
            log:printError("Error sending response", result);
        }
    }
}

y ahora de cliente : 

import ballerina/http;

import ballerina/io;

public function main() {

    http:Client clientEP = new ("http://www.mocky.io");

    var resp = clientEP->get("/v2/5ae082123200006b00510c3d/");    

    if (resp is http:Response) {

        var payload = resp.getTextPayload();

        if (payload is string) {

            io:println(payload);

        } else {

            io:println(payload.detail());

        }

    } else {

        io:println(resp.detail());

    }

}

Puff... lo que se puede hacer con un "hola mundo". Primera conclusión, claramente se ve que Ballerina esta ampliamente influenciado por Node y javascript. 

Veamos un objeto : 

import ballerina/io;

type Person object {

    public string name = "";

    public int age = 0;

    public Person? parent = ();

    private string email = "default@abc.com";

    string address = "No 20, Palm grove";

};

public function main() {

    Person p1 = new;

    io:println(p1.age);    

    

    Person p2 = new();

    io:println(p2.age);

    Person p3 = new Person();

    io:println(p3.age);

}

Se ve que las clases se declaran con type y se pueden hacer cosas más complejas : 

import ballerina/io;

type Person object {

    public int age;

    public string firstName;

    public string lastName;

    function __init(int age, string firstName, string lastName) {

        self.age = age;

        self.firstName = firstName;

        self.lastName = lastName;

    }

    function getFullName() returns string {

        return self.firstName + " " + self.lastName;

    }

};

public function main() {

    Person p1 = new(5, "John", "Doe");    

    io:println(p1.getFullName());

}

Ahora podemos ver la influencia de Go. Porque tiene la misma forma de manejar errores, los retorna y sigue la filosofía de que el error es un resultado más : 

import ballerina/io;

const ACCOUNT_NOT_FOUND = "AccountNotFound";

const INVALID_ACCOUNT_ID = "InvalidAccountID";

function getAccountBalance(int accountID) returns int|error {

    if (accountID < 0) {

        return error(INVALID_ACCOUNT_ID, accountID = accountID);

    } else if (accountID > 100) {

        return error(ACCOUNT_NOT_FOUND, accountID = accountID);

    }

    return 600;

}

public function main() {

    error simpleError = error("SimpleErrorType", message = "Simple error occurred");

    io:println("Error: ", simpleError.reason(),

                ", Message: ", simpleError.detail()?.message);

    int|error result = getAccountBalance(-1);

    if (result is int) {

        io:println("Account Balance: ", result);

    } else {

        io:println("Error: ", result.reason(),

                    ", Account ID: ", result.detail()["accountID"]);

    }

}

Y por último un ejemplo de interacción con Java : 

import ballerinax/java;

import ballerina/io;

function newArrayDeque() returns handle = @java:Constructor {

    class: "java.util.ArrayDeque"

} external;

function newArrayDequeWithInitialCapacity(int numElements) returns handle = @java:Constructor {

    class: "java.util.ArrayDeque",

    paramTypes: ["int"]

} external;

public function main() {

    var arrayDeque = newArrayDeque();

    io:println(arrayDeque);

    var arrayDequeWithCapacity = newArrayDequeWithInitialCapacity(10);

    io:println(arrayDequeWithCapacity);

}

No mucho que explicar, de esta manera podemos llamar clases java. 

Conclusión, me gusto!

Toma buenas cosas de diferentes lenguajes y lo mezcla de forma equilibrada. Lo único que le critico es el ";" que no lo veo necesario.  Por lo dicho, vamos a tener que estudiar un nuevo lenguaje :P

Dejo link: https://ballerina.io/v1-1/learn/by-example/

Ballerina un lenguaje pensado para la nube

Ballerina es un lenguaje de programación open-source y una plataforma para que los programadores de aplicaciones de la era de la nube escriban fácilmente software que simplemente funciona.

Durante décadas, los lenguajes de programación han tratado las redes simplemente como fuentes de entrada y salida. Ballerina presenta nuevas abstracciones fundamentales de objetos de clientes, servicios, funciones de recursos y oyentes para incorporar las redes al lenguaje de modo que los programadores puedan abordar directamente las problemática de la computación distribuida como parte de su lógica de aplicación. Esto facilita que las aplicaciones de red resistentes, seguras y de alto rendimiento estén al alcance de todos los programadores.

Los diagramas de secuencia han sido la herramienta favorita de todos para describir cómo funcionan los programas distribuidos y concurrentes. Sin embargo, ningún lenguaje de programación actual le permite escribir su lógica como un diagrama de secuencia en estas aplicaciones. En Ballerina, cada programa es un diagrama de secuencia que ilustra interacciones distribuidas y concurrentes automáticamente. El diagrama es el código y el código es el diagrama.

El tipado estático es el dolor de cabeza del programador de aplicaciones de red y el tipado dinámico es la pesadilla del ingeniero de aplicaciones confiables. El sistema de tipo estructural de tipo estático de Ballerina que está diseñado para ser compatible con el esquema de datos de red permite a los programadores de aplicaciones escribir código que se adhiera al Principio de Robustez: Sea conservador en lo que envía, sea liberal en lo que acepta.

En la era de la nube, ejecutar un programa ya no es solo una cuestión de compilación y ejecución, sino que se trata de compilar, construir la imagen, empujar la imagen, configurar la orquestación de contenedores y, finalmente, ejecutarla. Ballerina lleva todo el proceso de ejecución del programa a las manos del desarrollador con metadatos extensibles que se compilan en programas ejecutables para todas las principales plataformas en la nube.

Ballerina tiene todas las biblioteca estándar y la cadena de herramientas para ayudar a los desarrolladores a crear aplicaciones rápidamente. En el momento del desarrollo, Ballerina cubre documentación, pruebas, uso compartido, control de versiones y más.

Los programas en el mundo real se escriben una vez y se leen decenas a cientos de veces. Ballerina prioriza la conveniencia y productividad del programador con familiaridad, abstracciones más claras y conceptos más fáciles sobre el rendimiento del sistema.

Luego de leer todo esto, veamos un hola mundo, por lo menos :

import ballerina/io;

public function main() {
    io:println("Hello Ballerina!");
}

Si queres probar este codigo pode ir a : https://play.ballerina.io/

Dejo link: https://ballerina.io/

Libros de Java Code Geeks

Download IT Guides!   Multithreading and Concurrency Questions There is a number of things that could potentially blow up and the complexity of systems rises considerably when concurrency is introduced. However, the...     Java Annotations Tutorial We have provided an abundance of tutorials here at Java Code Geeks, like Creating Your Own Java Annotations, Java Annotations Tutorial with Custom Annotation and Java...     Spring Interview Questions The majority of the things you may be asked is collected in the list below. All core modules, from basic Spring functionality such as Spring Beans, up to Spring MVC framework are...     Android UI Design Android’s user interface is based on direct manipulation, using touch inputs that loosely correspond to real-world actions, like swiping, tapping, pinching and reverse pinching to...

Generar sitios estáticos con Hugo

Hugo es uno de los generadores de sitios estáticos de código abierto más populares. Con su sorprendente velocidad y flexibilidad, Hugo hace que la creación de sitios web sea divertido.

Homebrew, un administrador de paquetes para macOS y linux, se puede instalar desde brew.sh. Luego de instalar brew

brew install hugo

Para verificar su nueva instalación:

hugo version

Ahora podemos crear el sitio : 

hugo new site quickstart

El sitio se llama quickstart. Ahora vamos a agregar un tema. Primero, debemos descargar el tema de Github y agregarlo al directorio de temas de su sitio Hugo. Podemos ver los temas en themes.gohugo.io. Vamos a utilizar el tema Ananke.

cd quickstart
git init
git submodule add https://github.com/budparr/gohugo-theme-ananke.git themes/ananke

El tema lo podemos descargar desde: https://github.com/budparr/gohugo-theme-ananke/archive/master.zip si no queremos usar git. Extraemos ese archivo .zip para obtener un directorio "gohugo-theme-ananke-master". Luego cambiamos el nombre de ese directorio a "ananke" y lo movemos al directorio "themes /".

Luego, agregue el tema a la configuración del sitio:

echo 'theme = "ananke"' >> config.toml

Ahora agregamos el contenido :

Se puede crear archivos de contenido manualmente (por ejemplo, como contenido / <CATEGORY> / <FILE>. <FORMAT>) y proporcionar metadatos en ellos, sin embargo, puede usar un comando:

hugo new posts/my-first-post.md

Edite el archivo de contenido recién creado si lo desea, comenzará con algo como esto:

---
title: "My First Post"
date: 2019-03-26T08:47:11+01:00
draft: true
---

Ahora, vamos a iniciar el servidor Hugo:

hugo server -D

                   | EN
+------------------+----+
  Pages            | 10
  Paginator pages  |  0
  Non-page files   |  0
  Static files     |  3
  Processed images |  0
  Aliases          |  1
  Sitemaps         |  1
  Cleaned          |  0

Total in 11 ms
Watching for changes in /Users/bep/quickstart/{content,data,layouts,static,themes}
Watching for config changes in /Users/bep/quickstart/config.toml
Environment: "development"
Serving pages from memory
Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender
Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)
Press Ctrl+C to stop

Podemos navegar en http://localhost:1313/

Podemos editar o agregar contenido nuevo y luego simplemente actualizar el navegador para ver los cambios.

Cuando el sitio este listo, debemos cambiar las configuraciones. Debemos editar config.toml y cambiar los valores:

baseURL = "https://example.org/"
languageCode = "en-us"
title = "My New Hugo Site"
theme = "ananke"

Además, si ya tenemos un dominio listo, podemos configurar baseURL. Tenga en cuenta que este valor no es necesario cuando se ejecuta el servidor de desarrollo local.

Luego debemos reconstruir nuestro sitio con:

hugo -D

La salida estará en el directorio ./public/ de forma predeterminada (-d / - marca de destino para cambiarlo, o establecer publicar dir en el archivo de configuración).

Dejo link: https://gohugo.io/

ZIO

ZIO es una biblioteca Scala de dependencia cero para programación asincrónica y concurrente. Y tiene un logo muuuuyyyy copado...

Su filosofía esta basada en fibras (que son como hilos de ejecución) altamente escalables y sin bloqueo que nunca desperdician ni pierden recursos, ZIO permite crear aplicaciones escalables, resistentes y reactivas que satisfagan las necesidades de su negocio. Entre las características podemos nombrar:

• Alto rendimiento. 
• Tipe-safe. 
• Concurrente. 
• Asincrónico. 
• Seguridad en los recursos. 
• Probable 
• Elástico. 
• Funcional. 

Antes de empezar debemos incluir a ZIO en el proyecto agregando la siguiente entrade en el build.sbt:

libraryDependencies += "dev.zio" %% "zio" % "1.0.0-RC17"

Si deseamos utilizar streams ZIO, también debe incluir la siguiente dependencia:

libraryDependencies += "dev.zio" %% "zio-streams" % "1.0.0-RC17"

Ahora veamos un pequeño ejemplo: 

import zio.App

import zio.console._

object MyApp extends App {

  def run(args: List[String]) =

    myAppLogic.fold(_ => 1, _ => 0)

  val myAppLogic =

    for {

      _    <- putStrLn("Hello! What is your name?")

      name <- getStrLn

      _    <- putStrLn(s"Hello, ${name}, welcome to ZIO!")

    } yield ()

}

run debería devolver un valor ZIO que tenga todos sus errores manejados,

Como se puede ver myAppLogic, se plegó de tal forma que produce un valor si falla, habrá un 1; pero si tiene éxito, habrá un 0.

Si está integrando ZIO en una aplicación existente, utilizando inyección de dependencia, o no controla su función principal main, se puede crear un sistema de tiempo de ejecución para ejecutar sus programas ZIO:

import zio._

import zio.console._

object IntegrationExample {

  val runtime = new DefaultRuntime {}

  runtime.unsafeRun(putStrLn("Hello World!"))

}

ZIO proporciona un módulo para interactuar con la consola. Puede importar las funciones en este módulo con el siguiente fragmento de código:

import zio.console._

Si necesita imprimir texto en la consola, puede usar putStr y putStrLn:

// Print without trailing line break

putStr("Hello World")

// res8: ZIO[Console, Nothing, Unit] = zio.ZIO$Read@2ba3e0d1

// Print string and include trailing line break

putStrLn("Hello World")

// res9: ZIO[Console, Nothing, Unit] = zio.ZIO$Read@75e3acfe

Si necesita leer la entrada desde la consola, puede usar getStrLn:

val echo = getStrLn flatMap putStrLn

// echo: ZIO[Console, java.io.IOException, Unit] = zio.ZIO$FlatMap@72bc78be

Es importante utilizar la consola de zio porque cada fibra tiene sus propios recursos, y la consola de Zio soluciona la interacción con la consola. 

Dejo link : https://zio.dev/

Machine Learning. Curso básico de Machine Learning Gratis!!!

Quiero recomendar este curso gratuito de Machine Learning, donde aprenderas a usar Numpy, Pandas, Seaborn, Matplotlib, Plotly y Sckit-Learn con Python.

Entre los temas tenemos:

• Usar Python para Machine Learning y Data Science
• Implementar algoritmos de Machine Learning
• Usar Scikit-learn, el módulo más utilizado para Machine Learning
• Usar Plotly para hacer gráficos interactivos
• Aprender Numpy para el procesamiento numérico
• Aprender a usar Matplotlib para hacer gráficos con los datos
• Aprender Regresión Lineal para Machine Learning
• Aprender Regresión Logística para Machine Learning
• Aprender Random Forest para Machine Learning
• Aprender a contruir árboles de decisión para el aprendizaje de máquinas

Dejo link : https://www.udemy.com/course/curso-machine-learning/?fbclid=IwAR12pEVsdyfhcG-Aa35QOWFmgL2ATMhgEYPLF5WEACauP4a8G99RsVo9WMg

Kubernetes

Kubernetes es una plataforma de orquestación de contenedores. El origen de Kubernetes se remonta al data center de google. Todo comenzó con la plataforma llamada Borg. Borg era utilizado para la orquestación de aplicaciones. En 2014 google decide hacer open source a Borg con el nombre de “Kubernetes” que no es el más fácil de pronunciar pero así es google. En 2015, Kubernetes fue el primer proyecto donado a una joven organización llamada Cloud Native Computing Foundation. (CNCF)

De esta manera Kubernetes comenzó a tener cada vez más relevancia y su comunidad crecía rápidamente. Hoy en día, kubernetes es uno de los proyectos con más crecimiento en Github y se convirtió en una de las plataformas más utilizadas para orquestación de containers.


Kubernetes ofrece un conjunto de primitivas distribuidas y técnicas de encapsulamiento para la creación de aplicaciones automatizables. Kubernetes ofrece un entorno de administración centrado en contenedores. Kubernetes orquesta la infraestructura de cómputo, redes y almacenamiento para que las cargas de trabajo de los usuarios no tengan que hacerlo. Esto ofrece la simplicidad de las Plataformas como Servicio (PaaS) con la flexibilidad de la Infraestructura como Servicio (IaaS) y permite la portabilidad entre proveedores de infraestructura.

Por ahora eso es todo...

Dejo links:
https://kubernetes.io
https://cloud.google.com/kubernetes/

Libros de Java Code Geeks

Download IT Guides!

Continuous Intelligence 101 Continuous intelligence (CI) gives businesses the information needed to react to events as they are happening. It is a form of real-time analytics that uses artificial intelligence to support decisions when actions must be taken in milliseconds to minutes. This eBook provides an overview to CI, the reasons to use it, and what it can do for your business.	API Management Software Requirements Checklist Get the most important factors to consider when selecting an API management tool. This guide includes the key requirements for API creation and management along with an expert checklist of top features to consider when acquiring such a tool.
Hybrid Cloud Strategy for Dummies Cloud computing also grows more complex and multi-faceted daily. Getting onto the cloud is easy. Getting it right is trickier. You can probably see why a carefully thought-out and detailed approach to cloud computing	Cybersecurity - A Short Business Guide The best thing you can do for your business is to have a security-first mentality. No company is exempt from falling victim to a breach because of their size - both large and small companies are at risk. This resource includes

Guía de Raku en castellano

Quiero compartir esta pagina que es una guía rápida del lenguaje de programación Raku.
Para los novatos en Raku sería un punto de partida y puesta en marcha.

Y como todo buen tutorial comienza con un "Hola Mundo" : 

say 'hola mundo';

que también puede escribirse como:

'hola mundo'.say;

Dejo link: https://raku.guide/es/

Probar distribuciones linux sin instalarlas con DistroTest

Me gusta mucho probar distros de linux, por suerte ahora todo es más fácil con DistroTest. Es una pagina donde se lintan las dindtros, eliges una y las podes acceder por VNC. Sin instalar nada.

No más instalación!!!

Dejo link: https://distrotest.net/

El lenguaje de programación V, Parte 9

Seguimos con V


El modelo de concurrencia de V es muy similar a Go. Para ejecutar una función de modo concurrente simplemente se debe llamar con go foo (). En estos momentos se esta trabajando en rutinas y en un  planificador.


Si queremos probar nuestro codigo podemos hacerlo :

// hello.v
fn hello() string {
return 'Hello world'
}

// hello_test.v
fn test_hello() {
    assert hello() == 'Hello world'
}

Todas las funciones de prueba deben colocarse en archivos * _test.v y comenzar con test_.
Para ejecutar las pruebas, haga v hello_test.v. Para probar un módulo completo, haga v test mymodule.

Algo importante es que la palabra clave assert también se puede utilizar fuera de las pruebas.

Esto fue todo de V, si me piden una opinión es una buena combinación de Go y Rust. Que eso es bueno, pero no aporta mucho al mundo de la programación.


Dejo link: https://vlang.io/

El lenguaje de programación Raku

Hice un post de Raku, pero no mostré nada de código y quedo bastante incompleto. Por eso la idea de este post es mostrar un poco más. Vamos hacer una función que retorne el ultimo elemento de una lista :

use v6;

sub last-elem(@list) {
    @list[* - 1];
}

say last-elem(<a b c d e>);

nos retornará "e" veamos otro ejemplo, ahora vamos a retornar los 2 últimos elementos :

use v6;

sub last-two(@list)
{
    @list[* - 2, * - 1];
}

say "{last-two(<a b c d e>)}";

nos retornará "d" y "e", vamos hacer una función que busque un elemento por un indice pasado por parámetro :

use v6;

sub get-at(@list, $elem)
{
    @list[$elem];
}

say get-at(<a b c d e>, 4);

nos retornará "e" veamos otro ejemplo, ahora vamos a retornar una lista de reversa :

use v6;

sub reverse-list(@list)
{
    @list.reverse;
}

say "{reverse-list(<a b c d e>)}";
va retornar "e d c b a"

Por ultimo vamos a hacer una función que retorne n números :

use v6;

sub lotto-select($n, $m)
{
    gather for ^$n
    {
        take (1 ... $m).pick(1).first;
    }
}

say "{lotto-select(6, 49)}";

A mi entender tantos símbolos como @, $, etc, hacen difícil leer el codigo, sobre todo a las personas que no venimos de Perl


Dejo link: https://examples.p6c.dev/index.html