[ mona / prog / sol ]

prog


What is the most underrated Scheme implementation?

1 2020-05-26 05:13

I'd say Gauche or Kawa.

Gauche is excellent for system programming but obscured by Guile. Kawa running on the JVM and being ENTERPRISE QUALITY is looked down upon.

2 2020-05-26 07:11

Gauche is indeed very solid as a glue language for daily plumbing tasks. As for Kawa, one thing I particularly like about it is that it has high-level units of quantities: https://www.gnu.org/software/kawa/Quantities.html

3 2020-05-26 07:12

In my opinion, the most underrated Scheme implementation would be Sagittarius. It's a solid R6RS Scheme with clean code and really good SRFI support. The author also makes implementation agnostic libraries in R6RS (including an FFI wrapper).

4 2020-05-26 08:27

Can Kawa be used to build Android applications?

5 2020-05-26 08:49

>>4
Yes, although I've had better experience with Gambit using LambdaNative.

6 2020-05-26 12:28

>>1,2

Gauche is excellent for system programming but obscured by Guile.
Gauche is indeed very solid as a glue language for daily plumbing tasks.

Another great thing about Gauche is that it works very well across platforms. When I was first getting into programming I was running 32bit OpenBSD, and it was the only implementation conforming to R6RS or R7RS that I was able to run. It also has great documentation on their implementation of the specification and what this means for programmers (for example strings are immutable). It also tends to encourage standard compliant Scheme, primarily extending the standard for historical limitations of the standard and SRFI, and depreciating these deviations over time.

7 2020-05-26 15:36

I wanted to use Kawa before but it wasn't clear to me how the Java interoperability was actually supposed to work and I couldn't find any good tutorials on it at the time. I wanted to write a Kawa script that would make use of Java libraries, but couldn't figure out how I was supposed to load them. Was I supposed to use Maven or something? How would that work with an interactive REPL?

8 2020-05-26 17:44 *

>>4
Yes.
https://www.gnu.org/software/kawa/Building-for-Android.html

It's also been used in MIT App Inventor:
https://en.wikipedia.org/wiki/App_Inventor_for_Android

9 2020-05-26 20:23 *

>>3
I kind of lump together those Scheme implementations that I never tried even though they all seem very good: Sagittarius, Cyclone and Larceny. I know they're unrelated but they're like new kids on the block to me.

10 2020-05-29 21:59

s7 is a pretty fast r5/r7rs embedded Scheme with first-class environments and setf.
https://ccrma.stanford.edu/software/snd/snd/s7.html

11 2020-05-29 22:35

Since it's not mentioned and it passes all the chicken scheme benchmarks and looks pretty fast, there's cyclone. But yes s7 looks interesting. And microscheme.

12 2020-05-30 03:10

Speaking of Chicken, the original author has another implementation called Bones which is an r5rs that compiles directly to x86_64 machine code.
http://www.call-with-current-continuation.org/bones/

Another quite interesting implementation is Owl Lisp which is a "purely-functional" (in the sense of immutability; side-effects are still okay) subset of r7rs that ought to compile in pretty much any vaguely UNIX-y environment. It's full of clever tricks and has an eloquently-minimal vm and compiler-to-C. As an example of the clever tricks, it's got a system similar to erlang processes, IE closures with messageboxes, that you can use to simulate mutable state. There are some other immutable datastructure tricks to get efficient-enough, but conceptually much simpler under the hood, approximations of hashtables. Only thing is the documentation is essentially non-existent; you've got to look at the library source files. Still, it's fiendishly clever for how small and simple it is. A true embodiment of the minimal 'spirit' of Scheme.
https://gitlab.com/owl-lisp/owl

13 2020-06-02 16:34

>>3,9

In my opinion, the most underrated Scheme implementation would be Sagittarius
they all seem very good: Sagittarius

I've been playing around with Sagittarius because it does seem very nice. The interactive environment unfortunately leaves much to be desired. I think the attached output stands on its own as an explanation of the problems, but I'll add some description anyway. In reverse the order of the code block presented below, the output of a process is often extremely cryptic due to references being explicitly printed. There are no macros analogous to Chez Scheme's ‘define-trace’, ‘let-trace’, etc. the tracer does not print the arguments of the expression being traced, but only the output, which remains in the cryptic fashion mentioned earlier. (not that it's a big deal to copy Chez's macros) Lastly, exceptions are presented in a manner that is not easily interpreted, followed by the full stack trace, I could see other liking this but don't enjoy it. Perhaps I'll download Larceny to see if the interactive environment is more enjoyable there.

(define (subset s)
  (if (null? s)
      (list '())
      (let ((rest (subset (cdr s))))
        (append rest (map (lambda (r) (cons (car r) (car s))) rest)))))

(subset '(1 2 3))
Unhandled exception
  Condition components:
  1. &assertion
  2. &who car
  3. &message "pair" required, but got ()
  4. &irritants ()
  5. &stack-trace

stack trace: ...

(define (subset s)
  (if (null? s)
      (list '())
      (let ((rest #?=(subset (cdr s))))
        (append rest
          (map (lambda (r) (list (car s) r)) rest)))))

(subset '(1 2 3))

#?=(subset (cdr s))
#?=(subset (cdr s))
#?=(subset (cdr s))
#?-    (())
#?-    (() (3 ()))
#?-    (() #0=(3 ()) (2 ()) (2 #0#))

(() #0=(3 ()) #1=(2 ()) #2=(2 #0#) (1 ()) (1 #0#) (1 #1#) (1 #2#))
14 2020-06-02 16:50

Racket

15 2020-06-03 08:59

Scheme 48. It might be abandonware but it has a lot of didactic value. It's written very cleanly and can be used as a textbook example of a plain and simple Scheme implementation. That doesn't mean it's too basic to be of any use, though.

16 2020-06-03 10:40

Is there a Scheme zoo?

17 2020-06-03 11:30 *

>>16
Like this page http://community.schemewiki.org/?scheme-faq-standards#implementations ?

18 2020-06-03 11:46 *

>>15
I agree, it also had csch and the Scheme Underground (the best name ever given to a Scheme project)
I've tried the SUnet libraries once but everything is terribly outdated.

19 2020-06-04 01:24

STklos. It was revived last year after about a decade of abandonment. It's got a solid implementation of a CLOS-style object system that many other implementations borrow from.

20 2020-06-04 02:15

Now that almost all Scheme implementations have been cited, which are the overrated ones? (¬‿¬ )
I'd say >>14

21 2020-06-04 02:36

>>13
I think this is entirely due to the configuration of my machine, but for whatever reason I'm having some difficulty running Larceny (bash claims the executable does not exist even though I'm looking right at it). I'll likely reattempt some time in the future on a cleaner machine to try to figure out what's going on. I was a bit disappointed to see that the project hasn't been updated since 2017, but that's not the end of the world.

22 2020-06-04 10:30

>>20
Gerbil.

23 2020-06-04 11:14 *

>>22
I thought it was neither overrated or underrated. Only neverrated.

24 2020-06-04 12:23

>>23
People praise Gerbil a lot for different reasons (having rich libraries, being newbie friendly etc) but I find its opinionated style to be very off-putting. Not to mention that it teaches newbies an unidiomatic Scheme style. I'd rather write in Gambit with add-on libraries (although Black Hole is pretty crappy), or use another Scheme implementation built upon Gambit, like JazzScheme.

25 2020-06-04 12:30

>>20
I think Guile is a bit overrated. It seems to deviate from the standard and to keep its deviations due to legacy systems. Yet at the same time as deviating from the standard it doesn't seem to offer much in the way of functionality that goes beyond the standard and SRFI. In contrast while Racket deviates from the standard perhaps more than any other programming language which might be called a Scheme, much of the functionality and deviations are very interesting.

26 2020-06-04 13:33

>>21
Has anyone here tried larceny? I've ended up with same error on both of my machines running different operating systems, different user permissions, different version of larceny etc. To build the latest version you need an older version of larceny. Would anyone with access to a Linux arm7, Windows, or Mac OSX system mind attempting to run the interpreter? Here's the error log, but with the full path to my home directory replaced with “~”:

~/tmp/larceny-1.3-bin-native-ia32-linux86$ ls -lh larceny*
-rwxrwxr-x 1 1001 1001    2541 Aug  6 2017 larceny
-rwxrwxr-x 1 1001 1001  435799 Aug  6 2017 larceny.bin
-rw-rw-r-- 1 1001 1001 8544432 Aug  6 2017 larceny.heap
~/tmp/larceny-1.3-bin-native-ia32-linux86$ ./larceny
./larceny: 105: exec: ~/tmp/larceny-1.3-bin-native-ia32-linux86/larceny.bin: not found
~/tmp/larceny-1.3-bin-native-ia32-linux86$ ./larceny.bin
bash: ./larceny.bin: No such file or directory
27 2020-06-15 00:19

Underrated: Bigloo!
Overrated: Guile
Not underrated, not overrated, best overall: Chez Scheme

28 2020-06-16 00:37 *

>>26
Another anon was able to install larceny so there is some problem with both of my machines I suppose, or something like the archive was corrupted recently.

29 2020-06-17 21:16

>>25
Of all the schemes I've uses, guile appears to me as the most practical outside of a development environment. It has plenty of SRFI's, implements a POSIX interface and it has a lot of useful utilities (web server, text parser, ...). That makes it a iterestinf and cleaner replacment for what Perl or Python is often used for, and that gives it an edge.

30 2020-06-19 22:52

Does anyone here run Scheme with SLIME using a swank? It seems that Scheme48, MIT Scheme, Chicken Scheme, and Kawa all have robust swank implementations, with a number of others of varying quality floating around for other Scheme implementations (mostly in the form of r7rs-swank). I'm curious to here about your experience if this is the case.

https://github.com/emacsmirror/slime/tree/master/contrib
https://github.com/ecraven/mit-scheme-swank
http://mumble.net/~campbell/darcs/slime48/
https://github.com/nickg/swank-chicken
https://github.com/ecraven/r7rs-swank
https://github.com/mbal/swank-racket

Also apparently R7RS Large Tangerine Edition was released at some point, the most interesting additions to me being the R6RS numeric tower, Fixnums (SRFI 143), and Flonums (SRFI 144).

31 2020-06-20 08:21

>>26

That Larceny is 32-bit so you probably gotta install libc6-i386.

32 2020-06-20 12:29

>>31
One of the machines I attempted to install on was a 32 bit x86 machine, I'll try this on the other though when I have time.

33 2020-06-20 12:33

Gauche is excellent for system programming but obscured by Guile.

I've been reading Gauche manual this morning, but couldn't find anything that made it have a distinctive advantage over Guile, at least in my eyes. And if there really is no technical advantage, Guile appears to have the upper hand is speed (https://ecraven.github.io/r7rs-benchmarks/, whatever that means) and in pervasiveness - because certain GNU utilities optionally depend on it (GDB, Make, ...), you won't have to install another Scheme implementation just to run a script.

34 2020-06-20 14:06 *

>>33
I don't think Gauche has a real advantage over Guile anymore. One could always argue that it supports 83 SRFIs and Guile only 37 but that's meager.

35 2020-06-20 15:45

Gauche boasts a vast array of built-in libraries, very speedy startup times, much better documentation, and first-class regexps ('Scheme regular expressions', or SRE), making it an excellent sysadmin tool. It's what Perl should have been all along. I love Guile as much as anyone else but there's no Scheme to replace Gauche on my belt.

36 2020-06-20 17:16 *

>>35
Is gauche is still updated? What's the difference of say defining system configuration abstractions and doing configuration parsing with it compared to guile? Saying I wanted to write something that configured multiple nodes of different operating systems for specific distributed software and locked them all down to fascist firewall rules and those operating systems had no special support for guile or ganche, which would be better? How would it look? Can you give pseudo code examples of this for comparison? Not trying to challenge you here just curious about this as I've seen things like guix and how much guile you can use with GNU tools.

37 2020-06-20 18:36

>>35
I've noticed that Gauche seems to start faster, and that is interesting for scripting, and the documentation is structured better.

first-class regexps ('Scheme regular expressions', or SRE)

what makes it first class? Guile supports regular expression too (https://www.gnu.org/software/guile/manual/html_node/Regular-Expressions.html), and from a first glance, all I see that Gauche has are reader extensions.

I'm considering rewriting a few scripts in Scheme, and in general, it's a pity that Scheme despite all the SRFI's isn't portable enough for real-word development.

38 2020-06-20 18:58

>>36

Is gauche is still updated?

http://practical-scheme.net/gauche/
Yes. Last changelog entry 2020/05/22
>>37
It's also a pity that porting scsh to Guile has stalled 10 years ago.

39 2020-06-21 09:16

>>37
"Scheme regular expressions" is distinct from textual regexps. It's a more elegant DSL, leading to much more readable (and FWIW writeable) code.
See SRFI-115, which was modelled after Gauche's SREs, which were modelled after Raku's regexps.

40 2020-06-21 15:18

>>39
Ah, so it's something like Emacs' rx. But if there's a SRFI, won't Guile perhaps also implement them one day?

41 2020-06-21 17:55 *

>>40
They are unlikely to implement it as there is a portable implementation already that can be used with Guile:
https://guix.gnu.org/packages/guile-irregex-0.9.6/

42 2020-10-15 15:06

>>2

Gauche is indeed very solid as a glue language for daily plumbing tasks.

Can Gauche replace AWK?

43 2020-10-15 15:12

>>42
In some sense yes, but overall you'd probably be better off not. Much of the power of AWK comes not from its expressiveness, which Gauche can match and exceed, but from its ergonomics, which it does not match for the specific task of manipulating text programmatically. Something like TXR http://nongnu.org/txr/index.html would be a sound replacement however.

44


VIP:

do not edit these