Metaprogramming and Compile-Time

[crater2150]

@Hossein

I never said it’s not visible to the user. I just said REPL doesn’t make it visible. How does one time compilation in REPL?

If the REPL can’t make it visible, doesn’t it mean there isn’t a semantic difference? As types aren’t mutable, the only thing I can think of where laziness would make a semantic difference is infinite recursion, which the compiler doesn’t seem to allow on the type level (results in “illegal cyclic reference”). I don’t think the language specification says anything about compile-time performance (at least for 2.13, couldn’t find the spec for 3.0).

[Hossein]

@crater2150

If the REPL can’t make it visible, doesn’t it mean there isn’t a semantic difference?

No it doesn’t. But, anyway, that semantic difference is indeed what I am looking for.

@crater2150

As types aren’t mutable, the only thing I can think of where laziness would make a semantic difference is infinite recursion

You’re ignoring a number of decades’ research on Programming Languages there, I’m afraid. Haskell and Idris are both pure. Haskell is lazy but Idris is strict (both by default, albeit).

@crater2150

I don’t think the language specification says anything about compile-time performance (at least for 2.13, couldn’t find the spec for 3.0).

The matter of performance is only of a secondary interest to me. It’s the operational nature that I am after now.

[crater2150]

@Hossein

You’re ignoring a number of decades’ research on Programming Languages there, I’m afraid. Haskell and Idris are both pure. Haskell is lazy but Idris is strict (both by default, albeit).

I think “semantic” was probably the wrong term to use. I meant, are there cases where the resulting runtime code would produce different results, depending on the compile time type reduction being lazy or strict? I’d be interested to learn about such cases.

[jgulotta]

@Hossein

type P = (Foo[5], Foo[55])
...
def f1(p: P) = ???
def f2(p: P, i: Int) = ???

P above is equivalent to (String, Int). Is that equivalence established greedily, i.e., right at the first line above? Twice for its two occurrences on the two last lines? Or, once at the penultimate line and memoised afterwards, i.e., lazily?

I think the section of interest here for Scala 2.13 is Type Declarations and Type Aliases. In particular, this section says that certain declarations and definitions are illegal by themselves independent of usage, which implies greedy evaluation.