init commit

stubs/maps.clj

@@ -0,0 +1,148 @@
+(ns maps
+  "Erlang :maps module — map operations.
+
+   In CljElixir: (maps/get key map), (maps/put key value map), etc.
+   Lower-level than Elixir's Map module.")
+
+(defn get
+  "Gets value for `key`. Raises if missing (or returns `default`).
+   (maps/get :a {:a 1}) ;=> 1
+   (maps/get :b {:a 1} :default) ;=> :default"
+  ([key map])
+  ([key map default]))
+
+(defn find
+  "Returns {:ok value} or :error.
+   (maps/find :a {:a 1}) ;=> {:ok 1}"
+  [key map])
+
+(defn is-key
+  "Returns true if `key` exists in `map`.
+   (maps/is-key :a {:a 1}) ;=> true"
+  [key map])
+
+(defn keys
+  "Returns all keys.
+   (maps/keys {:a 1 :b 2}) ;=> [:a :b]"
+  [map])
+
+(defn values
+  "Returns all values.
+   (maps/values {:a 1 :b 2}) ;=> [1 2]"
+  [map])
+
+(defn size
+  "Returns the number of entries.
+   (maps/size {:a 1 :b 2}) ;=> 2"
+  [map])
+
+(defn put
+  "Puts `key`/`value` into `map`.
+   (maps/put :c 3 {:a 1 :b 2}) ;=> {:a 1 :b 2 :c 3}"
+  [key value map])
+
+(defn remove
+  "Removes `key` from `map`.
+   (maps/remove :a {:a 1 :b 2}) ;=> {:b 2}"
+  [key map])
+
+(defn update
+  "Updates `key` by applying `fun` to current value. Raises if key missing.
+   (maps/update :a (fn [v] (+ v 1)) {:a 1}) ;=> {:a 2}"
+  [key fun map])
+
+(defn update-with
+  "Updates `key` with `fun`, using `init` if key is missing.
+   (maps/update-with :a (fn [v] (+ v 1)) 0 {:a 1}) ;=> {:a 2}
+   (maps/update-with :b (fn [v] (+ v 1)) 0 {:a 1}) ;=> {:a 1 :b 0}"
+  ([key fun map])
+  ([key fun init map]))
+
+(defn merge
+  "Merges two maps. `map2` values take precedence.
+   (maps/merge {:a 1} {:b 2}) ;=> {:a 1 :b 2}"
+  [map1 map2])
+
+(defn merge-with
+  "Merges with a conflict resolver.
+   (maps/merge-with (fn [v1 v2] (+ v1 v2)) {:a 1} {:a 2}) ;=> {:a 3}"
+  [fun map1 map2])
+
+(defn intersect
+  "Returns intersection of two maps."
+  ([map1 map2])
+  ([combiner map1 map2]))
+
+(defn intersect-with
+  "Intersects with a combining function."
+  [combiner map1 map2])
+
+(defn from-list
+  "Creates a map from a list of {key, value} tuples.
+   (maps/from-list [[:a 1] [:b 2]]) ;=> {:a 1 :b 2}"
+  [list])
+
+(defn from-keys
+  "Creates a map from a list of keys, all with the same value.
+   (maps/from-keys [:a :b :c] 0) ;=> {:a 0 :b 0 :c 0}"
+  [keys value])
+
+(defn to-list
+  "Converts map to list of {key, value} tuples.
+   (maps/to-list {:a 1 :b 2}) ;=> [[:a 1] [:b 2]]"
+  [map])
+
+(defn new
+  "Creates an empty map.
+   (maps/new) ;=> {}"
+  [])
+
+(defn map
+  "Maps `fun` over map entries. `fun` receives (key, value).
+   (maps/map (fn [k v] (* v 2)) {:a 1 :b 2}) ;=> {:a 2 :b 4}"
+  [fun map])
+
+(defn filter
+  "Filters entries where `pred` returns true.
+   (maps/filter (fn [k v] (> v 1)) {:a 1 :b 2 :c 3}) ;=> {:b 2 :c 3}"
+  [pred map])
+
+(defn filtermap
+  "Filters and maps in one pass."
+  [fun map])
+
+(defn fold
+  "Folds over map entries.
+   (maps/fold (fn [k v acc] (+ acc v)) 0 {:a 1 :b 2}) ;=> 3"
+  [fun acc map])
+
+(defn foreach
+  "Calls `fun` on each entry for side effects.
+   (maps/foreach (fn [k v] (IO/puts (str k \": \" v))) my-map)"
+  [fun map])
+
+(defn with
+  "Takes only the given `keys` from `map`.
+   (maps/with [:a :c] {:a 1 :b 2 :c 3}) ;=> {:a 1 :c 3}"
+  [keys map])
+
+(defn without
+  "Drops the given `keys` from `map`.
+   (maps/without [:a] {:a 1 :b 2}) ;=> {:b 2}"
+  [keys map])
+
+(defn groups-from-list
+  "Groups list elements by key function.
+   (maps/groups-from-list (fn [x] (rem x 2)) [1 2 3 4]) ;=> {1 [1 3], 0 [2 4]}"
+  ([key-fun list])
+  ([key-fun value-fun list]))
+
+(defn iterator
+  "Returns a map iterator for lazy traversal.
+   (maps/iterator my-map)"
+  ([map])
+  ([map order]))
+
+(defn next
+  "Advances a map iterator. Returns {key value iterator} or :none."
+  [iterator])