When are nullary functions implicitly called? #629

osa1 · 2024-12-19T12:53:07Z

osa1
Dec 19, 2024

What are the rules of when a function with no arguments will be implicitly called?

Is there a difference between x.y and x.y() when y takes one argument? Are they always, in all contexts, the same?

I'm also confused about the "suspender" syntax. User manual says: (https://koka-lang.github.io/koka/doc/book.html#why-mingen)

but as a syntactic convenience, any function without arguments can be shortened further to use just braces, as { <body> }.

But in this example, the suspended code is evaluated:

fun int/increment(i: int): <console>int
  println("Incrementing " ++ i.show)
  i + 1

fun main()
  val x = 123.increment
  val y = { 456.increment } // why is the body of the lambda evaluated here?
  ()

This program prints

Incrementing 123
Incrementing 456

According to the book section linked above, I would expect y to be the same as val y = fn() { 123.increment }. Why are they not the same?

Answered by osa1

Dec 20, 2024

To answer my own question "when are nullary functions are implicitly called":

Implicit calling only happens in method/field selection syntax (x.y), so nullary functions are never implicitly called.
However if the x.y selecting a field, then the field's value is not implicitly called, even if the types are right (i.e. the field's type is a nullary function).

Example:

fun nullary-fun()
  println("In the nullary fun")

fun unary-fun(i: int)
  println("In the unary fun")

effect my-effect
  ctl nullary-effect-op(): ()
  ctl unary-effect-op(i: int): ()

val my-handler = handler
  ctl nullary-effect-op()
    println("Handling nullary op")
    resume(())

  ctl unary-effect-op(i: int)
    prin…

View full answer

TimWhiting · 2024-12-19T14:46:01Z

TimWhiting
Dec 19, 2024
Collaborator

Variable declarations implicitly define a block scope so that you can use multiple lines to define the variable. This is how you can do:

   val x = 
        with handler
        ...
   ...

Any place a block scope occurs adding explicit braces will not change the meaning.
For example function declarations

fun myfun(args,...)
   ....
// adding braces
fun myfun(args,...) {
   ....
}
// does not mean adding an extra nullary function
fun myfun(args,...) 
  fn() {
    ....
  }

In all cases x.y means y(x) whether y has parentheses after it or not. The one point where this can come to bite you is for struct accessor functions.

struct xtype
  f: () -> int
  g: (int) -> int
  ...

// generates
fun f(x : xtype)
  match x
    X(f_) -> f_
fun g(x : xtype)
  match x
    X(_, g_) -> g_

fun main()
  val x = X(fn(){1})
  x.f // access the f function and doesn't call it
  x.g // access the g function  
  // in the latest dev version of koka we can do the following to actually call the functions accessed from a datatype.
  x.f.()
  x.g.(0)

1 reply

osa1 Dec 20, 2024
Author

Thanks. So if I understand correctly, with val, the braces become the block for the variable declaration's RHS, instead of a suspender. It still seems like a footgun though..

osa1 · 2024-12-20T08:41:55Z

osa1
Dec 20, 2024
Author

To answer my own question "when are nullary functions are implicitly called":

Implicit calling only happens in method/field selection syntax (x.y), so nullary functions are never implicitly called.
However if the x.y selecting a field, then the field's value is not implicitly called, even if the types are right (i.e. the field's type is a nullary function).

Example:

fun nullary-fun()
  println("In the nullary fun")

fun unary-fun(i: int)
  println("In the unary fun")

effect my-effect
  ctl nullary-effect-op(): ()
  ctl unary-effect-op(i: int): ()

val my-handler = handler
  ctl nullary-effect-op()
    println("Handling nullary op")
    resume(())

  ctl unary-effect-op(i: int)
    println("Handling unary op")
    resume(())

value struct my-struct
  nullary-fun-field: () -> <console>()

fun main()
  val my-struct = My-struct(nullary-fun-field = nullary-fun)

  with my-handler
  nullary-fun           // not called
  nullary-effect-op     // not called
  1.unary-fun           // called
  1.unary-effect-op     // called

  my-struct.nullary-fun-field    // not called

  ()

To call a function in a struct field, we need double ()s.

my-struct.nullary-fun-field()()

This is because the first my-struct.nullary-fun-field() is the same as the version without ()s (fields are immutable and compiled to functions, so the first () calls the field getter function), a second () is needed to actually call the function.

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

When are nullary functions implicitly called? #629

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{editor}}'s edit

{{editor}}'s edit

Uh oh!

Replies: 2 comments 1 reply

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{editor}}'s edit

{{editor}}'s edit

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

When are nullary functions implicitly called? #629

Uh oh!

Uh oh!

osa1 Dec 19, 2024

Replies: 2 comments · 1 reply

Uh oh!

Uh oh!

TimWhiting Dec 19, 2024 Collaborator

Uh oh!

osa1 Dec 20, 2024 Author

Uh oh!

osa1 Dec 20, 2024 Author

osa1
Dec 19, 2024

Replies: 2 comments 1 reply

TimWhiting
Dec 19, 2024
Collaborator

osa1 Dec 20, 2024
Author

osa1
Dec 20, 2024
Author