News for hackers. Stuff that matters.
Re:Explicit vs. Clever by tome on Tuesday April 02, 2013 @04:30PM (#5481887)
One of the nice things about Python is that it has syntactic sugar for this. I find

    [order.total for order in orders]
very easy to understand in terms of natural language. Still, now I've learned Haskell I'd prefer to write

    map (^.total) orders
Re:Explicit vs. Clever by adambard on Tuesday April 02, 2013 @04:35PM (#5481907)
Are we having a code example party? I like Clojure:

   (map :total orders)
Re:Explicit vs. Clever by jimbokun on Tuesday April 02, 2013 @05:43PM (#5482323)
Frankly, I would like to have more code example parties.

Too often, differences between programming languages are treated as strictly philosophical arguments. Comparing and contrasting actual code is far more interesting, in my opinion.

Re:Explicit vs. Clever by bcoates on Tuesday April 02, 2013 @05:07PM (#5482095)
I'm partial to

  select total from orders
myself. I really wish was as much progress on syntaxes for expressing relational algebra as there is for the functional stuff. Dealing with map and apply seems a bit fiddly and low-level for what should be a straightforward thing to express declaratively.
Re:Explicit vs. Clever by adambard on Tuesday April 02, 2013 @05:13PM (#5482124)

    (defmacro select [total _ coll]
      (let [total (keyword total)]
        `(map ~total ~coll)))

    (select total from orders)
Problem solved!
Re:Explicit vs. Clever by draegtun on Wednesday April 03, 2013 @04:16PM (#5488740)
Nice.

Here are some interesting non-macro variants, first in Rebol:

  select: func [block] [
      totals: []
      parse block [
          set this word!
          'from
          set coll word!
          (totals: map-each n (get coll) [get in n this])
      ]
      totals
  ]
 
  ; then later...

  select [total from orders]

  ;; nb. `select` is a core function provided by Rebol
  ;;     so remember this example overwrites that
  ;;     (in this scope/context)  :)
  ;;
  ;;     Alternative `dialect` to strive for would be..
  ;;  
  ;;       doMap [select total from orders]

And also in Io:

  select := method(
      msg  := call argAt(0)
      this := msg name
      coll := msg next next name
  
      newMsg := message(COLL map)     // COLL just a placeholder message
      newMsg setName(coll)            // Now been changed to correct var provided
      newMsg next appendArg(this asMessage)
      call sender doMessage(newMsg)
  )

  # then later...

  select(total from orders)
Both examples work at runtime. However in Io you can also amend the AST directly.
Re:Explicit vs. Clever by njs12345 on Wednesday April 03, 2013 @07:17AM (#5485333)
There's a GHC (Haskell) extension which lets you use list comprehensions which read like SQL: http://www.haskell.org/ghc/docs/7.2.1/html/users_guide/synta...
Re:Explicit vs. Clever by tome on Tuesday April 02, 2013 @06:10PM (#5482499)
I agree, but I think that `map` is already a declarative interface (albeit to an implementation that is presumably functional).
Re:Explicit vs. Clever by damncabbage on Tuesday April 02, 2013 @06:56PM (#5482789)
Party time with Ruby:

  orders.map(&:total)
... Where :total is a symbol, and & is asking :total for the Proc version of itself (a Proc being an anonymous function of sorts), and map is then calling that Proc with a single argument (an order from the list of orders).

More detail: http://stackoverflow.com/a/1217114/3528

Re:Explicit vs. Clever by tome on Tuesday April 02, 2013 @04:37PM (#5481914)
Yeah you're welcome to bring Clojure to my party. I've never met him/her before but he/she looks like other languages I get on well with.
Re:Explicit vs. Clever by draegtun on Wednesday April 03, 2013 @10:52AM (#5486386)
These are also nice and would like to join in the party :)

  map *.total, @orders;        # perl6

  @orders.map: *.total;        # perl6 OO

  map {$_->total} @orders;     # perl5

  orders map(total)            # Io

  map-each n orders [n/total]  ; Rebol
Re:Explicit vs. Clever by ricardobeat on Tuesday April 02, 2013 @05:30PM (#5482239)
No need to go that far, CoffeeScript can do both:

    totals = (order.total for order in orders)

    totals = orders.map (o) -> o.total
Re:Explicit vs. Clever by jimmaswell on Tuesday April 02, 2013 @09:27PM (#5483568)
The c# syntax, myNewList = (from i in myList where i > 3 && i != 7 select i * 4).toList(), is nice too. Similar to using LINQ, myList.Where(i => i > 3), but I don't believe that form allows an easy use of the i * 4 part. One annoyance I have with .NET is there are too many types that are similar-but-not-quite a List<>, making me do conversions often. At least it's usually not much more than a .ToList(), except in the case of the controls in a Windows Form, which are their own weird list-type structure that doesn't support that.
Re:Explicit vs. Clever by dbattaglia on Thursday April 04, 2013 @07:59AM (#5492114)
For older .Net collections you can use Cast<T>() to get LINQ goodness. Something like this would work:

  var values = from x in combobox.Items.Cast<ComboBoxItem>() where x.Value > 5 select x.Value;