I wrote some wrapper macros around one JavaScript lib (PRNG).
Then I wanted to make functionality provided by this macros crossplatform.
(i.e. I want to have different implementation of this macros for JVM).
What is the proper way of doing it in Clojure?
Or can I just have one macros which at compile time detects if it's being used for JVM or JS and returns corresponding code?
Note that in ClojureScript, macros are written in Clojure (just as in Clojure). [Leaving aside the wrinkle of self-hosted ClojureScript.] So reader conditionals will only ever take the :clj branch in macro code in either case.
This is an ongoing subject of discussion. Related thread and ticket here:
https://groups.google.com/forum/#!msg/clojure-dev/f6ULUVokXrU/3uue5okSAgAJ
http://dev.clojure.org/jira/browse/CLJ-1750
One option is to simply write two versions of the macro, one for Clojure and one for ClojureScript. Another is to use some trick of the environment to determine which platform you are invoking the macro in the context of. There are several ways to do this. One example:
(def ^:private ^:no-doc cljs? (boolean (find-ns 'cljs.analyzer)))
Related
I know what the Clojure Repl does and how it is useful, but I do not have any information on how the internals of it works. Is it a program running in the JVM? How does the internals of a repl work?
The technology behind it:
the tiny Java entry point:
https://github.com/clojure/clojure/blob/clojure-1.7.0/src/jvm/clojure/main.java
the actual implementation of the REPL written in Clojure:
https://github.com/clojure/clojure/blob/clojure-1.7.0/src/clj/clojure/main.clj
The links are to the 1.7.0 versions of the files, that being the most recent stable release as of this writing.
To summarize what these do, clojure.main is a tiny Java class with a main method that serves as the entry point to the REPL. (So, it's just a standard Java program.) That main method accepts any arguments and hands them off to a function in the clojure.main Clojure namespace (using a few simple calls to methods in the clojure.lang.RT class which implements some core details of the Clojure runtime to get at the function in question – well, strictly speaking the Var that holds the function). Then the said function calls code that actually Reads user input, Evaluates it, Prints out the result and Loops around to the read more input again, until terminated by C-d or some other method, with various complications like setting up some Var bindings and such (to allow user control over some aspects of the REPL's operation and certain compiler settings).
Apologies in advance for the somewhat discursive nature of this clump of related questions; I hope the answers will be a useful resource for newcomers to Clojure.
I have just begun to learn Clojure, motivated in part by this essay. I'm not a professional developer but I have several decades of programming experience (ARexx, VB/VBScript/VBA, then Perl and daily use of R starting in 2011). My platform is Windows 7 64-bit. I'm using Emacs 24.3, cider 20131221 and Leiningen 2.3.3 on Java 1.7.0_45 Java Hotspot 64-bit server. I have bought Clojure Programming and the Clojure Data Analysis Cookbook and dipped into both. I have found them promising but I am getting lost in the detail.
Obviously the thing to do is to get stuck in and experiment with code exercises and small tasks, but the immediate problem for me has been the complexity of structuring, organising and even just plain running projects in Clojure. With R I can get away with a file of plain text containing the bulk of the code, perhaps with one or two others containing common functions for larger projects.
Clojure is very different and with no experience in Java I am struggling to put the pieces together. Clojure Programming has a whole chapter on organising and building projects, but it is so comprehensive that conversely I'm finding it difficult to tease out the information relevant to me now. I guess I'm looking for something like this answer on Swank, but the tools seem to have moved on since then. So here goes.
Leiningen produces amongst other things a project.clj file that contains the project definition and dependencies. I think I get this. Can I use this file for code not related to the definition, below the defproject, or is it best to leave this untouched and have the code itself in different clj file(s)?
If the answer is to leave the project.clj file alone, how is the relationship between that and other files established? Is it simply that all the clj files in the project folder are counted part of the project?
How do I define the main code file, the 'entry point' of the project? Let's say I have project.clj and main.clj with some helper functions in common.clj - how are the relations between these three files defined? I can call functions from main.clj but how does the project know that main is the core of the project if/when I package the project into an uberjar?
If I have a number of clj files, what is the best way to import functions? I have read about require and use (and import and refer and...) but I don't fully understand the difference and those two keywords are difficult to search for. The examples for REPL in the Clojure Data Analysis Cookbook most often opt for use. I found a similar question but it was a little over my head.
This is more tool-specific, but as Emacs seems to be widely used it seems fair to ask: what's a good workflow to run small bits of code given (say) the main.clj example given above? Currently I just open the main.clj file in Emacs, do an M-x cider-jack-in to establish the REPL, experiment in the REPL, then when I want to try something I select the whole buffer and select Eval region from the CIDER menu (C-c C-R). Is this standard operating procedure or utterly misguided?
Is there a convention for defining namespaces? I think I understand that namespaces can cover multiple clj files and that ns is used to define the namespace. Should I explicitly define the namespace (at the beginning of) every file of code? Clojure Programming has some recommendations but I'm interested in input from other users.
Clojure programming says to "Use underscores in filenames when namespaces contain dashes. Very simply, if your namespace is to be com.my-project.foo, the source code for that namespace should be in a file located at com/my_project/foo.clj". (EDIT as explained in this useful answer and also this one). This restriction would never have occured to me. Are there any other gotchas with regard to naming namespaces and variables? R frequently uses dots in variable names but I guess given the Java connection that dots should generally be avoided?
No, don't put actual code in there unless you know what you are doing (e. g. generate the version number for defproject from the local git repository like in the repositories of juxt)
The project.clj is simply one big parameter to Clojures build tool leiningen. See an example here https://github.com/technomancy/leiningen/blob/master/sample.project.clj. For example, you could specifiy a different source directory than src in the :source-path.
Default is the -main function in project.core, but you can specify various different configurations in the project.clj.
require is preferred. :use imports all publics of a namespace unless you use it in conjunction with :only. Require let's you use an alias for an entire namespace with :as, but you can have the same effect from use with :only using :refer. Notice that in ClojureScript :use without :only is not even allowed.
This is normal. There are other combos like e.g. C-c C-k to reload the entire file of the buffer. If you find yourself entering too many forms into a REPL and would rather edit them in a separate buffer https://www.refheap.com/22235.
I like to experiment trying to name namespaces in in verbs rather than nouns, e. g. I prefer myproject.parse, myproject.interpret, over myproject.parser, myproject.interpreter etc. But that's a question of personal style. EDIT: Yes, explicitly define the naming of the namespace by its filename and the ns form at the beginning of the source file. It is unusual to have multiple source-file defining one namespace.
Afaic this is the only caveat regarding naming of namespace. You can hardly know it in advance.
I like your "worried" approach. You will (hopefully) find out that Clojure and especially Leiningen are almost nonsense-free in terms of these questions.
Regarding REPL use: I saw your comment under #Mars answer that you want to use a REPL in a fashion that you can re-use what you are entering. Two things:
Dynamic development is awesome, allowing you to test small components or functions interactively without the need to run an entire program written for that purpose.
If you find your self entering huge forms at the REPL that you intend to de-/recompose into functions or tests later, I recommend editing them in a seperate clj file that is not part of the project source (i. e. not in a namespace). You can then use this Emacs hack to eval forms from a Clojure buffer in the REPL. Ideally split your Emacs in two windows (C-x 3) with the nrepl buffer on one side and your .clj on the other side. Then use C-x C-. from within the clj file to have the form at point pasted into the nrepl and be evaluated. Installation instructions are at the link (and your .emacs file usually resides in the home directory).
#Igrapenthin's answers are great. Here are a few other thoughts.
On namespaces, this tutorial is great.
Just to clarify re #2: No, don't just put the .clj files anywhere under the project. They have to be under src/, or in whatever directories are listed (as strings) in the vector after :source-paths in project.clj, if that entry exists. Then strip off that initial path when you're making your namespace names. This drove me crazy until I figured it out. (People who know better, please correct me if something here isn't right.)
One #3, you need Igraphenthin's answer, but why not just start by evaluating expressions in the REPL? I've been working on a project on and off for weeks, and it does a lot, but my -main function still doesn't do anything. I just run whatever parts I'm working on. Well, you're used to languages with fully operational prompts--you decide.
EDIT: Whether or not you define the -main function to do anything, you can also put :use or :require keywords in the ns statement that defines the namespace for that same file. These will automatically get invoked when you start the REPL with lein repl, and so whatever you have made available through the ns keywords will be available at the REPL. That way, you have your previous work available, but you can play around with it in different ways in the REPL. (Also, if you don't like the default name for the file that's automatically loaded, you can redefine it in project.clj with :main. Igraphenthin alluded to that.)
I'm a huge fan of Clojure and ClojureScript, and I would generally prefer to use ClojureScript over other alternatives for my projects, but one thing that sometimes holds me back from using it, particularly on smaller projects, is the ~80kb added by the inclusion of the Google Closure library in the generated javascript, even when I make no use of the apis in my code.
Is there any way to compile ClojureScript that avoids this extra weight?
The extra size isn't coming from the Google Closure library---if you have advanced optimizations turned on the Closure compiler will remove any Closure library code that you're not using from the final JavaScript.
Rather, the JavaScript seems big because there's a whole Clojure runtime in there implementing things like lazy seqs, promises, and everything else.
Correction: as Zubair points out, the step below disables the Google Closure optimization but does NOT eliminate Google Closure code from the final JavaScript. You should choose advanced optimization to eliminate unused JavaScript as the other answer suggests.
In ClojureScript: Up and Running, the authors explain how to disable the Google Closure step:
With an :optimizations value of :none [in project.clj], the Google Closure Compiler
will not be invoked at all, and the build will write out the
JavaScript produced by the ClojureScript compiler directly. This mode
is useful for development and debugging. However, the JavaScript
output will be split across many individual files, requiring slightly
different handling in a browser [...]
Note that this may or may not reduce the size of the produced JavaScript, since Google Closure does a fair bit of work to strip out anything your code doesn't specifically invoke. It's probably worth playing around with the various values of :optimizations (:none, :whitespace, :simple and :advanced) and seeing how big the resulting JavaScript is in each case.
It is often a pattern that I wish to poll a file for changes (when it was last written). When the file does change from its previous value, I wish to execute some function. Something of the form.
(poll-for-changes file-str on-change-fx current-value)
where
file-str is just a string that specifies the files location
on-change-fx is the function that should be called when the file at file-str changes. Let us say that the on-change-fx should take the File object pointing to file-str as a argument.
current-value the current value of the file in milliseconds. You might set to 0 to guarantee that this function will run at least once, or to the actual value to only run this function when you actually detect a change.
I would just like this function implemented in the clearest, most concise, Clojurist way possible. Thank you.
If you're looking to poll a directory or files and act on it, I think watchtower is pretty good to look at.
Java 7 has a WatchService, which uses file system events to react to changes. In this case, you don't poll at all, but block on a future file event. I don't think there are any projects in Clojure that are out there leveraging that, although I spent some time toying with it to write a small library. The source for it is here
I don't claim my library is even complete, but it does use the Java 7 service, so you could use that for inspiration on your own project.
There are two approaches you could use here:
Use Java interop and the Java 7 WatchService API.
Inspect and learn from existing idiomatic, concise code (in this case by Stuart Sierra) that does something like you want. Note it also uses Java Interop.
I think option #1 is your best bet, and the implementation of the function should be straight forward. You will likely want to use doto and the -> and ->> macros to make the code more readable.
Nowadays I would probably try hara.io.watch first.
Otherwise there are many alternatives (as stated in the hara docs) :
clojure-watch
dirwatch
hawk
watchtower
java-watcher
panoptic
ojo
filevents
And some code can be extracted from :
lein-midje
ns-tracker
lazytest
You could also do what hara does and wrap java.nio.file.WatchService.
Is there any plugin for VIM that I can use to index an C++ project code base?
I would apreciate functionalities like being capable of specifing a class and and may be a method and see what file/line the method/class is defined.
Regarding code navigation (and completion),
I'd take a look at clang_indexer (and clang_complete) --
ctag understanding of C++ code is quite bad, but universal-ctags has greatly improved the situation ; cscope understanding of C++ is non-existent.
Regarding plugins for C++ coding,
I have a suite for C and C++ programming. It is mainly oriented toward C++ programming, however a few, and unique features can be used in C as well:
context sensitive snippets (they require other plugins I'm maintaining);
a way to jump to a function definition from its declaration (or create it on the fly if it doesn't exists yet) (it used to requires the plugin alternate, which is a must have, however that I've forked it for my own needs) -> :GOTOIMPL;
a little tool that lists functions with a declaration and no definition, or functions with a definition and no declaration (NB: I haven't used it against C static function yet) (it requires ctags).
:Override that searches for overridable functions
:DOX that analyses C++ function signature to generate the appropriate (customizable) doxygen comment (with \param, \throw, ...)
a mapping to include the header file where the symbol under the cursor is defined* (which requires an up-to-date ctags base)
and few other things
Otherwise, I also use:
plugins like project/local_vimrc in order to have project specific settings ;
searchInRuntime to open/jump to files without the need to browse the directories of the current project ;
a refactoring plugin (that still lacks a few things ...) ;
a wrapper around :make in order to do background compiling, and to filter &makeprg results (e.g. pathnames conversions between cygwin posix form and dos form ; application of STLfilt ; etc.) (-> BuildToolWrapper which is stable, but still in an alpha stage) ;
and a few other things which have already been mentioned (alternate, ctags, ...).
Other Plugins.
Other people use c.vim, other templating systems (snipmate & co), pyclewn (that I highly recommend for debugging (with gdb) from within vim), other bracket-surrounding-and-expansion systems, ...
PS: I've answered, slightly differently, a question on the same subject on quora.
cscope is a nice tool for browsing. There is nice tutorial here.
ctags is another nice tool, I use it in my projects. Tutorial here. If you are in Ubuntu, you can install ctags by doing:
apt-get install exuberant-ctags
gtags is another tool.
I use taglist extensively.
The "Tag List" plugin is a source code browser for the Vim editor. It provides an overview of the structure of source code files and allows you to efficiently browse through source code files in different programming languages. It is the top-rated and most-downloaded plugin for the Vim editor.