#emacs

(define-minor-mode mipc-ff-hline-mode "Toggle form feed hline mode. Form feed characters on their own lines are rendered as horizontal separators using font-lock-mode, approximately like so:

^L----------------------------------------------------------------------" :after-hook (progn (funcall (if mipc-ff-hline-mode #'font-lock-add-keywords #'font-lock-remove-keywords) nil (list mipc-ff-hline-keyword)) (font-lock-update)))

(defface mipc-ff-hline '((t :inherit escape-glyph :strike-through t :extend t)) "Face for horizontal line.")

(defconst mipc-ff-hline-keyword `(,(rx bol ?\C-l (group-n 1 ?\C-j)) 1 'mipc-ff-hline))

(define-globalized-minor-mode mipc-ff-hline-global-mode mipc-ff-hline-mode mipc-ff-hline-mode--turn-on)

I lied, I spent more time with F#.

While I was still struggling with omnisharp, FSAutocomplete seems to work pretty much perfectly out of the box! You do need to add the :AutomaticWorkspaceInit init option to get it working though.

I'm still torn on the keybinds for editing files. I feel like I would be much happier with evil mode enabled... navigating files with the emacs defaults still feels really clunky in comparison. It *probably* doesn't help that I still use vim bindings at work...

More coffee ☕ and some staring ....

#linuxadmin #linuxkernel #mailinglist #tool #emacs #notmuch #opensource

To start, you'll probably just drive the REPL directly. Open a file by doing something like this:

$ python3 Python 3.14.6 (main, Jun 15 2026, 11:36:54) [GCC 16.1.1 20260430] on linux Type "help", "copyright", "credits" or "license" for more information. >>> filename = "/etc/NEWS" >>> f = open(filename) >>> buffer = f.read()

Then add + remove text with string operations:

>>> buffer = "\n".join(buffer.splitlines()[1:]) >>> buffer = "Name=\"Foobar Linux\"\n" + buffer

Print to screen to check your work:

>>> print(buffer)

And save how you would expect:

>>> f.write(buffer)

This is pretty similar to the ed editing model. A little more verbose, but significantly more powerful, because this isn't an editor. It's a REPL. We can use regular expressions from re. We can use sqlite3 to interact with SQLite databases. We can use xml.sax to edit XML documents. tomllib for TOML files. And we can build whatever scaffolding we want around all of this.

A lot of text editing involves inserting and deleting text around a cursor. We can emulate this in our Python REPL workflow like this:

>>> point = 5 >>> print(buffer[:point] + "#" + buffer[point+1:]) Lorem ipsum dolor #it amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.>>> buffer = buffer[:point] + "some new text " + buffer[point:] >>> point += len("some new text ") >>> print(buffer[:point] + "#" + buffer[point+1:]) Lorem ipsum dolor some new text #it amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.

But that's a little tedious to write every time. Let's define some helper functions to do this for us, and place them in a file called "init.py" which we'll place at $PYTHONSTARTUP. Something like this:

def forward(amount = 1): global point return point_to_char(point + amount) def insert(s): global buffer, point set_buffer(buffer[:point] + s + buffer[point:]) return forward(len(s)) def fmt_buffer(): global buffer, point return buffer[:point] + "#" + buffer[point:] def print_buffer(): print(fmt_buffer()) # ...

As well as functions for "save", "load", "next_line", etc. Next time we start Python, it'll load our startup file and helper function definitions. This is still the REPL, we still have the whole standard library at our disposal, but now common editing functions are way easier.

>>> find_file("/etc/NEWS") >>> print_buffer() #ew in 0.9: First release. >>> insert("New in 1.0:\n\tsome new stuff\n") 28 >>> print_buffer() New in 1.0: some new stuff #ew in 0.9: First release. >>> backward(14) 14 >>> print_buffer() New in 1.0: s#me new stuff New in 0.9: First release. >>> backspace() 1 >>> insert("S") 14 >>> save() 56

But not as easy as they could be. Wouldn't it be nice if we redisplayed the buffer after every edit, so we don't need to run print_buffer every time? That would save a ton of typing.

class BufferDisplayer: def __str__(self): display_str = fmt_buffer() display_str += "\n================================\n" display_str += fmt_status() display_str += "\n\n>>> " return display_str

if __name__ == "__main__": sys.ps1 = BufferDisplayer() code.interact(None, None, local=globals())

That'll be a big help.

$ python harness.py Python 3.14.6 (main, Jun 15 2026, 11:36:54) [GCC 16.1.1 20260430] on linux Type "help", "copyright", "credits" or "license" for more information. (InteractiveConsole) # ================================ visiting: not visiting any file line: 1, char: 0 last write: 0

>>> find_file("/tmp/NEWS") 56 #ew in 1.0: Some new stuff New in 0.9: First release.

================================ visiting: /tmp/NEWS line: 1, char: 0 last write: 0

>>>

Nice! But we can do even better. What if we could modify the REPL to bind certain keys to certain commands? e.g. to run insert("A") we would just press Shift+A, or to backspace() we would just press Backspace.

This is surprisingly easy to do with curses:

We maintain access to a REPL with the functions _read_eval_or_call() (bound to F1), _read_exec() (bound to F2), and exec_buffer(); plus the "ans" and "err" stacks.

_read_eval_or_call() is mostly for "interactive" commands. If a function takes no parameters, or has default values for every parameter, the parentheses are optional, e.g. "F1 save".

_read_exec() is for arbitrary Python, and simply runs whatever you type into the prompt.

Both of these write to the ans[] and err[] stacks. If the function exits successfully, its return value is pushed onto ans[]. If it errors, the error is pushed onto err[]. This allows a rudimentary sort of copy and paste via "F1 point", *some cursor movement*, "F1 buffer[ans[0]:point]", and "F1 insert(ans[0])", as well as some more complex transformations.

Likewise, exec_buffer() can be used to evaluate the contents of whatever you're editing in order to write your own functions at runtime. For example:

Here we define a function type_blimpy() and bind it to F3. After an "F1 exec_buffer", this becomes immediately available to us.

We can use this power to edit files however we want. Infinitely configurable. As long as we write enough of the right primitives, we could write a function that converts all tabs in the current file to spaces, or one that runs the current buffer through an AWK program and writes the results to a temporary file, or we could add undo and redo by hooking set_buffer, or we could add syntax highlighting, or we could change bindings depending on what kind of file we're editing, or we could add the ability to have multiple buffers open, or we could add a terminal -- we could do anything, because the editor is designed to edit itself.

With enough work, this could become better than any IDE or text editor you've ever used, couldn't it? I mean, you can do anything if you're willing to write it.

GNU Emacs is this hypothetical REPL-first editor. It -- and its package ecosystem -- have been under continuous development since 1985, and it really can do anything.