Not really. Let’s first consider how this code would be translated to ocaml. One would expect to use variants instead of strings, so e.g. gender should be:

Not really. Let’s first consider how this code would be translated to ocaml. One would expect to use variants instead of strings, so e.g. gender should be: type t = | Masculine | Feminine | Mixed And then one can match on them and match on tuples and so on. But what about countries? In this case you could write out all the cases separately (difficult to maintain), or you could use polymorphic variants to achieve the @foo.any behaviour: type vosotros = [ `Spain | ... ] type dialect = [ vosotros | ... ] And then do e.g. match dialect with | #vosotros -> ... But this has the disadvantages that polymorphic variants usually bring (difficulties with type inference/exhaustiveness checks). So instead one would probably have some function to decide if a dialect Is vosotros, and then match on the result of that, a slightly annoying to read boolean. And one would also need to match on the (perhaps) nonsense case of singular mixed-gender. One can get around this with types in one of two annoying ways. Either combine gender and number: type gender = Masculine | Feminine type genders = Masculine | Mixed | Feminine type number = | Singular of gender | Plural of genders Which is not great because it is now hard to extract the gender if that is all one wants (but it is perhaps not grammatically useful); or one can use GADTs: type singular = [ `singular ] type plural = [ `plural ] type 'number gender = | Masculine : 'a gender | Feminine : 'a gender | Mixed : plural gender type 'number number = | Singular : singular number | Plural : plural number type t = T : { number : 'num number; gender : 'num gender } -> t But this is also unpleasant. And how does one do other smart-match predicates? For example * > 0. This could either be: match number, ... with | num, ... when num > 1 -> ... Which separates the important part (num > 1) from the unimportant part (giving it the name when you don’t care), and you still need a catch all because of the exhaustiveness checks. So maybe instead you would have a helper function to change the number into a variant like One | Zero | Many. This also ignores the case when one might want to write some more traditional style Perl and put regular expressions as the predicates of those when blocks. This isn’t really an ocaml/SML thing to do but that doesn’t mean it should be disregarded as something bad/useless.