Hello everyone,

Being obsessed with shells and wanting very badly to have a racket
shell, I've spent a good chunk of time over the last couple of weeks
working on shell-related stuff for Racket.  First is a library for shell
pipelines (that may also contain racket functions).  The interface is
roughly like this (assuming `my-grep` is a racket function that
implements grep):

    (run-pipeline '(ls -l) (list my-grep "foobar") '(wc -l))

The docs for that library are here [1].

Additionally, I've got a rough sketch of a line-based syntax for writing shell
scripts or using a shell repl with embedded racket code.  Right now its syntax
looks like this:

    #lang rash
    ls -l | @my-grep "foobar" | wc -l
    ;; A line is not wrapped in a pipeline if it starts with &
    ;; You can get back into #lang rash syntax with @rash{} or @rash/out{}
    &@(define ttys @rash/out{ls /dev | grep tty})

I want to change the line syntax a lot (especially to not need &), but I
decided to put it up (with some very rough documentation) here [2] to
get some feedback on what people think of it.

I'm really interested in people's thoughts about both parts and ways people
think they could be improved.

Thanks,

William Hatch

[1] http://docs.racket-lang.org/shell-pipeline/index.html
[2] http://docs.racket-lang.org/rash/index.html

Cool! Will definitely check it out.

Is this at all related to Vincent's work? [1]

[1]: https://github.com/stamourv/rash
> --
> You received this message because you are subscribed to the Google Groups
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to racket-users...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.

>Is this at all related to Vincent's work? [1]
>
>[1]: https://github.com/stamourv/rash

I had no idea that existed.  (in my defense, I did google "racket
shell", "racket rash", etc before starting this)

I'll have to look at it as well.

This is super neat. I'd be interested in using a Racket-based shell once it gets to be more polished.

I’d love to use a Racket shell and script Unix in a ‘natural’ way.

You may wish to read up on scsh. While it was way ahead of its
time, Olin Shivers made the syntax as natural as possible so it
would be quickly useful to people used to basic shell scripting
syntax. After all, this syntax has a 40+ history and shouldn’t be
thrown out.



[1] https://scsh.net

William, hello.

On 20 Aug 2016, at 23:23, Matthias Felleisen wrote:

> You may wish to read up on scsh. While it was way ahead of its
> time, Olin Shivers made the syntax as natural as possible so it
> would be quickly useful to people used to basic shell scripting
> syntax. After all, this syntax has a 40+ history and shouldn’t be
> thrown out.

What Matthias said...

I think that Olin Shivers made a lot of excellent syntactical decisions
when designing scsh -- in particular his syntax for regular expressions
and for extended process forms -- to the extent that if one were simply
to reimplement the scsh syntax in Racket, that would be an excellent
departure point.  This is not to dispute your own syntactical choices,
but in an enterprise like this, scsh would be the elephant in the room.

There have been a couple of attempts to support the scsh syntax in
Racket, and the scsh code is still under active, though rather
low-level, maintenance <https://github.com/scheme/scsh>.  Incidentally,
scsh does start up very quickly, which is an attractive feature.

And this enthusiasm isn't just because scsh was the first Scheme
implementation I spent serious time with (*wipes wistful tear*).

Best wishes,

Norman


--
Norman Gray  :  https://nxg.me.uk
SUPA School of Physics and Astronomy, University of Glasgow, UK

William & Norman,

as much as I give credit to scsh, I just think that taking clues from scsh is enough. One could expand surface syntax into William’s pipe library for example.

The irony is of course that scsh’s start-up time was so bad back then, that we couldn’t use it for anything real.

— Matthias

I just ran across this little thing:

 https://asciinema.org/a/0utgivr7glk3ssn01fn5uwtey

People who want more shell ought to watch. It’s 2mins and cute  — Matthias

I've looked over the scsh docs at various times, though I've never
actually used it -- it's never been pre-packaged for distros I've used,
and every time I've tried to build it I've run into errors.  Perhaps I
should try again.  As far as  the process syntax goes, a little bit of
macros over my pipeline library should be able to get you something
pretty close.  I'll probably do that later.

The parts of scsh aside from the process forms, like the regex stuff, I
think are mostly orthogonal to the process stuff, so that could probably
just be a different library, then they could be used together.

>I just ran across this little thing:
>
> https://asciinema.org/a/0utgivr7glk3ssn01fn5uwtey

A lot of that does look pretty good.  I think he's probably right that
the |> piped output should be the last argument (I've had my `shellify`
wrapper making it the first).

>I’d love to use a Racket shell and script Unix in a ‘natural’ way.

Not just Unix -- it works on Windows too ;)

So is scsh what you consider natural?

I definitely want a nice s-expression syntax for it, but also a
convenient line-based syntax for interactive use.  I like the idea that
you can more or less turn a transcript of such commands into a script --
one of the reasons I always encourage people to get used to using a
shell is that it makes you think a lot more about automating tasks when
you type the same command sequence often.  It's something you just can't
do with GUI interfaces, and automating boring stuff is one of the joys
of programming.  Having a nice upgrade path (just gradually put more of
it in regular racket until it turns into a "real" program) for those
scripts that seem to grow over time is also really appealing to me.

Thanks for the feedback.

William

> On Aug 22, 2016, at 12:59 AM, William G Hatch <william@hatch.uno> wrote:
>
>  is scsh what you consider natural?

I’d like two different entry points:

— one for people who program in zsh, bash, tcsh, csh, sh, and perhaps even more primitive things (if they exist); scsh syntax appeals to those
— one for people like me who write Racket programs for their shell-like needs (HtDP/2e has several large script like that)

And of course, the ideal world has a path to go back and forth from these points. — Matthias, who always dreams of every thing

FWIW, the one thing that my `rash` really did was to put your $PATH in
your Racket namespace. That's one of the aspects of bash that I think
are really interesting and useful, and was the motivation for the project.
That it's also a nice showcase for `#%app` is just gravy. :)

The other aspect of bash that I find interesting, and was hoping to
capture in `rash` was easy port redirection, pipelines, etc. bash makes
simple patterns really easy. Racket is more flexible, but requires more
scaffolding. I didn't find a design that would combine the simplicity of
bash with Racket's syntax.

Then there's also the implicit coercion story. Unix utilities basically
all consume newline-separated strings. Racket functions typically need
more specific kinds of inputs. So mixing the two together (which is
really the point of having bash as a #lang) ended up requiring a lot of
adapters. It's not clear to me how to get that without making the result
as "ad-hoc" as bash itself, though.

Anyway, just a few thoughts on the topic.

Vincent

This reminds me of Scribble, which has two syntaxes:  one that looks like (and is)
Scheme, and one that's just ordinary text with a bit of markup..

-- hendrik

This discussion has reminded of SHILL
(https://www.usenix.org/system/files/conference/osdi14/osdi14-paper-moore.pdf)
which is less user focused, and more security / capabilities focused,
but the prototype (in Racket) utilizes contracts to enforce
capabilities checks.

I'm really into the idea of a nice Racket based shell that provides
more benefits than simply pipelines, though, `something/shell` did
look pretty neat by itself...

> --
> You received this message because you are subscribed to the Google Groups "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to racket-users...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.

--
http://www.apgwoz.com

On Mon, 22 Aug 2016 11:38:37 -0500,
Andrew Gwozdziewycz wrote:
>
> This discussion has reminded of SHILL
> (https://www.usenix.org/system/files/conference/osdi14/osdi14-paper-moore.pdf)
> which is less user focused, and more security / capabilities focused,
> but the prototype (in Racket) utilizes contracts to enforce
> capabilities checks.

Yes, that's really cool work!

For those interested, Scott will be speaking about Shill at RacketCon[1]
next month.

Vincent


[1] con.racket-lang.org

Oh, rad! I will watch out for the video. Sadly, I won't be attending.

On Sat, Aug 20, 2016 at 4:17 PM, William G Hatch <william@hatch.uno> wrote:
> I'm really interested in people's thoughts about both parts and ways people
> think they could be improved.

Hi, William.  Have you looked at ESHELL to see if it has anything of interest?

%(format-time-string "%D %H:%M:%S" (seconds-to-time 1471456370))
08/17/16 14:52:50
%

%for i in (list 'a 'b 'c) {echo $i}
a
b
c
%

%for i in (list 'a 'b 'c) {echo x = $i}
("x" "=" a)
("x" "=" b)
("x" "=" c)
%

This echo is actually a Lisp function.

%which echo
eshell/echo is a compiled Lisp function in `em-basic.el'
%

%which *echo
c:/emacs/git/usr/bin/echo.exe
%

To invoke the echo program, use an asterisk:

%for i in (list 'a 'b 'c) {*echo x = $i}
x = a
x = b
x = c
%

The manual:
https://www.gnu.org/software/emacs/manual/html_node/eshell/index.html

On Mon, Aug 22, 2016 at 12:59 AM, William G Hatch <william@hatch.uno> wrote:
> I've looked over the scsh docs at various times, though I've never
> actually used it -- it's never been pre-packaged for distros I've
> used, and every time I've tried to build it I've run into errors.
> Perhaps I should try again.  As far as the process syntax goes, a
> little bit of macros over my pipeline library should be able to get
> you something pretty close.  I'll probably do that later.

There were some problematic points with the scsh macro -- something
around the implicit backquoting that made things not compose nicely.
I think that this was what Mike Sperber told me at some point.

--
                   ((x=>x(x))(x=>x(x)))                  Eli Barzilay:
                   http://barzilay.org/                  Maze is Life!