How can I get the first letter of a word?

[jakcst]

Anyone have any idea how I could go about getting the first letter of a word in ink?
Somehow parsing a string

[Selsynn]

For that purpose, I would use an external method.
How you do it is different for the language you will be using with ink (js if that's in the web export, c# if in the unity port, and I don't know what other language for the other exports.)

For the ink documentation on creating the external method https://github.com/inkle/ink/blob/master/Documentation/RunningYourInk.md#external-functions

So the ink side would be creating a method like this

//Declare external funciton
EXTERNAL GetFirstLetter(word)

//Use it when you want
~ GetFirstLetter("Test")

//Declare somewhere your fallback method so Inky is not stuck when running the code 
=== function GetFirstLetter(word) ===
// Usually external functions can only return placeholder
// results, otherwise they'd be defined in ink!
~ return X

For example in js

function GetFirstLetter(word){
return word.charAt(0);
}

You will have the same kind of method in another language.

If you are still lost, let me know your language, how you are exporting/executing the ink file, and we can help you more

[Bard09]

I agree that using external functions is the best way to handle this-- but Ink should have more string-parsing functions!

Just to see if I could, I implemented a function that could do this using the ? expression, but it is slow and could have performance implications.

//Super-lame way of truncating a word without spaces to its first character.  Only checks for initial capital letters at this time.  Migrate to external function if performance is an issue.
//NOTE: If the word contains spaces, you will need to prepend a different uncommon character such as a % rather than a space.
=== function truncateWord(string_parameter) === 
    ~ temp fake_string = " " + string_parameter
    
    { 
    - fake_string ? " A":
        ~ return "A"
    - fake_string ? " B":
        ~ return "B"
    - fake_string ? " C":
        ~ return "C"
    - fake_string ? " D":
        ~ return "D"
    - fake_string ? " E":
        ~ return "E"
    - fake_string ? " F":
        ~ return "F"
    - fake_string ? " G":
        ~ return "G"
    - fake_string ? " H":
        ~ return "H"
    - fake_string ? " I":
        ~ return "I"
    - fake_string ? " J":
        ~ return "J"
    - fake_string ? " K":
        ~ return "K"
    - fake_string ? " L":
        ~ return "L"
    - fake_string ? " M":
        ~ return "M"
    - fake_string ? " N":
        ~ return "N"
    - fake_string ? " O":
        ~ return "O"
    - fake_string ? " P":
        ~ return "P"
    - fake_string ? " Q":
        ~ return "Q"
    - fake_string ? " R":
        ~ return "R"
    - fake_string ? " S":
        ~ return "S"
    - fake_string ? " T":
        ~ return "T"
    - fake_string ? " U":
        ~ return "U"
    - fake_string ? " V":
        ~ return "V"
    - fake_string ? " W":
        ~ return "W"
    - fake_string ? " X":
        ~ return "X"
    - fake_string ? " Y":
        ~ return "Y"
    - fake_string ? " Z":
        ~ return "Z"
    - else:
        ~ return ""
    }```

[IFcoltransG]

I used a similar method to this to create a capitalise function. I used a list of letters instead of a branching function. https://gist.github.com/IFcoltransG/9b33b6631b936b1d8692abb3f998fcc0
I shared some more ideas for how this could support punctuation as well, in the Inkle discord server.