Predicado que nos indique si un elemento existe en una lista en prolog

Vamos a hacer un predicado que nos indique si un elemento existe en una lista en prolog: 

existe(Elemento, [Elemento | _]).

existe(Elemento, [_ | Tail]) :-

    existe(Elemento, Tail).

Si la probamos : 

existe(5,[1,2,3,4])

false

existe(4,[1,2,3,4])

true

Contar elementos de una lista en prolog

Vamos a hacer un predicado que cuenten los elementos de una lista en prolog: 

count_elements([], 0).

count_elements([_ | Tail], Count) :-

    count_elements(Tail, TailCount),

    Count is TailCount + 1.

Contar valores que cumplan un criterio en Lisp

 

Función para contar valores de una lista en lisp según un criterio (que va a ser una función) : 

(defun contarSegun (lista fx) 

 (cond

     ((null lista) 0)

     ((funcall fx (first lista)) 

           (+ (contarSegun (rest lista) fx) 1))

     (T (contarSegun (rest lista) fx))

 )

)

Y vamos a probarla : 

> (contarSegun '(1 2 3 4 5 6) (lambda (a) (> a 3)))

3

> (contarSegun '(1 2 3 4 5 6) (lambda (a) (>= a 3)))

4

> (contarSegun '(1 2 3 4 5 6) (lambda (a) (= a 3)))

1

Slices en Rust

Los Slices brindan una vista de una colección más grande, es como una porción:

fn main() {

    let mut a: [i32; 6] = [10, 20, 30, 40, 50, 60];

    println!("a: {a:?}");

    let s: &[i32] = &a[2..4];

    println!("s: {s:?}");

}

Los Slice toman prestados el tipo del arreglo.

Si el Slice comienza en el índice 0, la sintaxis de rango de Rust nos permite eliminar el índice inicial, lo que significa que &a[0..a.len()] y &a[..a.len()] son idénticos. Lo mismo ocurre con el último índice, por lo que &a[2..a.len()] y &a[2..] son idénticos. Por lo tanto, para crear fácilmente un  Slice de todo el vector, podemos usar &a[..].

El tipo de s (&[i32]) ya no menciona la longitud de la matriz. Esto nos permite realizar cálculos en sectores de diferentes tamaños.

¿Qué es Go-Zero?

 

En el mundo del desarrollo de software, la velocidad, la eficiencia y la simplicidad son pilares fundamentales. El framework Go-Zero emerge como una solución poderosa para aquellos que buscan crear aplicaciones escalables y de alto rendimiento utilizando el lenguaje de programación Go (Golang).

Pero ¿Qué es Go-Zero? Go-Zero es un framework moderno y de código abierto diseñado para acelerar el proceso de desarrollo de aplicaciones en Go. Ofrece una arquitectura robusta y flexible, proporcionando herramientas y patrones que permiten construir aplicaciones web, API y microservicios de manera eficiente.

Características Principales:

• Alto rendimiento: Go-Zero se destaca por su capacidad para manejar cargas de trabajo intensivas y mantener un alto rendimiento incluso en entornos de gran escala.
• Productividad mejorada: Proporciona abstracciones y utilidades que reducen la complejidad del código, permitiendo a los desarrolladores enfocarse en la lógica de negocio en lugar de detalles de implementación.
• Facilidad de uso: Con una curva de aprendizaje amigable, su estructura modular y su amplia documentación, Go-Zero facilita a los desarrolladores tanto principiantes como experimentados.
• Soporte para microservicios: Ofrece herramientas específicas para la construcción de arquitecturas de microservicios, simplificando la comunicación entre ellos y la gestión de datos distribuidos.

Veamos un ejemplo básico de cómo se podría crear un servidor HTTP simple utilizando el framework Go-Zero:

package main

import (

"github.com/tal-tech/go-zero/core/conf"

"github.com/tal-tech/go-zero/rest"

"github.com/tal-tech/go-zero/rest/httpx"

)

type Request struct {

Name string `form:"name"`

}

type Response struct {

Message string `json:"message"`

}

func helloHandler(w httpx.ResponseWriter, r *httpx.Request) {

var req Request

if err := r.ParseForm(&req); err != nil {

w.Error(httpx.BadRequest(err.Error()))

return

}

resp := Response{

Message: "Hello, " + req.Name + "!",

}

w.WriteJson(resp)

}

func main() {

var c rest.RestConf

conf.MustLoad("path/to/config.yaml", &c)

server := rest.MustNewServer(c)

server.AddRoute(rest.Route{

Method:  "GET",

Path:    "/hello",

Handler: helloHandler,

})

defer server.Stop()

server.Start()

}

Go-Zero representa una opción valiosa para aquellos que buscan desarrollar aplicaciones en Go de manera rápida, eficiente y escalable. Su enfoque en el rendimiento y la productividad lo convierten en una herramienta atractiva para proyectos de diversos tamaños y complejidades.

Dejo link: https://github.com/zeromicro/go-zero

 Me llego el siguiente mail y queria compartirlo : 

Comienza a usar la IA generativa Aprende cómo alcanzar el éxito sin contratiempos con la IA generativa. desde tu primer caso de uso hasta lograr un valor continuo. Descargar guía

Hola Emanuel,

Cuatro de cada cinco responsables de toma de decisiones empresariales creen que la IA generativa transformará su industria en los próximos 12 meses.1 La IA generativa no tardará mucho en influir en casi todos los sectores de todos los negocios, ya sea con respecto a la creación de contenido, la programación colaborativa, la búsqueda empresarial o la creación de resúmenes.

Ningún líder empresarial puede permitirse quedarse atrás. Para ayudarte a mantenerte al día con la información más reciente, nos complace compartir contigo “La guía para ejecutivos sobre la IA generativa”.

En esta guía completa, encontrarás lo siguiente:

Una guía paso a paso de 30 días para comenzar KPI para medir el impacto de la IA generativa Casos de uso específicos de la industria junto con historias de clientes, como Deutsche Bank, TIME y muchos más

1. Google Cloud Gen AI Benchmarking Study, julio de 2023

Descargar guía

Nos vemos en la nube, El equipo de Google Cloud

Más información   Ver el blog   Contactar a ventas

Manejo de memoria en Rust

Los programas asignan memoria de dos maneras:

stack: Área continua de memoria para variables locales.

Los valores tienen tamaños fijos conocidos en el momento de la compilación.

Extremadamente rápido: basta con mover un puntero de pila.

Fácil de administrar: sigue llamadas a funciones.

Gran recuerdo de la localidad.

heap: almacenamiento de valores fuera de las llamadas a funciones.

Los valores tienen tamaños dinámicos determinados en tiempo de ejecución.

Ligeramente más lento que la pila: se necesita algo de contabilidad.

No hay garantía de localidad de memoria.

Veamos un ejemplo: La creación de una cadena coloca metadatos de tamaño fijo en el stack y datos de tamaño dinámico, la cadena real, en el heap:

fn main() {

    let s1 = String::from("Hello");

}

Una cadena está respaldada por un Vec, por lo que tiene capacidad y longitud y puede crecer si es mutable mediante reasignación en el heap.

Podemos inspeccionar el diseño de la memoria con Rust pero esto no es seguro.

fn main() {

    let mut s1 = String::from("Hello");

    s1.push(' ');

    s1.push_str("world");

    // DON'T DO THIS AT HOME! For educational purposes only.

    // String provides no guarantees about its layout, so this could lead to

    // undefined behavior.

    unsafe {

        let (ptr, capacity, len): (usize, usize, usize) = std::mem::transmute(s1);

        println!("ptr = {ptr:#x}, len = {len}, capacity = {capacity}");

    }

}

Slices bidimensionales en Go

Las matrices y Slices de Go son unidimensionales. Para crear el equivalente de una matriz o un Slice 2D, es necesario definir un conjunto de matrices o un Slice de Slices, como este:

type Transform [3][3]float64  // A 3x3 array, really an array of arrays.

type LinesOfText [][]byte     // A slice of byte slices.

Debido a que los Slices tienen una longitud variable, es posible que cada Slice interno tenga una longitud diferente. Esa puede ser una situación común, como en nuestro ejemplo de LinesOfText: cada línea tiene una longitud independiente.

text := LinesOfText{

    []byte("Now is the time"),

    []byte("for all good gophers"),

    []byte("to bring some fun to the party."),

}

A veces es necesario asignar un Slice 2D, una situación que puede surgir al procesar líneas de escaneo de píxeles, por ejemplo. Hay dos formas de lograrlo. Una es asignar cada porción de forma independiente; la otra es asignar una única matriz y apuntar los sectores individuales hacia ella. Cuál usar depende de su aplicación. Si los sectores pueden crecer o reducirse, deben asignarse de forma independiente para evitar sobrescribir la siguiente línea; de lo contrario, puede ser más eficiente construir el objeto con una única asignación. Como referencia, aquí hay bocetos de los dos métodos. Primero, una línea a la vez:

// Allocate the top-level slice.

picture := make([][]uint8, YSize) // One row per unit of y.

// Loop over the rows, allocating the slice for each row.

for i := range picture {

    picture[i] = make([]uint8, XSize)

}

Y ahora como una asignación, dividida en líneas:

// Allocate the top-level slice, the same as before.

picture := make([][]uint8, YSize) // One row per unit of y.

// Allocate one large slice to hold all the pixels.

pixels := make([]uint8, XSize*YSize) // Has type []uint8 even though picture is [][]uint8.

// Loop over the rows, slicing each row from the front of the remaining pixels slice.

for i := range picture {

    picture[i], pixels = pixels[:XSize], pixels[XSize:]

}

Closures en Rust

Los Closures o expresiones lambda tienen tipos que no se pueden nombrar. Sin embargo, implementan características especiales de Fn, FnMut y FnOnce:

fn apply_with_log(func: impl FnOnce(i32) -> i32, input: i32) -> i32 {

    println!("Calling function on {input}");

    func(input)

}

fn main() {

    let add_3 = |x| x + 3;

    println!("add_3: {}", apply_with_log(add_3, 10));

    println!("add_3: {}", apply_with_log(add_3, 20));

    let mut v = Vec::new();

    let mut accumulate = |x: i32| {

        v.push(x);

        v.iter().sum::<i32>()

    };

    println!("accumulate: {}", apply_with_log(&mut accumulate, 4));

    println!("accumulate: {}", apply_with_log(&mut accumulate, 5));

    let multiply_sum = |x| x * v.into_iter().sum::<i32>();

    println!("multiply_sum: {}", apply_with_log(multiply_sum, 3));

}

Una Fn (por ejemplo, add_3) no consume ni muta los valores capturados, o tal vez no captura nada en absoluto. Se puede llamar varias veces al mismo tiempo.

Un FnMut (por ejemplo, acumular) podría mutar los valores capturados. Puedes llamarlo varias veces, pero no al mismo tiempo.

Si tiene un FnOnce (por ejemplo, multiplicar_sum), solo puede llamarlo una vez. Podría consumir valores capturados.

FnMut es un subtipo de FnOnce. Fn es un subtipo de FnMut y FnOnce. Es decir. puede usar un FnMut donde sea que se requiera un FnOnce, y puede usar un Fn donde sea que se requiera un FnMut o FnOnce.

El compilador también infiere Copy (por ejemplo, para add_3) y Clone (por ejemplo, multiply_sum), dependiendo de lo que capture el Closure.

De forma predeterminada, los Closures trabajan por referencia si pueden. La palabra clave move los hace capturar por valor.

fn make_greeter(prefix: String) -> impl Fn(&str) {

    return move |name| println!("{} {}", prefix, name)

}

fn main() {

    let hi = make_greeter("Hi".to_string());

    hi("there");

}

Casting en Rust

Rust no tiene conversiones de tipos implícitas, pero admite conversiones explícitas con as. 

fn main() {

    let value: i64 = 1000;

    println!("as u16: {}", value as u16);

    println!("as i16: {}", value as i16);

    println!("as u8: {}", value as u8);

}

Los resultados de as siempre están definidos en Rust y son consistentes en todas las plataformas. Es posible que esto no coincida con su intuición para cambiar el signo o transformar a un tipo más pequeño; debemos consultar la documentación.

Generalmente se desaconseja el uso de as en casos en los que se puedan perder datos, o al menos merece un comentario explicativo.

Función para filtrar valores de una lista en lisp

Vamos a hacer rápidamente una función que permita filtrar valores de una lista según una función. Veamos el código : 

(defun filtrar (lista fx) 

  (cond 

     ((null lista) lista) 

     ((funcall fx (first lista)) 

         (cons (first lista) (filtrar (rest lista) fx)))

     (T (filtrar (rest lista) fx))

  )

) 

Si la lista esta vacía la retorna, sino se fija si ese elemento cumple el criterio y si lo cumple construye una nueva lista con este elemento y el resto filtrado. Y si no retorna el resto de la lista filtrado. 

Veamos si funciona: 

> (filtrar '(1 2 3 4 5) (lambda (a) (> a 5)))

NIL

> (filtrar '(1 2 3 4 5) (lambda (a) (> a 2)))

(3 4 5)

> (filtrar '(1 2 3 4 5) (lambda (a) (< a 2)))

(1)

Traits From y Into de Rust

Los tipos que implementan From y Into facilitan las conversiones de tipos:

fn main() {

    let s = String::from("hello");

    let addr = std::net::Ipv4Addr::from([127, 0, 0, 1]);

    let one = i16::from(true);

    let bigger = i32::from(123i16);

    println!("{s}, {addr}, {one}, {bigger}");

}

Into se implementa automáticamente cuando se implementa From:

fn main() {

    let s: String = "hello".into();

    let addr: std::net::Ipv4Addr = [127, 0, 0, 1].into();

    let one: i16 = true.into();

    let bigger: i32 = 123i16.into();

    println!("{s}, {addr}, {one}, {bigger}");

}

Es por eso que es común implementar solo From, ya que su tipo también entrará en la implementación de Into.

Al declarar un tipo de entrada de argumento de función como "cualquier cosa que pueda convertirse en una cadena", la regla es la opuesta, debes usar Into. Su función aceptará tipos que implementen From y aquellos que solo implementen Into.

Testear endpoints en go con echo

Supongamos que tenemos unos endpoints hechos con echo:

package handler

import (

    "net/http"

    "github.com/labstack/echo/v4"

)

type (

    User struct {

        Name  string `json:"name" form:"name"`

        Email string `json:"email" form:"email"`

    }

    handler struct {

        db map[string]*User

    }

)

func (h *handler) createUser(c echo.Context) error {

    u := new(User)

    if err := c.Bind(u); err != nil {

        return err

    }

    return c.JSON(http.StatusCreated, u)

}

func (h *handler) getUser(c echo.Context) error {

    email := c.Param("email")

    user := h.db[email]

    if user == nil {

        return echo.NewHTTPError(http.StatusNotFound, "user not found")

    }

    return c.JSON(http.StatusOK, user)

}

Lo que queremos hacer es un test de unidad que testee este comportamiento, y podemos hacerlo así: 

package handler

import (

    "net/http"

    "net/http/httptest"

    "strings"

    "testing"

    "github.com/labstack/echo/v4"

    "github.com/stretchr/testify/assert"

)

var (

    mockDB = map[string]*User{

        "jon@labstack.com": &User{"Jon Snow", "jon@labstack.com"},

    }

    userJSON = `{"name":"Jon Snow","email":"jon@labstack.com"}`

)

func TestCreateUser(t *testing.T) {

    // Setup

    e := echo.New()

    req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(userJSON))

    req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)

    rec := httptest.NewRecorder()

    c := e.NewContext(req, rec)

    h := &handler{mockDB}

    // Assertions

    if assert.NoError(t, h.createUser(c)) {

        assert.Equal(t, http.StatusCreated, rec.Code)

        assert.Equal(t, userJSON, rec.Body.String())

    }

}

func TestGetUser(t *testing.T) {

    // Setup

    e := echo.New()

    req := httptest.NewRequest(http.MethodGet, "/", nil)

    rec := httptest.NewRecorder()

    c := e.NewContext(req, rec)

    c.SetPath("/users/:email")

    c.SetParamNames("email")

    c.SetParamValues("jon@labstack.com")

    h := &handler{mockDB}

    // Assertions

    if assert.NoError(t, h.getUser(c)) {

        assert.Equal(t, http.StatusOK, rec.Code)

        assert.Equal(t, userJSON, rec.Body.String())

    }

}

Y listo!! 

Dejo link: https://echo.labstack.com/docs/testing

Unir dos listas en lisp

Vamos a unir dos listas en Lisp. Si la primera lista es vacia, retornamos la otra lista y si no lo es, costruimos una nueva lista con el primer elemento de la primera lista y la union del resto de la primera lista (porque al primero ya lo sacamos) con la otra lista. 

(defun unir (lista1 lista2) 

  (cond 

    ((null lista1) lista2)

    (T (cons (first lista1) (unir (rest lista1) lista2)))

  )

)

Si probamos : 

> (unir '(1 2 3) '(4 5 6))

(1 2 3 4 5 6)

> (unir '(1 2 3) '(4))

(1 2 3 4)

Sobrecarga de operadores por medio de traits en Rust

 La sobrecarga del operador se implementa mediante rasgos en std::ops:

#[derive(Debug, Copy, Clone)]

struct Point { x: i32, y: i32 }

impl std::ops::Add for Point {

    type Output = Self;

    fn add(self, other: Self) -> Self {

        Self {x: self.x + other.x, y: self.y + other.y}

    }

}

fn main() {

    let p1 = Point { x: 10, y: 20 };

    let p2 = Point { x: 100, y: 200 };

    println!("{:?} + {:?} = {:?}", p1, p2, p1 + p2);

}

Si lo ejecutamos : 

cargo run main.rs

   Compiling hello_cargo v0.1.0 

    Finished dev [unoptimized + debuginfo] target(s) in 0.58s

     Running `target/debug/hello_cargo main.rs`

Point { x: 10, y: 20 } + Point { x: 100, y: 200 } = Point { x: 110, y: 220 }

Podrías implementar Add para &Point. Si el tipo T para el cual está sobrecargando el operador no implementa Copy, debería considerar sobrecargar también el operador para &T. Esto evita clonaciones innecesarias.

Se podría implementar Add para dos tipos diferentes, p. impl Add<(i32, i32)> for Point agregaría una tupla a un Point.

Sería así :

impl std::ops::Add<(i32, i32)>  for Point {

    type Output = Self;

    fn add(self, other: (i32, i32)) -> Self {

        Self {x: self.x + other.0, y: self.y + other.1}

    }

}

fn main() {

    let p1 = Point { x: 10, y: 20 };

    let tuple= (100, 200);

    println!("{:?} + {:?} = {:?}", p1, tuple, p1 + tuple);

}

Y la salida va a ser : 

Point { x: 10, y: 20 } + (100, 200) = Point { x: 110, y: 220 }