+1 -341

CHANGELOG.md

View file Reviewed

··· 1 1 # Changelog 2 2 3 3 - ## v1.9.0-rc2 - 2025-03-07 4 4 - 5 5 - ### Compiler 6 6 - 7 7 - - Made runtime warnings regarding the use of deprecated BitArray properties in 8 8 - JavaScript FFI code more compact. They are now one line instead of three. 9 9 - ([Richard Viney](https://github.com/richard-viney)) 10 10 - 11 11 - ### Bug fixes 12 12 - 13 13 - - Fixed a bug that would result in displaying the wrong name when running 14 14 - `gleam --version`. 15 15 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 16 16 - 17 17 - - Fixed a bug in the `generate json encoder` and `generate dynamic decoder` that 18 18 - would result in generating invalid code for variants with no fields. 19 19 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 20 20 - 21 21 - ## v1.9.0-rc1 - 2025-03-04 3 3 + ## Unreleased 22 4 23 5 ### Compiler 24 6 25 25 - - You can now use the `echo` keyword to debug print any value: `echo` can be 26 26 - followed by any expression and it will print it to stderr alongside the module 27 27 - it comes from and its line number. This: 28 28 - 29 29 - ```gleam 30 30 - pub fn main() { 31 31 - echo [1, 2, 3] 32 32 - } 33 33 - ``` 34 34 - 35 35 - Will output to stderr: 36 36 - 37 37 - ```txt 38 38 - /src/module.gleam:2 39 39 - [1, 2, 3] 40 40 - ``` 41 41 - 42 42 - `echo` can also be used in the middle of a pipeline. This: 43 43 - 44 44 - ```gleam 45 45 - pub fn main() { 46 46 - [1, 2, 3] 47 47 - |> echo 48 48 - |> list.map(fn(x) { x * 2 }) 49 49 - |> echo 50 50 - } 51 51 - ``` 52 52 - 53 53 - Will output to stderr: 54 54 - 55 55 - ```txt 56 56 - /src/module.gleam:3 57 57 - [1, 2, 3] 58 58 - /src/module.gleam:5 59 59 - [2, 4, 6] 60 60 - ``` 61 61 - 62 62 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 63 63 - 64 64 - - Generated Erlang `.app` files now include external modules written in Elixir 65 65 - and Erlang. 66 66 - ([LostKobrakai](https://github.com/lostkobrakai)) 67 67 - 68 68 - - On the JavaScript target, bit array expressions and patterns no longer need to 69 69 - be byte aligned, and the `bits` segment type is now supported in patterns. 70 70 - ([Richard Viney](https://github.com/richard-viney)) 71 71 - 72 72 - - The code generated for list pattern matching on the JavaScript target is now 73 73 - more efficient. Gleam code that relies heavily on list pattern matching can 74 74 - now be up to twice as fast. 75 75 - ([yoshi~](https://github.com/yoshi-monster)) 76 76 - 77 77 - - On the JavaScript target, bit array patterns can now match segments of dynamic 78 78 - size. 79 79 - ([Surya Rose](https://github.com/GearsDatapacks)) 80 80 - 81 7 ### Build tool 82 8 83 83 - - The build tool now supports Git dependencies. For example: 84 84 - 85 85 - ``` 86 86 - [dependencies] 87 87 - gleam_stdlib = { git = "https://github.com/gleam-lang/stdlib.git", ref = "957b83b" } 88 88 - ``` 89 89 - 90 90 - ([Surya Rose](https://github.com/GearsDatapacks)) 91 91 - 92 92 - - The build tool now refuses to publish any incomplete package that has any 93 93 - `echo` debug printing left. 94 94 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 95 95 - 96 96 - - HexDocs documentation of Gleam packages now uses the ExDocs search data model, 97 97 - allowing for global indexing of Gleam packages in HexDocs, and 98 98 - making Gleam packages discoverable through global search of HexDocs. 99 99 - ([Diemo Gebhardt](https://github.com/diemogebhardt)) 100 100 - 101 101 - - Improved the styling of constructor argument descriptions in the generated 102 102 - documentation. 103 103 - ([Mikko Ahlroth](https://git.ahlcode.fi/nicd)) 104 104 - 105 105 - - Allow users to set the `GLEAM_CACERTS_PATH` environment variable to specify a 106 106 - path to a directory containing CA certificates to install Hex packages. 107 107 - ([winstxnhdw](https://github.com/winstxnhdw)) 108 108 - 109 9 ### Language server 110 10 111 111 - - The language server now has the ability to jump to the type definition of any 112 112 - hovered value. 113 113 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 114 114 - 115 115 - - The language server now offers a code action to convert the first step of a 116 116 - pipeline to a regular function call. For example, this code: 117 117 - 118 118 - ```gleam 119 119 - import gleam/list 120 120 - 121 121 - pub fn main() { 122 122 - [1, 2, 3] |> list.map(fn(n) { n * 2 }) 123 123 - } 124 124 - ``` 125 125 - 126 126 - Will be rewritten as: 127 127 - 128 128 - ```gleam 129 129 - import gleam/list 130 130 - 131 131 - pub fn main() { 132 132 - list.map([1, 2, 3], fn(n) { n * 2 }) 133 133 - } 134 134 - ``` 135 135 - 136 136 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 137 137 - 138 138 - - The language server now offers a code action to convert a function call into 139 139 - a pipeline. For example, this code: 140 140 - 141 141 - ```gleam 142 142 - import gleam/list 143 143 - 144 144 - pub fn main() { 145 145 - list.map([1, 2, 3], fn(n) { n * 2 }) 146 146 - } 147 147 - ``` 148 148 - 149 149 - Will be rewritten as: 150 150 - 151 151 - ```gleam 152 152 - import gleam/list 153 153 - 154 154 - pub fn main() { 155 155 - [1, 2, 3] |> list.map(fn(n) { n * 2 }) 156 156 - } 157 157 - ``` 158 158 - 159 159 - You can also pick which argument is going to be piped. In this case: 160 160 - 161 161 - ```gleam 162 162 - import gleam/list 163 163 - 164 164 - pub fn main() { 165 165 - list.map([1, 2, 3], fn(n) { n * 2 }) 166 166 - // ^ If you put your cursor over here 167 167 - } 168 168 - ``` 169 169 - 170 170 - The code will be rewritten as: 171 171 - 172 172 - ```gleam 173 173 - import gleam/list 174 174 - 175 175 - pub fn main() { 176 176 - fn(n) { n * 2 } |> list.map([1, 2, 3], _) 177 177 - } 178 178 - ``` 179 179 - 180 180 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 181 181 - 182 182 - - The language server now suggests a code action to generate a function to 183 183 - encode a custom type as JSON using the `gleam_json` package. For example: 184 184 - 185 185 - ```gleam 186 186 - pub type Person { 187 187 - Person(name: String, age: Int) 188 188 - } 189 189 - ``` 190 190 - 191 191 - Will become: 192 192 - 193 193 - ```gleam 194 194 - import gleam/json 195 195 - 196 196 - pub type Person { 197 197 - Person(name: String, age: Int) 198 198 - } 199 199 - 200 200 - fn encode_person(person: Person) -> json.Json { 201 201 - json.object([ 202 202 - #("name", json.string(person.name)), 203 203 - #("age", json.int(person.age)), 204 204 - ]) 205 205 - } 206 206 - ``` 207 207 - 208 208 - ([Surya Rose](https://github.com/GearsDatapacks)) 209 209 - 210 210 - - The language server now suggests a code action to inline a variable 211 211 - which is only used once. For example, this code: 212 212 - 213 213 - ```gleam 214 214 - import gleam/io 215 215 - 216 216 - pub fn main() { 217 217 - let greeting = "Hello!" 218 218 - io.println(greeting) 219 219 - } 220 220 - ``` 221 221 - 222 222 - Will be rewritten as: 223 223 - 224 224 - ```gleam 225 225 - import gleam/io 226 226 - 227 227 - pub fn main() { 228 228 - io.println("Hello!") 229 229 - } 230 230 - ``` 231 231 - 232 232 - ([Surya Rose](https://github.com/GearsDatapacks)) 233 233 - 234 234 - - The code action to generate a dynamic decoder for a custom type can now 235 235 - generate decoders for types with multiple variants. For example this code: 236 236 - 237 237 - ```gleam 238 238 - pub type Person { 239 239 - Adult(age: Int, job: String) 240 240 - Child(age: Int, height: Float) 241 241 - } 242 242 - ``` 243 243 - 244 244 - Becomes: 245 245 - 246 246 - ```gleam 247 247 - import gleam/dynamic/decode 248 248 - 249 249 - pub type Person { 250 250 - Adult(age: Int, job: String) 251 251 - Child(age: Int, height: Float) 252 252 - } 253 253 - 254 254 - fn person_decoder() -> decode.Decoder(Person) { 255 255 - use variant <- decode.field("type", decode.string) 256 256 - case variant { 257 257 - "adult" -> { 258 258 - use age <- decode.field("age", decode.int) 259 259 - use job <- decode.field("job", decode.string) 260 260 - decode.success(Adult(age:, job:)) 261 261 - } 262 262 - "child" -> { 263 263 - use age <- decode.field("age", decode.int) 264 264 - use height <- decode.field("height", decode.float) 265 265 - decode.success(Child(age:, height:)) 266 266 - } 267 267 - _ -> decode.failure(todo as "Zero value for Person", "Person") 268 268 - } 269 269 - } 270 270 - ``` 271 271 - 272 272 - ([Surya Rose](https://github.com/GearsDatapacks)) 273 273 - 274 274 - - The language server now suggests a code action to easily interpolate a value 275 275 - into a string. If the cursor is inside a literal string the language server 276 276 - will offer to split it: 277 277 - 278 278 - ```gleam 279 279 - "wibble | wobble" 280 280 - // ^ Triggering the action with the cursor 281 281 - // here will produce this: 282 282 - "wibble " <> todo <> " wobble" 283 283 - ``` 284 284 - 285 285 - And if the cursor is selecting a valid Gleam name, the language server will 286 286 - offer to interpolate it as a variable: 287 287 - 288 288 - ```gleam 289 289 - "wibble wobble woo" 290 290 - // ^^^^^^ Triggering the code action if you're 291 291 - // selecting an entire name, will produce this: 292 292 - "wibble " <> wobble <> " woo" 293 293 - ``` 294 294 - 295 295 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 296 296 - 297 297 - - The language server now shows module documentation when hovering over a module 298 298 - name. 299 299 - ([Surya Rose](https://github.com/GearsDatapacks)) 300 300 - 301 11 ### Formatter 302 12 303 303 - - Redundant function captures that take no additional arguments are now 304 304 - rewritten to not use the function capture syntax. 305 305 - 306 306 - ```gleam 307 307 - some_module.some_function(_) 308 308 - ``` 309 309 - 310 310 - This code is reformatted like so: 311 311 - 312 312 - ```gleam 313 313 - some_module.some_function 314 314 - ``` 315 315 - 316 316 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 317 317 - 318 13 ### Bug fixes 319 319 - 320 320 - - Fixed a bug where division and remainder operators would not work correctly 321 321 - in guards on the JavaScript target. 322 322 - ([Surya Rose](https://github.com/GearsDatapacks)) 323 323 - 324 324 - - Fixed a bug where the "Generate function" code action would ignore the 325 325 - provided labels. 326 326 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 327 327 - 328 328 - - Fixed a bug where the "Pattern match on argument" and 329 329 - "Pattern match on variable" code actions would not allow to pattern match on a 330 330 - private type used in the same module it's defined in. 331 331 - ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 332 332 - 333 333 - - Fixed a bug where `gleam export package-interface` would not properly generate 334 334 - the package interface file if some modules were cached. 335 335 - ([Pedro Francisco](https://github.com/mine-tech-oficial)) and 336 336 - ([Surya Rose](https://github.com/GearsDatapacks)) 337 337 - 338 338 - - Fixed a bug where pattern matching using a UTF-8 string constant would not 339 339 - work correctly on the JavaScript target when the string contained escape 340 340 - characters. 341 341 - ([Richard Viney](https://github.com/richard-viney)) 342 342 - 343 343 - - Fixed a bug where `gleam publish` wouldn't include gitignored or nested native 344 344 - files. 345 345 - ([PgBiel](https://github.com/PgBiel)) 346 346 - 347 347 - ## v1.8.1 - 2025-02-11 348 348 - 349 349 - ### Bug fixes 350 350 - 351 351 - - Fixed a metadata caching bug where accessors for opaque types could sometimes 352 352 - be used in other modules. 353 353 - ([Louis Pilfold](https://github.com/lpil))

+355

changelog/v1.9.md

View file Reviewed

··· 1 1 + # Changelog 2 2 + 3 3 + ## v1.9.0 - 2025-03-09 4 4 + 5 5 + ## v1.9.0-rc2 - 2025-03-07 6 6 + 7 7 + ### Compiler 8 8 + 9 9 + - Made runtime warnings regarding the use of deprecated BitArray properties in 10 10 + JavaScript FFI code more compact. They are now one line instead of three. 11 11 + ([Richard Viney](https://github.com/richard-viney)) 12 12 + 13 13 + ### Bug fixes 14 14 + 15 15 + - Fixed a bug that would result in displaying the wrong name when running 16 16 + `gleam --version`. 17 17 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 18 18 + 19 19 + - Fixed a bug in the `generate json encoder` and `generate dynamic decoder` that 20 20 + would result in generating invalid code for variants with no fields. 21 21 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 22 22 + 23 23 + ## v1.9.0-rc1 - 2025-03-04 24 24 + 25 25 + ### Compiler 26 26 + 27 27 + - You can now use the `echo` keyword to debug print any value: `echo` can be 28 28 + followed by any expression and it will print it to stderr alongside the module 29 29 + it comes from and its line number. This: 30 30 + 31 31 + ```gleam 32 32 + pub fn main() { 33 33 + echo [1, 2, 3] 34 34 + } 35 35 + ``` 36 36 + 37 37 + Will output to stderr: 38 38 + 39 39 + ```txt 40 40 + /src/module.gleam:2 41 41 + [1, 2, 3] 42 42 + ``` 43 43 + 44 44 + `echo` can also be used in the middle of a pipeline. This: 45 45 + 46 46 + ```gleam 47 47 + pub fn main() { 48 48 + [1, 2, 3] 49 49 + |> echo 50 50 + |> list.map(fn(x) { x * 2 }) 51 51 + |> echo 52 52 + } 53 53 + ``` 54 54 + 55 55 + Will output to stderr: 56 56 + 57 57 + ```txt 58 58 + /src/module.gleam:3 59 59 + [1, 2, 3] 60 60 + /src/module.gleam:5 61 61 + [2, 4, 6] 62 62 + ``` 63 63 + 64 64 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 65 65 + 66 66 + - Generated Erlang `.app` files now include external modules written in Elixir 67 67 + and Erlang. 68 68 + ([LostKobrakai](https://github.com/lostkobrakai)) 69 69 + 70 70 + - On the JavaScript target, bit array expressions and patterns no longer need to 71 71 + be byte aligned, and the `bits` segment type is now supported in patterns. 72 72 + ([Richard Viney](https://github.com/richard-viney)) 73 73 + 74 74 + - The code generated for list pattern matching on the JavaScript target is now 75 75 + more efficient. Gleam code that relies heavily on list pattern matching can 76 76 + now be up to twice as fast. 77 77 + ([yoshi~](https://github.com/yoshi-monster)) 78 78 + 79 79 + - On the JavaScript target, bit array patterns can now match segments of dynamic 80 80 + size. 81 81 + ([Surya Rose](https://github.com/GearsDatapacks)) 82 82 + 83 83 + ### Build tool 84 84 + 85 85 + - The build tool now supports Git dependencies. For example: 86 86 + 87 87 + ``` 88 88 + [dependencies] 89 89 + gleam_stdlib = { git = "https://github.com/gleam-lang/stdlib.git", ref = "957b83b" } 90 90 + ``` 91 91 + 92 92 + ([Surya Rose](https://github.com/GearsDatapacks)) 93 93 + 94 94 + - The build tool now refuses to publish any incomplete package that has any 95 95 + `echo` debug printing left. 96 96 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 97 97 + 98 98 + - HexDocs documentation of Gleam packages now uses the ExDocs search data model, 99 99 + allowing for global indexing of Gleam packages in HexDocs, and 100 100 + making Gleam packages discoverable through global search of HexDocs. 101 101 + ([Diemo Gebhardt](https://github.com/diemogebhardt)) 102 102 + 103 103 + - Improved the styling of constructor argument descriptions in the generated 104 104 + documentation. 105 105 + ([Mikko Ahlroth](https://git.ahlcode.fi/nicd)) 106 106 + 107 107 + - Allow users to set the `GLEAM_CACERTS_PATH` environment variable to specify a 108 108 + path to a directory containing CA certificates to install Hex packages. 109 109 + ([winstxnhdw](https://github.com/winstxnhdw)) 110 110 + 111 111 + ### Language server 112 112 + 113 113 + - The language server now has the ability to jump to the type definition of any 114 114 + hovered value. 115 115 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 116 116 + 117 117 + - The language server now offers a code action to convert the first step of a 118 118 + pipeline to a regular function call. For example, this code: 119 119 + 120 120 + ```gleam 121 121 + import gleam/list 122 122 + 123 123 + pub fn main() { 124 124 + [1, 2, 3] |> list.map(fn(n) { n * 2 }) 125 125 + } 126 126 + ``` 127 127 + 128 128 + Will be rewritten as: 129 129 + 130 130 + ```gleam 131 131 + import gleam/list 132 132 + 133 133 + pub fn main() { 134 134 + list.map([1, 2, 3], fn(n) { n * 2 }) 135 135 + } 136 136 + ``` 137 137 + 138 138 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 139 139 + 140 140 + - The language server now offers a code action to convert a function call into 141 141 + a pipeline. For example, this code: 142 142 + 143 143 + ```gleam 144 144 + import gleam/list 145 145 + 146 146 + pub fn main() { 147 147 + list.map([1, 2, 3], fn(n) { n * 2 }) 148 148 + } 149 149 + ``` 150 150 + 151 151 + Will be rewritten as: 152 152 + 153 153 + ```gleam 154 154 + import gleam/list 155 155 + 156 156 + pub fn main() { 157 157 + [1, 2, 3] |> list.map(fn(n) { n * 2 }) 158 158 + } 159 159 + ``` 160 160 + 161 161 + You can also pick which argument is going to be piped. In this case: 162 162 + 163 163 + ```gleam 164 164 + import gleam/list 165 165 + 166 166 + pub fn main() { 167 167 + list.map([1, 2, 3], fn(n) { n * 2 }) 168 168 + // ^ If you put your cursor over here 169 169 + } 170 170 + ``` 171 171 + 172 172 + The code will be rewritten as: 173 173 + 174 174 + ```gleam 175 175 + import gleam/list 176 176 + 177 177 + pub fn main() { 178 178 + fn(n) { n * 2 } |> list.map([1, 2, 3], _) 179 179 + } 180 180 + ``` 181 181 + 182 182 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 183 183 + 184 184 + - The language server now suggests a code action to generate a function to 185 185 + encode a custom type as JSON using the `gleam_json` package. For example: 186 186 + 187 187 + ```gleam 188 188 + pub type Person { 189 189 + Person(name: String, age: Int) 190 190 + } 191 191 + ``` 192 192 + 193 193 + Will become: 194 194 + 195 195 + ```gleam 196 196 + import gleam/json 197 197 + 198 198 + pub type Person { 199 199 + Person(name: String, age: Int) 200 200 + } 201 201 + 202 202 + fn encode_person(person: Person) -> json.Json { 203 203 + json.object([ 204 204 + #("name", json.string(person.name)), 205 205 + #("age", json.int(person.age)), 206 206 + ]) 207 207 + } 208 208 + ``` 209 209 + 210 210 + ([Surya Rose](https://github.com/GearsDatapacks)) 211 211 + 212 212 + - The language server now suggests a code action to inline a variable 213 213 + which is only used once. For example, this code: 214 214 + 215 215 + ```gleam 216 216 + import gleam/io 217 217 + 218 218 + pub fn main() { 219 219 + let greeting = "Hello!" 220 220 + io.println(greeting) 221 221 + } 222 222 + ``` 223 223 + 224 224 + Will be rewritten as: 225 225 + 226 226 + ```gleam 227 227 + import gleam/io 228 228 + 229 229 + pub fn main() { 230 230 + io.println("Hello!") 231 231 + } 232 232 + ``` 233 233 + 234 234 + ([Surya Rose](https://github.com/GearsDatapacks)) 235 235 + 236 236 + - The code action to generate a dynamic decoder for a custom type can now 237 237 + generate decoders for types with multiple variants. For example this code: 238 238 + 239 239 + ```gleam 240 240 + pub type Person { 241 241 + Adult(age: Int, job: String) 242 242 + Child(age: Int, height: Float) 243 243 + } 244 244 + ``` 245 245 + 246 246 + Becomes: 247 247 + 248 248 + ```gleam 249 249 + import gleam/dynamic/decode 250 250 + 251 251 + pub type Person { 252 252 + Adult(age: Int, job: String) 253 253 + Child(age: Int, height: Float) 254 254 + } 255 255 + 256 256 + fn person_decoder() -> decode.Decoder(Person) { 257 257 + use variant <- decode.field("type", decode.string) 258 258 + case variant { 259 259 + "adult" -> { 260 260 + use age <- decode.field("age", decode.int) 261 261 + use job <- decode.field("job", decode.string) 262 262 + decode.success(Adult(age:, job:)) 263 263 + } 264 264 + "child" -> { 265 265 + use age <- decode.field("age", decode.int) 266 266 + use height <- decode.field("height", decode.float) 267 267 + decode.success(Child(age:, height:)) 268 268 + } 269 269 + _ -> decode.failure(todo as "Zero value for Person", "Person") 270 270 + } 271 271 + } 272 272 + ``` 273 273 + 274 274 + ([Surya Rose](https://github.com/GearsDatapacks)) 275 275 + 276 276 + - The language server now suggests a code action to easily interpolate a value 277 277 + into a string. If the cursor is inside a literal string the language server 278 278 + will offer to split it: 279 279 + 280 280 + ```gleam 281 281 + "wibble | wobble" 282 282 + // ^ Triggering the action with the cursor 283 283 + // here will produce this: 284 284 + "wibble " <> todo <> " wobble" 285 285 + ``` 286 286 + 287 287 + And if the cursor is selecting a valid Gleam name, the language server will 288 288 + offer to interpolate it as a variable: 289 289 + 290 290 + ```gleam 291 291 + "wibble wobble woo" 292 292 + // ^^^^^^ Triggering the code action if you're 293 293 + // selecting an entire name, will produce this: 294 294 + "wibble " <> wobble <> " woo" 295 295 + ``` 296 296 + 297 297 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 298 298 + 299 299 + - The language server now shows module documentation when hovering over a module 300 300 + name. 301 301 + ([Surya Rose](https://github.com/GearsDatapacks)) 302 302 + 303 303 + ### Formatter 304 304 + 305 305 + - Redundant function captures that take no additional arguments are now 306 306 + rewritten to not use the function capture syntax. 307 307 + 308 308 + ```gleam 309 309 + some_module.some_function(_) 310 310 + ``` 311 311 + 312 312 + This code is reformatted like so: 313 313 + 314 314 + ```gleam 315 315 + some_module.some_function 316 316 + ``` 317 317 + 318 318 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 319 319 + 320 320 + ### Bug fixes 321 321 + 322 322 + - Fixed a bug where division and remainder operators would not work correctly 323 323 + in guards on the JavaScript target. 324 324 + ([Surya Rose](https://github.com/GearsDatapacks)) 325 325 + 326 326 + - Fixed a bug where the "Generate function" code action would ignore the 327 327 + provided labels. 328 328 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 329 329 + 330 330 + - Fixed a bug where the "Pattern match on argument" and 331 331 + "Pattern match on variable" code actions would not allow to pattern match on a 332 332 + private type used in the same module it's defined in. 333 333 + ([Giacomo Cavalieri](https://github.com/giacomocavalieri)) 334 334 + 335 335 + - Fixed a bug where `gleam export package-interface` would not properly generate 336 336 + the package interface file if some modules were cached. 337 337 + ([Pedro Francisco](https://github.com/mine-tech-oficial)) and 338 338 + ([Surya Rose](https://github.com/GearsDatapacks)) 339 339 + 340 340 + - Fixed a bug where pattern matching using a UTF-8 string constant would not 341 341 + work correctly on the JavaScript target when the string contained escape 342 342 + characters. 343 343 + ([Richard Viney](https://github.com/richard-viney)) 344 344 + 345 345 + - Fixed a bug where `gleam publish` wouldn't include gitignored or nested native 346 346 + files. 347 347 + ([PgBiel](https://github.com/PgBiel)) 348 348 + 349 349 + ## v1.8.1 - 2025-02-11 350 350 + 351 351 + ### Bug fixes 352 352 + 353 353 + - Fixed a metadata caching bug where accessors for opaque types could sometimes 354 354 + be used in other modules. 355 355 + ([Louis Pilfold](https://github.com/lpil))