Second of Two Lessons on Polymorphic Variants: Practical Usecases

Learning
1

This is the second of two lessons on polymorphic variants I’ve been drafting for potential inclusion in the Learn section of OCaml.org.

You can find the draft second lesson here. I appreciate any feedback you may have.

The OCaml.org discussion of the first lesson can be found here.

The goal of the first lesson was to introduce the foundational knowledge for how polymorphic variants work (row polymorphism, structural typing, upper bounds, lower bounds, …), their benefits and drawbacks, how they relate to “ordinary” variants, their notation (\``, >, <, #`, …), and their behavior during type refinement.

I am grateful to everyone that provided feedback on the first lesson. I incorporated most of the feedback into the lesson already, but it is not yet complete. I’ve held off finalizing the first lesson until this second lesson receives feedback, since there may be significant structural changes to the first lesson depending on the feedback received on this second part.

The objective of this second lesson is to demonstrate practical usecases for polymorphic variants. Presently, it demonstrates seven practical usecases of polymorphic variants, along with “ordinary” variant equivalents for comparison.

The seven usecases were sourced from:

Please consider this a rough draft. It does not include an indroduction and conclusion, and every example has minimal narrative supporting it.

The goal is to solicit feedback on the selected examples, the structure of the examples, and
to solicit additional examples if these are insufficient.

If you have experience with specific usecases for polymorphic variants that you feel would do a better job demonstrating specific usecases or that demonstrate features not presented here, please let me know. If you can supply a concise example with a quick overview I would be grateful. If that does not work with your schedule, I can formulate an example from a description and perhaps a github link if available.

For example, none of the usecases demonstrate explicit coercions. That may be a useful example to include, however this was not mentioned in the source material and am unsure how commonly it is employed by OCaml developers.

Once this document’s examples are locked down, I will consider the following:

  • Which lesson should be introduced first (demonstrations or foundations)?
  • Should the examples in this lesson be extracted into .ml files for readers to clone like in some other lessons on the site?
  • Should the two lessons be merged?
  • Is the length excessive?
  • Can any content be removed or extracted into a standalone lesson?

Once that is resolved, I will do a final pass on the lesson(s) and make another request for feedback.

Once again, I want to express my gratitude to everyone willing to work through these draft lessons, as well to those willing to provide feedback.

Example Usecases:

  • Monomorphic Usecases
  • Overloaded Tags
  • Compose with Result
  • Transitioning from Ordinary to Polymorphic Variants in an API
  • Polymorphic Variants with Phantom Types
  • Functional Reactive Programming with Polymorphic Variants
  • Encoding HTML in Hierarchical Structures
1 Like