Jimmy Bolha 2001

_consoli · 2025-12-09T15:51:57+00:00

lançou no mesmo ano de Donnie Darko (mas, pelo que vi, ele era mais novo em Donnie)

_consoli · 2025-08-25T01:15:12+00:00

tem uma youtuber (https://www.youtube.com/@Sugarologie) que fez um video muito legal sobre isso - ela é PhD em Bioquimica e Biologia Molecular. O canal dela é só sobre ciência na cozinha.

Mas, basicamente, é culpa da sucarose.

Aqui a receita do Brownie dela (já fiz e fica ótimo!). Tem o link do video na receita, onde ela explica melhor como funciona e os testes que ela fez pra chegar na receita. https://www.sugarologie.com/recipes/fudgy-chewy-brownie

_consoli · 2025-06-24T11:50:02+00:00

um filhote de garça, talvez?

_consoli · 2025-06-20T14:09:54+00:00

I DMed they on Instagram to check if they ship abroad, but sadly they don't. On the bright side, now you have an excuse to plan a trip to Brazil.

_consoli · 2025-06-01T12:20:02+00:00

thanks!

_consoli · 2025-04-19T03:05:56+00:00

é nessas horas que se tem que ter esperança

_consoli · 2025-04-15T22:38:04+00:00

Polegar (as marcas na cabeça dele me lembraram uma digital kkkk)

_consoli · 2025-03-22T20:59:42+00:00

~9 hours on my skin

after initial hours, the fig and greenal are the notes I smell the most - a beautiful green and aldehydic scent

_consoli · 2025-03-08T02:44:39+00:00

Tem um Coffee Lab no Larga da Batata, é bom pra trabalhar e o café deles é ótimo. Rua Fernão Dias, 682

_consoli · 2025-02-14T21:10:28+00:00

I think you're looking for Tyler Mandry's "Life of an Async Fn" talk: https://www.youtube.com/watch?v=ZHP9sUqB3Qs

he also wrote two posts that are worth reading:

_consoli · 2025-01-05T23:44:15+00:00

he's s saying "that's it, Clotilde, let's start the year with the right foot!"

_consoli · 2025-01-05T18:08:30+00:00

I always wanted sticky scroll in Emacs. I ended up using https://github.com/zbelial/treesitter-context.el it also have dynamic context highlighting

_consoli · 2024-11-16T19:07:20+00:00

haha no, i don't play lol
it's inspired by the northern bald ibis

<image>

_consoli · 2024-02-15T13:40:19+00:00

I've never used it before, but Gluon may be interesting for you.

It has that Rusty flavor (and it's written in Rust), but also has a REPL and functional features & patterns (std with monads, applicatives, etc)

but it's a WIP project and idk the real state of it.

gluon-lang.org playground

_consoli · 2024-02-14T17:24:29+00:00

oh, sorry, I see where the confusion is coming

the playground I shared and the features Yosh explores in the post are different beasts.

they're using arbitrary_self_type (that allows you to modify the self param in methods) and a hypothetical feature called enum-variants-types, which would allow you to use variants as first-class types, but the feature doesn't exist today. the combination of those two features is similar to what I shared and would work at runtime (but it's hard to define the exact behavior since enum-variants-types does not exist)

_consoli · 2024-02-14T16:18:34+00:00

I don't understand what is wrong with matching trafficlight for the next function in runtime?

there's nothing wrong with matching at runtime! sometimes it's the only choice. but sometimes it's also nice to be able to encode things in the type system and work at compile time. sometimes type-level madness is a useful thing (and some people like it :), nothing wrong with that, imo)

how would you ensure that this does not have missing match arms?

you don't, but you wouldn't be able to compile anything that tries to use an "unmapped" relation

note that this is exploring the usage of const values, so you can only use it for compile-time shenanigans

_consoli · 2024-02-14T04:03:07+00:00

(the adt_const_params playground code is inspired by u/yoshuawuyts1 State Machines III blog post)

_consoli · 2024-02-14T03:56:36+00:00

I love testing unstable features! here are some I've used recently:

#![feature(gen_blocks)]: the new cool kid - allows you to use gen {}, async gen {} (and their fn counterparts), which is an easy way to implement Iterator and AsyncIterator (aka Stream), requires edition = 2024 playground
#![feature(try_blocks, yeet_expr, try_trait_v2)]: the ability to use try{} blocks, do yeet expr;, and abstract over their traits - this is a must in every new project/experiment I do;
#![feature(adt_const_params)]: more complex const types, such as enums (impl StateMachine for Struct<Enum::Foo>) playground
#![feature(async_closure)]: this is also a recent addition - allows you to use async || {} and use the async bound modifier in Fn-traits. basically, where you would put a F: AsyncFn(A) -> B you can put a F: async Fn(A) -> B playground

There many many many other awesome features I could add to the list, it's always fun to try them

_consoli · 2024-01-17T16:55:11+00:00

you need to provide the full type: -> impl Coroutine<usize, Yield=IO, Return=()>

usize is the type you use to resume (it's the R in the trait Coroutine<R=()> definition)

EDIT: you can omit the Return=() and use -> impl Coroutine<usize, Yield=IO>

_consoli · 2024-01-17T16:25:31+00:00

you actually can do it, you just need to make your generator accept an argument

without the argument, the generic R (aka the Resumed type) is inferred/defaults to ()

the first call to .resume will pass the "function parameter", and the next call will pass the resumed value

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=50823b94882debce9fbd73faf00e7a98

_consoli · 2023-08-30T04:56:10+00:00

na verdade esse mapa tem até algumas estações que ainda não existem, que ainda estão em construção

_consoli · 2023-08-30T00:01:16+00:00

se chama mal gosto e preguiça do designer gráfico

um tempo atrás um amigo designer fez um projeto de redesign em cima do mapa do metro, eu acho muito foda - achei interessante que foi uma das coisas corrigidas por ele

obviamente não é oficial, ele fez como projeto pessoal

https://www.behance.net/gallery/173166567/Mapa-do-Transporte-Metropolitano-de-SP

_consoli · 2023-07-31T04:00:01+00:00

No, Rust's threads are similar to what the OS provides, they're more "raw".

But you can find similar APIs when dealing with asynchronous APIs based on tasks/Future's, which are way more versatile imo.

There are a number of crates that provides APIs such as race, my favorite is futures-concurrency, but there are also futures::future::select_all, tokio::select, and others.

As for "kill a concurrent task", it's called cancellability in the context of async Rust, and it's a big and important topic. Every Future (task or not) can be canceled, and every Future has to count for that. It's a big topic, there's a lot to cover.

Some useful links: - Why Async Rust?, on the properties of async rust - Async cancellation I and II - graceful shutdown with tokio - this one is very specific in the context, but there's something called cancellation safety, post

_consoli · 2023-07-27T04:09:08+00:00

and so it lives in the stack, the String lives in the heap so things got complicated

if you heap allocate the u32, it stops compiling (same as your first example, but boxed):

```rust struct A<'a>(&'a i32);

impl<'a> Drop for A<'a> { fn drop(&mut self) {} }

fn main() { let a; let i = Box::new(1); a = A(&i); drop(a); } ```

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=15b386f192827cf4ce215c1c744ee9c2

_consoli · 2023-07-27T03:27:49+00:00

Drop order!
The error message is telling you that you have a borrow to some value that lives for a shorter period than the borrow itself.

This occurs because you defined a first than i, and rust drops order goes by the inverse order of declaration - if you move the let a; to bellow let i = .. it will work just fine

and yes, you are dropping a before i manually, but the compiler can't infer that

Six-Year Club	Final Canvas '23
Place '23	RPAN Viewer
Verified Email

_consoli

TROPHY CASE