is there an up to date guide for clojure.java.jdbc?

I just got bit by some old example code

(for someone who has never used jdbc and just wants a sqlite db)

@emccue The repo links to the official community docs

Here http://clojure-doc.org/articles/ecosystem/java_jdbc/home.html

There's a #sql channel if you need more JDBC-focused help rather than Clojure-focused help.

Since I maintain clojure.java.jdbc (and honeysql now as well), I'm happy to help answer any questions you may have...

@roklenarcic Just do (meta *ns*)

So, I guess there's no way to have your return spec take into account the arity that was called? Say I have a function whose 1-ary returns an int?, but 2-ary returns a string?, and say my 2-ary has a bug which will return int? sometimes, any way I can spec it so check will find the bug?

The :fn spec can be used to check any relationship between args and ret

@alexmiller Oh, I see, so you're saying to use the fn spec to validate that the correct arity returns the correct value. Make sense. I guess fn can supersede ret in that case. Thanks

Hi, anyone know best practice to avoid side-effect? (like example write data on DB or change atom state)

I am writing a wrapper lib for a java api - I am trying to create a nice way of handling object creation.

(defmacro kv-calls [class m]
  (let [xs# (map (fn [[k arg]]
                   `(. ~(symbol (name k)) ~@(flatten (list arg)))) m)]
    `(-> (new ~class) ~@xs#)))

(macroexpand '(kv-calls CollectionCreateOptions {:journalSize 20 :waitForSync [true 100]}))
(. (. (new CollectionCreateOptions) journalSize 20) waitForSync true 100)

(defn ^SomeClass map->SomeClass
  [options]
  (kv-calls SomeClass options))

is this approach something that can only work at compile time? i.e the map needs to be present...

solved my own problem - might not be best practice, but it works...

(defn fn-builder [[k v]]
  (let [method-name (symbol (name k))
        args (flatten (list v))]
    `(fn [x#] (. x# ~method-name ~@args))))

(defn option-builder [object options]
  (reduce (fn [acc fn]
            ((eval fn) acc)) object (map fn-builder options)))

during the compilation options is just a symbol without any meaning. For me this case is perfectly solvable with a function call

is there any way to instantiate Java inner classes in Clojure? https://github.com/opencollab/jlatexmath/blob/master/jlatexmath/src/test/java/org/scilab/forge/jlatexmath/examples/basic/Example6.java#L76

an innner class is just a class with a funny name

what's the inner class?

(mainclass$innerclass.)

Should just be (OuterClass$InnerClass.)

if you want STYLE_DISPLAY that's likely an enum or static field and not an inner class

TexConstants/STYLE_DISPLAY

clojure makes things distinct that share syntaxes in java

I’m referring to new TeXIconBuilder()

which has the funny formula. preceding it

so I guess I should write something like (org.scilab.forge.jlatexmath.TeXFormula$TeXIconBuilder. f)

you can import it (import (org.scilab.forge.jlatexmath TexFormula$TexIconBuilder))

it's not really inside the other class, so you need the full funny looking name, and it isn't actually brought into scope in any way by importing the parent

@noisesmith thank you, I will attempt this

Hi all. Im getting a compiler error

CompilerException java.lang.IllegalAccessError: length-of-longest-key is not public, compiling:(sketch/core.clj:1:1)

From a super simple file

I think it actually happens when I do this

(ns sketch.dynamic
  (:require [quil.core :refer :all])
  ;; (:use [incanter.core :only [$=]])
  ;; (:use [clojure.math.combinatorics :only [combinations cartesian-product]])
  ;; (:use [clojure.pprint])
  ;; (:use [clojure.set :only [union]])
  ;; (:use [clojure.contrib.map-utils :only [deep-merge-with]])
  ;; (:import [org.apache.commons.math3.distribution ParetoDistribution])
  ;; (:import [processing.core PShape PGraphics])
  )

;; (defn setup []
;;   )


;; (defn draw []
;;   (no-loop)

;;   (color-mode :hsb 360 100 100 1.0)

;;   (background 220 200 66)
;;   (rect 100 100 400 400)
;;   (save "sketch.tif"))

(ns sketch.core
  (:require [quil.core :as q])
  (:require [sketch.dynamic :as dynamic])
  (:gen-class))

(q/defsketch example
             :title "Sketch"
             :setup dynamic/setup
             :draw dynamic/draw
             :size [900 900])

(defn refresh []
  (use :reload 'sketch.dynamic)
  (.loop example))

it seems like its something to do with quil?

I get the same error in either core.clj or dynamic.clj

I'm interested in introspection on closures returned by functions. I found that I could do this to get the namespaced symbol of a function that returned a closure:

(defn parent-symbol
  "somewhat hacky method to get namespaced symbol for a function.
  can find the parent of closures returned by functions"
  [f]
  (let [[ns nm]
        (->> f
             str
             clojure.repl/demunge
             (re-find #"^(.+)/(.+)/.*$")
             rest)]
    (symbol ns nm)))

Is there a better way to achieve such?

Are there other public functions like clojure.repl/demunge that can be used to parse function string representations?

For example:

(defn returner [x]
        (fn [a] (+ x a)))
#'user/returner
(parent-symbol (returner 7))
user/returner

@underplank Your code works for me with quil 2.7.1 -- what version are you using?

If you're using Leiningen, perhaps try lein clean to see if you have some outdated class files lying around...

Im using quil 2.7.1 as well.. it seems to be working. And I did do lein clean, which maybe why its fixed itself.

thanks for checking!

lein clean cures all manner of woes 🙂

@waffletower

user=> (parent-symbol ((fn foo [] (fn bar [] 1))))
user/eval159/foo--160

I hadn't tried the nested case 😏

Need a better regex

it's the same thing, just using an anonymous function at the outside instead of a defn

ya I read it incorrectly, I would need handling for named lambdas

this is what it does for unnamed

user=> (parent-symbol ((fn [] (fn bar [] 1))))
user/eval165/fn--166

it behaves differently when the provider doesn't have a var

(defn returner [x]
        (fn luck [a] (+ x a)))

(parent-symbol (returner 7))
user/returner

So named lambdas are ok

I am interested in getting at the var, which I have only been able to do with eval:

(defn parent-var [f]
  (eval (list 'var (parent-symbol f))))

(parent-var (returner 7))
#'user/returner

this is really pushing things

:user=> (reify Object (toString [this] "Bob") clojure.lang.IFn (invoke [this] (fn[])))
#object[user$eval217$reify__218 0x2c7b5824 "Bob"]
:user=> (parent-symbol (reify Object (toString [this] "Bob") clojure.lang.IFn (invoke [this] (fn[]))))
NullPointerException   java.io.Writer.write (Writer.java:157)

you are good at finding its shortcomings lol