Mirth – a type-safe concatenative purely functional programming language

LISP is a notable exception. Btw, I do believe a compiler should be one of the examples of a new language.

> Mirth hasn't been released. I found it and decided to share it.

So you are actually doing it a disservice. Perhaps the author intended a larger release with better docs and examples (or no release at all if it’s a toy project).

But now it will be yet another “ah, one of those languages with no documentation or viable use cases”.

Languages are a dime a dozen, there are several of then on HN each weak. “How dare you demand something from something made for free” is not a credible defence for anything.

The syntax is a bit peculiar, but they defined the union type Nat, defined the function + which takes two Nats and returns a Nat (which they defined in a thoroughly confusing point-free way because the language is concatenative), and demonstrated the associativity of +.

If you read any introduction to dependent types, they will do this.

The first confusing thing is the type signatures. Concatenative languages pass everything around with a stack so here the double dash separates a top part of the stack before application from what the application of the word transforms that bit of the stack into, so:

  succ : Nat -- Nat

means that if you can prove there is a Nat, n on the top of the stack, you can do succ to replace that with a Nat, succ n. Similarly we have:

  + : Nat Nat -- Nat

Which says if you have two Nats on the top of the stack you can do + to get a single Nat.

The next weird thing is pattern matching. + is defined with two cases. The first is:

  zero + = id

Which makes some sense: to add zero to x, do nothing. Making up a variable syntax it would look like:

  <x> zero + = <x>

The pattern matching on the next line is harder:

  succ + = + succ

Which (making up syntax again) says that if your stack looks like:

  m n

And n = succ k:

  m (succ k)

And you do +, you “unapply” succ to get a “stack” that looks like:

  m k succ

With the application of + shown:

  m k succ +

And this matches the pattern above so we transform:

  m k + succ

And evaluate:

  (m+k) succ
  (m+k+1)
  (m+n)

I think this is a rough idea of how the basic types work:

  Denote a “stack” of types (e.g. Nat Nat above) as [a], and single types a.
  If e : [a] -- [b] then for any [c], e : [c] [a] -- [c] [b]
  If dashes are omitted from a type a, it is the same as the type -- a (ie [b] -- [b] a for any [b])
  If e : [a] -- [b] and f : [b] -- [c] then e f : [a] -- [c]

  To define a word w : [a] -- [b], e w = f is a valid clause if:
  1. e has type [c] -- [a]
  2. f has type [c] -- [b]
  3. e is a valid pattern (ie made out of constructors (?))

I guess the rest of the typing rules are more complicated.

The "Development release" of Factor is the best version to use. I'll see about releasing point versions more often.

Well next time make something that you can turn into a viable business and build an org around that lang and that culture.

Be the change you want to see!

See https://arxiv.org/abs/0903.0340 for a basic introduction to the issues, and https://arxiv.org/abs/0908.3347 for a slightly more extensive treatment, also mentioning proof nets. This does not explicitly say that these diagrams can be understood as the equivalent to sequences in something FORTH-like, but this is in fact what the papers are pointing out in a general sense, so I see it as a rather trivial remark.

Trying to start from common ground isn’t “ammunition” imho.

Although it depends on how it is phrased of course.

There is always a person or two at the bottom of every thread like this that loves to spew hate towards people that like to share interesting side-projects, usually in a "you are wasting your time because your project has no immediate value to ME, go spend it serving my interests instead" sort of way. Claiming to also be a tinkerer in your public bio on the same website is gross, and IMO fair game to point it out.

> I've never liked using people's bios - even if public on HN - as ammunition against their comments

I'm inclined to agree, but in the case of outright hypocrisy I think the point deserves to be made, because hypocrisy is literally the worst

IIRC, site guidelines don't specifically say "no ad hominems," but it seems to be generally understood that "no ad hominems" is the correct interpretation of this guideline:

When disagreeing, please reply to the argument instead of calling names. "That is idiotic; 1 + 1 is 2, not 3" can be shortened to "1 + 1 is 2, not 3."

https://news.ycombinator.com/newsguidelines.html

Note that none of these languages have dependent types and that feature is sometimes impossible to add in full generic power after the fact without completely breaking existing code.

Unrelated, do you speak Ithkuil?

Insults like this are very annoying to read. If you think the moderation is too strict and is hurting HN's environment, then say that. There's no need to be so mean about it.

Wow.. and you don't feel like the comment you made is contributing to the problem?

If you want to live in a society where respect trickles up instead of violence trickling down then you mustn't express yourself with violence.

>I know you are a gigantic egomaniac and I'm wasting my time writing this, but if you could ever repress your inflated sense of (mis)justice for two seconds, you might notice that the poster actually asked a perfectly valid question.

Also a perfectly trivial one, an insulting one, and one that has been asked countless times, and that has no real place in a post presenting a new language but goes to meta yak shaving philosophy.

(A question like "what are Mirths differentiating points, what new does it bring" would be an acceptable version -- but that wasn't what was asked).

Note that by starting with "I know you are a gigantic egomaniac" and "inflated sense" and "Thanks for making HN cancer", you already show that you don't have a valid contribution to the discussion either. It even seems like the content of the discussion was secondary, just needed to vent at someone...