DEV Community: Douglas Massolari

Setting Up Neovim with Fennel

Douglas Massolari — Tue, 06 Jun 2023 09:34:56 +0000

It all starts on the moon Lua

One of the most anticipated and loved features by Neovim users is the lua support.

This support officially came in version 0.5 of the neovim, which went on to allow the users to ~~throw away~~ stop using their init.vim and set up the neovim with a nice init.lua.

And a happy consequence of this is that we can not only use Lua, but we can use lua ecosystem packages and languages that compile to Lua

Hello, Peter Fennel

Fennel is one of these languages that compile to Lua, which means you will write Fennel code and the compiler will generate Lua code, which will be read and run by neovim.



Fennel -> Lua -> Neovim

But why Fennel?

This is a very common question that people ask when I say that I use Fennel.

It seems that's a common question that people ask everyone who uses Fennel because the official Fennel website has the answer to exactly this question.

I will summarize their response in a few points.

Fennel is less error-prone

Lua is a great language, but some points can facilitate the occurrence of errors.

One of the points is the ease with which you access or change a global variable.
If you create a variable without the local keyword it is already a global variable. And to access the value of that variable, you just need to type the name of the variable, which can cause unexpected behavior, for example:



-- settings.lua
myVar = 'this is global'


-- init.lua
local myVal = 'local'
print('this is the value of local: ' .. myVar) -- Oops

Note that, due to a typing error in the word myVal, replacing l with r we end up accessing the value of a global variable defined elsewhere.
Errors like this can be difficult to find out.

Fennel prevents errors like this by allowing access to global variables only through the _G table.
When trying to simulate the above case in Fennel, the compiler will alert us that the myVar variable does not exist.



(local myVal "local")
(print (.. "This is the value of local: " myVar))

:: COMPILE ERROR
  xxx settings/globals.fnl
      Compile error in settings/globals.fnl:42
        unknown identifier in strict mode: myVar

      * Try looking to see if there's a typo.
      * Try using the _G table instead, eg. _G.myVar if you really want a global.
      * Try moving this code to somewhere that myVar is in scope.
      * Try binding myVar as a local in the scope of this code.

Another point, which can facilitate the occurrence of Lua errors, is the lack of validation of the number of arguments of a function.



local function myAnd(x, y)
  return x and y
end
print(myAnd(true)) -- nil

Notice that I only passed 1 argument, and the function works with 2 parameters, the code in Lua ran without telling me that I forgot to pass another argument to the function.

In Fennel, we can use the lambda keyword to create functions that validate parameters:



(lambda my-and [x y]
  (and x y))

(print (my-and true)) ; Error [...] Missing argument y

Note: In Fennel, ; is the character used to start a comment

(Syntax (from (Lisp!)))

This is a bit controversial because some people don't like Lisp's syntax, but it has some benefits:

Everything is an expression, i.e. we don't have statements
When dealing with operators, there is no ambiguity of what comes first, we have no "operator precedence". (In lua, for example, A or B and C or D)

These points make Fennel a very simple language to program and maintain.

Modernity and facilities

In addition to the points mentioned above, it is worth highlighting some interesting features that Fennel brings to make our lives easier.

With Fennel, we have destructuring, pattern matching, macros and more.

Destructuring

While on Lua we do:



-- Lua
local var = require'module'.var
local var2 = require'module'.var2

In fennel, we can simply do:



; Fennel
(local {: var : var2} (require :module))

Pattern matching

When we want to test the value of a variable several times, in Lua, we make an if sequence:



-- Lua
local function get_desc(key)
  if (key == "k1") then
    return "Key 1"
  elseif (key == "k2") then
    return "Key 2"
  elseif (key == "k3") then
    return "Key 3"
  else
    return nil
end

Whereas, in fennel, we can use match:



; Fennel
(lambda get-desc [key]
  (match key
    :k1 "Key 1"
    :k2 "Key 2"
    :k3 "Key 3"))

How to get started

Now that I've convinced you (at least I hope) to use Fennel, let's see how to start using it to configure Neovim!

We will use two plugins for this:

tangerine
udayvir-singh / tangerine.nvim

🍊 Sweet Fennel integration for Neovim
🍊 Tangerine 🍊

About • Installation • Setup • Commands • API • Development

About

Tangerine provides a painless way to add fennel to your config.

Features
- 🔥 BLAZING fast, compile times in milliseconds
- 🌊 100% support for interactive evaluation
- 🎍 Control over when and how to compile
- 🎀 Natively loads nvim/init.fnl
Comparison to other plugins

HOTPOT 🍲
- Abstracts too much away from the user.
- Hooks onto lua package searchers to compile [harder to debug].
ANISEED 🌿
- Excessively feature rich for use in dotfiles.
- Blindly compiles all files that it founds, resulting in slow load times.
Installation
1. Create file plugin/0-tangerine.lua to bootstrap tangerine:
Important

If you are using lazy.nvim then you should create init.lua instead of plugin/0-tangerine.lua.

Refer to #20 for more information.
-- ~/.config/nvim/plugin/0-tangerine.lua or ~/.config/nvim/init.lua -- pick your plugin manager local pack = "tangerine" or "packer" or "paq" or "lazy
…
View on GitHub
hibiscus
udayvir-singh
/
hibiscus.nvim

🌺 Flavored Fennel Macros for Neovim
Hibiscus.nvim

🌺 Highly opinionated macros to elegantly write your neovim config.

Companion library for tangerine but it can also be used standalone.

Rational
- 🍬 Syntactic eye candy over hellscape of lua api
- 🎋 Provides missing features in both fennel and nvim api
Installation
- Create file plugin/0-tangerine.lua to bootstrap hibiscus:
NOTE: if you are using lazy plugin manager, you should create /init.lua instead.
-- ~/.config/nvim/plugin/0-tangerine.lua or ~/.config/nvim/init.lua -- pick your plugin manager local pack = "tangerine" or "packer" or "paq" or "lazy" local function bootstrap(url, ref) local name = url:gsub(".*/", "") local path if pack == "lazy" then path = vim.fn.stdpath("data") .. "/lazy/" .. name vim.opt.rtp:prepend(path) else
…
View on GitHub

Tangerine integrates Fennel with Neovim very transparently, compiling Fennel files to Lua and bringing some interesting tools.
hibiscus brings several macros related to the Neovim ecosystem that help us to write less

The first step is to create the ~/.config/nvim/plugin/0-tangerine.lua file with the content:



local function bootstrap (name, url, path)
    if vim.fn.isdirectory(path) == 0 then
        print(name .. ": installing in data dir...")

        vim.fn.system {"git", "clone", "--depth", "1", url, path}

        vim.cmd [[redraw]]
        print(name .. ": finished installing")
    end
end

bootstrap (
  "tangerine.nvim",
  "https://github.com/udayvir-singh/tangerine.nvim",
  vim.fn.stdpath "data" .. "/site/pack/packer/start/tangerine.nvim"
)

bootstrap (
  "hibiscus.nvim",
  "https://github.com/udayvir-singh/hibiscus.nvim",
  vim.fn.stdpath "data" .. "/site/pack/packer/start/hibiscus.nvim"
)

require'tangerine'.setup{
  compiler = {
    verbose = false,
    hooks = { "onsave", "oninit" }
  }
}

This setup assumes you use Packer to manage your plugins, if you don't, check the Tangerine repository for how to install it in your plugin manager.

With this, when restarting Neovim, tangerine and Hibiscus will be downloaded and initialized.

This means you can now start configuring Neovim in Fennel by creating a ~/.config/nvim/init.fnl file 🎉

When you save this file, tangerine will already compile it and generate the lua file to be loaded by Neovim, not requiring any additional configuration for this.

Tips for getting started with Fennel

Documentation is your friend!

The two best sources for understanding how Fennel works are Fennel's tutorial and reference.

I'll advance some simple things for you to understand the basics.

Parentheses

You will see a lot of parentheses in Fennel, they serve to delimit where an expression starts and ends.

For example, to declare a variable in the local scope, in Lua, you use the keyword local, whereas in Fennel you call the function local:



(local myVar "myValue") ; myVar = "myValue"

If the value of the variable is the result of a concatenation, we will not use the operator .., but the function ..:



(local name "Fennel")
(local myVar (.. "Hello, " name)) ; myVar = "Hello, Fennel"

In short, every function you call will be enclosed in parentheses.

Neovim API

Everything you do with Lua, you do with Fennel, so the same call you make to a Neovim API in Lua, you'll make in Fennel.
This, on Lua:



-- Lua
print(vim.fn.stdpath"config")

this is it, in fennel:



(print (vim.fn.stdpath :config))

:symbol

You may have already noticed that, in some cases, I wrote some strings in Lua using : in fennel (if you didn't, just look at the last example)

This is another way to write a string. However, to write in this format, the string cannot contain spaces.



(= :str "str") ; true

Tangerine Mappings

The plugin we use to integrate Fennel with Neovim has some mappings and commands that help us write code that will generate what we want. I'll list the ones I use the most below:

gL

It can be run both in normal mode and in visual mode.
This mapping shows the Lua code that your Fennel code will generate.
For example, if I press gL after selecting the snippet:



(lambda add [x y]
  (+ x y))

It opens a window containing the code in Lua:



local function add(x, y)
  _G.assert((nil ~= y), "Missing argument y on globals.fnl:1")
  _G.assert((nil ~= x), "Missing argument x on globals.fnl:1")
  return (x + y)
end
return add

Very useful for quickly checking that the fennel code you are writing will generate the Lua code you expect.

Note: This mapping doesn't work very well in visual mode if you select a snippet that uses some macro unless the snippet has the macro import.

gO

This mapping opens the lua file compiled by the open fennel file, that is, if you have the plugins.fnl file open and press gO, it will open the plugins.lua file that was generated by the compilation of plugins.fnl.
Very useful for debugging.

:Fnl

You can run any code in Fennel with the :Fnl command, just like :lua.

:Fnl (print "hey")

Will print hey, equivalent to :lua print("hey")

Now it's up to you

From here, you're ready to have some fun using Fennel (and it is).

Any questions, ask here in the comments!

Happy Vimming!

Criando um ambiente de desenvolvimento com Nix

Douglas Massolari — Sat, 09 Jul 2022 06:50:15 +0000

O que é nix?

Se você não sabe o que é Nix, eu escrevi um artigo sobre como usá-lo como um gerenciador de pacotes onde eu falo sobre o que é Nix.

Para continuar a leitura desse artigo, eu recomendo que você leia o outro, pois vamos utilizar alguns conceitos explicados lá.

Preparação

Nesse artigo, vamos usar o flakes, assim como no artigo passado.

Se você usa o Nix como seu gerenciador de pacotes, da forma que expliquei no outro artigo, você pode pular para a próxima seção.

Caso contrário, você precisa habilitar o uso do flakes pelo Nix. Para isso, basta criar o arquivo ~/.config/nix/nix.conf com o conteúdo:

experimental-features = nix-command flakes

Isso diz ao Nix para habilitar o flakes sem precisar passar uma flag.

Agora, vamos em frente!

O que é um ambiente de desenvolvimento?

Um ambiente de desenvolvimento é um "ambiente" onde todas as ferramentas necessárias para desenvolver um projeto estão disponíveis.

Com o Nix, conseguimos utilizar pacotes sem instalá-los no nosso sistema, através de um arquivo declarativo.

Ou seja, conseguimos criar um arquivo com todos os pacotes que queremos e o Nix se encarrega de disponibilizá-los temporariamente para nós.

Isso é ótimo, pois, além de não precisarmos instalar ferramentas na nossa máquina para projetos específicos, se subirmos esse arquivo para o repositório do projeto, toda a equipe pode ter o mesmo ambiente sem precisar instalar nada (além do Nix, é claro)!

Criando seu ambiente

O que vamos fazer para criar um ambiente é, na verdade, bem parecido com o que você viu no outro artigo.

Vamos supor que eu quero fazer uns exercícios de Rust no Exercism, mas não quero instalar nada de Rust na minha máquina, nem quero instalar o exercism.

Vou começar criando uma pasta Exercism na minha pasta HOME:

mkdir Exercism

Dentro dessa pasta, vou criar um arquivo flake.nix com o conteúdo:

{
  description = "Ambiente para exercícios de Rust";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs { inherit system; };
      in {
        devShell = with pkgs; mkShell {
          packages = [
            exercism
            cargo
            libiconv
          ];
        };
      }
    );
}

Começamos definindo o campo description com uma descrição do que se trata esse arquivo.

Depois definimos nossas dependências no campo inputs, que são:

O repositório do nixpkgs
Um utilitário chamado flake-utils, que vamos utilizar para criar um ambiente que suporte várias plataformas

No outputs chamamos a função eachDefaultSystem do flake-utils. Essa função recebe um callback onde recebemos o system. O que essa função faz é chamar esse callback para todas as plataformas que o Nix suporta (Linux, Mac e Windows) passando o system desta plataforma.

Nós definimos a variável pkgs com o valor resultante do nixpkgs configurado com o system que recebemos. Assim, os pacotes instalados serão da plataforma correta.

Por fim, definimos o campo devShell, que se refere ao shell que vamos criar, o valor vai ser o retorno da função mkShell. Nós passamos para essa função um set com um único campo packages, que é a lista de pacotes que queremos disponíveis no nosso shell.

No nosso caso, vamos precisar de 3 pacotes, o exercism que vai servir para baixar os exercícios e enviar o resultado, o cargo para rodar os testes em Rust e o libiconv que é necessário para o cargo rodar.

Agora, vamos rodar o comando:

nix develop

E é aqui que a mágica acontece!

O Nix vai baixar os pacotes e torná-los disponíveis para a gente em um shell.

exercism version
> exercism version 3.0.13

cargo -V
> cargo 1.61.0

Isso significa que eu posso baixar um exercício executando, por exemplo:

exercism download --exercise=reverse-string --track=rust

E ele vai criar a pasta rust/reverse-string dentro da pasta Exercism que estamos.

Eu posso ir até essa pasta e rodar os testes usando o cargo:

cd rust/reverse-string
cargo test

Quando eu terminar, é só eu sair do shell com exit e os pacotes que estavam disponíveis não estão mais.

exercism version             
> zsh: command not found: exercism

cargo -V   
> zsh: command not found: cargo

Sistema limpo! ✨

Conclusão

Esse foi um exemplo bem bobo, mas deu para ter um gosto do que é capaz de fazer.

Você pode colocar qualquer ferramenta, como formatadores de código, language-servers etc.

No final, você vai ter o seu arquivo flake.nix e outro arquivo, criado pelo Nix, chamado flake.lock, esse último contém a versão de todos os pacotes baixados, assim, sempre que você ou uma pessoa da sua equipe rodar o nix develop, o ambiente vai ser o mesmo até na versão dos pacotes utilizados.

Espero que esse artigo tenha sido útil!

Boa sorte criando seus ambientes!

Até a próxima! 👋

O que é Nix e como utilizá-lo como seu gerenciador de pacotes

Douglas Massolari — Sat, 18 Jun 2022 00:20:31 +0000

Quando eu comecei a trabalhar na Tweag, eu conheci uma ferramenta chamada Nix.
Na Tweag praticamente todo mundo ama e usa Nix e eu me senti encorajado a aprender mais sobre ele.
Então, depois de ler, estudar e de receber uma grande ajuda do pessoal do trabalho, eu comecei a usar Nix como meu gerenciador de pacotes e configurações e estou gostando bastante.

Antes de mais nada, vamos partir do princípio...

O que é Nix?

Diretamente do site oficial

Nix is a tool that takes a unique approach to package management and system configuration. Learn how to make reproducible, declarative and reliable systems.

Traduzindo de forma livre

Nix é uma ferramenta que possui uma forma única de gerenciamento de pacotes e configuração de sistema. Aprenda como criar sistemas reprodutíveis, declarativos e confiáveis.

Isso não nos diz muita coisa, que "forma única" é essa? Vamos falar sobre os 3 pontos descritos acima: configuração declarativa, reprodutiva e confiável

Configuração declarativa

Em Nix não instalamos pacotes como em gerenciadores de pacotes tradicionais, isto é, executando um comando como apt install ou brew install. Até podemos fazer isso, mas não é a proposta, pois isso é um comando imperativo.

A proposta do Nix é configurar de forma declarativa e nós fazemos isso através de um arquivo de configuração aonde listamos todos pacotes e configurações, ou seja, nós declaramos quais pacotes queremos instalar e como configura-los.

Por exemplo, em vez de sudo apt install git wget yarn, eu tenho, em meu arquivo de configuração, as linhas:

home = {
  packages = with pkgs; [
    wget
    yarn
  ];
};
programs = {
  git = {
    enable = true;
    userName = "Douglas M.";
    userEmail = "douglasmassolari@hotmail.com";
  };
}

Repare que, além de listar os pacotes que quero instalar, posso configurar, diretamente, o git, através do Nix. Essas configurações serão, automaticamente, aplicadas por ele no arquivo de configuração do git.

Isso, obviamente, não se limita ao git, sendo possível configurar diversas aplicações como zsh, gh, kitty etc.
Outro ponto interessante é que, olhando o arquivo de configuração, fica bem claro quais os pacotes eu instalei, diferentemente de eu fazer um apt list, onde ele lista tudo o que eu instalei E as dependências instaladas.

Configuração reprodutível

Como temos esse arquivo de configuração, no qual declaramos os pacotes e temos a configuração dos mesmos, é fácil reproduzir um ambiente.

E é ainda mais fácil quando usamos o flakes!

Flakes permite que, além dos pacotes do repositório oficial do Nix, nós possamos declarar pacotes diretamente do GitHub, além disso, ele cria um arquivo flake.lock que contém a versão exata do pacote. Assim você consegue reproduzir de forma mais fiel uma configuração.

Configuração confiável

Umas das funcionalidades mais interessantes do Nix são as generations.

Para aplicar as suas configurações, você manda o Nix fazer o build do arquivo. Ele vai ler o seu arquivo, gerar os binários dos pacotes e o resultado disso é uma generation, cada vez que você faz um build que difere do anterior, uma nova generation é criada. Sendo que ele não apaga a anterior automaticamente, o que torna possível que você consiga aplicar uma generation criada anteriormente!

Isso é muito útil porque, caso você desconfigure alguma coisa, você pode simplesmente voltar para a última configuração funcional que você tinha.

É útil também para testar qualquer coisa sem medo de quebrar alguma coisa.

Um ponto interessante disso tudo é que ele só gera os binários e arquivos daquilo que está no seu arquivo de configuração, ou seja, nunca mais você vai ter "lixo" no seu sistema de coisas que você instalou e desinstalou.

Começando a utilizar o Nix

Depois de tanta explicação, vamos colocar a mão na massa e começar a instalar e a utilizar o Nix para gerenciar nossos pacotes.

Instalação do Nix

Primeiro, claro, precisamos instalar o Nix.

Na página oficial de instalação tem as instruções bem claras, basta segui-las e vai dar tudo certo 🤞🏻

Criação do arquivo `flake.nix`

Vamos começar a criar o arquivo que vai conter nossas configurações.

Esse arquivo precisa estar em um repositório, então, se você ainda não tiver um repositório de dotfiles, você pode criar com os comandos:

mkdir dotfiles
cd dotfiles
git init

Dentro dessa pasta, crie o arquivo flake.nix com o seguinte conteúdo:

{
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
    home-manager = {
      url = "github:nix-community/home-manager/master";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = { self, nixpkgs, home-manager, ... }:
    let
      system = "x86_64-linux"; # Se usa Mac: "x86_64-darwin"
      username = "USERNAME";
      pkgs = import nixpkgs {
        inherit system;
        config.allowUnfree = true;
      };
    in
    {
      homeConfigurations.${username} = home-manager.lib.homeManagerConfiguration {
        inherit pkgs;
        modules = [
          ({ config, ... }: {
            home = {
              stateVersion = "22.11";
              inherit username;
              homeDirectory = "/home/${username}"; # Se usa Mac: "/Users/${username}"

              file.".config/nix/nix.conf".text = ''
                experimental-features = nix-command flakes
              '';

              # Se usa Mac, descomente o código abaixo
              #
              # Isso vai fazer com que os programas instalados
              # apareçam no spotlight
              #
              # file."Applications/Home Manager Apps".source = let
              #   apps = pkgs.buildEnv {
              #     name = "home-manager-applications";
              #     paths = config.home.packages;
              #     pathsToLink = "/Applications";
              #   };
              # in "${apps}/Applications";

              packages = with pkgs; [ ];
            };

            programs = {
              home-manager.enable = true;
            };
          })
        ];
      };
    };
}

Nota: Onde está USERNAME você precisa colocar o seu nome de usuário.

Vamos falar um pouco sobre o conteúdo desse arquivo.
Você precisa saber algumas coisas sobre ele:

A linguagem na qual ele é escrita se chama Nix.
Pois é, além de um gerenciador de pacotes e um sistema operacional (NixOS), Nix também é a linguagem que usamos em arquivos nix.
Esse arquivo é um flake (você pode ter percebido pelo nome).
Mais acima, eu falei sobre flakes e deixei um link para a página oficial onde você pode saber mais sobre ele.
Resumidamente, ele facilita a maneira com que usamos o Nix para fazer nossa configuração.
Por causa dele é que temos inputs e outputs no arquivo.
Esse arquivo é como um arquivo JSON, é composto de chaves e valores, porém, diferentemente do JSON, ele permite que usemos alguma lógica enquanto escrevemos.
Podemos definir variáveis, usar if e mais.
Aqui tem um pequeno tutorial sobre a linguagem Nix.

Nos inputs nós declaramos nossas dependências que, neste caso, são duas:

O nixpkgs, que é o repositório de pacotes do Nix, estamos usando a versão unstable, mas você não precisa se preocupar com isso porque os pacotes lá são bem estáveis, apesar do nome.
O home-manager, que é uma ferramenta que permite gerenciarmos os pacotes e configuração à nível de usuário, que é o nosso objetivo. Você pode ler mais sobre ele na wiki do NixOS.

Nos outputs nós dizemos o que queremos gerar.

Vou explicar passo-a-passo o que estamos fazendo aqui, mas não vou explicar detalhes da linguagem, para isso que eu passei o link do tutorial acima.

A gente está passando uma função e, no corpo dela, começamos declarando 3 variáveis dentro do bloco let/in e definimos um valor no campo homeConfigurations.${username}.
O valor para esse campo é o retorno da função home-manager.lib.homeManagerConfiguration.
Para essa função, nós passamos um set.
inherit nome é a mesma coisa que nome = nome.
Em modules nós definimos os módulos que queremos configurar, que é onde fica nossa configuração de fato, com os pacotes e a configuração de cada um.
Nós definimos um módulo com duas chaves principais: home, que são as configurações relacionadas à pasta HOME e a lista de pacotes que queremos instalar, e programs que é onde vamos habilitar e configurar programas que são suportados pelo home-manager. Veremos isso melhor mais adiante.
Começamos habilitando o home-manager, assim ele mesmo se gerencia. Com essa sintaxe PROGRAMA.enable dentro de programs podemos instalar e configurar vários pacotes.
Usamos file dentro de home para criar um arquivo do nix na nossa pasta HOME com uma definição para habilitar o flakes sempre, assim, não precisamos passar --extra-experimental-features o tempo todo.
Em packages dentro de home é onde vamos declarar os pacotes que queremos instalar, repare que iniciamos com [], que é uma lista vazia.

Instalando o home-manager

O primeiro passo é adicionar o arquivo flake.nix ao staging do repositório git, basta executar:

git add flake.nix

Depois, vamos fazer o build do nosso flake.nix executando:

nix --extra-experimental-features 'nix-command flakes' build .#homeConfigurations."\"$USER\"".activationPackage

Esse comando é grande, mas não é complexo.
Na verdade, o comando é nix build, mas temos que passar o argumento --extra-experimental-features para habilitar o flakes e o nix-command, que são necessários dessa vez.
O que vem depois é só a gente passando o que ele tem que fazer o build, nesse caso, é o arquivo flake que existe na pasta atual, por isso . e, dentro desse arquivo (#) queremos executar a função activationPackage que existe dentro do homeConfigurations.$USER.

Não se preocupe porque só temos que executar esse comando uma vez.

Quando ele terminar, vai existir uma pasta result e, dentro dela, um binário chamado activate.
Vamos executá-lo:

./result/activate

Ao terminar, você já deve ter o comando home-manager disponível.

$ home-manager --version
22.05

A partir daqui, já conseguimos utilizar o Nix com home-manager para instalar e configurar nossos pacotes 🎉

Instalando e configurando pacotes

Usando `programs`

Vamos começar com o git, que é um programa comum que todos devemos ter.

Adicione, dentro de programs, as linhas:

git = {
  enable = true;
  userName = "NOME DE USUÁRIO";
}

Salve o arquivo e, no terminal, execute:

home-manager switch --flake .

Esse é o comando que você vai usar sempre que alterar sua configuração.

Ele vai fazer o build e criar uma generation.

Ao executar which git você deve reparar que o caminho fica na pasta .nix-profile/bin, o que significa que o git foi instalado pelo nix.

Ao executar git config user.name, você deve receber como retorno o valor que você definiu em seu arquivo de configuração.

Repare que não usamos a lista de pacotes packages em home, isso porque o home-manager possui a opção programs.git.

Para saber quais opções do home-manager existem, como programs.git, você pode olhar na página de opções do home-manager

Na linguagem Nix, os dois códigos abaixo, para habilitar o git, são equivalentes:

programs = {
  git = {
    enable = true;
  };
};

programs.git.enable = true;

Na documentação de opções do home-manager, você vai ver as opções sendo descritas do segundo modo, mas você pode escrever do primeiro modo, ou até uma mistura do dois, como por exemplo:

programs = {
  git = {
    enable = true;
    userName = "userName"
  };

  bat.enable = true;

  fzf.enable = true;
}

Usando `home.packages`

Agora, vamos supor que você queira instalar o wget.

O home-manager não possui essa opção, então não vamos usar o programs, em vez disso, vamos procurar por esse pacote no nixpkgs que é o repositório de pacotes do Nix.

Para procurar por um pacote, você pode usar o comando nix search nixpkgs PACOTE ou ir na página de pesquisa do nix e digitar o nome do pacote que deseja instalar.

Se buscarmos wget na página de pesquisa, encontramos o que queremos como primeiro resultado, isso significa que o pacote está no nixpkgs, então basta o colocarmos na em home.packages:

home = {
  # ...
  packages = with pkgs; [
    wget
  ];
};

Basta executarmos o comando:

home-manager switch --flake .

E, depois que o Nix terminar de fazer o build, o wget já vai estar instalado!

Generations

Listar

Cada vez que você faz o build, você vai ver o número da generation criada.
Para listar as generations você pode fazer

home-manager generations

Ele vai te mostrar as generations existentes em ordem decrescente com o caminho para cada uma.

Rollback

Para fazer um rollback, ou seja, retornar para uma generation anterior, basta copiar o caminho dela e executar o arquivo activate que existe dentro da pasta dela.
Por exemplo, ao listar minhas generations eu vejo que tenho:

$ home-manager generations
2022-06-17 21:06 : id 56 -> /nix/store/g5qzmkcwbxx786x8lb9xff776gffngyg-home-manager-generation
2022-06-17 21:05 : id 55 -> /nix/store/hb4p96vhkdvwirdsrjh5zi7cljd5d6mk-home-manager-generation
2022-06-15 13:02 : id 54 -> /nix/store/g5qzmkcwbxx786x8lb9xff776gffngyg-home-manager-generation
2022-06-08 12:46 : id 53 -> /nix/store/hb4p96vhkdvwirdsrjh5zi7cljd5d6mk-home-manager-generation

Se eu quero voltar para a 54, eu copio o caminho dela /nix/store/g5qzmkcwbxx786x8lb9xff776gffngyg-home-manager-generation e executo o arquivo activate dela:

$ /nix/store/g5qzmkcwbxx786x8lb9xff776gffngyg-home-manager-generation/activate

Apagar

Como não existe almoço grátis, as generations ocupam espaço em disco, então você vai querer ir deletando as mais antigas.

Você pode usar o comando home-manager remove-generations para remover uma generation.

Para remover uma série delas, você pode usar {N..M}.
Por exemplo, se eu quero remover todas as minhas generations da 1 até a 54 eu posso fazer:

home-manager remove-generations {1..54}

Dicas finais

Makefile

Para não ter que escrever sempre home-manager switch --flake ., você pode criar um arquivo Makefile com o conteúdo:

switch:
    home-manager switch --flake .

Assim você só precisa executar make e ele vai executar o comando do home-manager!

Meu repositório

Eu ainda não tenho muita coisa configurada, mas, se quiser dar uma olhada nas minhas configurações, é só ir ao meu repositório de dotfiles

Espero que o Nix seja útil para você! Vou ficando por aqui!

Configurando Neovim com Fennel

Douglas Massolari — Fri, 20 May 2022 19:26:38 +0000

Tudo começa na Lua

Uma das funcionalidades mais aguardadas e amadas pelos usuários do Neovim é o suporte à lua.

Esse suporte veio, oficialmente, na versão 0.5 do Neovim, o que passou a permitir que os usuários pudessem ~~jogar no lixo~~ deixar de usar seus init.vim e configurar o Neovim usando um belo init.lua.

E uma feliz consequência disso é que, não só podemos usar lua, mas podemos usar pacotes do ecossistema lua e linguagens que compilam
para lua

Hello, Peter Fennel

Fennel é uma dessas linguagens que compilam para lua, o que significa que você vai escrever código fennel, o compilador vai gerar código lua, que vai ser lido e executado pelo Neovim.

Fennel -> Lua -> Neovim

Mas, por que Fennel?

Essa é uma pergunta bastante comum que as pessoas fazem quando eu digo que uso Fennel.

Na verdade, é uma pergunta comum que as pessoas fazem para todos que usam Fennel, pelo que parece, porque no site oficial do Fennel tem a resposta para, exatamente, essa pergunta.

Vou resumir a resposta deles em alguns pontos.

Fennel é menos propenso à alguns erros

Lua é uma ótima linguagem, porém existem alguns pontos que podem facilitar a ocorrência de erros.

Um dos pontos é a facilidade com que você acessa ou altera uma variável global.
Se você criar uma variável sem a palavra chave local ela já é uma variável global. E para acessar o valor dessa variável, basta digitar o nome da variável, o que pode causar comportamentos inesperados, por exemplo:

-- settings.lua
myVar = 'this is global'


-- init.lua
local myVal = 'local'
print('this is the value of local: ' .. myVar)

Repare que, por um erro de digitação da palavra myVal, trocando o l pelo r acabamos acessando o valor de uma variável global definida em outro lugar.
Erros como esse podem ser difíceis de descobrir.

Fennel previne erros como esse permitindo que o acesso à variáveis globais sejam feitos apenas através da tabela _G.
Ao tentar simular o caso acima em Fennel, o compilador nos alertará que a variável myVar não existe.

(local myVal "local")
(print (.. "This is the value of local: " myVar))

:: COMPILE ERROR
  xxx settings/globals.fnl
      Compile error in settings/globals.fnl:42
        unknown identifier in strict mode: myVar

      * Try looking to see if there's a typo.
      * Try using the _G table instead, eg. _G.myVar if you really want a global.
      * Try moving this code to somewhere that myVar is in scope.
      * Try binding myVar as a local in the scope of this code.

Outro ponto, que pode facilitar a ocorrência de erros em lua, é a falta de validação do número de argumentos de uma função.

local function myAnd(x, y)
  return x and y
end
print(myAnd(true)) -- nil

Repare que eu apenas passei 1 argumento, sendo que a função trabalha com 2 parâmetros, o código em lua rodou sem me avisar que esqueci de passar outro argumento para a função.

Em Fennel, podemos usar a palavra chave lambda para criar funções que validam os parâmetros:

(lambda my-and [x y]
  (and x y))

(print (my-and true)) ; Error [...] Missing argument y

Nota: Em fennel, ; é o caractere usado para iniciar um comentário

(Sintaxe (do (Lisp!)))

Esse é um ponto um pouco polêmico porque algumas pessoas não gostam da sintaxe do Lisp, mas ela traz alguns benefícios:

Tudo é uma expressão, ou seja, não temos statements
Quando lidamos com operadores, não há ambiguidade do que vem primeiro, não temos "precedência de operadores". (Em lua, por exemplo, A or B and C or D)

Esses pontos tornam Fennel uma linguagem muito simples de se programar e de se dar manutenção.

Modernidade e facilidades

Além dos pontos mencionados acima, vale a pena ressaltar algumas funcionalidades interessantes que o Fennel traz para facilitar a nossa vida.

Com Fennel, temos desestruturação, pattern matching, macros e mais.

Desestruturação

Enquanto em lua fazemos:

-- Lua
local var = require'module'.var
local var2 = require'module'.var2

Em fennel, podemos, simplesmente, fazer:

; Fennel
(local {: var : var2} (require :module))

Pattern matching

Quando queremos testar o valor de uma variável várias vezes, em lua, fazemos uma sequência de if:

-- Lua
local function get_desc(key)
  if (key == "k1") then
    return "Key 1"
  elseif (key == "k2") then
    return "Key 2"
  elseif (key == "k3") then
    return "Key 3"
  else
    return nil
end

Enquanto, em fennel, podemos usar o match:

; Fennel
(lambda get-desc [key]
  (match key
    :k1 "Key 1"
    :k2 "Key 2"
    :k3 "Key 3"))

Como começar a usar

Agora que eu te convenci (pelo menos espero) a usar fennel, vamos ver como começar a usa-lo para configurar o Neovim!

Vamos usar dois plugins para isso:

tangerine
udayvir-singh / tangerine.nvim

🍊 Sweet Fennel integration for Neovim
🍊 Tangerine 🍊

About • Installation • Setup • Commands • API • Development

About

Tangerine provides a painless way to add fennel to your config.

Features
- 🔥 BLAZING fast, compile times in milliseconds
- 🌊 100% support for interactive evaluation
- 🎍 Control over when and how to compile
- 🎀 Natively loads nvim/init.fnl
Comparison to other plugins

HOTPOT 🍲
- Abstracts too much away from the user.
- Hooks onto lua package searchers to compile [harder to debug].
ANISEED 🌿
- Excessively feature rich for use in dotfiles.
- Blindly compiles all files that it founds, resulting in slow load times.
Installation
1. Create file plugin/0-tangerine.lua to bootstrap tangerine:
Important

If you are using lazy.nvim then you should create init.lua instead of plugin/0-tangerine.lua.

Refer to #20 for more information.
-- ~/.config/nvim/plugin/0-tangerine.lua or ~/.config/nvim/init.lua -- pick your plugin manager local pack = "tangerine" or "packer" or "paq" or "lazy
…
View on GitHub
hibiscus
udayvir-singh
/
hibiscus.nvim

🌺 Flavored Fennel Macros for Neovim
Hibiscus.nvim

🌺 Highly opinionated macros to elegantly write your neovim config.

Companion library for tangerine but it can also be used standalone.

Rational
- 🍬 Syntactic eye candy over hellscape of lua api
- 🎋 Provides missing features in both fennel and nvim api
Installation
- Create file plugin/0-tangerine.lua to bootstrap hibiscus:
NOTE: if you are using lazy plugin manager, you should create /init.lua instead.
-- ~/.config/nvim/plugin/0-tangerine.lua or ~/.config/nvim/init.lua -- pick your plugin manager local pack = "tangerine" or "packer" or "paq" or "lazy" local function bootstrap(url, ref) local name = url:gsub(".*/", "") local path if pack == "lazy" then path = vim.fn.stdpath("data") .. "/lazy/" .. name vim.opt.rtp:prepend(path) else
…
View on GitHub

O tangerine integra de maneira bem transparente o Fennel com o Neovim, compilando os arquivos fennel para lua e trazendo umas ferramentas interessantes.
O hibiscus traz várias macros relacionadas ao ecossistema do Neovim que nos ajudam a escrever menos

O primeiro passo é criar o arquivo ~/.config/nvim/plugin/0-tangerine.lua com o conteúdo:

local function bootstrap (name, url, path)
    if vim.fn.isdirectory(path) == 0 then
        print(name .. ": installing in data dir...")

        vim.fn.system {"git", "clone", "--depth", "1", url, path}

        vim.cmd [[redraw]]
        print(name .. ": finished installing")
    end
end

bootstrap (
  "tangerine.nvim",
  "https://github.com/udayvir-singh/tangerine.nvim",
  vim.fn.stdpath "data" .. "/site/pack/packer/start/tangerine.nvim"
)

bootstrap (
  "hibiscus.nvim",
  "https://github.com/udayvir-singh/hibiscus.nvim",
  vim.fn.stdpath "data" .. "/site/pack/packer/start/hibiscus.nvim"
)

require'tangerine'.setup{
  compiler = {
    verbose = false,
    hooks = { "onsave", "oninit" }
  }
}

Essa configuração supõe que você usa o Packer para gerenciar seus plugins, se você não usa, verifique no repositório do tangerine como instalar no seu gerenciador.

Com isso, ao reiniciar o Neovim, o tangerine e o hibiscus vão ser baixados e inicializados.

Isso significa que você já pode começar a configurar o Neovim em Fennel, criando um arquivo ~/.config/nvim/init.fnl 🎉

Quando você salvar esse arquivo, o tangerine já vai compila-lo e gerar o arquivo lua para ser carregado pelo Neovim, não sendo necessário fazer nenhuma configuração adicional para isso.

Dicas para começar com Fennel

A documentação é sua amiga!

As duas melhores fontes para entender como o Fennel funciona é o tutorial e a referência do Fennel.

Vou adiantar algumas coisas simples para você já entender o básico.

Parênteses

Você vai ver muitos parênteses no Fennel, eles servem para delimitar onde uma expressão começa e termina.

Por exemplo, para declarar uma variável no escopo local, em lua, você usa a palavra chave local, já em fennel, você chama a função local:

(local myVar "myValue") ; myVar = "myValue"

Se o valor da variável é resultado de uma concatenação, não vamos usar o operador .., mas sim, a função ..:

(local name "Fennel")
(local myVar (.. "Hello, " name)) ; myVar = "Hello, Fennel"

Resumindo, toda a função que você chamar, você vai colocar entre parênteses.

API do Neovim

Tudo o que você faz com lua, você faz com fennel, então a mesma chamada que você faz para uma API do Neovim em lua, você vai fazer em Fennel.
Isso, em lua:

-- Lua
print(vim.fn.stdpath"config")

é isso, em fennel:

(print (vim.fn.stdpath :config))

:symbol

Você já deve ter reparado que, em alguns casos, eu escrevi algumas strings em lua usando : em fennel (se não reparou, basta olhar para o último exemplo)

Isso, basicamente, é outro jeito de escrever uma string. No entanto, para escrever nesse formato, a string não pode conter espaços.

(= :str "str") ; true

Mapeamentos do tangerine

O plugin que usamos para integrar o Fennel com o Neovim tem uns mapeamentos e comandos que nos ajudam a garantir que estamos escrevendo um código que vai gerar o que queremos. Vou listar abaixo os que eu mais uso:

gL

Pode ser executado tanto no modo normal, quando no modo visual.
Esse mapeamento mostra o código lua que o seu código em Fennel vai gerar.
Por exemplo, se eu apertar gL após selecionar o trecho:

(lambda add [x y]
  (+ x y))

Ele abre uma janela contendo o código em lua:

local function add(x, y)
  _G.assert((nil ~= y), "Missing argument y on globals.fnl:1")
  _G.assert((nil ~= x), "Missing argument x on globals.fnl:1")
  return (x + y)
end
return add

Bem útil para checar rapidamente se o código fennel que você está escrevendo vai gerar o código lua que você espera.

Nota: Esse mapeamento não funciona muito bem no visual mode se você selecionar um trecho que usa alguma macro, a não ser que no trecho tenha a importação da macro.

gO

Esse mapeamento abre o arquivo lua compilado pelo arquivo fennel que está aberto, ou seja, se você está com o arquivo plugins.fnl aberto e aperta gO, ele vai abrir o arquivo plugins.lua que foi gerado pela compilação do plugins.fnl.
Muito útil para fazer debug.

:Fnl

Com o comando :Fnl você consegue executar qualquer código em fennel, da mesma forma que :lua.

:Fnl (print "hey")

Vai imprimir hey, equivalente à :lua print("hey")

Agora é contigo

A partir daqui, você já está preparado para se divertir usando Fennel (e é divertido mesmo).

Qualquer dúvida, pergunta aqui nos comentários!

Happy Vimming!

DEV Community: Douglas Massolari

Setting Up Neovim with Fennel

It all starts on the moon Lua

Hello, Peter Fennel

But why Fennel?

Fennel is less error-prone

(Syntax (from (Lisp!)))

Modernity and facilities

Destructuring

Pattern matching

How to get started

udayvir-singh / tangerine.nvim

🍊 Sweet Fennel integration for Neovim

🍊 Tangerine 🍊

About

Features

Comparison to other plugins

Installation

udayvir-singh / hibiscus.nvim

🌺 Flavored Fennel Macros for Neovim

Hibiscus.nvim

Rational

Installation

Tips for getting started with Fennel

Parentheses

Neovim API

:symbol

Tangerine Mappings

gL

gO

:Fnl

Now it's up to you

Criando um ambiente de desenvolvimento com Nix

O que é nix?

Preparação

O que é um ambiente de desenvolvimento?

Criando seu ambiente

Conclusão

O que é Nix e como utilizá-lo como seu gerenciador de pacotes

O que é Nix?

Configuração declarativa

Configuração reprodutível

Configuração confiável

Começando a utilizar o Nix

Instalação do Nix

Criação do arquivo flake.nix

Instalando o home-manager

Instalando e configurando pacotes

Usando programs

Usando home.packages

Generations

Listar

Rollback

Apagar

Dicas finais

Makefile

Meu repositório

Configurando Neovim com Fennel

Tudo começa na Lua

Hello, Peter Fennel

Mas, por que Fennel?

Fennel é menos propenso à alguns erros

(Sintaxe (do (Lisp!)))

Modernidade e facilidades

Desestruturação

Pattern matching

Como começar a usar

udayvir-singh / tangerine.nvim

🍊 Sweet Fennel integration for Neovim

🍊 Tangerine 🍊

About

Features

Comparison to other plugins

Installation

udayvir-singh / hibiscus.nvim

🌺 Flavored Fennel Macros for Neovim

Hibiscus.nvim

Rational

Installation

Dicas para começar com Fennel

udayvir-singh
/
hibiscus.nvim

Criação do arquivo `flake.nix`

Usando `programs`

Usando `home.packages`

udayvir-singh
/
hibiscus.nvim