Mark Engelberg Engelberg

As we've seen, seq is the mechanism in Clojure for converting a collection into something that responds to first and rest, so that we can traverse it as we would a linked list. Sequences automatically print at the REPL like a list.

=> (seq '(1 2 3 4))
(1 2 3 4)
=> (seq [1 2 3 4])
(1 2 3 4)
=> (seq #{1 2 3 4})
(1 4 3 2)
=> (seq {:a 1, :b 2})

First, here is the cleverly concise version of freqs that I showed in class, which builds a bunch of maps that map each element to the number 1, and then merges them together using +:

(defn freqs [l]
  (apply merge-with + (for [item l] {item 1})))

Here is one way of coding it using loop-recur:

	(ns compojure-example.handler
	(:require [compojure.core :refer :all]
	[compojure.route :as route]
	[ring.middleware.defaults :refer [wrap-defaults site-defaults api-defaults]]
	[ring.util.anti-forgery :refer [anti-forgery-field]]
	[ring.util.response :as response] ; for response/redirect, etc.
	[hiccup.core :refer [html h]]
	[hiccup.form :as form]
	[hiccup.element :refer [image link-to]]
	[hiccup.page :refer [html5]]))

	;; gorilla-repl.fileformat = 1

	;; @@
	(ns count-combinations)
	;; @@
	;; =>
	;;; {"type":"html","content":"<span class='clj-nil'>nil</span>","value":"nil"}
	;; <=

	;; **

	(ns mark.loco.grants2
	(:use loco.core loco.constraints))

	; Use whatever scoring function you want for the various
	; applicants, but ultimately, you want to assemble this
	; information into a data structure.

	(def applicants
	[{:name "Alex", :score 5, :grant-request 120}
	{:name "David", :score 4, :grant-request 100}

	(ns mark.loco.grants
	(:use loco.core loco.constraints))

	; Use whatever scoring function you want for the various
	; applicants, but ultimately, you want to assemble this
	; information into a data structure.

	(def applicants
	[{:name "Alex", :score 5, :grant-request 120}
	{:name "David", :score 4, :grant-request 100}

	; This is sort of a pseudo Clojure/Scala mash-up.

	; In an OO language, you might start off with the following class as a namespace
	; for all your functions that revolve around manipulating 3x4 grids.

	class Grid {
	val rows = 3
	val cols = 4
	val cells = for [row in range(rows), col in range(cols)] yield [row,col]

	(ns mark.grid)

	; I'm working with grids that are primarily 3x4.
	; I get up and running with the following simple code.

	(def rows 3)
	(def cols 4)

	(def cells (for [row (range rows), col (range cols)] [row col]))

	(defn logic-puzzle []
	(let [people [:amaya :bailey :jamari :jason :landon]]
	(for [[fortune time cosmopolitan us-weekly vogue] (permutations people) ; magazines
	:when (not= fortune :jamari)

	[asiago blue-cheese mascarpone mozzarella muenster] (permutations people) ; cheeses
	:when (= blue-cheese fortune)
	:when (not= muenster vogue)

	reservations (permutations people)