Advanced FP features? (HKTs, custom operators)

[cakekindel]

Hey! Just came across Mint by way of a Medium article. I'm a Haskeller, and I'm curious if Mint does or will support:

• typeclasses
• HKTs (typeclasses which allow for "type holes")
• custom operators (infix application and/or non alphanumeric function names)

Pros:

• supports a highly abstracted Prelude like Haskell's or PureScript's
• provides new functional programmers an easy path to Haskell-style programming
• appeals to people familiar with Haskell-style FP
• differentiates Mint from Elm and Reason (who have chosen explicitly to omit these features)

Cons:

• difficult to implement
• adds complexity to a very simple language

[gdotdesign]

Hi 👋

I'm a recent PureScript convert

Just curious what were you converted from? 🙂

---

I don't know if it will support more advanced FP features, honestly I don't see why building UIs would require them, but that said probably there will be some way to describe a type, basically you will be able to define:

• comparison function (for equality and ordering)
• iterator function
• decode / encode functions (to and from JavaScript objects)

As for custom operators, personally I don't like code where I can't tell what an operators does by first glance, but I can understand it's usefulness so we'll see.

But this will be after 1.0 for sure.

[cakekindel]

Just curious what were you converted from? 🙂

It's been a gradual journey all over the spectrum 😄 I wouldn't say there's a clear line of demarcation, just a "oh i like this style, i wonder if there's a language with more of it"

some way to describe a type, basically you will be able to define (Ord, Iteratable, De/Serializable)

Gotcha, yeah this is where typeclasses (Rust calls them "traits" which I like more than haskell's class/instance terminology) would come in. Some way of saying "A Foo is able to do bar and baz" then later a data structure can say "I am a Foo, here is how I do bar and baz"

Rust example

trait Foo {
  fn bar() -> String;
  fn baz() -> i64;
}

// i64 is 64 bit signed int
struct Me(i64);

impl Foo for Me {
  fn bar() { self.0.to_string() }
  fn baz() { self.0 }
}

As for custom operators, personally I don't like code where I can't tell what an operators does by first glance, but I can understand it's usefulness so we'll see.

Nor do I, again I definitely am asking these questions from the perspective of a functional prelude library author, not the average UI author. I think some standard ops for map, bind, composition, etc. (<$>, >>=, >>> respectively), not necessary but helpful for more concise general code