Re: using guile like a awk filter in a C program.

[Basile Starynkevitch]

Hello Pierre,

(if you reply privately, feel free to reply in French, we both are French)

You definitely could use libguile in your C program. Since Guile has a 
conservative garbage collector, and assuming your program is 
single-threaded, this should be reasonably easy. If your C program needs 
to be multi-threaded (with each thread doing garbage collection or GUILE 
object allocation) it would be probably a lot harder. If you need the 
full power of Scheme call/cc primitive (traversing C primitives and a 
mixed C/Scheme call stack) you could be in trouble.


You probably know about the Bigloo implementation of Guile (compiling to 
C) by Manuel Serrano https://github.com/manuel-serrano/bigloo (I don't 
know if it fits better your need, but that code is very well written and 
robust)

BTW, my pet open source project is 
https://github.com/RefPerSys/RefPerSys/ "REFlexive PERsistent SYStem" - 
it is not Guile, but provide orthogonal persistence (in JSON files), is 
GPLv3+ licensed, coded mostly in C++ for Linux, has a precise garbage 
collector (with some moving/copying of simple immutable data), a 
multi-threaded agenda mechanism. It is work in progress (aiming to 
become some open source inference engine). We are seeking some ITEA or 
ANR or HorizonEurope interested by this open source (or even informal 
students contributing to it).

On 5/10/24 15:55, Pierre LINDENBAUM wrote:
> Hi all,
>
> I tried to learn guile a few years ago with a side project that went 
> nowhere.
>
> I'm now back with guile that I would like to use as a filter, just 
> like awk, for my data.
> I've got question about the general design of such program.
>
> My program uses a C library ( https://github.com/samtools/htslib ) 
> scanning mutations/variants in large VCF files ( 
> https://en.wikipedia.org/wiki/Variant_Call_Format ).
>
> A typical C program looks like (pseudo code) ;
>
>     ```
>     header = read_header(input);
>     variant = new_variant();
>     while(read_variant(input,header,variant)) {
>         do_something(header,variant)
>         }
>     dispose_variant(variant)
>     dispose_header(header)
>     ```
>
> I would like to use guile to filter VCF using a custom user GUILE 
> expression/program . So my program would now look like
>
>     ```
>     header = read_header(input);
>     guile_context = my_initialize_guile(header, argc_argv_user_script)
>     variant = new_variant();
>     while(read_variant(input,header,variant)) {
>         if(!my_guile_test(guile_context,header,variant)) {
>             continue;
>             }
>         do_something(header,variant)
>         }
>     dispose_variant(variant)
>     my_dispose_guile(guile_context)
>     dispose_header(header)
>     ```
>
> and would may be be invoked like:
>
> ```
> ./a.out -e '(and (variant-is-snp? ) (equals? (variant-allele-count) 
> 2))' input.vcf > output.vcf
> ```
>
> where `variant-is-snp` would test if the current variant in the 
> 'while' loop is a 'single nucleotide polylmorphism' using `bcf_is_snp` 
> https://github.com/samtools/htslib/blob/develop/htslib/vcf.h#L889
>
>
> So my questions are:
>
> - is it possible to use guile for such task ? More precisely, can I 
> compile the guile script just once in `my_initialize_guile` and use it 
> in the while loop without having to recompile it.


Yes, by using scm_boot_guile and most importantly the internal functions 
it is calling. It is worth studying the source code of GNU guile.

> - furthermore, what's the best practice to include the user's script 
> in a larger script that would include the definitions of 
> `variant-is-snp?` , `variant-allele-count`, etc...
> - is there any implementation that works like this (something like a 
> AWK script in guile) ?
> - is there any way to make the program stateless ? I mean, any 
> invocation of `my_guile_test` would erase the definition of the 
> previous variant


Probably by having some Guile global variable. You want to read also 
https://www.gnu.org/software/guile/manual/html_node/Foreign-Object-Memory-Management.html

> Thanks for your answers,

Regards.

--
Basile Starynkevitch             <basile@starynkevitch.net>
(only mine opinions / les opinions sont miennes uniquement)
8 rue de la Faïencerie, 92340 Bourg-la-Reine, France
web page: starynkevitch.net/Basile/
See/voir:   https://github.com/RefPerSys/RefPerSys