Support for lazy let or lazy const in order to save execution units by default.

[matiwinnetou]

As I found out in Aiken / UPLC everything is evaluated eagerly but this can lead to execution cost bloat for many contracts.

Consider the code:

fn hello_world() -> Boolean {
  let deadline: Int = 5 // fake only for example
  let funds: Int = 10 // fake only for example

  let deadline_has_passed: Bool = deadline_passed(deadline)
  let funds_available: Bool = funds_available(funds)

   deadline_has_passed && funds_available
}

fn deadline_passed(deadline: Int) -> Bool {
   deadline < 2
}

fn funds_available(funds: Int) -> Bool {
  funds > 5
}

It makes absolutely no sense to check if funds are available so we could as well write this code like this:

fn hello_world() -> Boolean {
  let deadline: Int = 5 // fake only for example
  let funds: Int = 10 // fake only for example

  lazy let deadline_has_passed: Bool = deadline_passed(deadline)
  lazy let funds_available: Bool = funds_available(funds)

   deadline_has_passed && funds_available
}

fn deadline_passed(deadline: Int) -> Bool {
   deadline < 2
}

fn funds_available(funds: Int) -> Bool {
  funds > 5
}

lazy let would in fact be like calling function and putting parameter there once or even better once we have support for const in functions it should be a lazy const:

fn hello_world() -> Boolean {
  let deadline: Int = 5 // fake only for example
  let funds: Int = 10 // fake only for example

  lazy const deadline_has_passed: Bool = deadline_passed(deadline)
  lazy const funds_available: Bool = funds_available(funds)

   deadline_has_passed && funds_available
}

fn deadline_passed(deadline: Int) -> Bool {
   deadline < 2
}

fn funds_available(funds: Int) -> Bool {
  funds > 5
}

See discussion: #286 - regarding const in function scope instead of only allowing let (mutable and overshadowable).

[matiwinnetou]

[matiwinnetou]

Just to help to illustrate this from real world example as I am doing in order to achieve lazy effect I have to do this:

    can_still_bid(validity_range, datum.deadline) && has_new_bid_have_token_and_new_bid(
      validator_hash: validator_hash,
      datum_with_new_bidder: datum_with_new_bidder,
      outputs: outputs,
    ) && is_old_bidder_repaid(
      current_highest_bid: datum.highest_bid,
      current_highest_bidder: datum.highest_bidder,
      outputs: outputs,
    )

this feels like a nightmare to me, lazy const would totally solve this. However, needless to say this is post alpha, post beta. Obviously there are more important features, this is ergonomics and clean code feature.

[MicroProofs]

Will be handled automatically by items 2,3,4 in #135

[matiwinnetou]

@MicroProofs When you say it will be handled automatically, do you mean it will always be lazy, always be eager or it will be possible to choose if function evaluation is eager or lazy?