dupdrop

Good thing that companies never do anything illegal, and everyone lives in Europe.

I'm curious: what would make it so much worse in Fedora compared to Arch?

Only Python, is a language soooo dynamic, that the question "Does this code type-checks?" may get the valid response: "With which of the 5 existing type checkers?"

I don't know if your language is expression based like Rust, but in Rust the nice thing is that it's just the regular if syntax being used as an expression and not some additional special case syntax, which is elegant.

I actually like the Haskell syntax more because it's looks nicer when formatted in multiple lines:

  -- Haskell:
  -- single line
  if ... then ... else ...

  -- multiline
  if ...
      then ...
      else ...

Where in Rust with normal formatting it because 5 whole lines:

  // Rust:
  let result = if ... {
      ...
  } else {
      ...
  };

  // or, 4 lines but less common:
  let result = match ... {
      true => ...,
      false => ...,
  };

I think the strongest argument for condition-first that's unrelated to "taste" is the fact it is consistent with the order of execution:

  # Python:
  # you have to read "from the middle out" to read with the order of execution
  x = a() if b() else c()

I also strongly suggest you look up why Python ended up with the syntax it did. The reasons were not really good and not really applicable to a new language. Maybe my memory is bad because I can't find the source, but I remember one of the justifications was simply that it turned out faster in cpython (the python interpreter) in the test implementation they did.

I might also consider asking Chris Lattner (Mojo language). They did use that syntax in Mojo, because it is made to be a superset of Python. But I remember hearing him say he really disliked it.

I think I only started to really hate it when I had to deal with some Python code where people decided to nest them and made a really hard to read mess where they should have used just a normal if-else chain. A Rust style if-expression would be better IMO, but it was Python code.

On a more basic level, I just don't see any good reason to put the condition in the middle.

Lisp: `(if <cond> <then> <else>)` Haskell: `if <cond> then <then> else <else>` Rust: `if <cond> { <then> } else { <else> }`

All the above read fine and normal. In the python version the order of execution is different then the left-to-right reading order.

It's not like it's a fatal flaw for a language to do it like Python. But it is just silly IMO. My POV is that I actually really like if-expressions, but hate the condition-in-the-middle syntax, so I tend to avoid it unless it's really short. When code changes slightly and becomes longer I'd rather not have to always double take if this now should change to an if-statment or to an expression etc.

Sorry for the petty comment, but if you design your language syntax with `x if cond else y` with the condition in the middle like in the Python if-expression syntax, I cannot trust your judgment and we cannot be friends. (from one of the images of code)

I will take an actual look into it later though, seems interesting.