V (Vlang) A primeira versão principal 0.2 lançada, uma linguagem estática segura, rápida e compilável

Foi lançado o V (Vlang) 0.2. O autor anunciou que esta é a primeira versão principal. A atualização se concentra em melhorar a estabilidade e otimizar o gerenciamento de memória em tempo de compilação.

Alguns destaques da atualização

• -autofreeGerenciar a memória de tempo de compilação, habilitando parâmetros (planejado para ser habilitado por padrão em 0.3)
• Fornece suporte antecipado para iOS e Android
• Apresentar o fluxo IO
• Apresentar canal e bloquear
• Introduzir estrutura inline (incorporação Struct)
• Suporta compilação e implantação automáticas de arquivos binários V para Linux / Windows / macOS por meio de Ações GitHub
• Suporte para compilador C ++: o código gerado pelo backend C agora pode ser compilado pelo compilador C ++
• A sintaxe genérica é mais concisa, como em foo(5)vez de usarfoo<int>(5)
• V agora pode ser executado no navegador via WASM
• Melhorar a documentação
• ……

Para obter detalhes, consulte  https://github.com/vlang/v/discussions/7474
V 0.3 Roadmap: https://github.com/vlang/v/blob/master/0.3_roadmap.txt

V é uma linguagem estática que combina a simplicidade do Go e os recursos de segurança do Rust. O autor afirmou que V é muito semelhante ao Go. Se você conhece Go, já conhece 80% de V. V melhora com base no Go: https://vlang.io/compare#go .

V características principais

• Simples (o autor afirma ser capaz de aprender V em menos de uma hora)
• Compilação rápida (o compilador tem apenas 400kb e não há dependência de terceiros)
• Fácil de desenvolver: V compila em menos de um segundo
• Segurança: sem nulo, sem variáveis ​​globais, sem valores indefinidos, detecção de limite, estrutura imutável é usada por padrão
• Suporte para conversão C / C ++
• Compilação cruzada fácil de usar
• Fornece biblioteca de interface de usuário de plataforma cruzada
• Biblioteca gráfica integrada
• ORM integrado
• Estrutura da web integrada
• ……

Código de amostra

Acesso ao banco de dados:

struct User { /* ... */ }
struct Post { /* ... */ }
struct DB   { /* ... */ }

struct Repo <T> {
    db DB
}

fn new_repo<T>(db DB) Repo {
    return Repo<T>{db: db}
}

fn (r Repo) find_by_id(id int) T? { // `?` means the function returns an optional
    table_name := T.name // in this example getting the name of the type gives us the table name
    return r.db.query_one<T>('select * from $table_name where id = ?', id)
}

fn main() {
    db := new_db()
    users_repo := new_repo<User>(db)
    posts_repo := new_repo<Post>(db)
    user := users_repo.find_by_id(1) or {
        eprintln('User not found')
        return
    }
    post := posts_repo.find_by_id(1) or {
        eprintln('Post not found')
        return
    }
} 

Desenvolvimento web:

struct Story {
    title string
}

// Fetches top HN stories in 8 coroutines 
fn main() {
    resp := http.get('https://hacker-news.firebaseio.com/v0/topstories.json')?
    ids := json.decode([]int, resp.body)?
    mut cursor := 0
    for _ in 0..8 {
        go fn() {
            for  {
                lock { // Without this lock the program will not compile 
                    if cursor >= ids.len {
                        break
                    }
                    id := ids[cursor]
                    cursor++
                }
                resp := http.get('https://hacker-news.firebaseio.com/v0/item/$id.json')? 
                story := json.decode(Story, resp.body)?
                println(story.title)
            }
        }()
    }
    runtime.wait() // Waits for all coroutines to finish 
}