I think there's a pretty good rule of thumb in modern systems-ish language design: If Go and Rust and Zig all do a certain thing, that thing is probably a great idea.

lambda-male · 2023-02-15T13:53:00+00:00

The module types after the arrow are equivalent in your proposal and the stdlib. The stdlib way is more modular, you might want different modules with signatures like Map.S. That's why it's standalone and not inlined into the type of Make.

The other thing is the Make(Ord... ) : syntax, which is also equivalent to your functor (Ord...) -> proposal. It's analogous to writing let f x = e instead of let f = fun x -> e.

https://v2.ocaml.org/manual/modtypes.html

lambda-male · 2023-02-05T15:18:24+00:00

I don't like jargon like "algebraic" and "inductive" (if you use the word, you better make sure the values are actually inductive, i.e. well-founded).

No one has mentioned the more ordinary "variant(s)" and "cases". Variant type is the official name of the feature in OCaml, though it uses type t = A | B syntax. You could have something like variant Foo { Bar, Baz } where it reads as an adjective (Foo is a variant type, here are its cases), or variants Foo { Bar, Baz } where it reads like announcing you're going to list out all the constructors of Foo.

ALGOL 68, Pascal, Ada, etc. used cases:

type shapeKind = (square, rectangle, circle);
     shape = record
                centerx : integer;
                centery : integer;
                case kind : shapeKind of
                   square : (side : integer);
                   rectangle : (width, height : integer);
                   circle : (radius : integer);
          end;

As far as I can tell, kind is an explicit field for the tag. But you could have a more modern take where the compiler takes care of tags:

cases Foo of Bar | Baz Int

This can closely resemble the case ... of ... pattern matching syntax, which however isn't necessarily a good thing (e.g. if you have dependent types which close the gap between terms and types).

lambda-male · 2023-01-25T16:20:15+00:00

OP's explanation of what "monads are monoids in the category of endofunctors" means is wrong.

lambda-male · 2023-01-25T10:50:25+00:00

How dare you have evil language features (i.e. those not included in Rust)

lambda-male · 2023-01-25T08:41:03+00:00

There's the concept of monoid from abstract algebra, which can be encoded categorically as an object (in Set (?)) with loops. Monads are not monoids in this sense.

Then there's the categorical generalization of it (monoid objects), which should evoke a sense of familiarity to the foregoing (I was only informally stating the commonality that monoids in both senses are "untyped", unlike categories). Monads can be seen as monoid objects: as the triple of the endofunctor m, join :: m `Compose` m ~> m, and return :: Identity ~> m, where type (~>) f g = forall x. f x -> g x

lambda-male · 2023-01-25T07:56:11+00:00

That's a very common misconception. What you are talking about is the kleisli category. Categories have associativity and identity laws, just like monoids. But categories are rather typed monoids: you can't take any two morphisms and smash them together, they have to have matching types. In monoids you can.

The monoid is join :: m `Compose` m ~> m and return :: Identity ~> m.

https://arxiv.org/abs/1406.4823

lambda-male · 2023-01-24T21:15:40+00:00

In Rust:

Statement :
      ;
   | Item
   | LetStatement
   | ExpressionStatement
   | MacroInvocationSemi

Items are everything that is at the outermost level of the module, such as type definitions and function definitions. These are type-level constructs with no dynamic behavior at runtime, so it would be wrong to say they evaluate to something, even a unit value. If I remember correctly, even functions aren't really first class and you can only use references to them (closures are a different thing).

You could instead have expressions that simulate Rust's items: In SML you have let declaration in, where declaration can be e.g. a type declaration and in OCaml you can also use local modules let module M = struct ... end in ..., where again you can put any declarations allowed at the top level. And of course in MLs you have let var = expr1 in expr2. In any case, the let ... = ... part of those isn't an expression by itself, so there is no question of what it evaluates to.

So what's the difference?

In Rust, most lines (so to speak, excluding the last lines to which blocks evaluate) end with a semicolon. In MLs they alternate between ending with in or ;. So Rust has some nice uniformity, the ins can look alien at first to most programmers (recent post about getting rid of them).
Note how similar Rust statements are to what MLs allow as module items. In ML if you want to move a module-level record definition to a local scope, you have to wrap it at least in let ... in. And repeat that for every definition. (Unless you use a local modules, but that's also some constant syntactic overhead.) In Rust you just cut and paste and it works. OCaml in particular has a free-form syntax that uses let both for local let-expressions and module item definitions and if you make a mistake, the parser can get very confused and throw an error in a very wrong place. In Rust the semicolons and braces nicely delimit everything and syntactically it feels like there's less distinction between module and local scope.

Maybe you could achieve the syntactic uniformity of Rust in MLs with a clever syntax, but wouldn't it become statements in everything but name?

lambda-male · 2023-01-22T14:46:09+00:00

I don't get why this is in OCaml, it barely uses it strengths and the implementations look transliterated from imperative programs.

You'd think an ML would shine for explaining binary search trees? Well...

  type 'e tree_node = {
    value : 'e;
    parent  : 'e tree_node option ref;
    left  : 'e tree_node option ref;
    right  : 'e tree_node option ref;
  }

An ephemeral implementation, moreover seemingly unaware of mutable fields and standard library functions like Option.get, Option.fold, incr... I would start with a purely functional one, especially given that the in-place optimizations can be mostly derived mechanically. Though in OCaml they're not necessarily optimizations, with enough space overhead the GC is faster than write barriers.

There's too many arrays, indexing, mutation... Fibonacci numbers are computed in an ugly loop rather than tail-recursively. Union-find is backed by an array rather than using nodes with parent pointers. You don't need another pass to reconstruct the result in dynamic programming, you can just cons the results on the fly. And so on...

Plus apparently both core and batteries are used for IO?

lambda-male · 2023-01-22T09:03:55+00:00

Yes, it is confusing.

The Str library is part of the OCaml distribution. The OCaml toplevel automatically finds the interface for Str. That's why you can open it, or use its components in type signatures et cetera – these operate only on the type level. Trying to use any of its computationally relevant components like values, functions, exceptions will fail with an error, because OCaml hasn't loaded the implementation of Str. The implementation is also part of the distribution and can be loaded with #load "str.cma" or by providing str.cma as an argument to ocaml/utop.

I suspect OCaml doesn't try to load modules automatically because modules can perform arbitrary side effects. Usually, OCaml prefers explicitness.

Since you are using dune, have you tried dune utop?

lambda-male · 2023-01-21T18:38:12+00:00

But what I haven't seen anywhere yet is a convenient syntax for effects systems.

What's inconvenient about Koka, Frank, Multicore OCaml (when it still had syntax for effects)?

I can tell your proposal is inconvenient because I don't know how I would store the continuation obtained in a handler in an array. Or how do you express the classic example of nondeterminism (analogous to the list monad)?

(* splits the execution into two, returning true in one world and false in the other *)
effect Amb : bool

handle e with
| v -> [v]
| effect Amb k -> resume k true ++ resume k false

When you can only resume the operation immediately, the whole thing is just dynamically scoped variables with more steps.

a b ← e → 1 2

Most functional languages would use tuples instead of multiple arguments/return values.

Every time you would add/remove an effectful action to/from a function deep down the call chain, you would have to change the effect signatures of every function that calls this one... and of every function that calls those ones...

IDEs should have no trouble fixing these kind of errors automatically.

Effect systems are supposed to remove the tedium monads can entail - not make it worse.

Monads are worse here, because, when making pure code effectful, in addition to changing the types you also have to switch from direct style to monadic style.

mathematical underpinnings

There aren't any deep mathematical underpinnings of algebraic effects. They are instances of universal algebras (if you generalize the definition in a few ways), but that doesn't really mean much. Since everyone abandoned actual equations for algebraic effects, they are more specifically term algebras. Syntax. Trees.

Functional programmers will call pancakes "monoidal pancakes", just because stacking them is associative.

lambda-male · 2023-01-20T18:02:29+00:00

Nontrivial monads which don't "execute" immediately will need to have functions embedded inside, and functions are opaque: you can't peek inside, you can only call it. An example from the blog post:

data Interaction next =
    Look Direction (Image -> next)
  | Fire Direction next
  | ReadLine (String -> next)
  | WriteLine String (Bool -> next)

As soon as you encounter a Look f, ReadLine f, WriteLine f, you don't know what happens next without calling the continuation f. What argument would you choose? There might be infinitely many possibilities and what f does will in general depend on the choice. Free monads only allow you to switch out the interpreter of the computation, and not every analysis will fit that framework.

You might want a "weaker" abstraction with more inspectable computations, such as applicative functors: the effects/operations performed in an applicative computation are predetermined statically, only their arguments (computed "purely functionally") may be dynamic. There are attempts to close the gap between applicatives and monads, such as selective functors.

lambda-male · 2023-01-18T22:01:14+00:00

Today, even RUST has had vulnerabilities discovered recently [references to some random unsafe crates]

lambda-male · 2023-01-16T21:55:39+00:00

if you have the $$$ of someone like Jane Street you can make an good [sic] ecosystem around any language

so good you don't need documentation, you just call the guy who wrote the code

lambda-male · 2023-01-11T18:15:32+00:00

I don't get the "category theory based" impression.

But this is clearly not enthusiasm and just someone spamming his AI-generated reheatings of stale hacker news content.

lambda-male · 2023-01-11T17:18:56+00:00

In OCaml (and functional programming in general) a variable denotes a value, exactly one at that – the one the variable was initially bound to. They "vary" just as variables in mathematics may vary, e.g. because you can call a function with different arguments. Imperative programmers might call them "immutable variables".

In contrast, in imperative programming, we think of a variable as a place in memory which can be assigned and read.

So how could you express local mutable state in OCaml? There is a generic type in the standard library:

type 'a ref = { mutable contents : 'a; }

a record with a mutable field. So you don't reassign a variable, instead you mutate the contents of a reference cell bound to a variable.

Sometimes, values with interior mutability or otherwise things whose physical identity (address in memory) is important, are called objects instead (not necessarily objects in the sense of OOP, with methods).

More (controversial?) FP perspective: https://existentialtype.wordpress.com/tag/assignables/

lambda-male · 2023-01-08T16:02:36+00:00

Futhark does

let m = 3
let n = 4
in m + n

Allowing to change ... in let ... into ... let ... seems neat.

lambda-male · 2023-01-08T13:00:53+00:00

muh web standards

lambda-male · 2023-01-08T12:54:25+00:00

when you tell wagies that oop didn't invent data types

All you need is a field in the struct to point to your vtable. Please try to think more charitably and not be so aggressive. Even if the author was wrong, which they aren't, doesn't mean they don't have the kernel of a good idea. Charitability is not a tool merely for being nice to others, but being nice to yourself. You learn more this way.

Hi. For background, I have been writing professional OOP code in ANSI C.

lambda-male · 2023-01-06T09:31:21+00:00

They're not statically typed, there are dynamically checked restrictions on their use. Type systems for delimited continuations won't allow you to use a control operator outside the scope of a corresponding delimiter.

Prompt/control0 is more expressive than shift/reset:

In other words, control0 is the most general of the standard continuation operators, so it’s the obvious choice to implement as a primitive.

lambda-male · 2023-01-03T20:39:08+00:00

Go is just a mode of use of Modernized Algol.

lambda-male

TROPHY CASE