The Fixed Point Expression / Y Combinator expressed in horses:

    Y = (λ f. (λ x. f(xx))(λ x. f(xx)))
    ;; so then, give Y a horse argument with apple parameters:
    Y🐎️ = (λ f. (λ 🍎.  f(🍎🍎)) (λ 🍎. f(🍎🍎))) 🐎️   ;; [1]
        =       (λ 🍎. 🐎️(🍎🍎)) (λ 🍎. 🐎️(🍎🍎))      ;; [2]
        = 🐎️(   (λ 🍎. 🐎️(🍎🍎)) (λ 🍎. 🐎️(🍎🍎))   )  ;; [3]
        = 🐎️(Y🐎️)                                       ;; [4]

The LISP parentheses are not equally balanced. There are more ( than ).

But notice that lisp was the only one where you actually built a horse.

ruby: you built a horse that builds a horse to build your horse. your barn is too small. it crashes. everyone is dead.

Python:

from horses import Horse 

my_horse = Horse(color="brown")

There. Done.

C: You build a horse. Well, it’s not really a horse, but it can do almost all the essential horse-things. It’s incredibly fast and compact. Oh, and now someone else owns it.

you could say that it aged well

As a non-programmer, TIL Java and JavaScript are two different languages.

Is it a dig against C# only being good when using it from F#, i.e. OCaml for .Net or am I overthinking this?

And here I am glad that I try to avoid phpMyAdmin too, whenever possible.

Rust builds a unicorn

In Horse64:

import horses from horses.horse64.org

func main {
    var my_horse = horses.Horse(color="brown")
}

And in Horse64 Root:

import horses from horses.horse64.org

func main -> bool {
    var my_horse <- horses.Horse
    my_horse.init("brown")
    if failed(my_horse.init) {
        return no
    }

    defer my_horse.destroy()

    my_horse.run()
    if failed(my_horse.run) {
        my_horse.stop()
        return no
    }

    my_horse.stop()
    if failed(my_horse.stop) {
        return no
    }

    my_horse.eat("hay")
    if failed(my_horse.eat) {
        return no
    }

    return yes
}

Ctrl-F “rust” - > 0 matches

I sense a pertubance in the force

Needs a python horse in there.

Probably something about “why build a horse when you can just import horse from field?”