Skip to content

Instantly share code, notes, and snippets.

Created August 15, 2012 05:56
Show Gist options
  • Save andkerosine/3356675 to your computer and use it in GitHub Desktop.
Save andkerosine/3356675 to your computer and use it in GitHub Desktop.
Haskell-like list comprehensions in Ruby
$stack, $draws = [], {}
def method_missing *args
return if args[0][/^to_/]
$stack << { |a| a or $stack.pop }
$draws[$stack.pop(2)[0][0]] = args[1] if args[0] == :<
class Array
def +@
keys = $draws.keys & $stack
draws = $draws.values_at *keys
comp = draws.shift.product(*draws).map do |draw|
$ { |s| draw[keys.index s] rescue s }.reduce do |val, cur|
op = Symbol === cur ? [:send, :method][val.method(cur).arity] : :call
val.send op, cur
$stack, $draws = [], {}
Symbol === last ? : comp
def -@
case map(&:class).index Range
when 0 then first.to_a
when 1 then [first] + last.step(last.min.ord - first.ord).to_a
else self
foo =+ [x * y | x <- [1..3], y <- [4..6]]
# [4, 5, 6, 8, 10, 12, 12, 15, 18]
bar =+ [a + b | a <- ['n','p'..'t'], b <- %w[a i u e o]]
# ["na", "ni", "nu", "ne", "no", "pa", "pi", "pu", "pe", "po", "ra", "ri", "ru", "re", "ro", "ta", "ti", "tu", "te", "to"]
baz =+ [i ** 2 / 3 | i <- [3,6..100], :even?]
# [12, 48, 108, 192, 300, 432, 588, 768, 972, 1200, 1452, 1728, 2028, 2352, 2700, 3072]
quux =+ [s.size.divmod(2) | s <- %w[Please do not actually use this.]]
# [[3, 0], [1, 0], [1, 1], [4, 0], [1, 1], [2, 1]]
Copy link

be commented Aug 15, 2012


Copy link

rahult commented Aug 16, 2012


Copy link

Seriously though, couldn't you make this non-global by only having it work within a block passed to a method named something like list_comprehend ?

Copy link

elight commented Aug 16, 2012

Holy shit.....

Copy link

elight commented Aug 16, 2012

Gem it. Want. Want now.

Copy link

This is so, so "wrong", yet thrilling.

Copy link

@pmarreck It could definitely be cleaned up and made passably useful by wrapping everything in, say, a Raskell do block, but Kernel#method_missing is the only way to capture the bare variables that help to fully emulate Haskell's syntax, so it'd still be pretty unpleasant. This was mostly just an interesting proof of concept.

@elight I just can't bring myself to do it, at least not while there are so many holes: the magical undefined variables become nil after they're used once, so you'd have to ensure you're always using a different set of names in each comprehension; there's no way to filter a specific draw, only the entire result set; I couldn't figure out how to cleanly allow for previous variables to constrain subsequent ranges, and as long as Infinity forces a range into floats, the real power of Haskell's list comprehensions isn't available.

@FranklinChen I'm looking forward to laziness and refinements in 2.0, when something like this might actually be considered sane.

Copy link

This is amazing!

Copy link

gcao commented Aug 17, 2012

This is crazy stuff! I'm still trying to understand how this works. If you could provide some inline comment, it'll be great.

Copy link

styx commented Aug 18, 2012


Copy link

Wow, totally ridonkulous. Nicely done!

Copy link

rdp commented Aug 20, 2012

now if it could avoid using method_missing somehow...

Copy link

Wow, I'm amazed. I really wish Ruby supported this style.

Copy link

Nice work. Let's see if this can be made fly with 2.0...

Copy link

xatier commented May 12, 2013

Really cool!

Copy link


Copy link

Bonus points for the name!

Copy link

Amazing! Some comments would be useful, though.

Copy link

so cool!

Copy link

So, what about using it in place of function argument?

[x * y | x <- [1..3], y <- [4..6]].each { |a| print a }

Copy link

zh4ngx commented May 12, 2013

Ruby 2.1!

Copy link

Looks really nice!

Copy link

I played a bit with the idea to get that. Trying out ruby2 refinements. Too lazy for the "|" support but can do conditions.

Copy link

igbanam commented May 12, 2013

+1 for "Raskell". Pun in "Rascal"?

Copy link

darth10 commented May 13, 2013

Awesome job! ❤️ Gem it please?

Copy link

wteuber commented May 15, 2013

"Haskell-like" without lambdas?
Even if it doesn't look as much like Haskell, this snippet is much closer to the Haskell principles, without abusing Ruby.

foo = ->(x=(1..3), y=(4..6)){x.flat_map{|a|{|b| a*b}}}.call

(Of course you usually wouldn't need to call any lambdas before actually executing the application)

Copy link

hauleth commented May 18, 2013

Nice but for Ruby I prefer using Ruby syntax:

(1..3).zip(4..6).map { |a, b| a * b }

Copy link

I'd humbly like to up-vote the previous comment.

Copy link

Thats quite brilliant, the author does say "Please do not actually use this."
@hauleth zip is a bit different, list comprehensions are more like cross products:

(1..3).to_a.product((4..6).to_a).map{|a,b| a*b}

or you could do a double map_flat like @wteuber.

Copy link


Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment