undefined | Better HN

0 pointsdataflow3y ago0 comments

I agree tooling makes a huge difference but I specifically said this with the understanding that you're using C# with Visual Studio. Some stuff will be easier in C#, but a lot of other stuff just isn't as easy as in Python.

At the risk of setting up a strawman for people to punch down, try comparing how easy it is to do the equivalent of something like this in C#, and feel free to use as much IDE magic as you'd like:

  x = [t[1] for t in enumerate(range(1, 50, 4)) if t[0] % 3 == 0][2:]

Was it actually easier?

There's a million other examples I could write here, but I'm hoping that one-liner will be sufficient for illustration purposes.

0 comments

eterm3y ago

Here's a one liner in c# for that:

    Enumerable.Range(1,50).Where((x,i) => i % 4 == 0).Where(e => e % 3 == 0).Skip(1).Select(e => e+4)

Okay, so you might consider that last e+4 cheating and against the spirit, but I couldn't be bothered to spend money upgrading my linqpad to support the latest .net with Enumerable.Chunk which makes taking two at a time easier for the first part.

Edit: more in spirit:

    Enumerable.Range(1,50).Where(e => e % 4 == 0 && e % 3 == 0).Skip(1).Select(e => e + 1)

Jtsummers3y ago

If I understand dataflow's example correctly you don't need the Select at the end:

  var x = Enumerable.Range(1,50)
          .Where((num, index) => num % 4 == 1 && index % 3 == 0)
          .Skip(2)
          .ToArray();

That computes the same thing as their Python snippet: [25,37,49]. Of course, what this is actually computing is whether the number is congruent to 1 modulo 4 and 3 so it was a weird example, but here's how you'd really want to write it (since a number congruent to 1 modulo 4 and 3 is the same as being congruent to 1 module 12):

  var x = Enumerable.Range(1,50)
          .Where(num => num % 12 == 1)
          .Skip(2)
          .ToArray();

Rewriting that Python example to be a bit clearer for a proper one-to-one comparison:

  y = [t for t in range(1, 50, 4) if t % 3 == 1][2:]

That enumerate wrapper was unnecessary. I don't recall a way, in LINQ, to generate only every 4th number in a range, but I also haven't used C# in a few years so my memory is rusty on LINQ anyways.

eterm3y ago

You're right, the maths simplifies it a lot. I rushed out a one-liner without much analysis, and eventually come to the same conclusion.

There's no Range method that takes (start, stop, step) but it's trivial enough to write one, it's a single for loop and yield return statement.

We can even trigger the python users by doing it in one line ;)

    public static class CustomEnumerable { public static IEnumerable<Int32> Range(int start, int stop, int step) {for (int i = start; i < stop; i+=step) yield return i;}}

Try writing your function definitions on one line in python!

3695486848928263y ago

> LINQ, to generate only every 4th number in a range

Maybe something like this?

    Enumerable.Range(0,49).Select(x => 4*x + 1)

1 more reply

dataflowOP3y ago

> num % 12

> That enumerate wrapper was unnecessary.

I'm surprised you didn't go all the way and just write

  x = [25, 37, 49]

and tell me the rest of the code was unnecessary!

1 more reply

dataflowOP3y ago

Nah that part I'm not worried about. The "cheating" is omitting the rest of the line. What you really needed was:

  var y = Enumerable.Range(1, 50).Where((x, i) => i % 4 == 0).Where(e => e % 3 == 0).Skip(1).Select(e => e + 4).ToArray();

Compare that against:

  y = [t[1] for t in enumerate(range(1, 50, 4)) if t[0] % 3 == 0][2:]

It's almost twice as long, and doesn't exactly make up for it with readability either.

dmitriid3y ago

What you're missing is that C# example works on any Enumerable. And it's very hard to explain how damn important and impressive this is without trying it first.

Yes, it's more verbose, but I can swap that initial array for a List, or a collection, or even an external async datasource, and my code will not change. It will be the same Select.Where....

1 more reply

eterm3y ago

It's not "twice as long" in any syntactic sense, and readability is easily fixed:

    Enumerable.Range(1,50)
        .Where(e => e % 4 == 0 && e % 3 == 0)
        .Skip(1)
        .Select(e => e + 1)

That's very understandable, it's clear what it does, and if your complaint is that dotnet prefers to name expressions like Skip rather than magic syntax, we can disagree on what make things readable and easy to maintain.

1 more reply

radicalbyte3y ago

There's very little difference between the two as long as you're using modern versions of both and add your own functions to fill any API gaps and are using type hinting properly in Python. My C# tends to be "larger" because I use more vertical whitespace and pylint is rather opinionated.. :)

Where you can complain about C# - and I do - is where you're having to write (or work with) code which has been force to stick to strict architectural and style standards. That makes code-bases which are very hard to understand for newbies and are verbose.

On the flip side, once you start doing anything even slightly interesting with Python you run into the crappy package management. The end result of which is lots of frustration getting projects working and a lot of time wasted on administration vs work.

j / k navigate · click thread line to collapse

0 comments

eterm3y ago

Here's a one liner in c# for that:

    Enumerable.Range(1,50).Where((x,i) => i % 4 == 0).Where(e => e % 3 == 0).Skip(1).Select(e => e+4)

Edit: more in spirit:

    Enumerable.Range(1,50).Where(e => e % 4 == 0 && e % 3 == 0).Skip(1).Select(e => e + 1)

Jtsummers3y ago

If I understand dataflow's example correctly you don't need the Select at the end:

  var x = Enumerable.Range(1,50)
          .Where((num, index) => num % 4 == 1 && index % 3 == 0)
          .Skip(2)
          .ToArray();

  var x = Enumerable.Range(1,50)
          .Where(num => num % 12 == 1)
          .Skip(2)
          .ToArray();

Rewriting that Python example to be a bit clearer for a proper one-to-one comparison:

  y = [t for t in range(1, 50, 4) if t % 3 == 1][2:]

That enumerate wrapper was unnecessary. I don't recall a way, in LINQ, to generate only every 4th number in a range, but I also haven't used C# in a few years so my memory is rusty on LINQ anyways.

eterm3y ago

You're right, the maths simplifies it a lot. I rushed out a one-liner without much analysis, and eventually come to the same conclusion.

There's no Range method that takes (start, stop, step) but it's trivial enough to write one, it's a single for loop and yield return statement.

We can even trigger the python users by doing it in one line ;)

    public static class CustomEnumerable { public static IEnumerable<Int32> Range(int start, int stop, int step) {for (int i = start; i < stop; i+=step) yield return i;}}

Try writing your function definitions on one line in python!

3695486848928263y ago

> LINQ, to generate only every 4th number in a range

Maybe something like this?

    Enumerable.Range(0,49).Select(x => 4*x + 1)

1 more reply

dataflowOP3y ago

> num % 12

> That enumerate wrapper was unnecessary.

I'm surprised you didn't go all the way and just write

  x = [25, 37, 49]

and tell me the rest of the code was unnecessary!

1 more reply

dataflowOP3y ago

Nah that part I'm not worried about. The "cheating" is omitting the rest of the line. What you really needed was:

  var y = Enumerable.Range(1, 50).Where((x, i) => i % 4 == 0).Where(e => e % 3 == 0).Skip(1).Select(e => e + 4).ToArray();

Compare that against:

  y = [t[1] for t in enumerate(range(1, 50, 4)) if t[0] % 3 == 0][2:]

It's almost twice as long, and doesn't exactly make up for it with readability either.

dmitriid3y ago

What you're missing is that C# example works on any Enumerable. And it's very hard to explain how damn important and impressive this is without trying it first.

Yes, it's more verbose, but I can swap that initial array for a List, or a collection, or even an external async datasource, and my code will not change. It will be the same Select.Where....

1 more reply

eterm3y ago

It's not "twice as long" in any syntactic sense, and readability is easily fixed:

    Enumerable.Range(1,50)
        .Where(e => e % 4 == 0 && e % 3 == 0)
        .Skip(1)
        .Select(e => e + 1)

1 more reply

radicalbyte3y ago

j / k navigate · click thread line to collapse