[ANN] (potato make) - makefiles in scheme

[ANN] (potato make) - makefiles in scheme

[Mike Gran]

Hello All-

I wrote a pure scheme Guile library (potato make) that lets one write
makefiles in scheme.  The code lives at
https://github.com/spk121/potato-make.

If you are familiar with the cryptic makefile syntax, and with scheme
syntax, you may be able to decipher this makefile written in potato
make.  Here ':=' is variable assignment, ':' is a target rule and '->'
is a suffix rule.  The '~' syntax is a lazy concatenation operator
that passes its output as a string to the system() procedure.

  #!/usr/bin/env sh
  exec guile -s "$0" "$@"
  !#

  (use-modules (potato make))
  (initialize)

  (:= CC "gcc")
  (:= CFLAGS "-g -O2")

  (: "all" '("foo"))
  (: "foo" '("foo.o" "bar.o")
    (~ ($ CC) "-o" $@ $^))
  (-> ".c" ".o"
    (~ ($ CC) "-c" $<))

  (execute)

There is quite a bit of flexibility here.  You can write your recipes
in shell, in scheme, or in scheme that returns a string that gets
passed to the shell.

I'll probably rename the ':' syntax for the sake of SRFI-119 wisp
compatibility.  Translated to wisp, this really would look like a
dialect of makefile.

No official tarball yet. I'll do that soonish after I get better
coverage in the test suite.  I was just a bit proud of this silly
hack, and wanted to show it off.  Thanks for reading.

Regards,
Mike Gran

Re: [ANN] (potato make) - makefiles in scheme

[Olivier Dion via General Guile related discussions]

On Mon, 15 Feb 2021, Mike Gran <spk121@yahoo.com> wrote:
> Hello All-
>
> I wrote a pure scheme Guile library (potato make) that lets one write
> makefiles in scheme.  The code lives at
> https://github.com/spk121/potato-make.

Interesting project!  I'm currently working on a small utility that
takes Scheme definition of a C project and generates a Makefile for it.
potato-make could make things easier to emit Makefile text from s-exp
templates.

>
> If you are familiar with the cryptic makefile syntax, and with scheme
> syntax, you may be able to decipher this makefile written in potato
> make.  Here ':=' is variable assignment, ':' is a target rule and '->'
> is a suffix rule.  The '~' syntax is a lazy concatenation operator
> that passes its output as a string to the system() procedure.
>
>   #!/usr/bin/env sh
>   exec guile -s "$0" "$@"
>   !#
>
>   (use-modules (potato make))
>   (initialize)
>
>   (:= CC "gcc")
>   (:= CFLAGS "-g -O2")
>
>   (: "all" '("foo"))
>   (: "foo" '("foo.o" "bar.o")
>     (~ ($ CC) "-o" $@ $^))
>   (-> ".c" ".o"
>     (~ ($ CC) "-c" $<))
>
>   (execute)
>
> There is quite a bit of flexibility here.  You can write your recipes
> in shell, in scheme, or in scheme that returns a string that gets
> passed to the shell.
>
> I'll probably rename the ':' syntax for the sake of SRFI-119 wisp
> compatibility.  Translated to wisp, this really would look like a
> dialect of makefile.
>
> No official tarball yet. I'll do that soonish after I get better
> coverage in the test suite.  I was just a bit proud of this silly
> hack, and wanted to show it off.  Thanks for reading.
>
> Regards,
> Mike Gran
>
-- 
Olivier Dion
PolyMtl

Re: [ANN] (potato make) - makefiles in scheme

[Ludovic Courtès]

Hi Mike,

Mike Gran <spk121@yahoo.com> skribis:

> I wrote a pure scheme Guile library (potato make) that lets one write
> makefiles in scheme.  The code lives at
> https://github.com/spk121/potato-make.
>
> If you are familiar with the cryptic makefile syntax, and with scheme
> syntax, you may be able to decipher this makefile written in potato
> make.  Here ':=' is variable assignment, ':' is a target rule and '->'
> is a suffix rule.  The '~' syntax is a lazy concatenation operator
> that passes its output as a string to the system() procedure.
>
>   #!/usr/bin/env sh
>   exec guile -s "$0" "$@"
>   !#
>
>   (use-modules (potato make))
>   (initialize)
>
>   (:= CC "gcc")
>   (:= CFLAGS "-g -O2")
>
>   (: "all" '("foo"))
>   (: "foo" '("foo.o" "bar.o")
>     (~ ($ CC) "-o" $@ $^))
>   (-> ".c" ".o"
>     (~ ($ CC) "-c" $<))
>
>   (execute)

Nice!

As you may know, Guix is reducing its “binary seeds” (pre-built binaries
used to bootstrap the whole distribution) so that everything can be
built from source.

Part of the strategy revolves around doing more things in Scheme on top
of Guile or Mes, and that’s why people wrote Gash (POSIX shell + core
utilities).  With a makefile parser, (potato make) could be a useful
addition!

Also, we could imagine adding a Guix backend to (potato make), such that
each target is built as a Guix “derivation”.

Food for thought…

Ludo’.

Re: [ANN] (potato make) - makefiles in scheme

[Xinglu Chen]

On Mon, Feb 15 2021, Mike Gran wrote:

> Hello All-
>
> I wrote a pure scheme Guile library (potato make) that lets one write
> makefiles in scheme.  The code lives at
> https://github.com/spk121/potato-make.

Cool project!  How would I try this out on my own Guile project?  I
can't find any instructions in the repo. :)