Ruby/Clojure analogs

index.txt

For each Ruby module/class, we have Ruby methods on the left and the equivalent
Clojure functions and/or relevant notes are on the right.

For clojure functions, symbols indicate existing method definitions, in the 
clojure namespace if none is explicitly given.  clojure.contrib.*/* functions can
be obtained from http://github.com/kevinoneill/clojure-contrib/tree/master,
ruby-to-clojure.*/* functions can be obtained from the source files in this
gist.

If no method symbol is given, we use the following notation:

[name] Ruby method is an alias for Ruby method [name], see that method
[Enum] Ruby method is also defined in Enumerable, see the equivalent there
des!   Ruby method is destructive, an alternative may be suggested
ni     Ruby method doesn't have a direct equivalent, an alternative may be given
uf     Ruby method is IMO an "unfeature", so no equivalent is given
lib    Ruby method is not fundamental to data structure, belongs in other lib

Right now we only have Enumerable and Array, though we hope to have Set, Hash,
and String/Regexp eventually.

Note that Clojure data structures and the associated sequence functions are
fundamentally different from the Ruby data structures and methods because the 
Clojure data structures are always persistent and most of the sequence functions
are lazy. You can get started on the Ruby => Clojure road with a guide like 
this, but to fully leverage Clojure you will need to understand persistence and
laziness.

== Enumerable
each             doseq  (use for side effects only)
all?             every?
any?             some
collect          [map]
count            count
cycle            cycle
detect           some
drop             drop
drop_while       drop-while
each_cons        partition
each_slice       partition
each_with_index  ruby-to-clojure.seq-utils/map-with-index
entries          [to_a]
find             [detect]
find_all         [select]
find_index       ruby-to-clojure.seq-utils/some-index
first            first, take
grep             ruby-to-clojure.seq-utils/grep
group_by         clojure.contrib.seq-utils/group-by
include?         clojure.contrib.seq-utils/includes?
index_by         clojure.set/index or ruby-to-clojure.seq-utils/index-by
inject           [reduce]
map              map
max              last  (if ordered)
                 note that clojure/max acts on numerical args, not seqs
max_by           ni    (use sorted data structure with last)
member?          [include?]
min              first (if ordered)
                 note that clojure/min acts on numerical args, not seqs
min_by           ni    (use sorted data structure with first)
minmax           first and last
minmax_by        ni    (see max_by and min_by above)
none?            not-any?
one?             ruby-to-clojure.seq-utils/exactly? /one?
partition        clojure.contrib.seq-utils/separate
reduce           reduce
reject           remove
reverse_each     rseq, reverse
select           filter
sort             sort, sort-by 
sort_by          sort-by
take             take
take_while       take-while
to_a             seq, list, vector
to_set           set
zip              ruby-to-clojure.seq-utils/zip


== ARRAY
&                ni   (use clojure.set/intersection on sets)
*                ruby-clojure.seq-utils/cycle
+                concat
-                ni   (use clojure.set/difference on sets)
<<               des! (use clojure/conj)
<=>              compare
==               =
[]               get
[]=              des! (use clojure/assoc)
abbrev           lib
assoc            uf 
at               [[]]
choice           ruby-to-clojure.seq-utils/choice
clear            des!  (use empty)
collect          [map]
collect!         [map!]
combination      lib
compact          ruby-to-clojure.seq-utils/compact
compact!         !des
concat           !des  (use concat)
count            count
cycle            [*]
dclone           des!
delete           des!
delete_at        des!
delete_if        des!  (use remove)
drop             [Enum]
drop_while       [Enum]
each             [Enum]
each_index       (range (count arr))
empty?           empty?
eql?             =
fetch            get
fill             des!
find_index       [Enum]
first            [Enum]
flatten          clojure.contrib.seq-utils/flatten
flatten!         des!
frozen?          uf
hash             hash
include?         [Enum]
index            [find_index]
initialize_copy  uf
insert           des!
inspect          print-str
join             clojure.contrib.str-utils/str-join
last             last, (take (rseq coll))
length           [count]
map              map
map!             des!
new              vecotr
pack             lib  
permutation      clojure.contrib.lazy-seqs/permutations
pop              des! (use pop)
pretty_print     lib
product          lib
push             [<<]
rassoc           uf
reject           [Enum]
reject!          des!
replace          des!
reverse          rseq, reverse
reverse!         des!
reverse_each     [reverse]
rindex           uf
select           [Enum]
shelljoin        lib
shift            des!  (use first, rest)
shuffle          ruby-to-clojure.seq-utils/shuffle
shuffle!         des!
size             [count]
slice            subvec
slice!           des!
sort             [Enum]
sort!            des!
take             [Enum]
take_while       [Enum]
to_a             seq
to_ary           seq
to_csv           lib
to_s             [inspect]
to_yaml          lib
transpose        lib
try_convert      uf
uniq             distinct
uniq!            des!
unshift          des!
values_at        get, subvec
yaml_initialize  lib
zip              [Enum]
|                ni  (use clojure.set/union on sets)

seq_utils.clj

(ns ruby-to-clojure.seq-utils)

(defn map-with-index 
  "Like clojure/map, but f should accept 2 arguments: the element and its index
  in the collection."
  [f coll]
  (map f coll (iterate inc 0)))

(defn some-index 
  "Returns the index of the first element of coll for which (f elem) returns
  logical truth, or nil of no such element exists."
  [f coll]
  (loop [rcoll coll index 0]
    (when (seq rcoll)
      (if (f (first rcoll))
        index
        (recur (rest rcoll) (inc index))))))

(defn grep
  "Returns a lazy seq of strings in coll that match the given pattern."
  [re coll]
  (filter #(re-find re %) coll))

(defn index-by
  "Returns a map from the results of invoking f on elements of coll
  to the corresponding elements.  The order of elements in the values of the map
  reflects their order in the original collection, and there may be duplicates
  if there were duplicates in the collection."
  [f coll]
    (reduce
      (fn [map x]
        (let [k (f x)]
          (assoc map k (conj (get map k []) x))))
      {}
      coll))

(defn exactly?
  "Returns true if (f x) returns logical truth for exactly n xs in coll."
  [n f coll]
  (loop [m n more coll]
    (when (seq more)
      (if (f (first more)) 
        (if (= m 1)
          (not-any? f (rest more))
          (recur (dec m) (rest more)))
        (recur m (rest more))))))
        
(defn one? 
  "Returns true if (f x) returns logical truth for exactly 1 x in coll."
  [f coll]
  (exactly? 1 f coll))


(defn remove 
  "Returns a lazy seq: (filter (complement pred) coll)."
  [pred coll]
  (filter (complement pred) coll))

(defn zip 
  "Returns a sequence of sequences where the jth element of the ith inner 
  sequence corresponds to the ith element in the jth sequence in coll."
  [& colls]
  (apply map (fn [& xs] xs) colls))

(defn ncycle
  "Returns a lazy seq of repetitions of the items in coll n times."  
  [n coll]
    (take (* n (count coll)) (cycle coll)))

(defn choice
  "Returns a random element from the given vecotr."
  [#^clojure.lang.IPersistentVector vec]
  (get vec (rand-int (count vec))))

(defn compact 
  "Returns a lazy seq of non-nil elements in coll."
  [coll]
  (remove nil? coll))

; http://groups.google.com/group/clojure/browse_thread/thread/180842eb58c58370/43239b0de45a5d56?lnk=gst&q=shuffle#
(defn shuffle
  "Returns a shuffled seq for the given coll."
  [coll]
  (let [l (java.util.ArrayList. coll)]
    (java.util.Collections/shuffle l)
    (seq l)))