Clojure's nrepl provide a way to connect to a running remote Clojure program.
Does Kotlin have a network REPL like Clojure's nrepl?
maybe have a look at:
https://github.com/kscripting/kscript#treat-yourself-a-repl-with---interactive
maybe it comes near to what you want to have.
https://github.com/holgerbrandl/kscript
kscript by Holder Brandl adds enhanced scripting support for Kotlin on *nix-based systems. kscript provides an easy-to-use, very flexible, and almost zero-overhead solution to write self-contained mini-applications with Kotlin.
also available via https://sdkman.io/
$ sdk install kscript
For trying out small kotlin code snippets, I sometimes just use the scratches from my favorite IDE Intellij: https://www.jetbrains.com/help/idea/scratches.html
Maybe you find the latter also "helpful" for whatever you "intended" to achieve in using a REPL.
No there isn't - maybe you can define the requirements and what/why you want and someone might develop it
Related
I am looking for something along the same lines as this article: "Go With Go(Lang): Features and Testing Frameworks", featuring Clojure/Clojurescript. Similarly, any book(s) that contain examples of Clojure/Clojurescript being used as to create devops/test-automation applications, would also help.
I am the developer behind spire, a clojure DSL for idempotent machine provisioning over ssh. I built it using GraalVM and sci. I have also used it for automated testing.
Presently I am working on making it a babashka pod, so soon you will be able to use its functionality directly from babashka.
I do virtually all my AWS manipulations using aws-api. The dev-ops experience via clojure is much better than using bash/shell scripts and the AWS CLI.
Your question is a bit vague, but Clojure is IMHO the best general-purpose computer language (no surprise since you asked on a Clojure site!).
One solution that might work for you is the Babashka tool. It allows you to turn Clojure code in to a stand-alone executable. So, instead of using quirky, fragile bash scripts, you can write a robust & powerful Clojure program that has the instant startup & low memory usage of a Go or C program.
For more general purposes, you can write a complete general-purpose Clojure program and interop with the outside O.S. with a function like tupelo.misc/shell-cmd or the original Clojure version from clojure.java.shell. I have used this to drive AWS CLI functions, for example listing, cloning, and deleting RDS database instances.
The sky is the limit (along with your imagination).
Update
I forgot to mention GraalVM. It allows you to compile Clojure code into a static executable (the same as produced by a C/C++ program). Here is a Clojure/GraalVM demo project that creates a "Hello World" program even faster and more memory efficient than a Python script! Enjoy!
Is there a Plug-and-play Common Lisp/Scheme implementation?
By Plug-and-play I mean an implementation with an IDE that doesn't require you to play chords with a pianist dexterity(so not Emacs), where you can run a program by pressing a button not writing commands in a console, with modern libraries and that is portable.
Racket supports all the features above EXCEPT portability. I wrote a program in Racket that I couldn't send to friends because it wouldn't run on other computers. I want to make programs that I can send as easily as a Java programmer sends a Jar file and you can run it with double-click.
I also don't like how Clojure looks.
So the big question: if someone doesn't know programming, can he learn LISP using this implementation as easy as someone who would pick Java or C#?
I think you are mixing a lot of different requirements in your description:
If you need something that compiles to a binary executable file, you can use a bunch of CL implementations that compiles to an executable file. You can even use https://common-lisp.net/project/armedbear/ that runs on JVM.
If you need something easy to start with, with editor and runtime embedded, you can use http://www.lispworks.com or things like https://common-lisp.net/project/lispbox/.
But it seems that you are also talking about the language. Well, the syntax is only one part of the language, don't evaluate a language just taking into account its syntax.
Finally, I don't believe that it is easy to start working with Java or C#. You may think that these IDEs make life easier, but in the reality, it takes time to install them, solve dependencies and really learn how to be productive with them. Those IDEs end-up being much less flexible and usable than Emacs that you criticized. I have some experience teaching CL for students that after 1-2 months quickly started to be very productively why Emacs.
Well I think that this days is pretty easy to install common lisp and intall slime with quiclisp then you can have your environment quick and easy
take a look at this question
Setting the SLIME in emacs
and in quicklisp:
https://www.quicklisp.org/beta/#installation
also I recommend you to take a look at the roswell an intend to be a lisp installer and launcher for major environment that just work.
project on github in the wiki section they have an easy form of start emacs with roswell:
https://github.com/roswell/roswell/wiki
require you to play chords with a pianist dexterity(so not Emacs)
One can use emacs like notepad and use menus and buttons to do actions instead of key combinations, that although arbitrary, don't require much dexterity to reach. It is clear to someone that have used SLIME that you SLIME satisfies your requirements but are deadset against emacs. If so, give Allegro Common Lisp a try.
Racket supports all the features above EXCEPT portability. I wrote a program in Racket that I couldn't send to friends because it wouldn't run on other computers. I want to make programs that I can send as easily as a Java programmer sends a Jar file and you can run it with double-click.
In racket you can use raco exe will produce a Stand alone executable, so Racket will also do.
In my Python development, doctest has really helped both to
make writing unit tests less annoying, and
integrate usage examples with documentation.
I was wondering, is there anything like this available in the Matlab world? It doesn't have to literally use code comments as a test, but if it had those two desirable qualities, that would be great!
This exists now! There are three versions out there:
An Octave-compatible version that still gets some development
A version of Matlab-xUnit with an integrated doctest runner
The original version from 2010, which is self-contained and emits results in TAP format
Not yet, but there is something to generate documentation called M2HTML.
It is very useful, and you can take a look at the examples at that page to see how wonderful results it's producing (even dependency graphs :) ).
For unit testing in MATLAB, even if there are many solutions, mlUnit was the most efficient to me.
There is no direct equivalent to doctest in MATLAB.
There is, however, a nice unit testing framework on the Matlab File Exchange.
I'm thinking about writing my own little language.
I found a few options, but feel free to suggest more.
JVM
Parrot
OSA
A lot of languages are using the JVM, but unless you write a Java-ish language, all the power the stdlib gives you is going to feel ugly; It's not very good at dynamic stuff either.
Parrot seems a good VM for developing languages, but it has a little abandoned/unfinished/hobby project smell to it.
OSA is what powers Applescript, not a particularly well known VM, but I use Mac, and it offers good system integration.
CLR+Mac doesn't seem a good combination...
My language is going to be an object orientated functional concurrent dataflow language with strong typing and a mix of Python and Lisp syntax.
Sounds good, eh?
[edit]
I accepted Python for now, but I'd like to hear more about OSA and Parrot.
One approach I've played with is to use the Python ast module to build an abstract syntax tree representing the code to run. The Python compile function can compile an AST into Python bytecode, which exec can then run. This is a bit higher level than directly generating bytecode, but you will have to deal with some quirks of the Python language (for example, the fundamental difference between statements and expressions).
In doing this I've also written a "deparse" module that attempts to convert an AST back to equivalent Python source code, just for debugging. You can find code in the psil repository if you're interested.
Have a look at LLVM. It's not a pure VM as such, more a framework with it's own IR that allows you to build high level VMs. Has nice stuff like static code analysis and JIT support
Lua has a small, well-written and fast VM
Python VM - you can really attach a new language to it if you want. Or write (use?) something like tinypy which is a small and simple implementation of the Python VM.
Both options above have access to useful standard libraries that will save you work, and are coded in relatively clean and modular C, so they shouldn't be hard to connect to.
That said, I disagree that Parrot is abandoned/hobby. It's quite mature, and has some very strong developers working on it. Furthermore, it's specifically a VM designed to be targeted by multiple dynamic languages. Thus, is was designed with flexibility in mind.
Have you considered Pypy? From what I've read, in addition to being a Python JIT Compiler, it also has the capability to handle other languages. For example there is a tutorial which explains how to create a Brainfuck JIT compiler using Pypy.
I'm working on a project that requires me to create a series of editors for languages that are quite different. The syntaxes are defined by us.
I'm looking for a solution for this.
Is there a shortcut to take in this problem?
You could use XText:
a framework for development of textual domain specific languages (DSLs).
Just describe your very own DSL using Xtext's simple EBNF grammar language and the generator will create a parser, an AST-meta model (implemented in EMF) as well as a full-featured Eclipse text editor from that.
Alternatives to XText are Rascal or Spoofax, both less popular than XText but interesting for they support more general context-free grammars, among other things. Nice to check out.
If you are looking for a more low level, programmable solution, then Eclipse's IDE Meta-tooling platform is a good choice (IMP).
What IMP gives you is API to connect your existing parsers to Eclipse without much hassle. You need to implement an IParseController interface, to call your parser and ITokenIterator to produce tokens and some other interface to assign fonts to each kind of token.
The aforementioned Rascal and Spoofax are both build on top of IMP.
Not mentioned is DLTK (proposed also in Tutorial regarding the development of a custom Eclipse editor)
There are Ruby, bash that are implemented with it.