Clojure

 user=> (defn f [x y] (+ (* 3 x) (* 4 y)))
 #'user/f
user=> 
user=> (f 4 5)
32
user=> (f 5 6)
39
user=>

user=> (defn sqr [x]
         "Computes the square of a number"             
         (* x x))
 #'user/sqr
user=> (sqr 10)
100
user=> (map sqr '(1 2 3 4 5 6))
(1 4 9 16 25 36)
user=>



user=> (doc sqr)
 -------------------------
user/sqr
([x])
  Computes the square of a number
nil
user=>

user=> (defn my-variadic-fun [& vars]
          (println vars))


user=> 
user=> (my-variadic-fun 1 2 3 4 'z 'w )
(1 2 3 4 z w)
nil

user=> (my-variadic-fun 1 2 3 4 'z 'w :key)
(1 2 3 4 z w :key)
nil
user=> 

user=> (my-variadic-fun)
nil

user=> (defn variadic2 [x & vars]
        (do (println x)
          (println vars)))


user=> 
user=> (variadic2  2 'a 'b' 'c 'd)
2
(a b' c d)
nil
user=> 

user=> (variadic2  10)
10
nil
nil
user=>

(defn fun-optional-c [a b & [c]]
    {:a a :b b :c c})

user=> (fun-optional-c 1 2)
{:a 1, :b 2, :c nil}

user=> 
user=> (fun-optional-c 1 2 3)
{:a 1, :b 2, :c 3}
user=>

(defn predefined-c-and-d [a b & {:keys [c d] :or {c 100 d 30}}]
    { :a a, 
      :b b,
      :c c,
      :d d}) 

user=> (predefined-c-and-d 10 20)
{:a 10, :b 20, :c 100, :d 30}
user=> 

user=> (predefined-c-and-d 10 20 :c 'c )
{:a 10, :b 20, :c c, :d 30}
user=> 

user=> (predefined-c-and-d 10 20 :d -100 )
{:a 10, :b 20, :c 100, :d -100}
user=> 

user=> (predefined-c-and-d 10 20 :c -90 :d -232 )
{:a 10, :b 20, :c -90, :d -232}
user=>

user=> (fn [x] (* x x))
#object[user$eval369$fn__370 0x11bfe23 "user$eval369$fn__370@11bfe23"]
user=>    

user=> ((fn [x] (* x x)) 5)
25
user=> 

user=> (map (fn [x] (* x x)) '(1 2 3 4 5))
(1 4 9 16 25)
user=> (map (fn [x] (* x x)) '[1 2 3 4 5])
(1 4 9 16 25)
user=> 


user=> (map (fn [x] (* x x)) (range 1 10))
(1 4 9 16 25 36 49 64 81)
user=> 

user=> ((fn [x y] (+ ( * 2 x) (* 3 y))) 10 20)
80
user=> 

user=>  ((fn [a b c] (+ a b c)) 2 4 6)
12
user=> 

;;; Lambda functions can be stored in variables
;;;
user=> (def f_xy  (fn [x y] (+ (* 2 x) (* 3 y))))
#'user/f_xy
user=> 
user=> (f_xy 10 20)
80
user=> (f_xy 10 30)
110
user=>

    user=> (#(+ 3 %) 4)
    7
    user=> (#(+ 3 %) 5)
    8
    user=> (map #(+ 3 %) '[1 2 3 4 5])
    (4 5 6 7 8)
    user=> 

;;; This is equivalent to
;;
    user=> (map (fn [x] (+ 3 x)) '[1 2 3 4 5])
    (4 5 6 7 8)

    user=> (Math/pow 2 3)
    8.0


    user=> (map #(Math/pow % 3) '[1 2 3 4 5 6])
    (1.0 8.0 27.0 64.0 125.0 216.0)

   ;; It is equivalent to:

    user=> (map (fn [x] (Math/pow x 3)) '[1 2 3 4 5 6])
    (1.0 8.0 27.0 64.0 125.0 216.0)
    user=> 

    ;;;;;;;

    user=> (map #(Math/pow 2 %) '[1 2 3 4 5 6])
    (2.0 4.0 8.0 16.0 32.0 64.0)    

    ;;;------------------------------------;;



    user=> #(+ (* 3 %1) (* 4 %2))
    #object[user$eval435$fn__436 0x79dfad "user$eval435$fn__436@79dfad"]
    user=> 

    ;; It is equivalent to

    user=> (fn [x y] (+ (* 3 x) (* 4 y)))
    #object[user$eval439$fn__440 0x1629510 "user$eval439$fn__440@1629510"]
    user=>     

    user=> ( #(+ (* 3 %1) (* 4 %2)) 4 5)
    32
    user=> 

    user=> (map #(+ (* 3 %1) (* 4 %2)) '[1 2 3 4 5] '[4 5 6 8 9])
    (19 26 33 44 51)
    user=>

;; Load clojure.string namespace as str 
;;
(require '[clojure.string :as str])

;; List all functions in the namespace
;;
;;----------------------------
user=> (dir clojure.string)
blank?
capitalize
escape
join
lower-case
re-quote-replacement
replace
replace-first
reverse
split
split-lines
trim
trim-newline
triml
trimr
upper-case
nil
user=>     


user=> (str/split-lines  "line1\nline2\nline3")
["line1" "line2" "line3"]
user=> 

user=> (str/split-lines  "line1\rline2\rline3")
["line1\rline2\rline3"]
user=> 

user=> (str/replace "foo bar foobars" #"foo" "0x00121")
"0x00121 bar 0x00121bars"
user=>     

user=> (str/join "," ["x" "y" "z"])
"x,y,z"
user=> 

user=> (str/trim "   \n\n\nsome \n white space \n\n\n")
"some \n white space"
user=> 

user=> (str/split "a,b,c,d," #",")
["a" "b" "c" "d"]
user=> 


user=> (str/join "-" ["a" "b" "c" "d"])
"a-b-c-d"
user=> 

user=> (map str/blank? ["" "\n" "\r" "\r\n" " " "\t" "asdas"])
(true true true true true true false)
user=>

user=> (Integer/parseInt "202323")
202323

;; Scheme Notation: [from type]->[to type]
;;
user=> (defn string->int [str] 
            (Integer/parseInt str))
#'user/string->int
user=> 
user=> (string->int "10223232")
10223232
user=>

user=> (Float/parseFloat "2323.2323e-3")
2.3232324
user=> 

(defn string->float [str]
    (Float/parseFloat str))

user=> (map (constantly 10) '(1 2 3 4 5 6))
(10 10 10 10 10 10)
user=>

user=> (map identity '(a b c d 1 2 3 "hello" world))
(a b c d 1 2 3 "hello" world)
user=>

user=> (range 1 10)
(1 2 3 4 5 6 7 8 9)

user=> (range 0 100 10)
(0 10 20 30 40 50 60 70 80 90)

user=> (map (fn [x] (* x x)) '(1 2 3 4 5 6))
(1 4 9 16 25 36)
user=> 

user=> (map (fn [x y] (+ (* x x) (* y y))) '(1 2 3 4 5) '(3 5 7 8 9))
(10 29 58 80 106)
user=>

user=> (map #(* % 2) (range 10))
(0 2 4 6 8 10 12 14 16 18)
user=> 


user=> (mapv #(* % 2) (range 10))
[0 2 4 6 8 10 12 14 16 18]
user=>

user=> 
(defn single-double-triple [x]
  [(* x 1) (* x 2) (* x 3)])
#'user/single-double-triple
user=> 
user=> (mapcat single-double-triple (range 10))
(0 0 0 1 2 3 2 4 6 3 6 9 4 8 12 5 10 15 6 12 18 7 14 21 8 16 24 9 18 27)
user=>

(defn for-each [f xs] (doseq [x xs] (f x)))

user=> (for-each println '[1 2 3 4 5 6])
1
2
3
4
5
6
nil
user=>

user=> (filter even? (range 1 20))
(2 4 6 8 10 12 14 16 18)
user=> 
user=> (filter odd? (range 1 20))
(1 3 5 7 9 11 13 15 17 19)
user=>

user=> (defn f [x y] (+ (* 3 x) (* 4 y)))

user=> 
user=> (apply f '(7 8))
53
user=> 

user=> (apply f '(7 8))
53
user=> (defn map-apply [f arglist] (map (fn [xs] (apply f xs)) arglist))
#'user/map-apply
user=> 
user=> (map-apply f '((7 8) (3 4) (5 6)))
(53 25 39)
user=>

user=> ((partial + 3) 4)
7
user=> (map (partial + 3) '(1 2 3 4 5 6))
(4 5 6 7 8 9)
user=>

user=> ((comp (partial + 3) (partial * 4)) 10)
43
user=>


user=> (map (comp (partial + 3) (partial * 4)) '(1 2 3 4 5 6))
(7 11 15 19 23 27)
user=>


   comp - Can be used to invert predicates

user=> (filter (comp not zero?) [0 1 0 2 0 3 0 4])
(1 2 3 4)
user=>

user=> (def f (juxt (partial + 3) (partial * 4) (partial * 5)))
#'user/f
user=> (f 5)
[8 20 25]
user=> (map f '(1 2 3 4 5))
([4 4 5] [5 8 10] [6 12 15] [7 16 20] [8 20 25])
user=>


user=> ((juxt + * min max) 3 4 6)
[13 72 3 6]
user=>

user=> 
(dotimes [x 10]
          (dotimes [y 10]
            (print (format "%3d " (* (inc x) (inc y)))))
          (println))
  1   2   3   4   5   6   7   8   9  10 
  2   4   6   8  10  12  14  16  18  20 
  3   6   9  12  15  18  21  24  27  30 
  4   8  12  16  20  24  28  32  36  40 
  5  10  15  20  25  30  35  40  45  50 
  6  12  18  24  30  36  42  48  54  60 
  7  14  21  28  35  42  49  56  63  70 
  8  16  24  32  40  48  56  64  72  80 
  9  18  27  36  45  54  63  72  81  90 
 10  20  30  40  50  60  70  80  90 100 
nil
user=>

user=> (doseq [x '[1 2 3 4 5]]  (println (+ 2 (* 3 x))))
5
8
11
14
17
nil
user=> 

user=> (doseq [x '[1 2 3]
               y '[a b c d e]
               ]
         (println (list x y)))
(1 a)
(1 b)
(1 c)
(1 d)
(1 e)
(2 a)
(2 b)
(2 c)
(2 d)
(2 e)
(3 a)
(3 b)
(3 c)
(3 d)
(3 e)
nil
user

user=> 
user=> (take 5 (iterate (partial + 1) 0))
(0 1 2 3 4)
user=> 
user=> (take 15 (iterate (partial + 1) 0))
(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
user=> 
user=> (take 15 (iterate (partial * 2) 1))
(1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384)
user=>

user=> (take 5 (repeat 10))
(10 10 10 10 10)
user=> (take 5 (repeat 5))
(5 5 5 5 5)
user=> (take 5 (repeat "a"))
("a" "a" "a" "a" "a")
user=>

user=> (repeatedly 5 #(rand-int 500))
(303 29 253 250 120)
user=>

user=> (def j (new java.util.HashMap))
#'user/j
user=> j
{}
user=> (.put j "a" 100)
nil
user=> (.put j "b" "Hello world")
nil
user=> j
{"a" 100, "b" "Hello world"}
user=>

user=> (def j  
            (doto (new java.util.HashMap)
              (.put "a" 100)
              (.put "b" "Hello world")))
#'user/j
user=> j
{"a" 100, "b" "Hello world"}
user=>

user=> 
(doto (javax.swing.JFrame.)
  (.setLayout (java.awt.GridLayout. 2 2 3 3))
  (.add (javax.swing.JTextField.))
  (.add (javax.swing.JLabel. "Enter some text"))
  (.setSize 300 80)
  (.setVisible true))

;; import java.util.Date,  java.util.Stack
;; import java.net.Proxy,  java.net.URI
;;
user=> (import [java.util Date Stack] [java.net Proxy URI])
java.net.URI
user=> (Date.)
#inst "2015-09-16T01:39:21.365-00:00"
user=>

user=> (java.util.Date.)
#inst "2015-09-16T18:11:15.686-00:00"
user=> 
user=> (new java.util.Date)
#inst "2015-09-16T18:11:21.166-00:00"
user=>

user=> 
user=> (import '(java.util Date GregorianCalendar))
java.util.GregorianCalendar
user=> 
user=> Date
java.util.Date
user=> 
user=> GregorianCalendar
java.util.GregorianCalendar
user=> 
user=> (new Date)
#inst "2015-09-16T18:12:46.308-00:00"
user=> 
user=> (new GregorianCalendar)
#inst "2015-09-16T15:12:54.212-03:00"
user=>

user=> (. java.util.Calendar APRIL)
3
user=> java.util.Calendar/APRIL
3
user=>


user=> (import [java.util Calendar])
java.util.Calendar

user=> 
user=> (. Calendar APRIL)
3
user=>

user=> (.parse (new java.text.SimpleDateFormat "dd/MM/yyyy") "03/01/2013")
#inst "2013-01-03T03:00:00.000-00:00"
user=> 
user=> 


(defn date-parser [date-format date-str]
  (.parse (new java.text.SimpleDateFormat date-format)
          date-str))

(defn date-dmy [sep date-str]
  (date-parser (str "dd" sep "mm" sep "yyyy") date-str))

(defn date-ymd [sep date-str]
  (date-parser (str "yyyy" sep "mm" sep "dddd") date-str))


(defn date-mdy [sep date-str]
  (date-parser (str "mm" sep "dd" sep "yyyy") date-str))

user=> (date-dmy "/" "04/01/2013")
#inst "2013-01-04T03:01:00.000-00:00"
user=>

import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;

public class GetStringFromClipboard {

    public static void main(String[] args) throws Exception {

        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Clipboard clipboard = toolkit.getSystemClipboard();
        String result = (String) clipboard.getData(DataFlavor.stringFlavor);
        System.out.println("String from Clipboard:" + result);
    }

}

(import java.awt.Toolkit)
(import [java.awt.datatransfer Clipboard DataFlavor])

(defn getClipboard [] 
    (->
     (Toolkit/getDefaultToolkit)
     .getSystemClipboard
     (.getData DataFlavor/stringFlavor)))

( import java.io.BufferedReader )
( import java.io.IOException )
( import java.io.InputStreamReader )
( import java.io.OutputStream )
( import java.net.HttpURLConnection )
( import java.net.URL )

(defn buffread->string [buff]
  (clojure.string/join "\n"
                       (line-seq buff)))

(defn format-params [params]
  (clojure.string/join "&"
                       (map #(format "%s=%s" %1 %2)
                            (keys params) (vals params))))


(defn http-get
  "
   http-get <url> [:user-agent <user-agent string] [:params {key: value}]

  "

  [url & {:keys [user-agent params]
                        :or { user-agent "",  params {}}}]                 
  (let
      [
       conn (doto (.openConnection (new URL url))
             (.setRequestMethod "GET") 
             (.setRequestProperty "User-Agent" user-agent)
             (.setDoOutput false))


       in   (new BufferedReader
                 (new InputStreamReader
                      (.getInputStream conn)))
       ]
  (if (not (= (.getResponseCode conn) 200))
    nil ;; Request has failed
    (buffread->string in))))

(defn http-post
  "
   http-post <url> [:user-agent <user-agent string] [:params {key: value}]

  "
  [url & {:keys [user-agent params]
                        :or { user-agent "",  params {}}}]                 
  (let
      [
       conn (doto (.openConnection (new URL url))
             (.setRequestMethod "POST") 
             (.setRequestProperty "User-Agent" user-agent)
             (.setDoOutput true))


       os  (doto (.getOutputStream conn)
             (.write (.getBytes (format-params params)))
             (.flush)
             (.close))

       in   (new BufferedReader
                 (new InputStreamReader
                      (.getInputStream conn)))
       ]
  (if (not (= (.getResponseCode conn) 200))
    nil ;; Request has failed
    (buffread->string in))))


user=> (println (http-get "http://httpbin.org/headers" :user-agent "http://httpbin.org/get"))
{
  "headers": {
    "Accept": "text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2", 
    "Host": "httpbin.org", 
    "User-Agent": "http://httpbin.org/get"
  }
}
nil
user=> 

user=> (println (http-post "http://httpbin.org/post" :params {"user" "dummy" "name" "john"}))

{
  "args": {}, 
  "data": "", 
  "files": {}, 
  "form": {
    "name": "john", 
    "user": "dummy"
  }, 
  "headers": {
    "Accept": "text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2", 
    "Content-Length": "20", 
    "Content-Type": "application/x-www-form-urlencoded", 
    "Host": "httpbin.org", 
    "User-Agent": "FIREFOX"
  }, 
  "json": null, 
  "url": "http://httpbin.org/post"
}
nil


user=> (println (http-post "http://httpbin.org/post" :params {"currency" "BRL" "country" "BRAZIL" "lang" "pt-BR"}))
{
  "args": {}, 
  "data": "", 
  "files": {}, 
  "form": {
    "country": "BRAZIL", 
    "currency": "BRL", 
    "lang": "pt-BR"
  }, 
  "headers": {
    "Accept": "text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2", 
    "Content-Length": "38", 
    "Content-Type": "application/x-www-form-urlencoded", 
    "Host": "httpbin.org", 
    "User-Agent": ""
  }, 
  "json": null, 
  "method": "POST", 
  "origin": "187.113.121.52", 
  "url": "http://httpbin.org/post"
}
nil
user=>