I don't know #haskell but Groovy omits parenthesis extremely: drink tea, coffee with milk, sugar and toasts

I'm not a fan of this, personally, and the only reason I'm okay with

infix

is because you have to opt into it. My coworkers all thought

to

was a keyword at first, but it's just the stdlib infix method to make a Pair. I don't want more functions that look like keywords, especially if we do it like Groovy where all parens can be omitted for one-arg functions. Maybe it'd be clearer if you can at least opt into it with a keyword somehow

Ruby is a good language for DSLs. What is the production-tier use case for making syntax more confusing?

Confusion:

val log = Logger.global

log "Hello log"

Is that the

log

variable I just made? Is it a function taking in a

String

? Is it a prefix extension function on the String?

Now in Kotlin we can write:

fun log(str:String) = println("$str in fun")

val log = { str: String -> println("$str in lambda") }

log("hello")

What will be output? And what is the difference if we omit parens:

log "hello"

? Logger functions is not very good example. Look at

await

,

yield

. Suspending call isn't ordinary and dropping parens so they would look like keywords (with IDE colored highlighting) would be a good idea

Just a note: being able to call functions without parenthesis is the most problematic feature of Groovy. Half of the Groovy Puzzlers are fixed by adding the parenthesis back

Also, I love how I can use

await()

in call chains without wrapping the expression in paranthesis.

x.foo()
  .await()
  .bar()
  .baz()

vs.

(await x.foo())
  .bar()
  .baz()

Let's just drop parens everywhere and go full AppleScript 🙂

tell application "TextEdit"
    activate
    make new document
    set text of front document to "hello world"
end tell

suspend parenless fun await(...) = ...
suspend parenless fun yield(...) = ...

usage :

val backgroundImage = await loadImage(...)
val image = await loadImage(...)
yield 1
yield longComputation()

but cannot use in nested call or with more than 1 argument without parenthesis :

saveImage await loadImage()
yield result1, result2

because it is not clear and creates puzzlers Also, IDE highlighting can help in recognizing this calls

parenless

is kinda lengthy and hard to read if you don't know what it means. Perhaps follow the

infix

notation and call it

prefix

although I feel like IDEs should not be needed to separate keywords from functions.

(I'm looking at you,

synchronized

)

`make new document`:

make

is a top-level property,

new

is infix function,

document

is a property.

Maybe that's just me, but I'm strongly against various "literate programming" features. Because they do make code harder to read, especially when you're not quite familiar with a particular DSL. I's more like "look, mom, I can has no parens in my code" than something serious to me.

"literate" languages like this are actually harder to read than human languages, in my opinion. Think about every time you've been learning a foreign language. I think that if the language followed the form

subject.verb(object)

, it would be easier for me to read it than if I had to parse out what each part was individually because there were no symbols to give me context

also, as someone who was using Gradle since way before I was using Kotlin, when I first saw things like

compile group: "foo", name: "bar", version: "1.0"

, I was very confused. It took me months to even realize

compile

was a function and that's how you use 1-arg functions in Groovy, and you could easily also do it with parens. Granted, maybe that's because Groovy has terrible IDE support, but it still reduces visibility for absolutely no readability gains. If we're not allowing these for nested calls, I'm wondering where this would seriously benefit anyone. Just use the parens

well SQL is one of the most successful bits of technology in history and it chose a command-based language

I don’t think it matters that much, I think the world needs more DSLs not fewer, (mho)

on the other hand, COBOL is... wait a sec...

maybe that sort of syntax works better for languages like SQL than it does for object-oriented or functional languages.

I think it's easy enough to see what function is being called, ide knows all. Also, gradle has its own problems with discovery and erroring

while I love IntelliJ and it's the only editor I use, I think that if we have to rely on syntax highlighting to make the language readable... it really isn't

We just had the discussion in #general about interface delegation like this

@User uploaded a file: Untitled

Could that work?

Could you provide a use case scenario refining this snippet, please? It's hard to trace initial intent behind the code piece which semantics is yet undefined.

Here's a very minimal example:

interface EventHandler {
  fun handle(event: Event)
}

class EventHandlerImpl(val ctx: Context) {
  override fun handle(event: Event) {
    doSomethingWith(event, ctx)
  }
}

class SomeActivity: Activity(), EventHandler by eventHandler {
  private val eventHandler = EventHandlerImpl(this)
}

I needed that feature a couple of times, and JB would love to provide it AFAIK, but this syntax is reserved. We need a different syntax for that, like

class Foo: Bar by &baz

Then what is the procedure? Who creates the KEEP documents?

@Paul Woitaschek I've got some free time tomorrow, so I can prepare a draft. Will ping you if you'd like to help too.