The Builder Pattern and Typestate Programming - Stefan Baumgartner - Rust Linz January 2023

Almost 30 years ago, the Gang of Four wrote about software design patterns. They were highly influential, and over the course of decades, the proposed patterns have been cited, reused, misused, thrown away, and found again, over and over. One of those patterns -- the builder pattern -- gained some popularity in Rust's libraries. Let's take a look at what does, why the builder pattern is such a great fit for Rust, and how we can use some of the unique features of Rust's type system to make them even better.
--
Stefan Baumgartner works at Dynatrace. He writes for Manning, Smashing Magazine and A List Apart and made the Kessel run in less than 12 parsecs.
In his spare time, he organizes ScriptConf and DevOne in Linz, and co-hosts the German language Working Draft podcast. Stefan enjoys Italian food, Belgian beer and British vinyl records.

[@Lantalia]

Ahh yes, the Design Patterns book

[@chillyvanilly6352]

18:45 => Typestate Programming "chapter"

[@erlonpb]

the code demonstration at the end with neovim (nice setup!) really nailed it! Things became very clear

[@nirmalyasengupta6883]

Having done quite some FSM-based programming, I completely understand and appreciate the value of Typestate! While getting it correct requires time and effort ( _con_ , some may say ), prevention of wrong APIs being called by the compiler, carries immense value ( the obvious _pro_ ). Thank you for a concise presentation, Stefan!

[@kieransweeden]

This was really interesting! It was especially satisfying seeing the types change to reflect state based on previous calls. Thank you!

[@billyean]

What if the build is available when set mutiple things need to be set, I guess you might have to use a bitset to decide if all things are set or not? Is there any better way?

[@user-uk6th6pm2j]

Wow! So compiler will not let you forget to pass a workload to construct a worker!

[@axisaligned9799]

small typo at 9:50:
.uri("...");
.header("...", "...");
there shouldnt be a semicolon after the .uri()

[@MrYevelnad]

This is really confusing at first but very insightful at the end.

[@OliverUnderTheMoon]

Thanks for the vid. I'd be curious if anyone might remark on these things:
* I remember a criticism of "patterns" is that may indicate a deficit in language constructs, or maybe the wrong tool for the job -- it makes me wonder how else this problem could be solved, e.g. with some kind of imperative programming.
* Could this pattern heighten the stack in an undesirable way?
* Is this what the Warp library is doing with it's Boxy filter chains?

[@cramhead]

Thanks for sharing this insight using typestate with the builder pattern. It sends very useful.
One thing I wonder about is how would this scale when multiple required properties need to be set. I have to expect that either the required properties would have to be set in a specific order or that there would be an explosion of possible typestates. Is there another elegant solution that would deal well with that scenario?

[@peter9477]

If multiple properties are *required* then I think (maybe) you could simply keep the final state as a separate typestate. I don't think the intermediate (incomplete) states are so important here, but I am not adept at using the typestate pattern yet so maybe I'm wildly off-base.

[@ChronosWS]

The other variant of this I have seen uses PhantomData and a typestate struct like here, rather than using the typestate as the type of the missing data. I think I like the version presented here, which does not need PhantomData to implement. I wonder if there is some more subtle difference?

[@boenrobot]

I wonder how this generics approach works under the hood... specifically, does it do a copy on each state transition.
I imagine maybe the PhantomData approach does not cause a copy on a state transition.

[@TonyUnderscore]

I think the difference is that if you do use phantomdata, you can't store any data in whatever you are gentrifying over. In this example we say that workload is of type W which we then directly use in the build method with workload.into(). This means that it is not actually a zero sized type whilst if we used phantomdata, this would not be possible (as we can't store anything in it).
I wouldn't consider myself anywhere near knowledgable in the language so please correct me if Im wrong :)

[@TinBryn]

@@boenrobot There really should be no difference between state transition using PhantomData or Unit structs, both are zero sized. The main difference is you can go from a unit struct to a non-zero sized type and add data to the new version, you can't do that with PhantomData. I would also add that storing the generic type directly also helps with type inference. I would argue that if you have a generic struct, and you intend for that generic type to be zero sized, you shouldn't use PhantomData and just store the type directly. One more thing is it should be the last field of a struct, this prevents it affecting alignment and padding of the rest of the fields, and allows unsizing.

[@CristianGarcia]

Feels like someone could create a macro for this that boils it down to a single python-like constructor.

[@skytech2501]

Enums instead of generics?!!

[@linkernick5379]

Are named arguments abandoned forever? 😢