Skip to content Search Apps Documentation Source Content Run Reset Eval Playground File Folder Download Copy Actions State String Boolean Number Struct Map Slice Pointer Function Closure Reference Nil Package Type Interface Unknown

Playground

gnomod.toml

module = "gno.land/r/moul/x/daily/markovdemo/v0"
gno = "0.9"

[addpkg]
  creator = "g1manfred47kzduec920z88wfr64ylksmdcedlf5"
  height = 26369
  max_deposit = "100000000ugnot"

markovdemo.gno

// Package markovdemo is a small on-chain demo of the Markov-chain text
// generator provided by the [p/moul/x/daily/markov](/p/moul/x/daily/markov/v0)
// library.
//
// It holds a single package-level [markov.Chain] as the corpus and wires it to
// the chain: Feed appends words to that persistent chain (a crossing function,
// since it mutates on-chain state), while Generate and Render walk it with a
// seed derived from runtime.ChainHeight() — so babbling is a pure, reproducible
// query that still varies block to block. It contains no Markov logic of its
// own — build/walk math all lives in the library.
package markovdemo

import (
	"chain"
	"chain/runtime"
	"strconv"
	"strings"

	"gno.land/p/moul/x/daily/markov/v0"
)

// maxGen clamps Generate / Render so output stays bounded.
const maxGen = 200

// mc is the single on-chain corpus, seeded at deploy time.
var mc = markov.New()

func init() {
	// Two seed sentences with heavy two-word-prefix overlap, so a fresh deploy
	// already babbles something recognizably chain-like.
	mc.Build("it was the best of times it was the worst of times " +
		"it was the age of wisdom it was the age of foolishness")
	mc.Build("i am a free man i am not a number " +
		"i am the master of my fate i am the captain of my soul")
}

// seedFor derives a Generate seed from the current chain height so the babble
// changes block to block yet stays reproducible for anyone querying the same
// height.
func seedFor() uint64 {
	return uint64(runtime.ChainHeight())*2654435761 + 0x9e3779b97f4a7c15
}

// Feed appends text to the on-chain corpus, extending the Markov chain. Any
// caller may enrich the corpus — this is the open-membership demo model.
func Feed(cur realm, text string) string {
	if strings.TrimSpace(text) == "" {
		panic("markov: empty text")
	}
	added := mc.Build(text)
	words, prefixes := mc.Stats()
	chain.Emit("Feed", "words", strconv.Itoa(added), "total", strconv.Itoa(words))
	return "fed " + strconv.Itoa(added) + " words; corpus now " +
		strconv.Itoa(words) + " words across " +
		strconv.Itoa(prefixes) + " prefixes"
}

// Generate babbles up to nWords of Markov text from the current corpus, seeded
// deterministically by the chain height. Read-only.
func Generate(nWords int) string {
	if nWords <= 0 {
		nWords = 20
	}
	if nWords > maxGen {
		nWords = maxGen
	}
	return strings.Join(mc.Generate(nWords, seedFor()), " ")
}

// Stats returns (totalWords, prefixCount) for the current corpus.
func Stats() (int, int) {
	return mc.Stats()
}

// parseN pulls a trailing positive integer out of a Render path such as
// "/40" or "gen/40"; it returns 0 when there is none.
func parseN(path string) int {
	p := strings.Trim(path, "/")
	if i := strings.LastIndex(p, "/"); i >= 0 {
		p = p[i+1:]
	}
	n, err := strconv.Atoi(p)
	if err != nil || n < 0 {
		return 0
	}
	return n
}

// Render shows a freshly generated sample plus corpus stats. The path may
// carry a word count, e.g. Render("/60").
func Render(path string) string {
	n := parseN(path)
	if n == 0 {
		n = 40
	}
	if n > maxGen {
		n = maxGen
	}

	words, prefixes := mc.Stats()

	var b strings.Builder
	b.WriteString("# Markov Babbler\n\n")
	b.WriteString("A demo of the [`p/moul/x/daily/markov`](/p/moul/x/daily/markov/v0) " +
		"library — an on-chain port of Go's classic *\"Generating arbitrary text: " +
		"a Markov chain algorithm\"* codewalk. Every two-word **prefix** maps to " +
		"the words that followed it; `Generate` walks that chain, picking suffixes " +
		"with a PRNG seeded by the block height — deterministic, yet different each " +
		"block.\n\n")

	b.WriteString("## Fresh sample (" + strconv.Itoa(n) + " words, height " +
		strconv.FormatInt(runtime.ChainHeight(), 10) + ")\n\n")
	sample := strings.Join(mc.Generate(n, seedFor()), " ")
	if sample == "" {
		sample = "_(empty corpus)_"
	}
	b.WriteString("> " + sample + "\n\n")

	b.WriteString("## Corpus\n\n")
	b.WriteString("- **Words:** " + strconv.Itoa(words) + "\n")
	b.WriteString("- **Distinct prefixes:** " + strconv.Itoa(prefixes) + "\n")
	b.WriteString("- **Prefix length:** " + strconv.Itoa(markov.PrefixLen) + " words\n\n")

	b.WriteString("## Some prefixes → suffixes\n\n")
	b.WriteString("| prefix | can be followed by |\n|---|---|\n")
	shown := 0
	mc.Iterate(func(k string, suffixes []string) bool {
		disp := k
		if disp == " " || disp == "" {
			disp = "_(start)_"
		}
		b.WriteString("| `" + disp + "` | " + strings.Join(suffixes, ", ") + " |\n")
		shown++
		return shown >= 12 // cap the table
	})
	b.WriteString("\n_Call `Feed(\"your text here\")` to teach it new words, then " +
		"reload for a new sample._\n")

	return b.String()
}