oessessnex @ oessessnex @programming.dev

Posts

0

Comments

47

Joined

2 yr. ago

The way you can think of it is that in OCaml everything is implicitly wrapped in an IO monad. In Haskell the IO monad is explicit, so if a function returns something in IO you know it can perform input and output, in OCaml there is no way to tell just from the types. That means that in Haskell the code naturally stratifies into a part that does input and output and a pure core. In OCaml you can do the same thing, however it needs to be a conscious design decision.

The implementations mostly don't matter. The only thing that you need to get right are the interfaces.

XKB config files work under sway without XWayland.

Well, most people installing Arch for the first time have no idea what a typical Linux install does under the hood. That makes it a worthwhile learning experience. The same commands you use during the setup you can later use to fix or change things. It basically forces you to become a somewhat proficient Linux user.

On a phone with spyware installed that wouldn't do anything. There are probably ways to get rid of it, but how can you be sure?

Nope. Monads enable you to redefine how statements work.

Let's say you have a program and use an Error[T] data type which can either be Ok {Value: T} or Error:

    
var a = new Ok {Value = 1};
var b = foo();
return new Ok {Value = (a + b)};

  

Each statement has the following form:

    
var a = expr;
rest


  

You first evaluate the "expr" part and bind/store the result in variable a, and evaluate the "rest" of the program.

You could represent the same thing using an anonymous function you evaluate right away:

    
(a => rest)(expr);

  

In a normal statement you just pass the result of "expr" to the function directly. The monad allows you to redefine that part.

You instead write:

    
bind((a => rest), expr);


  

Here "bind" redefines how the result of expr is passed to the anonymous function.

If you implement bind as:

    
B bind(Func[A, B] f, A result_expr) {
   return f(result_expr);
}


  

Then you get normal statements.

If you implement bind as:

    
Error[B] bind(Func[A, Error[B]] f, Error[A] result_expr) {
   switch (result_expr) {
       case Ok { Value: var a}:
           return f(a);
       case Error:
           return Error;
   }
}


  

You get statements with error handling.

So in an above example if the result of foo() is Error, the result of the statement is Error and the rest of the program is not evaluated. Otherwise, if the result of foo() is Ok {Value = 3}, you pass 3 to the rest of the program and you get a final result Ok {Value = 4}.

So the whole idea is that you hide the if Error part by redefining how the statements are interpreted.

You can probably replace it with ImageMagick.

Some people consider working on programming languages fun, so they create new ones.

I usually kill them with my phone with the screen turned on (the background needs to be blueish and the room needs to be completely dark). For some reason they don't see it, they just sit there until they get squashed.

This doesn't work for tiger mosquitoes.

I randomly generated mine using a Markov model. It's just pronounceable nonsense.

Turn JavaScript into Bash with these easy steps...

First focus on working on projects instead of improving your skills. The concepts you learn are usually a solution to some problem. Things are easier if you first encounter the problem yourself and then learn the solution, than if you do it in reverse. It is ok to do things poorly when you are starting out.