Words & interpolation#

-- `word` is FREAK's string type. These methods are compiler builtins,
-- available with no import.
task main() -> void {
    pilot s: word = "  Muv-Luv Alternative  "

    say s.trim()
    say word_from_int(s.length())
    say s.trim().to_upper()
    say s.trim().to_lower()
    say word_from_bool(s.contains("Luv"))
    say word_from_bool(s.trim().starts_with("Muv"))
    say word_from_bool(s.trim().ends_with("ive"))
    say s.trim().replace("Luv", "Love")
    say s.trim().substring(0, 3)
    say s.trim().char_at(0)

    -- Concatenation with `+`, or with the builtin.
    say "Muv" + "-" + "Luv"
    say word_concat("XM", "3")

    -- Numeric conversion in both directions.
    say word_from_int("108".to_int())
    say format_num("2.5".to_num())
    say char_to_word(70)
}

Muv-Luv Alternative
23
MUV-LUV ALTERNATIVE
muv-luv alternative
true
true
true
Muv-Love Alternative
Muv
M
Muv-Luv
XM3
108
2.5
F

-- `{path}` inside a double-quoted word interpolates a binding.
-- A path is an identifier plus zero or more `.field` hops, and must
-- resolve to word, int, num or bool. Anything that is not a valid path
-- stays literal text.
-- (`Aviator`, not `Pilot`: V3 keywords are case-insensitive, so `Pilot`
-- is the `pilot` keyword and cannot name a shape.)
shape Aviator {
    name: word
    score: int
}

impl Aviator {
    task summary(self) -> word {
        give back "{self.name} scored {self.score}"
    }
}

task main() -> void {
    pilot callsign: word = "Valkyrie"
    pilot sorties: int = 12
    pilot rate: num = 0.75
    pilot active: bool = true

    say "callsign={callsign} sorties={sorties}"
    say "rate={rate} active={active}"

    pilot p: Aviator = Aviator { name: "Meiya", score: 98 }
    say "shape: {p.name} / {p.score}"
    say p.summary()

    -- Not a path, so it is printed literally:
    say "literal {1 + 2} braces"
}

callsign=Valkyrie sorties=12
rate=0.75 active=true
shape: Meiya / 98
Meiya scored 98
literal {1 + 2} braces

-- `word_builder::*` accumulates a word without the quadratic cost of
-- repeated `+` concatenation. The builder is an `int` handle.
task main() -> void {
    pilot b: int = word_builder::new()

    word_builder::append(b, "Mission: ")
    word_builder::append(b, "Valkyries")
    word_builder::append_char(b, 32)      -- a space, by codepoint
    word_builder::append_int(b, 4)

    say word_from_int(word_builder::length(b))

    -- `finish` consumes the builder and returns the accumulated word.
    say word_builder::finish(b)

    -- with_capacity pre-allocates; clear reuses; discard frees unused.
    pilot c: int = word_builder::with_capacity(64)
    word_builder::append(c, "scratch")
    word_builder::clear(c)
    word_builder::append(c, "reused")
    say word_builder::finish(c)
}

20
Mission: Valkyries 4
reused

-- std/string.fk ships as plain FREAK source and is always linked in by
-- `freak build` / `freak run`. Its tasks are global; there is no import.
task main() -> void {
    say string_repeat("ha", 3)
    say string_reverse("FREAK")
    say word_from_int(string_count("banana", "an"))
    say string_pad_left("7", 4, "0")
    say string_pad_right("7", 4, ".")
    say word_from_int(string_index_of("alternative", "native"))
    say word_from_bool(is_digit("5"))
    say word_from_bool(is_alpha("x"))
    say word_from_bool(is_whitespace(" "))
}

hahaha
KAERF
2
0007
7...
5
true
true
true

-- A complete small program: split a sentence into words, count them,
-- and report the longest one. Uses shapes, arrays, loops and std tasks.
shape Report {
    total: int
    longest: word
}

impl Report {
    task show(self) -> word {
        give back "total={self.total} longest={self.longest}"
    }
}

task split_words(text: word, out: int) -> void {
    pilot mut current: word = ""
    pilot mut i: int = 0

    repeat text.length() times {
        pilot c: word = text.char_at(i)
        if c == " " {
            if current.length() > 0 {
                array_push(out, current)
                current = ""
            }
        } else {
            current = current + c
        }
        i += 1
    }

    if current.length() > 0 {
        array_push(out, current)
    }
}

task analyse(text: word) -> Report {
    pilot words: int = array_new()
    split_words(text, words)

    pilot mut longest: word = ""
    pilot mut i: int = 0

    repeat array_len(words) times {
        pilot w: word = array_get(words, i)
        if w.length() > longest.length() {
            longest = w
        }
        i += 1
    }

    -- `result` is a reserved word in V3, so the binding is `summary`.
    pilot summary: Report = Report { total: array_len(words), longest: longest }
    array_release(words)
    give back summary
}

task main() -> void {
    pilot r: Report = analyse("the beta will not negotiate with humanity")
    say r.show()
    say word_from_int(r.total)
    say r.longest.to_upper()
}

total=7 longest=negotiate
7
NEGOTIATE