Separating Mars Rover code into different name spaces

I've separated the Mars Rover kata code I started in a previous post into different namespaces.

This is the new directory structure in which there are three new name spaces: commands, worlds and rover.

mars-rover
├── project.clj
├── README.md
├── src
│   └── mars_rover
│       ├── commands.clj
│       ├── core.clj
│       ├── rover.clj
│       └── worlds.clj
└── test
    └── mars_rover
        └── core_test.clj

view raw mars-rover-tree.md hosted with ❤ by GitHub

The commands name space contains the code in charge of creating the commands from the messages received:

	(ns mars-rover.commands
	(:require [mars-rover.rover :as rover]))
	(def commands-by-message
	{"r" rover/rotate-right
	"l" rover/rotate-left
	"f" rover/move-forwards
	"b" rover/move-backwards})
	(defn create-from [messages]
	(map #(commands-by-message (str %)) messages))

view raw mars-rovers-commands.clj hosted with ❤ by GitHub

The rover name space contains the rover factory function and the command multimethods that are applied on rovers:

	(ns mars-rover.rover)
	(defn rover [x y direction]
	{:x x :y y :direction direction})
	(defmulti rotate-left :direction)
	(defmethod rotate-left :north [{x :x y :y}]
	(rover x y :west))
	(defmethod rotate-left :south [{x :x y :y}]
	(rover x y :east))
	(defmethod rotate-left :east [{x :x y :y}]
	(rover x y :north))
	(defmethod rotate-left :west [{x :x y :y}]
	(rover x y :south))
	(defmulti rotate-right :direction)
	(defmethod rotate-right :north [{x :x y :y}]
	(rover x y :east))
	(defmethod rotate-right :south [{x :x y :y}]
	(rover x y :west))
	(defmethod rotate-right :east [{x :x y :y}]
	(rover x y :south))
	(defmethod rotate-right :west [{x :x y :y}]
	(rover x y :north))
	(defmulti move-forwards :direction)
	(defmethod move-forwards :north [{x :x y :y direction :direction}]
	(rover x (inc y) direction))
	(defmethod move-forwards :south [{x :x y :y direction :direction}]
	(rover x (dec y) direction))
	(defmethod move-forwards :east [{x :x y :y direction :direction}]
	(rover (inc x) y direction))
	(defmethod move-forwards :west [{x :x y :y direction :direction}]
	(rover (dec x) y direction))
	(defmulti move-backwards :direction)
	(defmethod move-backwards :north [{x :x y :y direction :direction}]
	(rover x (dec y) direction))
	(defmethod move-backwards :south [{x :x y :y direction :direction}]
	(rover x (inc y) direction))
	(defmethod move-backwards :east [{x :x y :y direction :direction}]
	(rover (dec x) y direction))
	(defmethod move-backwards :west [{x :x y :y direction :direction}]
	(rover (inc x) y direction))

view raw mars-rover-rover.clj hosted with ❤ by GitHub

and the worlds name space contains the code related to wrapping rovers in a world and detecting obstacles:

	(ns mars-rover.worlds)
	(defn square-world [x y size & obstacles]
	{:wrap-fn
	(fn [{x-rover :x y-rover :y :as rover}]
	(cond
	(and (> y-rover y)
	(> (- y-rover y) size))
	(assoc-in rover [:y] (- y-rover size))
	(and (< y-rover y)
	(< (- y y-rover) size))
	(assoc-in rover [:y] (+ y-rover size))
	(and (> x-rover x)
	(> (- x-rover x) size))
	(assoc-in rover [:x] (- x-rover size))
	(and (< x-rover x)
	(< (- x x-rover) size))
	(assoc-in rover [:x] (+ x-rover size))
	:else rover))
	:obstacles obstacles})
	(def infinite-world
	{:wrap-fn identity
	:obstacles []})
	(defn hit-obstacle? [{x-rover :x y-rover :y} obstacles]
	(= (some #{{:x x-rover :y y-rover}} obstacles)
	{:x x-rover :y y-rover}))

view raw mars-rover-worlds.clj hosted with ❤ by GitHub

I also simplified the application of commands to the rover in the core name space by using a closure so that the apply-command function captures the world instead of passing it in the reduce accumulator as I was doing before:

	(ns mars-rover.core
	(:require [mars-rover.commands :as commands]
	[mars-rover.worlds :refer (infinite-world hit-obstacle?)]))
	(defn- make-apply-command [world]
	(fn apply-command [rover command]
	(let [new-rover ((world :wrap-fn) (command rover))]
	(if (hit-obstacle? new-rover (world :obstacles))
	rover
	new-rover))))
	(defn- validate-initial-position [rover {obstacles :obstacles}]
	(when (hit-obstacle? rover obstacles)
	(throw (IllegalArgumentException.
	"Initial position is on an obstacle!"))))
	(defn receive [rover messages & {world :world :or {world infinite-world}}]
	(let [apply-command (make-apply-command world)]
	(validate-initial-position rover world)
	(reduce apply-command
	rover
	(commands/create-from messages))))

view raw mars-rover-core.clj hosted with ❤ by GitHub

I also learned how to use :refer to require only specific symbols from a name space. I'm also using it in the tests (which except for that are exactly as in the previous version of the code).

I think the code has a better structure now.

You can find the code in this GitHub repository.

-----------

Update: I continued working in this code on Mars Rover code version using protocols instead of multimethods and Mars Rover using a finite state machine implemented with mutually recursive functions and trampoline