Unified Condition Expressions (soc.me)
from soc@programming.dev to programming_languages@programming.dev on 26 Apr 14:11
https://programming.dev/post/29277009

A design that subsumes the various syntactic forms of

and scales from simple one-liners to complex pattern matches.

#programming_languages

threaded - newest

mobotsar@sh.itjust.works on 26 Apr 15:50 next collapse

A quite decent syntax and an excellent domain name!

tyler@programming.dev on 26 Apr 17:50 next collapse

How does $person get set?

soc@programming.dev on 26 Apr 18:13 collapse

Good catch, that should have been if person in the first line.

It’s been a left-over from when syntax looked like this:

  is Person("Alice", _)$person then "{$person.age}"
  is Person("Bob", $age)       then "$age"
armchair_progamer@programming.dev on 26 Apr 19:58 next collapse

This looks very similar to The Ultimate Conditional Syntax, although that’s for ML so it doesn’t have the nice syntax for chaining method calls.

soc@programming.dev on 26 Apr 21:12 collapse

The author of that paper hung around in the lang design forum were I originally presented this.

considerealization@lemmy.ca on 01 May 15:58 collapse

Isn’t match already such a unified expression? Especially once you extend matches with guards, it seems to me like this is a solved problem. E.g.,

if x == 1.0 then "a" else "x"

is

match x with | 1.0 -> "a" | _ -> "b"

and

if x ==
  1.0 then "a"
  2.0 then "b"
      else "z"

is (and IMO reads much clearer this way):

match x with
| 1.0 -> "a"
| 2.0 -> "b"
| _ -> "z"

and

if xs
  .isEmpty then "e"
  .contains(0,0) then "n"
  else "z"

is

match () with
| _ when x.isEmpty -> "e"
| _ when x.contains(0,0) then "n"
| _ -> "z"

and

if person
  .age < 18                 then 18
  is Person("Alice", _)     then person.age
  is Person("Bob", let age) then age
                            else -1

is

match person with
| _ when person.age < 10 -> 18
| Person("Alice", _) -> person.age
| Person("bob", age) -> age
| _ -> -1

.

Finally,

if person is Person("Alice", let age) then age else -1

Would be the simple

match person with
| Person("Alice", age) -> age
| _ -> -1

Seems to me this reads more clear in general and has less magic. Plus, it’s already implemented in a bunch of languages.