I’m working with 150MB file, so I used powershell to pipe the first 10 lines to a test file, and this changed formats. I’ll report if I can explain what’s going on their. Got the wiki articles up now, thanks for your thoughtful response!

Yeah, not surprising if inserting another tool in the middle, especially one that does its own independent guessing/interpretation of input file format, and choice of encoding when writing an output file, causes different results than when the intermediate step is removed.

Right…didn’t realize head would be unsafe in powershell

You can wish/hope that such intermediate tools preserve the text encoding in all cases, but I do not think that is the case, and some are even designed to help you convert between text encodings.

:encoding "UTF-16" would be the solution

Isn’t that the default encoding on .net?

Yeah, I just didn’t realize powershell changed encoding while reading some lines and piping out. Hind-sight I guess I could have assumed this. Otherwise how would powershell know what a line is.

Ha and it makes sense seeing all the spaces between letters too. Hindsight

@seancorfield Could not find artifact org.ode4j:core-cpp:jar:pom:0.4.0 in central () ; sadly, this is what drove me to extension in the first place, and so i'll let the thread drop.

Hello all, how do I interop with this?

glfwSetKeyCallback(window, (window, key, scancode, action, mods) -> {
			if ( key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE )
				glfwSetWindowShouldClose(window, true); // We will detect this in the rendering loop
		});

you need to figure out what class those static methods are on first

I saw something by using reify but no interface to implement. Is it not like anon function:

?

(Foo/glfwSetKeyCallback window (reify SomeClass (someMethod [window key scancode action mods] (if ... (Bar/glfwSetWIndowSHouldClose window true)))))

it's an anonymous inner class, the method sig is used to figure out what it implements

I tried

(fn [window key scancode action mods]
                                    (when (and (= action GLFW/GLFW_RELEASE) (= key GLFW/GLFW_KEY_ESCAPE))
                                      (.glfwSetWindowShouldClose window true)))

a function won't work, you need to implement a specific class or interface

that syntax is a java 8 lambda https://www.geeksforgeeks.org/lambda-expressions-java-8/

@FunctionalInterface
public interface GLFWKeyCallbackI
extends CallbackI.V

java lambdas are a lot like clojure functions, but they were implemented after clojure, so clojure's functions are not compatible

void (*) (
     GLFWwindow *window,
     int key,
     int scancode,
     int action,
     int mods
 )

that looks right

right for what?

you need to reify that, and put the code in its method

the GLFWKeyCallbackI interface

what´s the method´s name?

I think it's apply https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html

but really you need to find the doc or implementation for that class (if you use an ide it will look that stuff up, and most java ecosystem assume you are using a tool that does that stuff for you since it's so tedious)

you got multiple levels of things going on here a C library wrapped by some Java interfaces/classes,

then wanting to reify those interfaces from Clojure

start here:

https://clojurians.slack.com/archives/C053AK3F9/p1580178164301600

figure out what the 2 arguments to glfwSetKeyCallback are

first one is "window", whatever that is

second one is a Java lambda, which is essentially a syntax sugar for an anonymous implementation of some interface

if you look at the javadoc of glfwSetKeyCallback, the second argument will be some interface

there will only be one possible method on that interface

(Java lambdas are known as "SAM"s - single abstract method)

oh yeah I got lambda / Function conflated, and the method you want really isn't apply

yeah Function doesn't have anything to do with this, except that Function is one of many SAM interfaces

Can't define method not in interfaces: apply` 

:-)

please don't paste error messages without pasting the full text of what you tried

yeah - you really need to find the classes these static methods are on, and their docs

I think @fabrao was confirming what you said already

(GLFW/glfwSetKeyCallback window (reify GLFWKeyCallbackI
                                    (apply [this window key scancode action mods]
                                      (when (and (= action GLFW/GLFW_RELEASE) (= key GLFW/GLFW_KEY_ESCAPE))
                                        (.glfwSetWindowShouldClose window true)))))

Caused by java.lang.IllegalArgumentException
   Can't define method not in interfaces: apply

sorry

thanks -- now look up GLFWKeyCallbackI

it is an interface with a single method

quick question why does the libspec in require need to be quoted (require '[compojure.core :as c]) -> ok (require [compojure.core :as c]) -> syntax error

@fabrao https://github.com/LWJGL/lwjgl3-generated/blob/master/glfw/src/generated/java/org/lwjgl/glfw/GLFWKeyCallbackI.java#L55 is that the method?

@jakub696 require isn't a macro, and those things don't exist until you load them, so quoting allows you to use a data structure of symbols to ask for them

@ghadi I thnk so

if so, it will be (reify GLFWKeyCallbackI (invoke [this window key scancode action mods]....))

it worked

many thanks

the formula to pass Java lambdas:

find the interface that the lambda is sugar for

(this will be in the java apidocs)

look up that interface's only abstract method

reify that interface and fill in the method

I know that reify that interface and fill in the method

but about function interface not

I wonder what I'm doing wrong about using the REPL

What's the idiomatic way of using constants? I have seen the use of CONST: (def ^:const url "http://...", as ex-java this would suffice, is there any alternatives?

Forgive me now, but... aren’t all defs pretty much constant? As another ex Java dude I haven’t worried too much 🙂

Yeah, I'd say that's a good default assumption in Clojure: all vars are immutable. I've never used ^:const myself mainly for that reason in fact but I do seem to recall reading somewhere that there was some oddness to it too - it doesn't necessarily behave as you'd expect.

@mattias504 replied on the thread

^:const is a hint to allow the compiler to inline certain constant literals, namely strings and numbers

it should not be used liberally and doesn't mean the same thing as e.g. const in C++

I used to use ^:const but I stopped given the reasons above - vals are immutable, so it's implicit

question is, what's the favourite - to uppercase the def val, or to keep it lowercase? 🙂

I just don't use def at all, then you don't have to decide :)

(not really, but minimizing use is imo a good idea)

and I think lower is fine, what is this, Java?

just wrap your whole namespace in a let and you'll never need a def

that's the javascript solution IIFE!

I've started to favour keeping the defs lowercase (I don't use that many @alexmiller honest!) as well, as above, it's implicit and seems more clojure-ish!

curious - beginner myself i would be inclined to do this in my code (def tax_rate 0.13) - is that wrong?

that's fine

(and this really is the case where inlining via ^:const makes sense)

it's really stateful or side-effecting defs that are problematic

What’s keeps that def from being optimized/inlined/otherwise tricked with (without const)?

vars

vars are stateful and require dereferencing (they can change)

One of the things I had to understand is that when playing with the repl, you can define a var, i.e., (def foo "hello") then eval it foo, then change it (def foo "goodbye"), eval it and it'll print out goodbye - from my understanding is we all talk about Clojure having immutable values, but those values can change if confined to the same thread, thus foo can be redefined since it's in the same thread. Have I got that hopelessly wrong?

immutable values are good

vars created with def however are stateful identities that refer to an immutable value

and can be changed to refer to a different immutable value

and this is not confined to a single thread; vars are global and can be redefined from any thread (as can all stateful values, if you have a reference to them).

so, is the var acting like a pointer to an immutable value, and that var pointer can change to another immutable value?

tbh, it's one of the first questions that I'm asked when I demostrate clojure at the repl, and I haven't given a good answer yet (as I'm still very much a newbie), when I def a var, then show how I can redef the var and the person asks "I thought Clojure values were immutable, how come the var has changed?"

In Java, you can demonstrate mutability by having a reference to an object. Date d = new Date(); and you can then d.mutateTheValue(...) and, the critical thing here is, without changing the instance of the object that d references, you have mutated the value it's referencing - the instance of the Date was changed. That can't happen in Clojure.

That's a good thing to show to people. I'll add that to my demonstration :)

the var is a box - it holds an immutable value

but you can put a different immutable value in the box

(def a 1) means "declare a, in this namespace, to refer to a var, that holds the value 1"

the key thing is that we have separated the identity (a), from the state (the var), from the value (1)

https://clojure.org/about/state is a good follow up read

Hi guys. I am trying to slurp some json data, and I get the following error: No such namespace: http: Any idea why? Also, is there a specific way to “connect” to an API, or do you just slurp URLS and convert them from JSON -> CLJ?

@georghagen sounds like you've missed the string delimiters around your URL

thanks @alexmiller

(slurp )
Syntax error compiling at (REPL:1:1).
No such namespace: http:

(slurp "")

@dharrigan here's a nice little demo to show Java-minded folks, an example showing how even aggregates/collections/"objects", in Clojure, are immutable (and how this same exercise would end up with a different result in a similar Java scenario):

user=> (def v1 {:type :famous-person :fname "Luke" :lname "Wilson"})
#'user/v1
user=> (def v2 v1)
#'user/v2
user=> v1
{:type :famous-person, :fname "Luke", :lname "Wilson"}
user=> v2
{:type :famous-person, :fname "Luke", :lname "Wilson"}
user=> (assoc v1 :lname "Skywalker")
{:type :famous-person, :fname "Luke", :lname "Skywalker"}
user=> v1
{:type :famous-person, :fname "Luke", :lname "Wilson"}
user=> (def v1 (assoc v1 :lname "Skywalker"))
#'user/v1
user=> v1
{:type :famous-person, :fname "Luke", :lname "Skywalker"}
user=> v2
{:type :famous-person, :fname "Luke", :lname "Wilson"}
user=> 

Screenshot 2020-01-28 17.19.30

@chepprey nice! thanks!

nvm you were correct. I had done it somewhere else in the editor

@georghagen regarding connecting to an API, I use clj-http (https://github.com/dakrone/clj-http). When Cheshire (https://github.com/dakrone/cheshire) is also on the classpath you can get it to convert JSON responses into Clojure maps, like so (clj-http.client/get "http://...." {:as :json}) (https://github.com/dakrone/clj-http#output-coercion)

clj-kondo issues me a warning about my horrible fn:

(defn- safe-read-int [^DataInputStream dis]
  (try
    (.readInt dis)
    (catch .EOFException e nil)))

@michael.e.loughlin what warning do you get?

it's about the unused symbol e

replace it with _e

but it drew my attention to the function, and it made me wonder if returning nil from a catch is Not Good

in %IMPERATIVE_LANG% that's a no-no 🙂

@michael.e.loughlin as always, "it depends"

I won't dwell on it then! Thanks @delaguardo and @borkdude

Why does (set! **print-length** 10) work, but this raises:

(def ^:dynamic d)
(set! d 1)
;; Can't change/establish root binding of: d with set

because the repl establishes a root binding for a number of vars like print-length

I am trying to extract the value associated with a keyword in a file of .clj, but it only returns to me the key, not the value.

(def return-station-id #(get-in % [:station] :station_id))
(map return-station-id si)

Example of data in the .clj: {:stations [{:station_id "1755", :name "Aker Brygge",

@georghagen Your data structure has :stations (plural) but your code has :station singular. So it doesn't find a match and returns the "not found" value -- :station_id -- the third argument to get-in

I think you want (map :station_id (:stations si)) ?

hey, how would you recommend limiting api calls? the limit is 5 per minute/500 day, but not sure how to do it? write the result of every call to a db with timestamp and check when the last call was?

hey guys,

how I can do this

(defn -main [& _] 
  (loop [line (read-line)]
    (when-not (nil? (parser line))

      ....

      (recur (read-line)))))

to read a line and in every interation add a line to a vector?

(defn -main [& _] (loop [line (read-line) p (conj [] line)] (when-not (nil? (parser line)) (println (conj p line)) (recur (read-line) (conj p line)))))

@d.ian.b (loop [lines []] (when-not .... ... (recur (conj lines (read-line))))

there's no need to have read-line twice, unless there's a special case where the first line is used even if it's not parsed

also, consider that when-not makes the whole block return nil instead of a vector as soon as a line isn't accepted

(this might be OK, maybe the vector is only used inside the loop)

also, idiomatically (when-not (nil? ...) ...) is just (when ... ...) - nil is falsey

(unless parser returning false is still acceptable, but I'd still avoid double negation (when (some? ...) ...) )

psst when-some is a thing

(and it's a homonym for winsome, which I really don't think is well enough appreciated)

I would have suggested when-some but the origiinal did not bind the return value of the parser