changelog/v1.9.md
Fixed a bug that would result in displaying the wrong name when running
gleam --version.
(Giacomo Cavalieri)
Fixed a bug in the generate json encoder and generate dynamic decoder that
would result in generating invalid code for variants with no fields.
(Giacomo Cavalieri)
You can now use the echo keyword to debug print any value: echo can be
followed by any expression and it will print it to stderr alongside the module
it comes from and its line number. This:
pub fn main() {
echo [1, 2, 3]
}
Will output to stderr:
/src/module.gleam:2
[1, 2, 3]
echo can also be used in the middle of a pipeline. This:
pub fn main() {
[1, 2, 3]
|> echo
|> list.map(fn(x) { x * 2 })
|> echo
}
Will output to stderr:
/src/module.gleam:3
[1, 2, 3]
/src/module.gleam:5
[2, 4, 6]
Generated Erlang .app files now include external modules written in Elixir
and Erlang.
(LostKobrakai)
On the JavaScript target, bit array expressions and patterns no longer need to
be byte aligned, and the bits segment type is now supported in patterns.
(Richard Viney)
The code generated for list pattern matching on the JavaScript target is now more efficient. Gleam code that relies heavily on list pattern matching can now be up to twice as fast. (yoshi~)
On the JavaScript target, bit array patterns can now match segments of dynamic size. (Surya Rose)
The build tool now supports Git dependencies. For example:
[dependencies]
gleam_stdlib = { git = "https://github.com/gleam-lang/stdlib.git", ref = "957b83b" }
The build tool now refuses to publish any incomplete package that has any
echo debug printing left.
(Giacomo Cavalieri)
HexDocs documentation of Gleam packages now uses the ExDocs search data model, allowing for global indexing of Gleam packages in HexDocs, and making Gleam packages discoverable through global search of HexDocs. (Diemo Gebhardt)
Improved the styling of constructor argument descriptions in the generated documentation. (Mikko Ahlroth)
Allow users to set the GLEAM_CACERTS_PATH environment variable to specify a
path to a directory containing CA certificates to install Hex packages.
(winstxnhdw)
The language server now has the ability to jump to the type definition of any hovered value. (Giacomo Cavalieri)
The language server now offers a code action to convert the first step of a pipeline to a regular function call. For example, this code:
import gleam/list
pub fn main() {
[1, 2, 3] |> list.map(fn(n) { n * 2 })
}
Will be rewritten as:
import gleam/list
pub fn main() {
list.map([1, 2, 3], fn(n) { n * 2 })
}
The language server now offers a code action to convert a function call into a pipeline. For example, this code:
import gleam/list
pub fn main() {
list.map([1, 2, 3], fn(n) { n * 2 })
}
Will be rewritten as:
import gleam/list
pub fn main() {
[1, 2, 3] |> list.map(fn(n) { n * 2 })
}
You can also pick which argument is going to be piped. In this case:
import gleam/list
pub fn main() {
list.map([1, 2, 3], fn(n) { n * 2 })
// ^ If you put your cursor over here
}
The code will be rewritten as:
import gleam/list
pub fn main() {
fn(n) { n * 2 } |> list.map([1, 2, 3], _)
}
The language server now suggests a code action to generate a function to
encode a custom type as JSON using the gleam_json package. For example:
pub type Person {
Person(name: String, age: Int)
}
Will become:
import gleam/json
pub type Person {
Person(name: String, age: Int)
}
fn encode_person(person: Person) -> json.Json {
json.object([
#("name", json.string(person.name)),
#("age", json.int(person.age)),
])
}
The language server now suggests a code action to inline a variable which is only used once. For example, this code:
import gleam/io
pub fn main() {
let greeting = "Hello!"
io.println(greeting)
}
Will be rewritten as:
import gleam/io
pub fn main() {
io.println("Hello!")
}
The code action to generate a dynamic decoder for a custom type can now generate decoders for types with multiple variants. For example this code:
pub type Person {
Adult(age: Int, job: String)
Child(age: Int, height: Float)
}
Becomes:
import gleam/dynamic/decode
pub type Person {
Adult(age: Int, job: String)
Child(age: Int, height: Float)
}
fn person_decoder() -> decode.Decoder(Person) {
use variant <- decode.field("type", decode.string)
case variant {
"adult" -> {
use age <- decode.field("age", decode.int)
use job <- decode.field("job", decode.string)
decode.success(Adult(age:, job:))
}
"child" -> {
use age <- decode.field("age", decode.int)
use height <- decode.field("height", decode.float)
decode.success(Child(age:, height:))
}
_ -> decode.failure(todo as "Zero value for Person", "Person")
}
}
The language server now suggests a code action to easily interpolate a value into a string. If the cursor is inside a literal string the language server will offer to split it:
"wibble | wobble"
// ^ Triggering the action with the cursor
// here will produce this:
"wibble " <> todo <> " wobble"
And if the cursor is selecting a valid Gleam name, the language server will offer to interpolate it as a variable:
"wibble wobble woo"
// ^^^^^^ Triggering the code action if you're
// selecting an entire name, will produce this:
"wibble " <> wobble <> " woo"
The language server now shows module documentation when hovering over a module name. (Surya Rose)
Redundant function captures that take no additional arguments are now rewritten to not use the function capture syntax.
some_module.some_function(_)
This code is reformatted like so:
some_module.some_function
Fixed a bug where division and remainder operators would not work correctly in guards on the JavaScript target. (Surya Rose)
Fixed a bug where the "Generate function" code action would ignore the provided labels. (Giacomo Cavalieri)
Fixed a bug where the "Pattern match on argument" and "Pattern match on variable" code actions would not allow to pattern match on a private type used in the same module it's defined in. (Giacomo Cavalieri)
Fixed a bug where gleam export package-interface would not properly generate
the package interface file if some modules were cached.
(Pedro Francisco) and
(Surya Rose)
Fixed a bug where pattern matching using a UTF-8 string constant would not work correctly on the JavaScript target when the string contained escape characters. (Richard Viney)
Fixed a bug where gleam publish wouldn't include gitignored or nested native
files.
(PgBiel)