Skip to main content

सतत

Documenting my metamorphosis through code, circuits, and containers

Abstract and readable code

Daily practice, learning, unlearning things, muscle memory

Same approach with programming, writing small utility functions, getting comfortable with IDE, learning more about its REPL features

Picked up on a problem I was given for a technical round: cleaning up a CSV file https://github.com/Quartz/bad-data-guide\

revisiting old code:

Problem: flatten the orders

It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures.

--Alan Perlis 

(defn single-row-per-sku
  "Convert consolidated processed orders to rows containing each SKU"
  [orders]
  (reduce (fn [result order] (concat result (map #(merge % (dissoc order :items)) (:items order)))) [] orders))

refactored code: 

(defn order->address [order]
  (dissoc order :items))

(defn order->items [order]
  (order :items))

(defn simpler-reordering
  [orders]
  (for [order orders
        :let [address (order->address order)
              items (order->items order)]]
    (->> items
         (map #(merge address %)))))

Python equivalent: 

def flatten-orders (orders: Dict):
    flat_orders = []
    for order in orders:
        items = order.pop("items", [])
        for item in items:
            flat_orders.append(order | item)
    return flat_orders