Exploring SumTypes.jl: An Enum Type System for Julia
Written on
Chapter 1: Introduction to SumTypes.jl
The Julia programming language boasts an impressive array of modules within its package ecosystem that can significantly modify its syntax. This capability primarily stems from macros, though introspection can also yield remarkable outcomes. One standout package is SumTypes.jl, which introduces sum types into Julia. This module adeptly alters the language's syntax to enable the use of sum types, also referred to as discriminated or disjoint unions.
Section 1.1: Understanding Sum Types
Sum types represent a type system in which types are associated with their originating types. The term "sum types" aptly describes this concept, as it involves the aggregation of types in a linear fashion. Picture a planet with multiple moons, where each moon shares a connection as a satellite of that planet. Delving deeper, these moons have revolving debris that orbits around them. This analogy encapsulates the essence of sum types, which has now been integrated into Julia via the SumTypes.jl module.
Section 1.2: Utilizing SumTypes.jl
Creating sum types using SumTypes.jl is remarkably straightforward. To define a sum type, simply invoke the sum_type macro and specify a type name, such as Vegetable. For instance:
Copy@sum_type Vegetable{C, P, O} begin
Cucumber{C}(::C)
Pepper{P}(::P)
Onion{O}(::O)
end
With this setup, each of the types—Cucumber, Pepper, and Onion—becomes associated with the Vegetable type. However, distinguishing among these types remains easy through parameters, represented by the values within {} above, and the sum types themselves.
typeof(Cucumber(:green))
The type output would be Vegetable{Symbol, Uninit}, showcasing how we effectively encapsulate a value of a specific type along with the argument types provided to the constructor through our parameters.
Subsection 1.2.1: The Power of Pattern Matching
The true potential of SumTypes emerges when combined with pattern matching. This approach excels in constructing efficient and straightforward data structures that share a common inheritance and type. Consider a scenario where we have various key names associated with distinct key codes. While one could utilize a Dict{String, Any} to manage this, sum types offer a more elegant solution than juggling multiple indexing pairs.
Copy@cases in my_salad begin
Cucumber() => "cucumber"
Pepper() => "pepper"
Onion() => "Onion"
end
This setup allows us to easily retrieve the value associated with Cucumber, yielding "cucumber" effortlessly.
Chapter 2: Conclusion
In summary, SumTypes.jl is an intriguing package that introduces unique functionalities to the Julia programming language. The module's developer, Mason Protter, is also behind ReplMaker.jl, another noteworthy package previously discussed. Here’s a link to that article for further exploration:
Mason is undoubtedly someone worth following and supporting in the Julia community! I am excited to experiment with this module in my upcoming projects, and I hope you find it as compelling as I do. Thank you for taking the time to read this overview!
