e.InfoLog.Println("\nFerret:")

var Correction = func(b []byte) [][]byte { return ferret.ErrorCorrect(b, ferret.LowercaseLetters) }

var Converter = func(s string) []byte { return []byte(s) }

var Data []interface{}

for i := range ExampleUint32 {

Data = append(Data, ExampleUint32[i])

}

f := ferret.New(ExampleWords, ExampleWords, Data, Converter)

f.Insert("blest i most", "blest i most", 7)

e.InfoLog.Println(f.ErrorCorrectingQuery("blest", 4, Correction))

e.InfoLog.Println(f.Query("blest", 10))

e.InfoLog.Println("\nRTrie:")

t := trie.New()

for i := range ExampleWords {

t.Add(ExampleWords[i], ExampleUint32[i])

}

t.Remove("coca cola")

node, _ := t.Find("blost og storm")

e.InfoLog.Println(node.Meta().(uint32))

e.InfoLog.Println(t.PrefixSearch("blost"))

e.InfoLog.Println(t.FuzzySearch("blest"))

e.InfoLog.Println("\nN-Gram:")

index, _ := ngram.NewNGramIndex(ngram.SetN(3))

var token ngram.TokenID

for i := range ExampleWords {

token, _ = index.Add(ExampleWords[i])

}

str, _ := index.GetString(token) // str == "hello"

e.InfoLog.Println(str)

resultsList, _ := index.Search("blest")

for _, v := range resultsList {

e.InfoLog.Println(v.TokenID)

}

e.InfoLog.Println("\nTST:")

n := tst.T{}

for i := range ExampleWords {

n.Insert(ExampleWords[i], nil)

}

n.Delete("coca cola")

result := n.StartsWith("blost") //buggy, try searching for blest

for _, v := range result {

e.InfoLog.Println(v)

}

e.InfoLog.Println("\nRadix:")

r := radix.New()

for i := range ExampleWords {

r.Set(ExampleWords[i], ExampleUint32[i])

}

x := r.GetAllWithPrefix("blost")

for _, v := range x {

i := v.(uint32)

e.InfoLog.Println(i)

}

e.InfoLog.Println("\nPatricia:")

printItem := func(prefix patricia.Prefix, item patricia.Item) error {

e.InfoLog.Println(string(prefix), item.(uint32))

return nil

}

trie := patricia.NewTrie()

for i := range ExampleWords {

trie.Insert(patricia.Prefix(ExampleWords[i]), ExampleUint32[i])

}

trie.Set(patricia.Prefix("coca cola"), 188)

e.InfoLog.Println("SubTree:")

trie.VisitSubtree(patricia.Prefix("blost"), printItem)

e.InfoLog.Println("Prefixes:")

trie.VisitPrefixes(patricia.Prefix("borte med blesten mega"), printItem)

trie.Delete(patricia.Prefix("coca cola"))

trie.DeleteSubtree(patricia.Prefix("blost"))

e.InfoLog.Println("What is left:")

trie.Visit(printItem)

e.InfoLog.Println("\nIradix:")

out := []string{}

fn := func(k []byte, v interface{}) bool {

out = append(out, string(k))

return false

}

r := iradix.New()

for i := range ExampleWords {

r, _, _ = r.Insert([]byte(ExampleWords[i]), ExampleUint32[i])

}

x := r.Root()

m, _, _ := x.LongestPrefix([]byte("borte med blesten mega"))

e.InfoLog.Println(string(m))

x.WalkPrefix([]byte("blost"), fn)

for i := range out {

e.InfoLog.Println(out[i])

}

e.InfoLog.Println("\nDeaccent:")

str := "æblekage med ål og øl"

e.InfoLog.Println(string(StripÆØÅ(str)))

str = strings.ToLower(str)

b := (make([]byte, len(str)))

pos := 0

for _, char := range str {

if char > 127 {

switch char {

case 'å':

b[pos] = 'a'

case 'æ':

b[pos] = 'a'

case 'ø':

b[pos] = 'o'

}

} else {

b[pos] = byte(char)

}

pos += 1

}

return b[:pos]

source := []string{ "ral", "mag", "dyn", "kunda", "sim"}

traits, err := codex.NewTraits(source)

if err != nil {

panic(err)

}

gen := traits.Generator()

var str [200]string

// Print twelve random words.

for i := 0; i < 200; i++ {

str[i] = gen()

}

e.InfoLog.Println("Codex, Words generated: ", str)

// Find out how many words can be generated from this sample.

gen = traits.Generator()

i := 0

for gen() != "" {

i++

}

e.InfoLog.Println("total:", i)

}