mookid11

you might like diffr (https://github.com/mookid/diffr) (disclaimer: my project)

Matija Pretnar about the eff programming language and mathematical foundations for Effect Handlers.

I wrote diffr [0] for that purpose; it serves me well, especially if your team makes code with long lines.

In my opinion, a simple approach that does NOT make any parsing is more efficient (what about bugs in your parser? code with syntax errors? also, how fast would the parser be?)

[0]: https://github.com/mookid/diffr

Sort of related: as I never made diff-highlight work correctly on Windows, I wrote diffr[0] which goes a little bit behond what diff-highlight does.

[0]: https://github.com/mookid/diffr

The point is to share intermediate state of your data structure without headache.

For instance, if you write an interpreter, representing variable bindings with a functional map allows to reason about scope super easily; when you change scope, you just create a new map with the new variable bindings, and when the scope ends you just get back the map at the scope beginning which is still valid.

With a stateful hashtable, you need to undo the changes you did in you scope; the value of the table when opening the scope that you want to get back to is gone forever. Now it ties you program to a certain execution order. One way to see that is that if you want to collect environment to each scope in some data structure for some reason, you need to make deep copies everywhere.

> For example, you'd not get far in Rust without Result<>, Option<> or Future<> which are all make use of delayed resolution for their value.

Certainly not for Result<> or Option<>.

It depends if you enjoy NullPointerExceptions.

Unless experienced, you have no clue how a piece of code will be parsed. With ocaml, where is very little ambiguity; and indentation tools can take care of proper formatting, you only need to break lines.

And it can be pretty bad with haskell, which has complex semantics compared to, say, python.

With whitespace sensitive syntax, I feel like in the dark age of manual indentation.

> Haskell has some nice things going for it. Its syntax is cleaner than OCaml's, for example.

While I find the ocaml syntax very far from perfect, the whitespace sensitivity of Haskell makes it immediately worse. What a silly design.

To allow IEEE compliant float with tagged pointers.

However, note that floats are not boxed in the OCaml's arrays. Boxing floats is a pain because it makes the price of defining subroutines taking float arguments high.

Interesting how the author avoids to mention OCaml's (far from perfect, but still) object system.

I think this is the first time I see anyone like the OCaml syntax.

I think that you only need isearch + occur (M-s .), not ace-jump.

I tried ace-jump and have it configured for months, I never use it. neither do I use swiper, because it is too slow to start.

Also, don't forget C-M-{left, right, up, down} commands :)

> Yes, but hardly anybody uses that part of the language. We tend to stick with modules and variations over them.

You can have inheritance via polymorphic variants: see Garrigue's `Code reuse through polymorphic variants`.

You can use the ocaml toolchain (for instance: ocamllex and ocamlyacc) and stop writing ad hoc parsers.

I like: http://caml.inria.fr/pub/docs/oreilly-book

Real world ocaml is not so complete, and light on subjects such as C interop.