Cases for a limited number of fields

[blerner]

(migrated from https://github.com/orgs/brownplt/teams/pyret/discussions/7)

I'm writing an example that has 6 fields(because I'm mimicking a table).

data Pedigree:
  | dog(
      name :: String,
      sex :: String,
      breed :: String,
      weight :: Number,
      dam :: Pedigree,
      sire :: Pedigree)
  | unknown
end

fun depth(d):
  cases(Pedigree) d:
    | unknown => 0
    | dog(_, _, _, _, dam, sire) =>
      num-max(depth(dam), depth(sire)) + 1
  end
end

Four underscores, oh my! And then I add “height” and need to add underscores all over the place. Proposal below. The first desugars directly in to the above, the second means the same thing but uses shorter names:

fun depth(d):
  cases(Pedigree) d:
    | unknown => 0
    | dog{dam, sire} =>
      num-max(depth(dam), depth(sire)) + 1
  end
end

fun depth(d):
  cases(Pedigree) d:
    | unknown => 0
    | dog{d=dam, s=sire} =>
      num-max(depth(d), depth(s)) + 1
  end
end

[blerner]

@ds26gte on Feb 24, 2018

Yes. By-order-of-argument (BOA) constructors (a pun made very long ago by GLS) are prone to user error. (I assume this desugaring will be available even for constructing instances of datatypes, rather than just for deconstructing cases arguments.)

I would also invert d=dam to dam=d. I.e, dog{dam=d, sire=s}.

[blerner]

@shriram via email on Feb 25, 2018
I like this idea. I’m happy to defer syntax to Ben.

I’m not a fan of Dorai’s proposal: we already write the name of the newly-bound identifier on the left of =, not the right, and Dorai’s suggestion inverts that, surely creating confusion down the road.

[blerner]

@sorawee on Feb 25, 2018

I am against = because = is symmetric and it is confusing either way. I suggest as which has a clear meaning and is not symmetric. The order that Dorai suggests would make most sense with as:

fun depth(d):
  cases(Pedigree) d:
    | unknown => 0
    | dog{dam as d, sire as s} =>
      num-max(depth(d), depth(s)) + 1
  end
end

[blerner]

@ds26gte on Feb 25, 2018

I was reading the = as a :, in which case dog{dam: d, sire: s} has an intuitive and/or familiar reading. i.e., a dog object whose dam field has the value d, and sire field has the value s."

[blerner]

@sorawee on Feb 25, 2018

This is in the binding position though, so saying "a dog object whose dam field has the value d" seems a little bit weird.

The reason I advocate for as is because we have been using as like this already in the import statement:

import lists as L

[blerner]

@blerner on Mar 20, 2018

For a single point of comparison, JS destructuring assignment uses colons as @ds26gte wrote above, and like @sorawee I find it really confusing in the Pyret context to make that make sense to me :-)

For a second point of comparison, both OCaml and Haskell uses the syntax @jpolitz showed above... but OCaml also uses as patterns to bind a name to a nested pattern, while Haskell uses @. Go figure.

I think I like as here better: if you're going to shorten a name, it had better be worth it to type in the extra four characters [space]as[space] :)