@Thuna What's funny is I just looked at the documentation for string-join, and it even includes other functionality that I had implemented myself. It allowed me to delete an entire other function.
I mean, there's no reason to feel dirty calling `eval`. Writing code which generates and then evals new code is a long established and honourable #Lisp pattern. But equally, you don't need `eval` here.
All interned symbols can be found in a lookup table. This table is bound to the obarray symbol.
Hang on a minute...
I can only assume that the underlying C code has its own pointer to this table and the obarray symbol is only provided as a convenience for elisp functions that can't see this pointer? #emacs #lisp
No no, the obarray you see from elisp is the same one used by the reader. Elisp is an old-style Lisp here, and the obarray is a first-class thing: you can make a new one, rebind obarray, etc.
That's the sort of thing people don't do much anymore, but used to do. The documentation covers it reasonably well gnu.org/software/emacs/manual/…
That's awesome. I need to hear my own advice, of course, but don't be inhibited to share something that isn't finished. It's the Fediverse! We're all anarchists! The kind sort, I mean.
I'm finally MOOing from #Emacs. I've still got a bunch of work to do to port my customizations over from my old client, but it's Emacs... I'm sure it can do that. #LambdaMOO #moo #mud
I am dangerously close to unleashing my first #emacs package on the public. It's nothing fancy and still relatively niche, but I deem it potentially useful enough to be worth publishing.
There are a couple small features I want to add and a few things that still need some polish, but it's almost ready for a version 0.1 release.
It's not anything ground breaking or anything. I'm still pretty much an #elisp novice, but I'm proud of it anyway.
@Álvaro R. At this point all I need to add is a README and two features (which will mostly reuse code I've already written just in a slightly different way).
Surprisingly enough, the hardest part of the whole project was getting it to display numbers with thousands separators. That code might exist in the bowels of the calc package, but it was easier to just roll my own.
Okay, my first #Emacs package is officially released. It was strongly inspired by @Soroban Exam Website's work, providing practice tools for the #soroban. This is the first Emacs package I've ever released. It's probably not perfect, but I welcome feedback on how it can be improved.
I wonder if there is an overlap of more than say five people who are both soroban and emacs users. 🙃
@Soroban Exam Website Might as well. I wrote it mainly for myself, partly because I don't own a printer and this makes it easier to practice when working from a computer screen, but also just to see if I could.
Still, if someone else is going to find it useful, that's probably the place I'll find them.
@Soroban Exam Website Yeah, that's what I'd been using. I just wanted sonething that worked offline. It's also got some tweaks that make it easier to see what line I'm on when doing additions since I can't slide my soroban over the page.
Another #elisp question: Why does #Emacs have separate bits for the meta key (2**27) and alt (2**22)? Aren't they the same key, or is it a remapping thing like the ESC prefix?
@donaldh Yeah, I get that, but when emacs says I need to use the meta key, it's actually alt that I use. I'm guessing this is a remapping because most modern keyboards don't actually have an alt key, in much the same way you can use escape if you don't have an alt key?
not sure but IIRC the lisp machine keyboard distinguishes various special keys like ALT, META, HYPER etc. So on a modern machine they aren't distinguished, but in an alternate computing history we would have these modifiers on our keyboard and could map them differently.
Meta and ALT are not the same key. The original keyboards used long ago had Ctrl, Super, Hyper, Meta, and ALT keys. We now map Meta (i.e. ESC) to the Alt key on our keyboards as a convenience. I do not believe there is a way, on modern keyboards, to have both META and ALT mapped to a key. We can have Super, and Meta. I can't recall if I was able to map Hyper on a modern keyboard.
I've been playing around with keymaps. Apparently they can be used to create menus that give the user a visual list of options. The canonical way to make them is aparently with make-sparse-keymap to create the menu and define-key to add options to it, but this causes some confusing behaviour.
Take the following example:
(let ((menu (make-sparse-keymap "My menu")))
(define-key menu "a"
'(menu-item "Foo" foo))
(define-key menu "b"
'(menu-item "Bar" bar))
menu)
Each new entry is added to the top of the list, so when the menu is displayed, they're listed in reverse order. This is very counter intuitive.
Now, I understand that the nature of lists in lisp make inserting an element at the top of the list less computationally expensive, but when you've already got to walk the whole list anyway to ensure the key binding isn't already present, this no longer feels like an adequate excuse.
I'm confused as to what you're trying to achieve. If it's for popup options you can look at 'transient' or 'hydra'. If it's for a keymap then 'defvar-keymap'
@Robert Pluim 🇪🇺 Yeah, it is for a keymap. I just want a menu on the screen to display what key corresponds to what option. I'm guessing defvar-keymap is worth investigating.
@Robert Pluim 🇪🇺 I seem not to have function definitions for either defvar-keymap or which-key. I'm using Emacs 28.2 (as found in the Debian 12 repositories).
I think you've got it right. Many who write lisp think of adding to the head of the list as normal, even if they still have to walk it for things like uniqueness checks.
I virtually never set custom keybindings in #Emacs preferring instead to rely on M-x function calls because I had such a hard time finding key sequences that weren't used by something else. Since learning that C-c /[A-Za-z]/ is reserved for user-defined keybindings, I've gone mad with power.
@rpluim no way. I'm actually super curious what you use repeat for that isn't accidental when trying to undo something after coming from typing in a browser or something
@Lens @Robert Pluim 🇪🇺 On my system C-z suspends Emacs and drops me back to the terminal until I issue the fg command to bring it back. I use this for issuing git commands. I could probably do this from within Emacs, but I haven't bothered to figure it out.
@lens_r magit is awesome, but it's not part of standard Emacs. VC is, but that's not as good as magit for git (it's great however when you're forced to use some other version control system like CVS, since VC provides bindings that work whatever the underlying system is)
@Zenie That's an option, but my concern is that the reason they might be vague in the docs is because the specific error might change in future versions.
It's lisp. Stuff doesn't change that much. Usually errors are obvious and for very specific reasons. You can just catch them and print the message so if anything does change you will know. I don't think it's worth worrying about.
Long-winded post about Emacs and gripe about modern computing
I think I've been able to pin down what it is that I like about #Emacs so much. When I first started using computers, I was using a TRS-80. If you didn't have a cartridge inserted, It'd boot directly into BASIC where you could program the machine directly. That wasn't a bug, it was a feature.
Modern computing seems to do its best to hide all that stuff away. Everything is treated more like a simple (albeit specialized) appliance, not a powerful machine that can be made to do literally anything you want. Instead, it's about what the various software vendors want it to do.
Emacs by contrast not only gives you all the tools you need to modify it in any way you want, but actively encourages you to do so. It feels a lot more like the computing systems of old. Perhaps that's not for everyone. There's a reason computers were so niche back in the early days. Most people just didn't care to learn what was going on under the hood, and that's valid. There's something to be said for a tool that just works effortlessly out of the box. Also, to be clear, you don't strictly speaking need to dig into the internals to use Emacs, but I prefer for my technology to serve me, and I'm willing to put the effort in to make that happen.
Long-winded post about Emacs and gripe about modern computing
Sensitive content
❤️ Yessss! The ability to make the computer do tasks specific to *you* has always been what separates users from "power users". And being able to write the simplest loop in any language is a *super* power.
(I do the Vim calling out to external tools thing and I like it, but I have always harbored a certain amount of jealousy for Emacs.)
Long-winded post about Emacs and gripe about modern computing
@ratfactor I don't know enough about vim to really make a fair comparison. I used it in the late 90s to early 00s, but then I was working a job that was made easier by some custom elisp scripts. Then it was just the editor I became comfortable with.
Maybe I could've done it in vim, but it was just where I happened to land.
Long-winded post about Emacs and gripe about modern computing
Sensitive content
I got heavy into Vimscript long enough to know that it's the worst thing I've ever used. Now I have Vim call out to Bash or Ruby scripts to process text...But you can't modify how Vim actually works that way. Emacs is way better for making true in-editor functionality. I just never was able to get the hang of it as an editor.
• (eepitch-shell) cd foo tar xvf testpackage-0-0.tar • (add-to-list 'load-path "~/foo/testpackage-0.0") • (load "testpackage") • (apropos "testpackage") => testpackage-func is an interactive Lisp function in ‘testpackage.el’.
Ah, yeah, I thought a little bit more and you weren't actually saying I-want-to-load-this-file. I guess the concept of a package in emacs lisp does not resemble common lisp at all. I.e. a symbol doesn't have a package like a lisp symbol does. Packaging refers to packaging e.g. a mode for distribution, right? At which point I think we would refer to e.g. melpa github.com/melpa/melpa?tab=rea… about what melpa wants you to do. That's my 25 cents anyway. @sacha
i think -pkg files are possibly outdated or else rarely used (i have never used mastodon.el's, it is just there, possibly stale code). your testpackage doesn't seem to have enough juice in it to be a package, normally it'd have a provide statement at end, and in that file, there is possibly not enough in your file headers. try `auto-insert` to insert a file header will some details, or look at some existing Emacs packages (their main files). eg codeberg.org/martianh/mastodon…. or perhaps read up on the docs about writing a package, regardless of multi files or not? (these are my random ideas after looking at your files.) (+ re your first comment, docs may well be lies. i learned about multi files pkgs (after accidentally inheriting one) only by looking at existing ones that i actually use and asking folks when stuck.)
If we look at Xahlee's site here: xahlee.info/emacs/emacs/elisp_… he notes that "The terms “Package” and “Library” do not have technical meaning in elisp.
The term “module” is not used by emacs."
} really, we are concerned with writing modes for emacs. Packaging them for distribution means meeting the package-source's requirements for the mode to be built and then distributed from a git, e.g.. That is my other 25 cents ;p.
This is different to #commonLisp in which I might CL-USER> (uiop:define-package foo) #<"FOO" package> CL-USER> (in-package foo) #<"FOO" package> FOO> (defvar bar) BAR FOO> (export 'bar) T
} this is not an emacs idiom. Similarly, common lisp does not have a notion of interaction major and minor modes like emacs does. I guess package in emacs means something similar to system in the de facto asdf sense in common lisp. In my opinion this collision is confusing.
it feels like you're manually creating a .tar like what would be in an ELPA, but you can submit things to NonGNU ELPA or MELPA as a recipe, which can include your .texi manual if you want. github.com/melpa/melpa/blob/ma…emacsredux.com/blog/2021/08/11… . Before inclusion in one of those repos, people can also install it manually or with use-package :vc or package-vc-install: gnu.org/software/emacs/manual/…
Recently I wrote an article about NonGNU ELPA and I promised to check for myself how easy it is to submit a new package there. I made good on my promise and in this article I’ll briefly describe the process.
@Sacha Chua @screwlisp Yeah, that's essentially what I'm trying to do. My eventual goal is to create my own semi-private ELPA archive, mostly because I don't want to bother people with having to review my probably terrible novice code before including it in their archives. 🙃
None of this code is really ready for public consumption yet. It's more of a learning exercise.
I picked a trivial multifile package example, seq: Tree: gitweb.git.savannah.gnu.org/gi… A package of three files, seq.el, seq-24.el and seq-25.el, and if you are in emacs 25 or later, seq.el requires seq-25 or seq-24 otherwise. Presumably your multi-file elisp project should meaningfully resemble seq e.g. with the conventional package headers.
Yes, you don't write that stuff. []. You just write your major/minor modes as normal, and your headers provide metadata that is used by package sources to generate the package tars. @sacha
as we can see in > (directory "~/.emacs.d/elpa/seq-2.24/*.*") (#P"~/.emacs.d/elpa/seq-2.24/seq.elc" #P"~/.emacs.d/elpa/seq-2.24/seq-25.elc" #P"~/.emacs.d/elpa/seq-2.24/seq-24.elc" #P"~/.emacs.d/elpa/seq-2.24/seq-autoloads.el" #P"~/.emacs.d/elpa/seq-2.24/seq-25.el" #P"~/.emacs.d/elpa/seq-2.24/seq-pkg.el" #P"~/.emacs.d/elpa/seq-2.24/seq.el" #P"~/.emacs.d/elpa/seq-2.24/seq-24.el") if you will forgive some of the-other-lisp ;p @sacha
@screwlisp @Sacha Chua What I'm curious about is how it made the determination that seq.el was the main file. This is fairly obvious with my human intuition. Was it just because all the other .el files started with seq-, or was it doing something more fancy by looking at the contents of the files and seeing what requited what?
Edit: Ah, I bet it has to do with the fact that only seq.el had ;; Package: and ;; Version: lines, which explicitly set the package name (and version).
I thought maybe it needed to be in some GNU variant of the tar format for Emacs to be able to read it, but when I just open the tar file directly in Emacs I get a directory listing and can read all the files, so that's not it.
You could try package-build-create-recipe It will need to be filled in, but if your headers are correct, with author, packages-required, version, etc.
Edit the recipe for your git. You'll be in recipe mode. Saving it puts it in .../elpa/recipes/ Building it with C-c C-c will make a package and install it in your elpa..
That might teach you what you need.
It will automatically pick up .el and .texi files. Not eld, but if you have some odd file, you can add the pattern to the recipe. I have an eld which is not in the list of automatic files.
EDIT: The solution was simple but "bonus points" for anyone that can explain why my method didn't work.
ORIG:
I would like an org-mode-custom-command to display an agenda which is only made from the
I am using many different org mode files for various projects, and I rev them by adding the date to the filename eg filename-2020-09-17.org. I realize I could use version control but in this case t...
"If the current buffer is in Org mode and visiting a file, you can also first press ‘<’ once to indicate that the agenda should be temporarily (until the next use of ‘SPC o a’) restricted to the current file. Pressing ‘<’ twice means to restrict to the current subtree or region (if active). "
In other words, execute org-agenda then press "<" before the command you want to run against the agenda.
So, I've been using nov.el for #emacs to read epubs. It does a pretty decent job of it, but I have one point of irritation: I can't for the life of me find a way to tell how far through the book I am. Is there some way to see this?
I use it! It shows a % figure on the bottom line, but it does it only if I maximize past the 80 columns (in other words, it doesn't appear on my VT terminal!).
@मोक्ष / untrusem ⁂ This package appears to render documents using SVG output. Considering that I spend 95% of my time in the terminal, this would likely be a deal-breaker for me unfortunately. 🙁
@Zenie The mode line shows the position in the current buffer. The buffer displays the current chapter. Thus, it shows your position in the current chapter, not the book overall.
@Zenie The feature might actually exist for all I know, so I hesitate to put in a feature request. I was just hoping that it was an already solved problem.
I glanced at the code. But I'm not at my usual computer so I can't look at help, the mode or the code more thoroughly. I only just installed it recently so don't know it well.
Just spent a good half hour pulling my hair out trying to figure out why one of the #elisp functions I had just written was always returning nil when I tested it. Turns out, my test was mistakenly passing its inputs to the wrong (but similarly named) function (pivot-table-get-columns instead of pivot-table-get-body).
It sounds like the sort of thing a more type-ful Lisp implementation would have detected too. I bet SBCL would have have given you a compiler note warning of an analogous problem, for example.
C's type system would also have caught it, and it isn't worth a hill of beans.
By caught it what do we mean? This is not a case of some undetected error escaping your attention due to dynamic typing. You know you got a nil which is unexpected and wrong. It's in a test case which catches it.
The only thing a type system would change is that you would instead waste a half hour not understanding how your obviously correct function call can possibly have the wrong return type.
I have a function, pivot-table-get-columns (shorthanded as pt-get-columns). Its job is to take an #OrgMode table and produce an alist of mappings of column names to column numbers. The column names are as defined by section 3.5.10 of the org-mode manual.
Edit: I've been beating my head against a wall for some time on this getting nowhere and less than a minute after asking this, I see it. My first unless should be a when. I'll fix it later.
what does org table source look like by the way? I normally pass org tables into org source blocks (where they become s-expressions in lisp), but I'm not sure what the tables look like internally to org.
further about eq in common lisp at least, I've seen people make a mistake before- when you compile code, if you referred to "" twice, in common lisp compilers are allowed to coalesce them at which point they /will/ be eq. (Eq would be a good test to see if they /had/ been coalesced). But in the general case two strings entered in different places are not eq.
@screwlisp I've not seen the comma prefix used outside a macro before. Also, this would probably be better written as: (push (cons (format "%s" cell) n) result)
it is very exciting! commas have to appear inside backticks, and backticks are just quotes that can have certain things inside of them unquoted (using a comma).
Macros to a large extent work like this because one principle of lisp is that lisp code be regular lisp sequences. At read time, the function names are just symbols. So it's a list of symbols/atoms and lists.
However, sometimes we /do/ want to run some code, hence backtick and comma/unquote.
Backquote forms are merely list (S-expression) constructors where some pieces are constant and some pieces are evaluated. (The latter are marked with commas.) Such forms can be used anywhere. Obviously they are often used in macros, because macro functions construct lists (S-expressions).
I often write `(,foo ,bar) instead of (list foo bar) because the former seems clearer, especially when the structure is more involved.
#cfw got an org-table import/export functionality. Just select the org-table and run M-x cfw-org-load. Analyse, sort, edit, filter your table in CFW. Then update the original org-table by M-x cfw-org-save.
If there was no original org-table (the table was created from scratch or from other source like CSV), the cfw-org-save places the exported table into the kill-ring. This way org pivottables can be generated from CFW.
The seemingly canonical way of detecting whether the C-u modifier was used on an interactive function call (when an actual numerical argument wasn't provided) in #elisp feels... icky. #emacs
Wrapping my brain around using #org-mode as a spreadsheet. Is there a way to pass a range of cells as a vector to a custom function? Ideally, I'd like to embed this function into the file itself. #emacs
That shows you how to define a column formula with elisp. I think think usual "vsum" and friends are vector operations from the emacs calculator, so it seems very likely?
I gotta go to the bike shop, but my heuristic would be:
1. I know vsum works in org-mode spreadsheet formulas 2. I know the v stands for "vector" 3. Can I use that function's source to define my own vector operations?
I like to think the answer is YES. I am hopeful at least.
@Shae Erisson So, of appears that I can pass simple (single cell) references into raw elisp functions, but not ranges. I'll have to have a closer look at vsum as mentioned earlier to see if there's a solution there.
Hi @me If you insert a formula in a table cell #orgmode will put it after the table in a special line (so you can see and edit it after) and insert the result in place. Of course, it can be recalculated anytime you want to.
I guess you could fairly easily write a macro that automatically created a lexical scope and added some prefixes to variable used within its body - Doug Hoyte's "Let over lambda" book has #CommonLisp examples of this kind of approach as way to cut down the syntactic overhead of using gensym in macros. Without much thought, I'd assume something similar could be done in #EmacsLisp
@The ol' tealeg 🐡 I'm thinking something a little more robust involving using a symbol's property list to store everything contained within that namespace.
I'm probably biting off more than I can chew at this point in my understanding of elisp, but I'm sure this idea will stick around in my brain until I have enough of an understanding to pull it (or something comparable) off.
...or I find some already existing thing that does what I want (which is more likely).
SBCL, for example, has the in-package macro set the value of the special variable *PACKAGE* which, I guess, would then ultimately get used in every definition and reference.
I haven't having looked at it, but I imagine that it mostly comes down to switching out in-buffer eval functions to those which are current-package aware. If you resolve and swap out all symbols with their "absolute" versions during definition, you should be able to call that code from different namespaces without problems.
where (:use nil) serves the same purpose as (:use :cl) in Common Lisp.
Afterwards, you can either do
(in-namespace :foo) ...
or
(with-namespace :foo ...)
You should also be able to file-locally set `buffer-namespace', but I haven't tried it.
Here's a working snippet:
(define-namespace :foo (:use nil) (:export bar setq nil))
(define-namespace :baz (:use :foo) (:export bar))
(with-namespace :foo (setq foo 2))
foo:bar ;; => 2
(with-namespace :baz (setq bar 5) (setq quux 10))
foo:bar ;; => 5 baz:bar ;; => 5 baz:quux ;; => 10
although you'll need to patch elisp--preceding-sexp for C-x C-e to see the individual values. Here's the code you need to evaluate (at least on my version, I suggest trying this in a fresh emacs in case something goes wrong): 0x0.st/84sj.txt
I have fleshed it out more (or rather, ported over CL's packages): git.sr.ht/~thuna/cl-package (this is still the same repo, but I've changed the name).
The demo is: - require cl-package / load cl-package.el - require cl-package-reader / load cl-package-reader.el - go to a new buffer (or the scratch buffer) - M-x cl-package-activate-reader RET - Insert the snippet - Do eval-buffer, or after applying the same patch as before (replace `(read...)' with `(funcall load-read-function...)' in `elisp--preceding-sexp') go through each form (you can skip cl-in-package) one by one with C-x C-e - Have fun
The snippet is:
(cl-defpackage test (:use :global) (:shadow baz) (:export baz))
Where the second nil means that no symbol with the literal name "test:baz" exists in emacs, and that the symbol we're referring to with test:baz is something else entirely, which you can also see with:
(eq (intern "test:baz") 'test:baz) => nil
There are probably a lot of problems, some of which are: - defpackage does not play nice with redefinitions (or rather, you can't do it at all), just pop cl-package-registry (but not completely, always leave the last item, if you want to fully reset it set it to (list obarray)) and redefine it again - I have the elisp runtime in the pseudo-package :global, but trying to use :global in your own package will force it to check all (tens of thousands of!) symbols for conflicts, so it'll take a couple seconds during the defpackage in the snippet. I will later define packages containing the various elisp packages for proper modularity, so it should get better - Once you evaluate cl-in-package, eval-buffer starts with cl-in-package, which it probably shouldn't be doing, but I don't know and who knows how many more!
@screwtape Oh come on you understand the situation perfectly ;) You can write hacks to make it look like there are namespaces, but at the end of the day, they are just hacks.
There has been multiple discussions about it on emacs-devel, and there is no way to get elisp out of the dark ages until the usual suspects are replaced. Which is not happening any time soon.
@screwlisp @Nicolas Martyanoff If you think I'd actually have anything interesting to say. I feel I can't really hold a candle to some of your previous guests. I'm just aimlessly noodling around with stuff.
You know I like to set an extremely low bar for quality personally. And after all, everyone eats at your sushi place every week...!
It's also interesting to everyone to get opinions on common lisp from the outside or somewhat recent arrivals. I think you and jeremy_list are both interesting as sort of Haskell/MOO/emacs/common lispers.
Counterpointing the "golang for serious business" long-time lisp-heads like @galdor
I have successfully built my first #Emacs package. I want to clean it up a bit before I consider releasing it though. Also, while I can build a simple (single file) package, buildig a multi-file one is still eluding me.
When I try to install it, I get the following (less than helpful) error message: Wrong type argument: stringp, nil
Is there a way I can get more detail on why this is failing?
If you use M-x toggle-debug-on-error, you should get a full stack trace showing what was called, with what value and from where. That should at least get you started.
So getting a stack trace doesn't seem to have provided any useful additional information, but I have a potential starting point. When I look at the auto-generated *-pkg.el file from the installed single file version, I notice that there are some additional parameters passed to define-package that were not mentioned in the elisp documentation.
To demonstrate that I'm not crazy, this is from section 42.3 of the elisp manual: Function: define-package name version &optional docstring requirements
This is from the documentation for define-package: (define-package NAME-STRING VERSION-STRING &optional DOCSTRING REQUIREMENTS &rest EXTRA-PROPERTIES)
I've been an #Emacs user for like 20 years because there was one thing I needed to do back then that was made easier by elisp, and I just got used to using it. In all that time, I hardly ever tinkered much with the config, save a few minor tweaks it was pretty much stock. I had no strong feelings about Emacs in general, it was just the text editor I'd grown comfortable with.
I've recently been diving into #Lisp and poking around with my Emacs config, and after all these years, I think I'm starting to get the appeal. I am still a proponent of "use the tool that works for you", but I'm personally firmly on team Emacs now.
I'd been told that there were add-ons that could do things like making vim more Emacs-like, but I never saw the point in spending energy to make some arbitrary tool more like the one I was already using for no particular reason.
Is there a way to tell #Emacs #org-mode to omit yhe TOC and headline numbers when exporting to a text or markdown file? I'm trying to implement a #JohnnyDecimal system, so I'm supplying my own numbers and the 00.00-index.org file essentially is the table of contents.
Edit: Because not all replies federate, here's the solution I ended up with:
Sorry I don't have an answer. Nonetheless as an Emacs user (albeit only rarely in org-mode) I'll be interested in the responses you get. Cheers, -Randy
wwolf
in reply to Jonathan Lamothe • • •Sensitive content
try `apply`:
(apply 'concat (my-function arg1 arg2))
Jonathan Lamothe
in reply to wwolf • •@wwolf Ohh... that feels much safer.
Thanks!
hajovonta
in reply to Jonathan Lamothe • • •Sensitive content
(concat . (my-function arg1 arg2))
is really:
(concat my-function arg1 arg2)
Try to visualize the cons cells (and re-read how Lisp represents lists as cons cells) to understand why.
So this is actually correct.
Jonathan Lamothe
in reply to hajovonta • •@hajovonta Yup. Got my answer.
I had figured out why it wasn't working. I was just unaware of the existence of the
applyfunction, which turned out to be exactly what I needed.Thuna
in reply to Jonathan Lamothe • • •Sensitive content
Jonathan Lamothe
in reply to Thuna • •@Thuna ...and this is why I wish I could search for functions by type signature like in Haskell. 😛
I find myself reinventing the wheel oftentimes simply because I didn't know the function I wanted already existed.
Jonathan Lamothe
in reply to Jonathan Lamothe • •string-join, and it even includes other functionality that I had implemented myself. It allowed me to delete an entire other function.tusharhero
in reply to Jonathan Lamothe • • •Sensitive content
Jonathan Lamothe
in reply to tusharhero • •dolistloop.Simon Brooke
in reply to Jonathan Lamothe • • •Sensitive content
Why not just
`(apply my-function (list arg1 arg2))`
I mean, there's no reason to feel dirty calling `eval`. Writing code which generates and then evals new code is a long established and honourable #Lisp pattern. But equally, you don't need `eval` here.
Jonathan Lamothe
in reply to Simon Brooke • •@Simon Brooke What I was looking to do was to call
concatwith the list returned by(my-function arg1 arg2)used as arguments.As it turns out, all the functionality I was looking for was already supplied by the
string-joinfunction. I just didn't know it existed.Jonathan Lamothe
in reply to Simon Brooke • •Greg A. Woods
in reply to Jonathan Lamothe • • •evalway, but I'm no expert.