Made a desktop file generator, would like some code suggestions

[ajusa]

Hello everyone!
I've been playing around with min the last few days, and decided to rewrite a small utility I had originally written in Nim. Unfortunately, the resulting min code feels pretty cumbersome/hard to reason about. I would appreciate any tips/tricks that I could use here, especially any that result in fewer variables being declared. It feels like I'm just missing some sort of core concept or symbol.

Anyway, here's the code!

(" " "\ " replace) :bash_escape
"template.desktop" fread :template
"$1/.local/share/applications/" ($HOME) =% :dir
(quote :n
 template n % :desktop
 dir "deskgen_$1.desktop" suffix n % :fn
 desktop fn fwrite
) :make_desktop
(
("test application" "https://github.com/")
)
(quote :n n last "xdg-open " prefix :re n re 1 set)
map 'make_desktop foreach
"$1/Videos/" ($HOME) =% ls 'dir? filter
(
    :n n filename :fn n bash_escape "celluloid " prefix @n
    (fn n) apply make_desktop
)
foreach

Where template.desktop looks like

[Desktop Entry]
Version=1.0
Encoding=UTF-8
Type=Application
Name=$1
Exec=$2

Thanks for taking a look!

[h3rald]

Well, let's start by saying that concatenative languages with postfix notation are hard to reason about, and I have been trying to make min more readable over the past few weeks/months.

While you could reduce the number of variable you declare, I believe that will make your program even harder to read 🙄

There's nothing wrong in your code, but admittedly it took me a bit to figure out what you were doing, even though it's pretty simple.

One of the problem could be that n is meant to be a quotation of two elements, but there's no way to understand that without knowing what the template file looks like.

Another problem is that it's often not straightforward to figure out how many values a symbol will use up from the stack.

Also, if I understand correctly you are also executing the program on an example quotation, instead I would have expected a parametrized quotation maybe built up from args.

You could try splitting the code in more operators to do different things.

Also the new operator symbol which allows you to specify a signature for your symbol definitions and also captures input/output values automatically, after validating them.

(
  symbol make_desktop
  (quot :n ==>)
  (
    template n % :desktop
    dir "deskgen_$1.desktop" suffix n % :fn
    desktop fn fwrite
  )
) ::
;; Creates a desktop file given a quotation containing App and Exec values.

Then you could also (although a bit of an overkill in this case but you get the point) define a typeclass to validate n as a quotation of two elements:

(:q ((q quotation?) (q size 2 ==)) &&) 'quot-2 typeclass

...which would let you write the signature of the previous operator like this:

(quot-2 :n ==>)

Not a huge help but still...

I have been trying to make programs more readable, and the answers seems to be splitting into more operators specifying also a signature, and ideally even making more use of type classes -- although actually all this actually increase the program complexity, variable allocation etc.

Any other ideas is welcome of course! Like you, I would like programs to be more readable without diverging too much from the concatenative paradigm... but the two things seem to be opposites 🤣

[h3rald]

Uhm some interesting ideas here!

The nth map function seem to be useful to solve a particular pattern... but I am wondering how often you'd use it, and how to call it 🤣

The func idea is actually pretty clever! I have been struggling to make min code easier to read without losing the concatenative feel of it but so far I managed to come up with variables and validates mostly to keep what goes on the stack under control, but this actually makes a lot of sense. As you say it's pretty easy to implement in min itself, so I'll try integrating it in my programs. As you said if you know what it does it makes code more readable, and you can keep on chaining without variables. Again, not sure about the name, that's the only thing. I like the fact that you can do whatever you want in that separate stack and still get only one value at the end. Acts as a sort of sink, in a way.

Now... about using define with quotations... that's possibly one of the things of min that I like the least.
Right, say you want to define an operator that does something to the stack. How do you do it (without using the operator keyword)? Easy:

(dup *) :square 

Right? So basically if there's a number on the stack and you push square on it, you get its value squared. Pretty straightforward.

Now save a quotation containing two strings to a variable... how do you do that? Well... you could do this:

("s1" "s2") :test

Right but what happens when you push it on the stack? Well... it gets dequoted like our square operator above, so you get "s1" and then "s2" on the stack... that's why you get the last value on the stack when you try to save a quotation using define.

That is actually one of the biggest sources of bugs in min 😞 because there's no way for the interpreter to know whether you want to define a new operator or a list of things.

That's currently solved using the quote-define operator and the corresponding sigil, which indeed quotes your quotation before saving it so that you get the original value when your symbol gets pushed on the stack:

("s1" "s2") =test

Now this works as intended and you get ("s1" "s2") on the stack when you push test.

This is one way to solve it, the other way that I was considering is to basically say that define is only used for saving values, and operator is used to create operators. I would have to change the meaning of define though, to make it "auto-quote" quotation values. The only drawback apart from breaking compatibility (gotta do it before 1.0.0) is that defining simple operators would get more verbose... unless of course you still use define, but then you dequote your quotation afterwards using dequote (->), which incidentally is what you should be using for "unpacking" tuples (and quotations in general).

Thoughts??

EDIT: Actually, using quote-define and quote-bind always is actually safer it turns out, as it double-quote quotations but not other values, so:

5 =test

Is the same as:

5 :test

Just gotta try using it more I guess. Still, maybe some changes would still be needed to make things easier.

[ajusa]

Yeah, nth map might be really specialized for my use case. I'll try implementing it in min and put it here once I've got it working.
The name "func" is just something I chose randomly. I would love for it to be a system sigil, since that would look a lot more readable than "func" being sprinkled everywhere. Thank you for explaining the quote thing though, that makes a lot of sense. I think that keeping a quote-define is probably fine, but it might be confusing for other people learning min.

What I would also like to have work with func is access to the last pushed variable on the stack, as a sort of input. Still not entirely sure how to do that, I think I'd need to quote and concat somehow?

[ajusa]

Example of mapn, to make it more clear. Maps over the nth element of a list of lists.

(:n :f (=e e n get f =new e new n set) map) :mapn
(("asdf" "asdf") ("test" "test")) ("I can " prefix) 1 mapn

Output is (("asdf" "I can asdf") ("test" "I can test"))

[h3rald]

Yup... mapn makes sense to manipulate quotations of quotations, I may add it to the seq module, I think it makes sense in certain situations.

For your apply-last thing yes, a quote and concat would do the trick but... other than making it "safer" by using its own stack, what would be the advantages of using it? Just remove the quotation and you'd have the same result, right? Just trying to figure out if we are missing something here...

[ajusa]

On second thought, I think that you are correct. The only advantage is slightly less typing potentially.
For example, I could do 5 (5 +) func to end up with only 10 on the stack, without any intermediates. The idea was that if you had an element already on the stack, you wouldn't have to repeat it within the quotation that is passed to func. Eg, if you had 2 2 * (5 +) func if the last element on the stack was passed in to the inner quotation, you could avoid having to do 2 2 * :n (n 5 +) func which is a bit more verbose. Again, this is all in the context of making sure that func acts like a sink, as you mentioned earlier. The goal is to not have any intermediate variables on the stack if you have a sequence of steps/transformations to perform.