Compile-Time Evaluation clarification.

[s3rj1k]

Readme says that

Only functions that can be fully resolved with the provided literal arguments can be evaluated at compile-time, therefore it is impossible to use any values from IO operations.

So it's not possible to read file content at compile time?

[pijng]

Frankly speaking, you can try to do some very simple cases with comptime.

Read plain txt inline

Original file:

package main

import (
  "fmt"
  "os"

  "github.com/pijng/prep"
)

func main() {
  config := prep.Comptime(readFile("./test.txt"))
  fmt.Println(config)
}

func readFile(path string) string {
  content, err := os.ReadFile(path)
  if err != nil {
  	panic(err)
  }

  return string(content)
}

Then compile:
go build -a -toolexec="prep $PWD" main.go

And remove test.txt from the directory, run the binary:

 ./main
some content of a file

But anything less trivial is unlikely to be accomplished yet :(
I mean there is always a //go:embed pragma to read file at compile time. If it's possible in your case, of course.

[s3rj1k]

Yea I guess //go:embed should work, just that it was not clear on IO limitations in readme.

Possible usecase of comptime for reading files is actually do some parsing on them before getting results in, so with embedded parsing results would be basically in runtime and storing whole file, with comptime we just store the result of parsing as var (would be nice to have this as const but I assume it's very hard to do).

[pijng]

I think now (with v0.0.8) you can do something like this:

package main

import (
	"fmt"
	"os"
	"strings"

	"github.com/pijng/prep"
	"gopkg.in/yaml.v2"
)

var gToken = prep.Comptime(extractToken("./config.yml"))

func main() {
	fmt.Println(gToken)
}

func extractToken(path string) string {
	type Config struct {
		Name  string
		Token string
	}

	b, err := os.ReadFile(path)
	if err != nil {
		panic(err)
	}

	var config Config
	err = yaml.Unmarshal(b, &config)
	if err != nil {
		panic(err)
	}

	return strings.ToUpper(config.Token)
}

Where config.yml has this content:

path: '/var/lib/moonlogs/database.sqlite'
token: "very_secure_123"

And after building it with prep we can print the token value that was present during compilation, even if we change config.yml content or remove it completely afterwards:

rm ./config.yml
./main
"VERY_SECURE_123"

The key here is to encapsulate all the “components” of config parsing into the parseConfig function as much as possible. For example, the Config type itself. If you declare it outside the function, this type will not be visible to the interpreter during parseConfig evaluation.

Yeah, consts is still not possible, since go won't let you do stuff like:

const gToken = prep.Comptime(extractToken("./config.yml"))

It is what it is.

(I had to additionally make a fork of yaegi as it didn't support go modules 🥲)