Re: Threading / Pipe Macro

[Erik Edrosa]

On 7/7/19 6:42 AM, Zelphir Kaltstahl wrote:
> 
> (1) Does something already exist?
> 

This project was posted not too long ago on this mailing list.

https://bitbucket.org/bjoli/guile-threading-macros/src/default/

- Erik

[ANN] Guile-Git 0.3.0 released

[Erik Edrosa]

Hello everyone,

The release of Guile-Git version 0.3.0 is now out.

Guile-Git is a GNU Guile library providing an API for interacting with
git repositories using libgit2.

Guile-Guile is free software, licensed under the GPLv3 or later.


Latest release:
  https://gitlab.com/guile-git/guile-git/-/tags/v0.3.0

Latest release tarball:

https://gitlab.com/guile-git/guile-git/uploads/4c563d8e7e1ff84396abe8ca7011bcaf/guile-git-0.3.0.tar.gz

Repository:
  https://gitlab.com/guile-git/guile-git

Report issues:
  https://gitlab.com/guile-git/guile-git/issues


NEWS

* Changes in 0.3.0 (since 0.2.0)

** New Functionality
*** Add new (git tag) procedures
*** Add (git signature) module
*** Add (git describe) module
*** Support for Guile 3.0
*** Add accessor and setter for the download tags of ~fetch-options~
*** Add ~CREDTYPE-*~ variables
*** Add ssh authentication support
*** Add (git blob) module

** Changes
*** ~repository-state~ return a symbols instead of an int
*** Rename ~foo-init-options~ procedures to be more idiomatic

Thanks,
Erik (OrangeShark)
Member of https://libremiami.org/

[potluck dish] A CommonMark parser

[Erik Edrosa]

Hello,

I've been working on a parser for CommonMark[0], a specified version of
Markdown[1] being worked on (still not 1.0). It currently does not parse
the full spec, but it works so far for all block structures except for
HTML blocks. The code is still pretty rough and I welcome any feedback
to improve it. I am following their suggested strategy of parsing
CommonMark in two steps by parsing the block level structure and then
inline.

The code can be found at https://github.com/OrangeShark/guile-commonmark

Here is an example usage:
(use-modules (commonmark)
 (sxml simple))

(define doc
  "A CommonMark Document
===
Here is some scheme code
```scheme
(display \"Hello, World!\")
```

1. A list
2. Another item")

;; Parse the CommonMark document into sxml
(define doc-sxml (commonmark->sxml doc))

;; Writes to current output port
(sxml->xml doc-sxml)
(newline)


which outputs(formatted for readability):
A CommonMark Document
Here is some scheme code

  
(display "Hello, World!")
  


  
A list
  
  
Another item
  



I plan to have the 0.1 release cover both blocks and inlines and as much
of the current spec as possible. This will include parsing HTML in
CommonMark documents, but I am unsure if whether the default behavior
should be unsafe (does not escape any HTML) with a safe flag or the
opposite. Any suggestions to improve is appreciated.

Thanks
Erik - OrangeShark


[0]: http://commonmark.org/
[1]: http://daringfireball.net/projects/markdown/

[ANN] guile-commonmark 0.1 (A markdown parser)

[Erik Edrosa]

Hello everyone,

Awhile back for the potluck I posted a CommonMark[0] parser I written in
pure Guile Scheme which outputs SXML. Today I have decided to release
version 0.1, it currently supports parsing almost the entire CommonMark
spec besides block and inline HTML. guile-commonmark will not support
block and inline HTML as the spec allows malformed HTML to be written
which can't be transformed to SXML. guile-commonmark also follows a
slightly older version of the spec and one of the major differences are
tabs are expanded into spaces(including tabs in code blocks).

Here is an example usage:
(use-modules (commonmark)
 (sxml simple))

(define doc
  "A CommonMark Document
===
Here is some *scheme* `code`
```scheme
(display \"Hello, World!\")
```

1. A list
2. Another item in a list

Read more about [CommonMark](http://commonmark.org/)")

;; Parse the CommonMark document into sxml
(define doc-sxml (commonmark->sxml doc))

;; Writes to current output port
(sxml->xml doc-sxml)
(newline)


Which outputs(formatted for readability):

A CommonMark Document
Here is some scheme code

  (display "Hello, World!")
  


  A list
  Another item in a list

Read more about http://commonmark.org/";>CommonMark


You may download the release at
https://github.com/OrangeShark/guile-commonmark/releases/download/v0.1/guile-commonmark-0.1.tar.gz

GNU Guix users can install guile-commonmark using the attached guix.scm file

guile-commonmark is still a young project, so expect plenty of bugs.
Please report any bugs to https://github.com/OrangeShark/guile-commonmark


As a bonus for haunt users, here is an example using guile-commonmark as
a reader to generate a blog written in markdown.

(use-modules (haunt asset)
 (haunt builder blog)
 (haunt builder atom)
 (haunt reader)
 (haunt site)
 (haunt post)
 (commonmark))

(define commonmark-reader
  (make-reader (make-file-extension-matcher "md")
   (lambda (file)
 (call-with-input-file file
   (lambda (port)
 (values (read-metadata-headers port)
 (commonmark->sxml port)))

(site #:title "Built with Guile"
  #:domain "example.com"
  #:default-metadata
  '((author . "Eva Luator")
(email  . "e...@example.com"))
  #:readers (list commonmark-reader)
  #:builders (list (blog)
   (atom-feed)
   (atom-feeds-by-tag)))

Now just save the above as haunt.scm and put your markdown blog posts in
the posts directory with a .md extension and run `haunt build`. Here is
an example blog post:

title: Hello World!
date: 2016-07-24 10:00
tags: guile, commonmark, scheme
---

A CommonMark Document
===
Here is some *scheme* `code`
```scheme
(display "Hello, World!")
```

1. A list
2. Another item in a list

Read more about [CommonMark](http://commonmark.org/)


Please note the header on top portion of the post which allows you to
add metadata to your blog posts for haunt.

Thanks,
Erik

[0]: http://commonmark.org/
(use-modules (guix packages)
 (guix licenses)
 (guix build-system gnu)
 (guix download)
 (gnu packages guile))

(package
  (name "guile-commonmark")
  (version "0.1")
  (source
   (origin
 (method url-fetch)
 (uri 
   (string-append "https://github.com/OrangeShark/guile-commonmark/releases/download/v";
  version "/guile-commonmark-" version ".tar.gz"))
 (sha256
  (base32
"12cb5fqvvgc87f5xp0ih5az305wnjia89l5jba83d0r2p8bfy0b0"
  (build-system gnu-build-system)
  (inputs
   `(("guile" ,guile-2.0)))
  (synopsis "CommonMark parser for GNU Guile")
  (description
   "guile-commonmark is a library for parsing CommonMark, a fully specified
variant of Markdown.")
  (home-page "https://github.com/OrangeShark/guile-commonmark";)
  (license lgpl3+))

Re: [ANN] guile-commonmark 0.1 (A markdown parser)

[Erik Edrosa]

On 07/25/2016 09:44 AM, Thompson, David wrote:
> On Sun, Jul 24, 2016 at 10:33 PM, Erik Edrosa  wrote:
>>
>> As a bonus for haunt users, here is an example using guile-commonmark as
>> a reader to generate a blog written in markdown.
>>
>> (use-modules (haunt asset)
>>  (haunt builder blog)
>>  (haunt builder atom)
>>  (haunt reader)
>>  (haunt site)
>>  (haunt post)
>>  (commonmark))
>>
>> (define commonmark-reader
>>   (make-reader (make-file-extension-matcher "md")
>>(lambda (file)
>>  (call-with-input-file file
>>(lambda (port)
>>  (values (read-metadata-headers port)
>>  (commonmark->sxml port)))
>>
>> (site #:title "Built with Guile"
>>   #:domain "example.com"
>>   #:default-metadata
>>   '((author . "Eva Luator")
>> (email  . "e...@example.com"))
>>   #:readers (list commonmark-reader)
>>   #:builders (list (blog)
>>(atom-feed)
>>(atom-feeds-by-tag)))
>>
>> Now just save the above as haunt.scm and put your markdown blog posts in
>> the posts directory with a .md extension and run `haunt build`. Here is
>> an example blog post:
>>
>> title: Hello World!
>> date: 2016-07-24 10:00
>> tags: guile, commonmark, scheme
>> ---
>>
>> A CommonMark Document
>> ===
>> Here is some *scheme* `code`
>> ```scheme
>> (display "Hello, World!")
>> ```
>>
>> 1. A list
>> 2. Another item in a list
>>
>> Read more about [CommonMark](http://commonmark.org/)
>>
>>
>> Please note the header on top portion of the post which allows you to
>> add metadata to your blog posts for haunt.
> 
> This is just wonderful! Thank you!
> 
> If you have the time/motivation, I would love to see a patch to Haunt
> itself that adds guile-commonmark as an optional dependency.  There's
> prior art for this because guile-reader is also optional, so it would
> mostly be a copy/paste job in configure.ac and Makefile.am to
> conditionally include the markdown reader module in the list of source
> modules.
> 
> - Dave
> 

Definitely, I have been playing around with haunt and managed to switch
my current blog to use haunt and guile-commonmark. I have a couple of
ideas to add to haunt, so I will hopefully be sending you some patches soon.

Thanks,
Erik

Re: How to make GNU Guile more successful

[Erik Edrosa]

On 03/04/2017 06:41 PM, Alejandro Sanchez wrote:
> If I may add my two cents as a Scheme layman: the question is not so much 
> about making Guile more popular, but about making Scheme itself more popular.
> 
> One big reason for Python’s popularity is something I haven’t seen mentioned 
> in this thread so far: if you know pseudocode you basically know Python 
> already. Of course this is hyperbolic, there are a lot of finer details to 
> Python, but the superficial simplicity of Python makes you think you already 
> know the language and that you can get started right away. By the time you 
> encounter the more arcane aspects of Python you have already invested enough 
> time into it that you will put up with learning something new.
> 
> Scheme on the other hand is weird; weird in a good way, but still weird. For 
> me the reason for picking up Scheme was working my way through SICP, but even 
> before that I had heard of the Lisp family. Every time I tried to find out 
> what the fuss was about Lisp all I could find was nebulous concepts like 
> “it’s a programmable programming language” without explaining what that even 
> meant and why I would ever want to use it.
> 
> Of course once I got over the weird parentheses and I understood why they are 
> actually a beneficial aspect I liked it. Yet, even after getting into Scheme 
> there are problems. The r5rs standard is pretty limited, and so every 
> implementation does its own thing. There was not even a standard module 
> system until r6rs. Unfortunately r6rs never got fully adopted by any of the 
> major implementations, so we are back to where we were with r5rs more or 
> less. r7rs-small looks like it could finally fill in the most glaring gaps, 
> and r7rs-large is still nowhere done.
> 
> All this is very frustrating, and getting into a new language is a long-term 
> commitment to learn something new. When faced with Python, Ruby, JavaScript, 
> Lua and Scheme, it’s easy to go with the flow and just use what everyone else 
> is using.
> 
> I think someone here mentioned the lack of a proper Scheme IDE, other than 
> Dr. Racket for Racket. I don’t use IDEs anymore, but I can see how that can 
> be a problem for other people who only want to do intermediate scripting 
> rather than write entire applications. Writing a full IDE would be quite a 
> lot of work, so perhaps integrating with existing IDEs would be better. Think 
> something like Geiser for programs other than Emacs. There is the “language 
> server protocol" by Microsoft, the idea is to have a standardised protocol 
> that can be supported by a language server and an editor application.
> https://github.com/Microsoft/language-server-protocol
> 
> I know it’s Microsoft, but this is just a specification. With this protocol 
> one would write a Scheme server that receives instructions form the editor 
> via RPC and sends the result back to the server via RPC as well. This would 
> allow using the same Scheme server regardless of the editor (Emacs, Vim, 
> Neovim, Eclipse, …). I had wanted to write something like this for Neovim 
> myself, but I don’t know enough of Scheme yet.
> 
> I hope these ramblings of mine offer something useful from an outsider 
> perspective to you guys.
> 

I think one issue when you want to compare languages like Python to
Scheme is that these languages are dominated by a single implementation.
Python, Ruby, Go, Rust, Clojure, and many others have a single dominate
implementation. The compatibility of libraries isn't something devs
usually have to worry about (except for breaking changes in the language
like Python 2 to Python 3). I agree with how r5rs standard is pretty
limited, languages with multiple implementations tend to have pretty
large standards so that these implementations are somewhat compatible. I
am liking the direction of r7rs and I hope it will bring scheme
implementations closer together. Probably the other option for scheme
would be for everyone to get behind a single implementation like Chez
Scheme.

Of course that isn't the only thing needed to make Scheme or Guile more
popular. I believe a programming language needs a somewhat unique and
powerful library or framework, an awesome application to show off the
power of the language, good tooling, and some luck.

The language server protocol is pretty cool and I would like to see a
lisp implement it. An IDE for a lisp obviously needs to implement more
features to be useful, I believe being able to easily interact with a
REPL is one of those.

Re: How to make GNU Guile more successful

[Erik Edrosa]

On 03/05/2017 06:57 AM, Jan Wedekind wrote:
> According to Alan Kay's research, the future might be a lot of domain
> specific mini languages. I.e. languages tomorrow are going to be like
> libraries today. Guile supports custom languages which makes it future
> proof at least to some extent.
> 

I think I can see how domain specific mini languages might be the
future. You can look at what has happened in web development to see this
explosion of JavaScript transpilers, hoping to either extend or provide
new ways to design web applications.

> Myself, I am using Scheme because of it's unique metaprogramming
> facilities (Scheme macros) and GNU Guile because it has
> multiple-dispatch object oriented programming (unlike Racket). Also
> Guild's native interface with the Boehm Garbage Collector is quite easy
> to use.
> 
> 
> -- 
> Diese Nachricht wurde von meinem Android-Mobiltelefon mit K-9 Mail
> gesendet.

I started using GNU Guile after reading about rms, emacs, and GNU Guile
where GNU Guile would be used as a similar way to extend software. Then
I fell in love with scheme.

Re: How to make GNU Guile more successful

[Erik Edrosa]

On 03/05/2017 09:27 AM, Arne Babenhauserheide wrote:
> 
> Erik Edrosa  writes:
> 
>> I think one issue when you want to compare languages like Python to
>> Scheme is that these languages are dominated by a single
>> implementation.
> 
> I read this argument repeatedly, but it does not apply to C and C++, two
> of the most widely used languages. Therefore that argument might just
> interpret too much into a coincidence — or rather: into a situation
> which happens in the beginning of language development.
> 
> Even Java nowadays has several different implementations.
> 

C, C++, and Java have very large specifications and standards which are
meant to keep the various implementations as compatible as possible.
Although implementations do provide their own extensions and there is
issues between OSes. I agree this argument isn't too strong, but I see
it brought up once in awhile. One issue is it does fracture the
community a bit. If implementations have greater compatibility you see
developers use them in interesting ways. For example in Common Lisp,
I've heard some developers will use CCL in development because it
compiles faster and produces easier to debug code and use SBCL for
building releases because it produces faster code.


>> an awesome application to show off the
>> power of the language, good tooling, and some luck.
> 
> And zealots, never forget zealots. I’d dare to say that people, who
> believe that the language or tool is the best thing in existence and
> give lots of talks about it, are a far too easily underestimated factor
> in the success of any tool.
> 
> Best wishes,
> Arne
> 

I think we have many of those. ;)

- Erik

Re: Getting started web developpement with GNU Guile (with guile fibers) and BiwaScheme

[Erik Edrosa]

WASM is still pretty far off to be a full replacement of what JavaScript
currently does in the browser. It would be interesting to have a scheme
web front-end for Artanis, it will be like using Clojure for the
back-end and ClojureScript for the front-end.

On 05/08/2017 10:55 AM, Nala Ginrut wrote:
> I'm planning to add Scheme web front-end stuff to let Artanis do every web
> thing in Scheme.
> Is it too extremist ?  : -P
> But nowadays we have WASM, JavaScript is not needed as the high level
> language anymore.
> 
> 
> 
> 
> 2017年5月8日 20:53，"Amirouche" 写道：
> 
>>
>>
>> Le 06/05/2017 à 21:18, Nala Ginrut a écrit :
>>
>>> Oh I'd love to see someone write web front-end with Scheme. Good job !
>>>
>>>
>>>
>> I will see what new artanis will be out :)
>>
>> Tx!
>>
>>
>>> 2017年5月7日 02:47，"Amirouche" >> amirou...@hypermove.net>>写道：
>>>
>>> I made a screencast explaining how I would start building a poll
>>> application
>>> using by favorite tools of the moment.
>>>
>>> There GNU Guile in the backend using the new guile-fibers to run
>>> the http server
>>> workers.
>>>
>>> In the frontend I use BiwaScheme with snabbdom library for
>>> interacting with the
>>> browser.
>>>
>>> BiwaScheme is a Scheme interpreter written in JavaScript.
>>>
>>> Snabbdom is library that implement a diff+patch algorithm which
>>> allows to declare
>>> how the page will look and it make it happen. It also handles
>>> bindings events to
>>> callbacks. The use of snabbdom is bound to scheme and its use is
>>> transparent.
>>>
>>> The first video, I try to explain what tools I will use and sort
>>> of why. It's not
>>> very interesting https://youtu.be/i47QgE0ihSw
>>>
>>> The second video, I tackle an issue in forward.scm, basically I am
>>> bug hunting in
>>> the browser: https://youtu.be/to8vdri82_E
>>>
>>> The last is the most interesing, it restart where I left it in the
>>> previous video
>>> with basically a minimal frontend (so you might want to look at
>>> the 20 last minutes
>>> of the second video). Anyway, then it goes on to allow the
>>> frontend (client side)
>>> to communicate with the backend (server side) using HTTP:
>>> https://youtu.be/ePiHp1lgbas
>>>
>>> The code can be found @ https://framagit.org/a-guile-mind/azul
>>> 
>>>
>>> azul means "hello" in amazigh.
>>>
>>> Happy hacking!
>>>
>>> ~ amz3 ~ http://hyperdev.fr
>>>
>>>
>>>
>>>
>>

Re: Lessons learned building a small blog engine

[Erik Edrosa]

On 10/09/2017 03:17 PM, Amirouche Boubekki wrote:
> On 2017-10-09 21:14, Amirouche Boubekki wrote:
>> On 2017-10-09 13:36, Amirouche Boubekki wrote:
>>> Héllo all,
>>>
>>>
>>> Last week end I tried to build a blog engine.
>>>
>>>   git clone https://github.com/a-guile-mind/presence
>>>
>>
>> Now, accept to following challenge:
>>
>>    Try to add an article on http://presence.hyperdev.fr/
>>
>> Tips: For that you need to read the code.
>>
>> Happy hacking!
> 
> Another tips: You need to workaround at least two bugs.
> 
> Please post a mail on the mailing list if you succeed.
> 


Managed to add an article. The key is to look at the routes in the
scheme code and then sort of follow it. The bugs prevent you from easily
progressing but you can still proceed if you follow the routes. Thank
you Amirouche for the fun little challenge.

- Erik (OrangeShark)

Issues with GUILE_PROGS autoconf macro

[Erik Edrosa]

Hello Guilers,

I am using a recent version of the autoconf macros from guile.m4 and I
am having issues with the GUILE_PROGS macro to find the correct guile
and guile cli tools. The issue essentially involves how various
GNU/Linux distros install GNU Guile.

So on Fedora 26, I have guile 2.2 installed by GNU Guix and guile 2.0
installed by Fedora's package manager. Fedora installs GNU Guile as
guile as well as a symlink named guile2. guile-tools is installed as
guile-tools and a symlink named guile2-tools, guile-config is just
installed as guile-config, and finally guild is just installed as guild.
Now GNU Guile 2.2 is installed as guile by GNU Guix. Now when I just use
GUILE_PROGS with no argument, it tries to find guile 2.2 and thus goes
on by checking guile-2.2, guile2.2, guile-2, then it finally reaches
guile2, but that is of course guile 2.0 from Fedora and it fails the
minimum version check. Now if I put a minimum version for this macro

   GUILE_PROGS([2.0.14])

It will then proceed to check guile-2.0.14, it will go through the
checks and reach guile2, which passes the version check and then go on
to check for guild2, guile-config2, and guile-tools2 which do not exist.
The configure script still finishes but now those variables are not set
and might produce an error later in the build process if you need to use
these tools.

Now on Ubuntu 17.04, I only have guile 2.0 installed by Ubuntu's package
manager. So it is similar to Fedora, except it only provides a symlink
for guile as guile-2.0. It is basically the same issue as putting the
minimum version on Fedora, it will not find guild, guile-config, or
guile-tools.

I guess one of the real issues is how distros package GNU Guile, they
should provide symlinks to all of the guile cli tools (probably also fix
GUILE_PROGS to find naming like Fedora's guile2-tools?). For my own
builds, I can just use GNU Guix's pure environments to just use guile
2.2 or 2.0, but this can be an issue for users wanting to build and
install guile programs that use this macro. Another option is to go with
a slightly older version of guile.m4 which didn't have this issue.

Not really sure what is the best way to handle this, any ideas?

- Erik (OrangeShark)

What tools do you use with Guile?

[Erik Edrosa]

Hello everyone,

Something I have been wondering is what tools does the community use to
work on their GNU Guile projects?

What do you use to build your projects? Do you use autotools,
handwritten Makefiles, some other build system, or don't even use any
build tools?

How do you manage your software written in Guile? Do you use a package
manager like GNU Guix, use the build system to install packages, or just
copy files to your project directories?

What do you use to test your projects? srfi-64, guile-lib, or some other
library?

What text editor do you use? GNU Emacs, vim, or some other editor? What
extensions do you use for your editor?

Do you use other languages on Guile? Wisp, Lua, or some other language?

Any other tool worth mentioning?

Thanks,
Erik (OrangeShark)

Re: What tools do you use with Guile?

[Erik Edrosa]

Stefan Israelsson Tampe writes:

>> Do you use other languages on Guile
> prolog (guile-log)
>

Didn't know there was a prolog implementation, I will definitely check
this out.

[ANN] Guile-Git 0.1.0 released

[Erik Edrosa]

Hello everyone,

This is the first release of Guile-Git, GNU Guile bindings to
libgit2[0]. Guile-Git provides modules for interacting with git
repositories. Here is a small example program which clones guile-git
repo and prints some information:

(use-modules (git))

(define repo (clone "https://gitlab.com/guile-git/guile-git.git";
"/tmp/guile-git"))

(display (repository-directory repo))
(newline)

(let ((commit (commit-lookup repo (string->oid 
"92b5ad587351423cc64372d525946c8fdcf23467"
  (display (signature-name (commit-author commit)))
  (newline)
  (display (commit-message commit)))

It outputs:

    /tmp/guile-git/.git/
Erik Edrosa
build: Change version to 0.1.0

* configure.ac: Change version 0.1 to 0.1.0.


You may download Guile-Git's release tarball at:

https://gitlab.com/guile-git/guile-git/uploads/e8c218ac7ae77b745c44d1ffbe34f1dd/guile-git-0.1.0.tar.gz

The Guile-Git repository may be found at:
https://gitlab.com/guile-git/guile-git

Thanks to Amirouche Boubekki, Ludovic Courtès, Jelle Licht, and Mathieu
Othacehe for their contributions to this release.

Thanks,
Erik (OrangeShark)

[0]: https://libgit2.github.com/

[ANN] Guile-Git version 0.2.0 released

[Erik Edrosa]

Hello everyone,

Guile-Git version 0.2.0 has been released.

Guile-Git[0] is a GNU Guile library providing an API to create and
interact with git repositories by using libgit2[1].

Guile-Git is free software and is licensed under GPLv3+.

* Download

  Here is the release tarball:

https://gitlab.com/guile-git/guile-git/uploads/160f6a36c1be8d4fc1990a193081a04d/guile-git-0.2.0.tar.gz


* Changes in 0.2.0 (since 0.1.0)

** New Functionality

*** Add (git submodule) module

Add some initial bindings to libgit2's submodule functions. These
include ~git_submodule_name~, ~git_submodule_path~,
~git_submodule_owner~, ~git_submodule_head_id~,
~git_submodule_lookup~, ~git_submodule_init~, ~git_submodule_reload~,
~git_submodule_add_setup~, ~git_submodule_add_finalize~,
~git_submodule_add_to_index~, ~git_submodule_set_branch~, and
~git_submodule_update~.

** Bug fixes

*** Fix experience in REPL

When in the ~(git)~ module, you can use ~,use~ and ~,apropos~ in the
Guile REPL to get module and bindings in the module.

*** Correctly export ~repository-working-directory~

~(git repository)~ was exporting the incorrectly named
~repository-workdir~.


[0]: https://gitlab.com/guile-git/guile-git
[1]: https://libgit2.org/