HN Explorer

10 comments

[ 2.8 ms ] story [ 36.6 ms ] thread
[dead] MHollender
Also, Hollender's Tenth Rule (tongue-in-cheek): Any sufficiently user-friendly functional programming library contains an ad hoc, informally-specified, bug-ridden, slow implementation of SQL.
arnorhs
is what a good idea in python?
gaius
From the article:

    #
    #Problem: all these lambdas suck. Any better ways to do it?
    #
 
    #
    #TODOS/QUESTIONS:
    #
    #1. is it a good idea?
    #
    #2. can it be made to not suck (do something with all those lambdas)?
run4yourlives
Issue being that how can anyone answer those two questions without understanding the problem he/she is attempting to solve?

It very well might be the only way to solve the issue given external constraints, but it may also be the case that, for example, reworking the problem space would lend itself to a much more elegant solution.

Code should never be treated as if it exists in some sort of bubble.

[dead] MHollender
Um, what's hard to understand in:

"#LINQ in C# is cool #Python doesn't quite need it as it has generatior expressions, sum(), len(), sorted() and itertools.groupby() #so let's just wrap a nice SQL-like interface over them in order to make them more familiar." ?

It's getting the above-mentioned features as easy to use for the SQL-familiar programmer as possible.

russell
Lambdas pretty much suck because there has not been a good brace-free syntax proposal, There was a pretty good proposal for a where clause a couple of years ago, but it doesn't seem to have gotten any traction, probably because it was not made into a PEP (see python.org about PEP's).

http://groups.google.com/group/comp.lang.python/browse_threa...

d0mine
Your examples rewritten in a different style:

  table = ((8, 2, 9), (4, 5, 6), (2, 1, 9))
  my_sum = sum(row[0] for row in table if row[2] == 9) 
  # assert my_sum == 10

  my_lst = [row[0] for row in table if row[2] == 9]
  # all row[2] == 9 therefore OrderBy is a no-op in your example 
  # assert my_lst == [8, 2]
Modified example:

  myLst = From(table) \
        .Where(lambda column: column[2]==9) \
        .OrderBy(lambda column: column[1])  \
        .Select(lambda column: column[0])

  my_lst = sorted((row[1], row[0]) for row in table if row[2] == 9)
  my_lst = map(itemgetter(1), my_lst)
  # assert my_lst == [2, 8]
Or to preserve order in case some row[1] are equal:

  my_lst = [row for row in table if row[2] == 9]
  my_lst.sort(key=itemgetter(1)) # requires "lambda"
  my_lst = [row[0] for row in my_lst]
  # assert my_lst == [2, 8]
[dead] MHollender
Um, exactly what words in

"#LINQ in C# is cool #Python doesn't quite need it as it has generatior expressions, sum(), len(), sorted() and itertools.groupby() #so let's just wrap a nice SQL-like interface over them in order to make them more familiar"

you have trouble understanding?

I'm trying to wrap a unified and familiar SQL-like, LINQ-like interface over gen. expressions, sorted(), len() and suchlike and you remark that gen. expressions, sorted() and suchlike exist. Wow!

jcl
As a side note, you don't need the line continuation characters if you wrap the expression in parentheses.