Módulos, testes e leis
Slide 40 de 85
40importMódulos, testes e leis

Módulos

Gramática: import, file
importPATHasIDENT
import = "import" PATH [ "as" IDENT ] ;
importdeclarationEOF
file = { import | declaration } EOF ;Como o compilador lê; o §2.1 da especificação está desatualizado aqui.

import traz as declarações de outro arquivo para o escopo, alcançadas por um nome. O caminho diz que tipo de import é:

  • import ./lib/text é um arquivo Hive em disco, relativo à pasta do próprio arquivo que importa, sem o .hive. Um caminho com espaços vai entre aspas: import "./lib dir/text" as words.
  • import https://github.com/owner/repo/src/text é um arquivo dentro de um repositório git.
  • import hive.net as web nomeia um módulo da biblioteca padrão. Todo módulo já atende pelo próprio nome sem import — crypto.sha256 é hive.crypto.sha256 — então importar um só dá a ele outro nome. Um módulo não acrescenta nada à build a menos que seja usado.

O nome é o do próprio arquivo, ou o último segmento do módulo, a menos que as dê outro. Ele é camelCase, então um arquivo cujo nome não é um — text-utils.hive — precisa ser importado com as, e nenhum import pode se chamar hive. Um import nomeia um módulo e nada dentro dele, então import hive.ui.View é recusado, e um módulo que a biblioteca não tem também.

O nome próprio de um módulo da biblioteca é mantido como o de uma função nativa: uma declaração, um import, uma variável local ou um parâmetro de mesmo nome vem primeiro, só naquele arquivo, e hive.<módulo> sempre alcança a biblioteca.

Tudo o que um módulo declara é visível; não existe pub. Um nome só significa o que o módulo que você está lendo diz que significa, então dois arquivos podem declarar cada um o seu Align e os dois continuam distintos, o do outro arquivo sendo text.Align. Um chamável importado é um valor comum. Um erro dentro de um arquivo importado é reportado naquele arquivo, com os nomes grafados como no código dele.

Um import remoto precisa do git no PATH. O repositório é https://host/owner/repo e o resto é o caminho dentro dele; uma revisão vai onde o repositório termina — um commit de pelo menos sete dígitos hexadecimais, uma tag, ou um branch, que é seguido para onde quer que ande. Os clones ficam em cache uma vez por commit em ~/.hive/pkg. Um import sem revisão é fixado no primeiro uso: o commit em que ele se resolveu é escrito em um arquivo de trava ao lado do ponto de entrada, main.hive-lock, que pertence ao controle de versão. Um com revisão pergunta ao repositório o que ela nomeia em toda checagem e build. Ciclos de import são recusados, e o erro imprime o ciclo.

Um módulo da biblioteca, pelo próprio nome
import hive.net as web

proc main(): void {
	// Todo módulo da biblioteca atende pelo próprio nome, sem import.
	echo crypto.sha256("hive")

	// `hive.` é a grafia longa da mesmíssima chamada.
	echo hive.crypto.sha256("hive")

	// `as` dá outro nome a um módulo.
	if web.resolve("localhost") is Result.Ok(addresses) {
		echo addresses
	}

	// Um nome do próprio programa vem primeiro, como acontece com uma
	// função nativa, e a biblioteca continua sendo `hive.time`.
	time := "nove e meia"
	echo time
	echo hive.time.year() > 2000
}
lib/text.hive
type Align {
	Left
	Right
}

func pad(s: Str, width: Int, side: Align): Str {
	mut out := s
	for ; len(out) < width; {
		if side is Align.Left { out = out + "." } else { out = "." + out }
	}
	return out
}

func repeat(s: Str, times: Int): Str {
	mut out := ""
	for i := 0; i < times; i++ { out = out + s }
	return out
}
main.hive, ao lado dele
import ./lib/text

// O Align deste arquivo e o Align de lib/text são dois tipos diferentes: um
// nome só significa o que o módulo em que você o lê diz que ele significa.
type Align {
	Centre
}

proc main(): void {
	mine := Align.Centre()
	if mine is Align.Centre { echo "o nosso" }

	echo text.pad("total", 16, text.Align.Left())

	// Um chamável importado é um valor comum.
	rule := text.repeat("~", _)
	echo rule(16)
}
Um módulo em um repositório
// O repositório é `https://host/dono/repo`; tudo depois disso é o caminho
// dentro dele, e o .hive fica de fora exatamente como fica em disco.
import https://github.com/owner/repo/src/text

// Uma revisão vai onde o repositório termina: commit, tag ou branch.
import https://github.com/owner/[email protected]/src/pricing

// Um arquivo Go dentro de um, sob as mesmas regras — .go ainda obrigatório.
import https://github.com/owner/repo@a1b2c3d/go/slugs.go as slugs

proc main(): void {
	// O nome é o do arquivo, não o do repositório nem o do host: mover um
	// módulo para um repositório não muda nada em como esta linha se lê.
	echo text.repeat("=", 28)
	echo pricing.line("Beeswax", 450)
	echo slugs.slugify("Hive Tool")
}
O que a primeira compilação deixa para trás
$ hive check main.hive
No problems found in main.hive (3s)

$ cat main.hive-lock
# Written by the Hive compiler: the commit each remote import was
# resolved to. Keep this in version control — it is what makes another
# machine build the same program. Delete a line to take the latest of
# that repository again.
https://github.com/owner/repo 4f2a9c1e8b7d6a5f4e3d2c1b0a9f8e7d6c5b4a39
Um ciclo, recusado
$ hive check main.hive
lib/pricing.hive:1: this import forms a cycle:

    lib/inventory.hive
      -> lib/pricing.hive
      -> lib/inventory.hive