fmnoise

module Monads
  class Maybe
    def self.[](value)
      self.new(value)
    end

    def initialize(value)
      @value = value
    end

fmnoise

class Pipe
  def self.[] value
    self.new value
  end

  def initialize value
    @value = value
  end

  def >> 

fmnoise

; inspired by example from "Clojure Applied"
; book says that it's not possible

(ns sales.core)

(defprotocol Cost 
  (cost [this]))

(defrecord Product [price quantity]
  Cost

fmnoise

(defn make-transitions [& states]
  (let [statemap 
        (zipmap
          (map str states) 
          (rest (conj (vec states) (first states))))]
    (fn [state] (statemap (str state)))))

(def moore-machine (atom :stopped))
(def transitions (make-transitions :starting :started :stopping :stopped))

fmnoise

(ns machines.moore)

(defn make-state-fn [& states]
  (let [statemap
        (zipmap
          (map str states)
          (rest (conj (vec states) (first states))))]
    (fn [state] (statemap (str state)))))

fmnoise

module Monads
  class Box
    def self.[](value)
      self.new(value)
    end

    def initialize(value)
      @value = value
    end

fmnoise

Clojure Destructuring Tutorial and Cheat Sheet

(Related blog post)

Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.

Vectors

fmnoise

;; Inspired by George Jahad's version: http://georgejahad.com/clojure/debug-repl.html

(defmacro local-bindings
  "Produces a map of the names of local bindings to their values."
  []
  (let [symbols (map key @clojure.lang.Compiler/LOCAL_ENV)]
    (zipmap (map (fn [sym] `(quote ~sym)) symbols) symbols)))

(declare *locals*)
(defn eval-with-locals

fmnoise

(require '[clojure.core.async :as a])

(def xform (comp (map inc)
              (filter even?)
              (dedupe)
              (flatmap range)
              (partition-all 3)
              (partition-by #(< (apply + %) 7))
              (flatmap flatten)
              (random-sample 1.0)

fmnoise

(defn respond-to?
  "Check if object can respond to method"
  [obj method]
  (boolean
   (some->> obj
            class
            .getMethods
            (filter #(= (.getName %) (name method)))
            first
            .getModifiers