FreekPaans

 (ns layered-example.data.mysql-cargo-repository
   (:refer-clojure :exclude [find])
   (:require [layered-example.domain.cargo.cargo-repository :refer [CargoRepository -find -add! -update!]]
             [layered-example.domain.cargo.cargo :refer [map->Cargo set-cargo-id]]
             [clojure.set :refer [rename-keys]]
             [clojure.java.jdbc :as db]))

 (defn row->cargo [row]
   (-> row
       (select-keys [:id :size :voyage_id])

FreekPaans

(ns layered-example.domain.cargo.cargo-repository
  (:refer-clojure :exclude [find]))

(def find nil)
(def add! nil)
(def update! nil)

(defprotocol CargoRepository
  (-find [this cargo-id])
  (-add! [this a-cargo])

FreekPaans

(ns layered-example.domain.cargo.cargo)                           
                                                                  
(defrecord Cargo [cargo-id size voyage-id])                       
                                                                  
(defn create-new-cargo [& {:keys [size voyage-id] :as cargo-data}]
  {:pre [(integer? size)                                          
         (nil? voyage-id)]}                                       
  (map->Cargo cargo-data))                                        
                                                                  
(defn book-onto-voyage [a-cargo & {:keys [voyage-id]}]            

FreekPaans

autocmd FileType clojure nnoremap <buffer> <F5> :Require!<CR>:RunTests<CR>
  0 autocmd FileType clojure nnoremap <buffer> <F6> :Require!<CR>:.RunTests<CR>

FreekPaans

module Vector = 
    type private PolarVector = {
        r: double;
        a: double;
    }

    type private RectangularVector = {
        x: double;
        y: double;
    }

FreekPaans

module Vector = 
    type PolarVector = {
        r: double;
        a: double;
    }

    type RectangularVector = {
        x: double;
        y: double;
    }

FreekPaans

function Vector(rep) {
    switch (rep) {
        case Vector.representations.Polar:
            this.vector = { rep: rep, r: arguments[1], a: arguments[2] }
            break;
        case Vector.representations.Rectangular:
            this.vector = { rep: rep, x: arguments[1], y: arguments[2] }
            break;
        default:
            throw Error("Unknown representation " + rep)

FreekPaans

function Vector(x, y) {
    this.x = x;
    this.y = y;

    this.Add = function(addend) {
        if(!(addend instanceof Vector)) {
           	throw Error("addend not a Vector")
        }
        return new Vector(this.x + addend.x, this.y+addend.y)
    }

FreekPaans

var v1 = new VectorMagnitudeAngle(10, Math.PI/4)
var v2 = new Vector(-10/Math.sqrt(2), 10/Math.sqrt(2))
var v3 = v1.Add(v2);

console.log(v3.X()+ ", " +v3.Y())
//outputs: 8.659560562354932e-16, 14.14213562373095

FreekPaans

function VectorMagnitudeAngle(r, theta) {
    this.X = function() {
        return r * Math.cos(theta)
    }

    this.Y = function() {
        return r * Math.sin(theta)
    }

    this.Add = function(addend) {