Methods.

[Kesanov]

I strongly believe that no functional language can become mainstream without methods.

Why are methods important:

1. Familiarity. Almost all popular languages have them.
2. Autocomplete. Modern languages need excellent IDE support.
3. Boilerplate removal.
4. Typeclasses are not a proper replacement.

What are methods?

Functions that dispatch on the type of given argument. Example:

-- imperative syntax
person.name.myTransform().filter(c => c.isAscii())
-- functional syntax
person . name . myTransform . filter  c => c . isAscii

An example

With implicit this (this.foo == foo) and a syntax sugar for lambdas foo(x, lambda) == foo(x) lambda,
you can really improve on code readability:

List.foldl!!("",
(str, result) 
    str = String.to_upper(str)
    str = String.reverse(str)
    result | str,
["cba","fed","ihg"])

Becomes

["cba","fed","ihg"].fold!!("") (str)
    str = str.to_upper()
    str = str.reverse()
    this | str

Furthermore, in combination with monads, this allows for a very powerful typesafe builder DSL:
If we assume that function() == function, and that monadic do is implicit. You can write html like this:

html
  body
    h("Monadic DSL")
      size(42)
    p
      text(lore_ipsum)

Since all html elements are just methods, you will get perfect autocomplete support from IDE out of the box!

Implementation

There are two ways to implement them, based on what argument gets dispatched:

1. Dispatch on last argument

Here, foo . bar baz is equal to bar baz foo. This plays nice with currying, as . can be defined as an ordinary function:

a . b = b a

However, this will lead to some very surprising behavior:

useName: String -> Person-> Person
-- then someone later defines a generic version
useName: a -> String -> Foo a -> Foo a

Here, either person . useName or foo . useName will call the wrong function.
That is, unless your language supports multiple dispatch. Which opens its own can of worms.

2. Dispatch on first argument.

Here, foo . bar baz is equal to bar foo baz.

The . operator must have special support from the compiler.
However, this implementation requires only minimal extension to the typesystem.

[dvberkel]

Regardless of the necessity of methods, the current proposal would break existing code.

As I understand it, the . can be used in identifiers.