viebel

function joinArrays(a, b, keyA, keyB) {
  var mapA = _.keyBy(a, keyA);
  var mapB = _.keyBy(b, keyB);
  var mapsMerged = _.merge(mapA, mapB);
  return _.values(mapsMerged);
}

var dbBookInfos = [
  {
    "isbn": "978-1982137274",

viebel

| | Object-Oriented | Functional |
|----- | ----- | | | Statically-typed | Java
C#
C++ | OCaml
Haskell
Scala | | Dynamically-typed | Ruby Python | JavaScript Clojure Erlang Elixir |

viebel

function setVerbatim (obj, k, v) {
    // In Lodash, a dot in a key is interpreted as a nesting object
    // For instance, _.set({}, "a.b", 2) returns {"a": {"b": 2}}
    // While setVerbatim({}, "a.b", 2) returns {"a.b": 2}
    return _.merge(obj, {[k]: v})
}

function flattenObject(obj, prefix = '') {
    return _.reduce(obj,
                    function(acc, v, k) {

viebel

(defprotocol FullName
  (full-name [person]))

(defrecord AuthorEncapsulation [firstname lastname]
  FullName
  (full-name [author] (str (:firstname author) 
                           " "
                           (:lastname author))))

(defrecord AuthorData [firstname lastname])

viebel

(ns simple.core
  (:require 
    [reagent.core :as reagent :refer-macros [with-let]]
    [reagent.dom :refer [render]]))

(def my-org 
  {:name "nestle"
   :description "bla bla bla"
   :children [{:name "Choco"
               :description "woo"}

viebel

(ns simple.core
  (:require [reagent.core :as reagent]
            [reagent.dom :refer [render]]))


(defn ui []
  [:div
   [:h1 "Hello world"]])

viebel

(defn fizzbuzz-clean [n]
  (let [fizzes (cycle ["" "" "Fizz"])
        buzzes (cycle ["" "" "" "" "Buzz"])
        words (map str fizzes buzzes)
        numbers (map str (rest (range)))]
    (take n (map choice words numbers))))

viebel

(require '[clojure.walk :refer [prewalk postwalk]])

(def data {:a 1
           :b {:c 2}
           :d [3 {:e 4}]})

;; prewalk: node -> map f to children of f(node) 
;; prewalk: [a b c] -> (map f (f [a b c]))
;; prewalk: transform node and then transform chilren

viebel

Self-hosted:

$ plk
ClojureScript 1.10.597
cljs.user=> (require '[foo.core :refer [defnmy]])
nil
cljs.user=> (defnmy FOO clojure.string/lower-case [x]
       #_=>   (inc x))
#'cljs.user/foo

viebel

(defn vec->matrix [n v]
  (->> v
       (partition n)
       (mapv vec)))

(defn empty-vec [n]
  (into [] (repeat n nil)))

(defn rand-numbers [n k]
  (->> (range n)