5 ms·

Not directly related to the article, but string interpolation in code samples in step 6 looks somewhat unreadable without proper syntax coloring: Console.Wri

by magnat 9y ago

Not directly related to the article, but string interpolation in code samples in step 6 looks somewhat unreadable without proper syntax coloring: Console.WriteLine($"lhs=({lhs.x}, {lhs.y}); rhs=({rhs.x}, {rhs.y})"); Console.WriteLine($"{lhs.x == rhs.x}, {lhs.y == rhs.y}");

masklinn 9y ago
They look fine to me, but I guess it helps that both Python and Rust use the same interpolation style.
- gpm 9y ago
  Err... do either python or rust allow this style, in both languages I've always used ("lhs=({}, {}); rhs=({}, {})", lhs.x, lhs.y, rhs.x, rhs.y)
  - cyphar 9y ago
    Python added "f strings" recently (read: in 2015)[1], which look like f"{some_var}" which evaluates "some_var" in the local scope. Sort of like Ruby's "#{...}" (if I'm remembering that syntax correctly). Rust supports named parameters in format strings[2] but that's not quite the same. [1]: https://www.python.org/dev/peps/pep-0498/ https://www.python.org/dev/peps/pep-0498/ [2]: https://doc.rust-lang.org/std/fmt/#named-parameters https://doc.rust-lang.org/std/fmt/#named-parameters
    - vog 9y ago
      Note that you can do this in old version of Python, too, using the "format-locals" idiom: some_var = ... "{some_var}".format(**locals()) Although this does have some limitations regarding variables to strictly being in the local scope, this is a fine idiom if you need to be compatible with older Python versions.
      - cyphar 9y ago
        That is a bit of a hack though ;). You could also do it with %-style formatting as well: some_var = ... "%(some_var)s" % locals() If you want to do both locals and globals you can do: some_var = ... "%(some_var)s" % dict(globals(), **locals()) New Python versions (>=3.5) have this syntax: "%(some_var)s" % {**globals(), **locals()} But those versions also have f-strings so that's sort of moot.
  - antsar 9y ago
    In addition to f-strings, Python supports this (slight) improvement on your version. "lhs=({l.x}, {l.y}); rhs=({r.x}, {r.y})".format(l=lhs, r=rhs)
  - masklinn 9y ago
    I was mostly talking about the placeholders (hence style), but > ("lhs=({}, {}); rhs=({}, {})", lhs.x, lhs.y, rhs.x, rhs.y) Python 3.6 added "natively interpolated" f-strings, just replace C#'s `$` prefix by `f`, and even without f-strings you could write e.g. "lhs=({lhs.x}, {lhs.y}); rhs=({rhs.x}, {rhx.y})".format(lhs=lhs, rhs=rhs) Rust supports named parameters but IIRC not attribute access or method calls.
    - steveklabnik 9y ago
      Yes, you can't do something like this in Rust, you'd be doing what's in the quote above; named params are it. You have to do the attribute access/method call when binding the parameter, not applying it to a parameter somehow.

by magnat 9y ago

masklinn 9y ago

They look fine to me, but I guess it helps that both Python and Rust use the same interpolation style.

gpm 9y ago
Err... do either python or rust allow this style, in both languages I've always used ("lhs=({}, {}); rhs=({}, {})", lhs.x, lhs.y, rhs.x, rhs.y)
- cyphar 9y ago
  Python added "f strings" recently (read: in 2015)[1], which look like f"{some_var}" which evaluates "some_var" in the local scope. Sort of like Ruby's "#{...}" (if I'm remembering that syntax correctly). Rust supports named parameters in format strings[2] but that's not quite the same. [1]: https://www.python.org/dev/peps/pep-0498/ https://www.python.org/dev/peps/pep-0498/ [2]: https://doc.rust-lang.org/std/fmt/#named-parameters https://doc.rust-lang.org/std/fmt/#named-parameters
  - vog 9y ago
    Note that you can do this in old version of Python, too, using the "format-locals" idiom: some_var = ... "{some_var}".format(**locals()) Although this does have some limitations regarding variables to strictly being in the local scope, this is a fine idiom if you need to be compatible with older Python versions.
    - cyphar 9y ago
      That is a bit of a hack though ;). You could also do it with %-style formatting as well: some_var = ... "%(some_var)s" % locals() If you want to do both locals and globals you can do: some_var = ... "%(some_var)s" % dict(globals(), **locals()) New Python versions (>=3.5) have this syntax: "%(some_var)s" % {**globals(), **locals()} But those versions also have f-strings so that's sort of moot.
- antsar 9y ago
  In addition to f-strings, Python supports this (slight) improvement on your version. "lhs=({l.x}, {l.y}); rhs=({r.x}, {r.y})".format(l=lhs, r=rhs)
- masklinn 9y ago
  I was mostly talking about the placeholders (hence style), but > ("lhs=({}, {}); rhs=({}, {})", lhs.x, lhs.y, rhs.x, rhs.y) Python 3.6 added "natively interpolated" f-strings, just replace C#'s `$` prefix by `f`, and even without f-strings you could write e.g. "lhs=({lhs.x}, {lhs.y}); rhs=({rhs.x}, {rhx.y})".format(lhs=lhs, rhs=rhs) Rust supports named parameters but IIRC not attribute access or method calls.
  - steveklabnik 9y ago
    Yes, you can't do something like this in Rust, you'd be doing what's in the quote above; named params are it. You have to do the attribute access/method call when binding the parameter, not applying it to a parameter somehow.