1. imagine I'm editing foo.clj I can define a macro, and use it later in the same file 2. now, imagine I'm editing foo.cljc and I define a macro, say via #?(:cljs (defmacro ...)) now, I should be able to use this macro in foo.cljc on the clojure side -- but is there anyway to also use it from the cljs side? or does cljs absolutely require macros come from other namespaces, that are pure *.clj files ?

(binding [*out* /dev/null]) Obviously /dev/null isn't a thing in Clojure, but how to supress stdout? Forgot

will the output overwhelm with-out-string ?

possibly not. resulting string wouln't be colossal, still I'd like to learn the cleanest pattern

implement your own PrintWriter class, which does nothing

( "/dev/null") too

=> (binding [*out* (proxy [java.io.Writer] [] (append [& _]) (close []) (flush []) (write [& _]))] (println "hello, black hole"))
nil

https://stackoverflow.com/questions/29914967/can-cljc-single-file-macro-definitions-to-work-with-clojurescript <-- does this trick still work ? I'm getting 'macro not found from my cljs compilation'

I’m trying to find an article I read a while ago, told as a parable about a guy named Rich in the land of boxes, about how complex objects were and how simple composable tools could be more enjoyable

and my google-fu is failing me… so, does anyone know this piece and can remember the title?

@mattly not referring to kingdom of nouns are you?

That was one of Steve Yegge's big ol' rants... http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html

no, I very specifically remember it referring to objects as some kind of blocks or boxes, and a shout-out to Rich

ah yeah that does sound different

hmm, is there a plan to have https://github.com/clojure/brew-install in a apt/yum repository?

seeing great potential for JVM/Clojure command line scripting 🙂

ah, missed this: https://clojure.org/guides/deps_and_cli#_installation_on_linux

hey folks - veteran c++ game engine programmer here, emacs hacker / elisp user, getting into clojure

I was thinking about trying to do some kind of music visualizer (think g-force / milkdrop / etc) - what's the best approach to get framebuffer access and / or shader access in clojure? thanks in advance!

@iwannaseethelight making a brower UI or desktop?

replacing ruby with sed from install.sh and nearly there :)

framebuffer/shader sounds like native interop

for ClojureScript you can use https://github.com/thi-ng/shadergraph to get easy GLSL access

@viesti GLSL is shader access

@niklas.collin I'm just doing this for fun to learn the language - I love Lisp and its derivatives 🙂

yeah, well for ClojureScript and browsers there are several options out there, less so for Clojure

maybe quil?

I'll take a look - I mostly wondered if Clojure would even be capable of something like this given its immutable state

yes it can do anything, you can ask though if Clojure is the right tool for the job

In this particular case I'm just doing it for fun / learning - I build game engines for a living, it's definitely not the right language for graphics, but we'll see what it can do 😉

for the performance intensive mutable data stuff your code will end up looking an awful lot like java

I remember John Carmack rewrote Wolfenstein 3D in Haskell, it was pure madness

one could write a very efficient 3d engine with immutable data structures but only if the hardware drivers and APIs supported that properly

opengl etc have been written to handle this mutable state machine

you can also check out https://github.com/ztellman/penumbra

which is no longer developed

but maybe as a way to get started

Thanks guys, I'll take a look - I have to run to a meeting, bbs

For this toy example I'm wondering if I can just modify a framebuffer directly and blit it to the screen

for the browser just use some Canvas wrapper or WebGL wrapper or interop

I think you can do that stuff with GLSL, accessing framebuffer that is. Been a while since I last did any GPU level coding 🙂

@niklas.collin yeah, getting to shaders through the browser may help, don’t need to write the interop yourself since there’s stuff in the browser already 🙂

Quil might be the best option here

if the idea was to learn the language while doing something graphical

too much to ask for to “go write some JNI” while learning Clojure the language 🙂

results in “wtf” moments

on other GPU related, but not graphics, Dragan Djuric has done great work on getting the compute side of GPU’s available to Clojure with http://uncomplicate.org/

totally unrelated to graphics though

I'd like to parse clojure source file. What's the good way to do this? Using clojure.tools.reader/read-string gives me only the first namespace form:

(r/read-string (slurp "src/clojure_repl_experiments/experiments.clj"))
;;=> (ns
 clojure-repl-experiments.experiments
 (:require [clojure.set :as set] [criterium.core :as c] [seesaw.core :as see]))

You could just use a loop to read the whole file. What's the context?

@jumar because of clojure's evaluation model it's not generally possible to read a whole namespace w/o compiling each form as you go

altho since 1.9.0-alpha<something> (or by using tools.reader) there's ways to make this work, but it's still tricky

@cddr let's say I want to analyze which clojure functions are called in that code

take a look at https://github.com/clojure/tools.analyzer.jvm

will do, thanks!

You guys might appreciate this https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext

that's odd. their data suggests typescript is more likely to contain bugs than unadorned js.

Yeah, real data has a way of messing up 'intuition' and theorizing...

IIRC, the .ts extensions would also match C++ projects as they are Qt translation files

there was a long twitter thread with critique about that study, but I’m failing to find it now

yeah, I have my issues with a study like this too. It misses lots of context

for example, I’m working on TS project at the moment, and we ran into an issue that was not TS’s fault, but the JS library that did not have a type file.

and because I commit often, I committed the buggy code, but fixed it later, before the PR was made. So in a study like this, that would appear as a bug.

while it misses the context

Especially for languages that compile to JS, it won’t catch the edge cases when you try to interact with JS libraries

Of course there are issues with it - any such study is going to have issues. But at least it is actual data and not just sitting around making goofy claims

agreed, it’s better than just claiming things based on anecdotes

what would be a good/easy way to disable logging when running tests?

(using leiningen)

well also setting the level to WARN is enough (probably better)

in Python for example pytest captures all the logs during tests and only display the relevant logs in case of failure

@andrea.crotti depends how you're logging, logback supports a logback_test.xml for example.

which is quite handy

just using tools.logging at the moment

I'm not sure what that uses by default

@iwannaseethelight take a look at https://github.com/oakes/play-clj, it's got bindings to OpenGL etc through libgdx. I've been using it for making arcade games.

@andrea.crotti apparently the fallback is java.util.logging if nothing else is found 🙂 so you'll have to figure out how to configure that for testing.

well in theory I just need (.setLevel (Logger/getRootLogger) Level/WARN)

the only question is where to hook that up

there are hooks in clojure.test

I have something like this for lein run

mm not sure I find anything useful there

unless I make a fixture for each test namespace that does that?

which is not very convenient

I'm trying to recreate an aot behavior I've accidentally seen before, I'd like to capture a couple of environment variables at build time, so I can use version data automatically. I'm on 1.9.0-beta3, perhaps aot capture changed a bit? I've just got

(def DESCRIBE (System/getenv "GIT_DESCRIBE"))

whoops, dropped this: )

Top-level defs are run at namespace load time (so, essentially, runtime).

@seancorfield correct me if I'm wrong, but if you AOT, doesn't that make the load time earlier? (which is why you shouldn't (launch-missiles) at the top level)

it certainly does sometimes, because it's been a pretty common confusing deployment issue. that's where I've encountered it in the past

It loads namespaces for AOT and for running -- so it will execute both times:

(! 510)-> lein uberjar
Compiling aotit.core
I'm a top-level form
Created /Users/sean/clojure/aotit/target/uberjar/aotit-0.1.0-SNAPSHOT.jar
Created /Users/sean/clojure/aotit/target/uberjar/aotit-0.1.0-SNAPSHOT-standalone.jar

Thu Nov 02 08:28:52
(sean)-(jobs:0)-(~/clojure/aotit)
(! 511)-> java -jar target/uberjar/aotit-0.1.0-SNAPSHOT-standalone.jar 
I'm a top-level form
Hello, World!

That's with (def foo (println "I'm a top-level form"))

oh interesting, I thought it stored the "result" in some way. Cool.

Am i misunderstanding spec? It should return whether something is a spec, correct?

2nd arg to s/valid? should be a spec

so: (s/valid? ::first-name "mgrbyte") -> true

(s/spec? ::first-name) -> true

I get (s/spec? ::first-name) -> nil

on 1.9.0-beta2

ignore me, I'm wrong

string? returns a spec-predicate, not a spec i think

from https://clojure.org/guides/spec: Any existing Clojure function that takes a single argument and returns a truthy value is a valid predicate spec

string? is a predicate, (s/spec string?) is a spec that conforms to the string? predicate

specs and predicates are interchangeable in lots of places but not all

and ::first-name is a keyword, not a spec

ah. (s/spec? (s/spec int?)) returns an obj

you can use keywords that represent spec definitions in lots of places that you can use specs and predicates, but not all (and specifically it seems not in s/spec?)

you can get the spec object from the registry using (s/get-spec ::first-name)

so (s/spec? (s/get-spec ::first-name)) should return true

or... truthy

got it

thx for the insight

no worries

I'm hitting an anti-pattern often, and wonder if there is a better approach... I write a function, fn-a, that takes a map of parameters and does nothing with them but pass on to fn-b. It could be written as (defn fn-a [options] (fn-b options) ...) But, I want to supply useful arglist info, so I write (defn fn-a [{:keys [param1 params2 params3] :as options}] (fn-b options) ...)

But, later, fn-b gains a few more parameters. My code continues to work, but my arglist is out of date.

I'd love some way to declare that arglist info should be taken from another function.

sounds like a job for spec, or prismatic/schema

also, as Rich Hickey eloquently argues, it's good to have an open information model - specify the keys you need, but it should be OK if other things end up in there too

@noisesmith How? I see how I could use them for checking, but I'm looking for arglist as documentation.

the fact that the check passed in dev mode (even if turned off in prod) is more useful than pure documentation that isn't executable

if all you need is documentation, we have doc strings too

I can write (defn foo [{:keys [a b c d]}] ...) and pass it an empty map - clojure doesn't care

the a b c d there isn't any more informative than text in the doc string would be, nor is it more enforcible

That just begs the issue. I would still see the doc string of fn-a. But, really, the caller of fn-a needs to know the parameters of fn-b in order to effectively use the fn-a wrapper.

which is why an executable validation that can optionally be turned off is more useful

I'm not lookinf for enforcement in the question, I'm looking for, if you will, enlightenment.

why would a name that isn't enforced in an arg map be more enlightening than a string that isn't enforced in a doc string?

When I'm writing code in emacs, I want to do a quick C-c d d to see what parameters to type.

But, that forces me to keep the doc-string or the parameters of fn-a in lockstep with fn-b.

sounds like an emacs problem - a doc string can give you a lot more nuance and information than names in a destructure can

and an optional validation verifies that the code you are using actually works that way

When, really, fn-a's mandate is, rightly "take whatever I get and pass it to fn-b, because I have no right to care"

I would much rather spend one second when I'm typing my code, rather than one minute later, when a runtime check finds a problem. (and that's even assuming that someone did the unlikely task of writing a run-time checker for misspelled parameters in a map).

spec and prismatic/schema can both warn you about such things, and can be turned off in production

Spec can, but not naturally. As you pointed out above "specify the keys you need, but it should be OK if other things end up in there too".

But, even that is not the point. I want auto-maintained arglist documentation that I can see when I'm writing code.

Emacs, and all other sane tools give this naturally for most functions.

But, there is just one missing case, which is pretty common in my code.

So, let me restate my question:

emacs 4 lyfe

What is a tasteful way to document a function whose mandate is to pass a map of parameters to deeper code? The user typically knows only about this function, but needs to see an accurate list of the parameters that it expects.

A spec?

he already explicitly turned down using spec or schema for this

Not to mention a docstring.

and doc string 😄

🙂

doc string requires repeating myself in both functions.

I feel like I've made my cases so won't belabor them here

Spec is really the right answer, but I don't think the tooling is quite right yet.

You could abuse destructuring {:as foo :keys [...]} but that d be odd if you dont use them

(def ^{:arglists (-> (var map) (meta) (:arglists))} my-map (fn [f coll] (map f coll)))
#'boot.user/my-map

(doc my-map)
-------------------------
boot.user/my-map
([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])
nil

@mpenet. Yes, that was my original anti-pattern in my initial quesiton.

Or use a record but even then, they re quite open

spec is really really the right answer seeing as it shows up in docstrings

Does spec show up in docstrings? I'd not realized that.

@deg this is also true for prismatic.schema/defn btw

+user=> (s/defn foo :- s/Num [] 42)
#'user/foo
+user=> (doc foo)
-------------------------
user/foo
([])
  Inputs: []
  Returns: s/Num
nil

@sundarj Nice idea. But, currently, does not quite work in ClojureScript because there is an open bug in the handling of some arglists.

these tools are imperfect, but they really are designed with these issues in mind

Re spec, one problem is that this forces creating a name to describe this map. For a simple set of parameters used in only a few functions, this is a bit heavy.

if it's worth describing it's worth giving a name IMHO

Some people wrote macros to work around this. But ultimately you ll grow to like this (I did)

But, agreed, spec does the heavy lifting nicely for "big" cases. And, arglist spoofing covers the remaining cases, I guess.

why does it force you to create a name? (s/fdef my-fun :args (s/cat :the-arg-map (s/keys :req-un [::foo ::bar ::bash]))) is fine

Because I need to use it twice. (in fn-a and fn-b in my original example)

And, of course, I still need to list the parameters in the definition of fn-b.

how could you use it twice without assigning it to some sort of name for any solution? 0_o

In the code, I only need to use it once. fn-b requires me to list the parameters. fn-a only needs (defn fn-a [options] (fn-b options))

you do need to list the parameters twice, that's true

Right. I'm trying to avoid any need to list the options in or near fn-a, which may well be in a different file than fn-b.

You can combine the groups of keys with s/and

Is there a way to add annotations to an interface when using gen-interface?

Which groups of keys?

So your fist takes a spec with (s/and ::mapfoo ::mapbar etc)

And rest of fns just the precise submap

Thats one way

I don't think you are answering the same question that I'm asking.

@pelletier yes https://github.com/clojure/clojure/blob/master/test/clojure/test_clojure/genclass/examples.clj - you should be able to adapt this to gen-interface

My functions take exactly the same parameters as each other. Only fn-b cares about them in detail. fn-a is just an exposed surface wrapped around it.

imo you're working too hard to avoid duplication here. just

(s/def ::param-list (s/cat :opts-map (s/keys ...) :other-arg ...))
(s/fdef fn-a :args ::param-list)
(s/fdef fn-b :args ::param-list)

Yes, understood, and not terrible since the duplicated code can sit next to its copy. But, this still requires: - Repeating the param list in both the spec and fn-b (admittedly, this is no worse than any other spec, so ok...) - Creating the name ::param-list -- Well, more likely ::fn-b-param-list which, again, is not terrible but adds a bit of weight. In short. Yes, this is a reasonable answer and about the best that can be done today (with the arguable exception of the meta :arglists hack above). But, there is still a bit of a smell here that bothers me. Sorry that I obviously can't pin down my discomfort well enough... I'm clearly in the minority here. 🙂

I am using at-at to schedule some functions and want to persist the schedules (preferably to datomic) - is there anything that can help with that or any pointers ?

I have some macros in a clj file (no coresponding cljs file exists). I want to import these from some cljc files. Doing a normal :require in the cljc files fails, because the cljs namespace doesn't exist:

No such namespace: common.css, could not locate common/css.cljs, common/css.cljc, or JavaScript source providing "common.css" in file src/common/pages/timesheet.cljc

@len I'm sure it's possible (and I've done variations on it myself) but quartzite is made for this purpose http://clojurequartz.info/

@ghopper cljc files may be compiled as clojurescript or clojure, you are compiling it as clojurescript, so clojurescript features are there

thanks @noisesmith looks like thats the option

@hiredman Except it's being compiled as clojure as well without issue.

@ghopper the error message mentioning JavaScript is the clue

it isn't

The error message was with the normal (:require), not the (:require-macros).

There isn't any error with :require-macros.

right

and between those two attempts, are you loading the code the exact same way?

Shouldn't there be? When it's compile to clojure and it can't find the namespace, because it doesn't recognize the require-macros method?

Yeah, same way.

so clojurescript

the error message can only come from compiling clojurescript, if you are loading them the same way then they are being compiled the same way, so both are being compiled as clojurescript ∎

Oh... you're right. It wasn't being compiled to clojure as well. It thows a ns doesn't comform error now.

So I need a reader conditional to switch between require-macros and require?

yes

(ns hitch.selector
  #?(:cljs (:require-macros hitch.selector))
  (:require [hitch.oldprotocols :as oldproto]
            [hitch.protocol :as proto]
            [hitch.tracking.halt :as halt]
            [hitch.selector-tx-manager]))

an example from us ^

@dpsutton Well, the second require would be only for clj, since I don't have a cljs namespace of the macros namespace.

(ns common.core
  #?(:clj
     (:require [common.css :as css])
     :cljs
     (:require-macros [common.css :as css])))

I suppose that works:

(ns common.core
  (:require
   ...
   #?(:clj [common.css :as css]))
  #?(:cljs (:require-macros [common.css :as css])))

What does https://clojurescript.org/about/differences#_namespaces mean by "implicit macro loading". It's not clear to me how that's accomplished.

Is there anything I use to purposely return nil from a function's tail when there's a call at the tail returning something?

yeah, just put nil at the end

:)

oh, so it's totally ok to do so?

sure!

I’ve run into this occasionally and don’t know of any other solution

you could write a function and wrap the validate if that was nicer looking to you

Reminds me of actual Java code I saw once, 'if (c==null) return null else return c;'

nice, thanks alex! i'm still learning, so just looking for best practices

(defmacro swallow [& body]
  `(do ~@body nil))

then (swallow (s/validate …))

woah, that's interesting

prob a simpler way to do that

if it’s always wrapping a single expression, you could just do (def swallow (constantly nil))

i guess i prefer this alternative with constantly, most of the time it would be used for calls at the function's tail

thanks again alex! i didn't know about constantly

I had a hunch that constantly obviates the need for a macro that creates a do form

+user=> (def foo (constantly :OK))
#'user/foo
+user=> (foo (println :a) (println :b) (println :c))
:a
:b
:c
:OK

I wonder if it still works for large arg lists

oh yeah, constantly creates a functions that accepts any number of arguments. that invalidates my argument to prefer it over the macro form

I do not understand what the n argument does in practice in pipeline-async 0_o

How do I use apply with a Java object?

I want to call a method on a java object using the apply function. Is this possible?

How do I call a java method with potentially different number of arguments?

@nick319 afaik not without explicitly using reflection

and even if you could figure out how to do it implicitly... it would still be expensive

How expensive is reflection?

quite a few orders of magnitude more expensive than a regular function call

but, if you're in a context where you're doing io... not at all

bfabry: https://dev.clojure.org/jira/browse/ASYNC-163?focusedCommentId=42480&amp;page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-42480

ta, sounds like what I thought. practically it's only a limit if tasks are completing and sending results