or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

async-programming.md character-operations.md collections.md configuration.md core-infrastructure.md data-encoding.md date-time.md external-integration.md index.md numeric-types.md reactive-programming.md string-operations.md type-system.md

tile.json

String Operations

Comprehensive string manipulation, regular expression processing, and character operations with full .NET String API compatibility and Unicode support.

String Module - String Manipulation

Rich string manipulation capabilities matching the .NET String API, providing extensive text processing functions.

Enums and Types

StringComparison

enum StringComparison {
    CurrentCulture = 0,
    CurrentCultureIgnoreCase = 1,
    InvariantCulture = 2,
    InvariantCultureIgnoreCase = 3,
    Ordinal = 4,
    OrdinalIgnoreCase = 5
}

Printf Interfaces

interface IPrintfFormat {
    input: string;
    cont: IPrintfFormatContinuation;
}

interface IPrintfFormatContinuation {
    // Continuation type for printf formatting
}

Comparison Functions

String comparison with culture and case sensitivity options.

// Multi-overload comparison function
function compare(...args: any[]): number;

// Ordinal comparison (byte-by-byte)
function compareOrdinal(x: string, y: string): number;

// Instance comparison
function compareTo(x: string, y: string): number;

// Usage
import { compare, compareOrdinal, StringComparison } from "fable-library/String.js";

// Different comparison modes
console.log(compare("apple", "APPLE", StringComparison.Ordinal)); // > 0
console.log(compare("apple", "APPLE", StringComparison.OrdinalIgnoreCase)); // 0
console.log(compareOrdinal("apple", "banana")); // < 0

String Analysis

Functions to analyze string content and structure.

// Pattern matching
function startsWith(str: string, pattern: string, ic: number): boolean;
function endsWith(str: string, search: string): boolean;

// Null/empty checking
function isNullOrEmpty(str: string | any): boolean;
function isNullOrWhiteSpace(str: string | any): boolean;

// Character searching
function indexOfAny(str: string, anyOf: string[], ...args: number[]): number;

// Usage
import { 
    startsWith, endsWith, isNullOrEmpty, 
    isNullOrWhiteSpace, indexOfAny, StringComparison 
} from "fable-library/String.js";

const text = "Hello World";

console.log(startsWith(text, "Hello", StringComparison.Ordinal)); // true
console.log(endsWith(text, "World")); // true

console.log(isNullOrEmpty("")); // true
console.log(isNullOrEmpty(null)); // true
console.log(isNullOrWhiteSpace("   ")); // true

console.log(indexOfAny("Hello", ["e", "o"])); // 1 (first 'e')

String Transformation

Functions to modify and transform strings.

// Insertion and removal
function insert(str: string, startIndex: number, value: string): string;
function remove(str: string, startIndex: number, count?: number): string;

// Replacement
function replace(str: string, search: string, replace: string): string;

// Trimming
function trim(str: string, ...chars: string[]): string;
function trimStart(str: string, ...chars: string[]): string;
function trimEnd(str: string, ...chars: string[]): string;

// Padding
function padLeft(str: string, len: number, ch?: string, isRight?: boolean): string;
function padRight(str: string, len: number, ch?: string): string;

// Usage
import { 
    insert, remove, replace, trim, trimStart, 
    padLeft, padRight 
} from "fable-library/String.js";

const text = "Hello World";

console.log(insert(text, 5, " Beautiful")); // "Hello Beautiful World"
console.log(remove(text, 5, 6)); // "Hello"
console.log(replace(text, "World", "Universe")); // "Hello Universe"

const padded = "  Hello  ";
console.log(trim(padded)); // "Hello"
console.log(trimStart(padded)); // "Hello  "
console.log(trimEnd(padded)); // "  Hello"

console.log(padLeft("42", 5, "0")); // "00042"
console.log(padRight("42", 5, "0")); // "42000"

String Generation

Functions to create strings programmatically.

// Initialize with function
function initialize(n: number, f: (i: number) => string): string;

// Replicate string
function replicate(n: number, x: string): string;

// Join arrays/sequences
function join(delimiter: string, ...xs: any[]): string;
function joinWithIndices<T>(delimiter: string, xs: string[], startIndex: number, count: number): string;

// Usage
import { initialize, replicate, join, joinWithIndices } from "fable-library/String.js";

// Generate string by index
const indexed = initialize(5, i => `Item${i}`); // "Item0Item1Item2Item3Item4"

// Repeat string
const repeated = replicate(3, "Hello"); // "HelloHelloHello"

// Join arrays
const joined = join(", ", ["apple", "banana", "cherry"]); // "apple, banana, cherry"

// Join with range
const partial = joinWithIndices("-", ["a", "b", "c", "d", "e"], 1, 3); // "b-c-d"

String Splitting and Filtering

// Split strings
function split(str: string, splitters: string[], count?: number, removeEmpty?: number): string[];

// Filter characters
function filter(pred: (char: string) => boolean, x: string): string;

// Get character at index
function getCharAtIndex(input: string, index: number): string;

// Usage
import { split, filter, getCharAtIndex } from "fable-library/String.js";

const text = "apple,banana;cherry:date";

// Split by multiple delimiters
const parts = split(text, [",", ";", ":"]);
console.log(parts); // ["apple", "banana", "cherry", "date"]

// Filter characters
const onlyVowels = filter(c => "aeiou".includes(c.toLowerCase()), "Hello World");
console.log(onlyVowels); // "eoo"

// Get character
console.log(getCharAtIndex("Hello", 1)); // "e"

GUID Operations

Generate and manipulate GUIDs (UUIDs).

// GUID validation
function validateGuid(str: string, doNotThrow?: boolean): string | [boolean, string];

// Generate new GUID
function newGuid(): string;

// GUID conversion
function guidToArray(s: string): Uint8Array;
function arrayToGuid(buf: ArrayLike<number>): string;

// Usage
import { newGuid, validateGuid, guidToArray, arrayToGuid } from "fable-library/String.js";

// Generate GUID
const guid = newGuid();
console.log(guid); // "12345678-1234-1234-1234-123456789abc"

// Validate GUID
const [isValid, cleanGuid] = validateGuid(guid, true) as [boolean, string];
console.log(isValid); // true

// Convert to bytes and back
const bytes = guidToArray(guid);
const restored = arrayToGuid(bytes);
console.log(restored === guid); // true

Base64 Operations

Encode and decode Base64 strings.

// Base64 encoding/decoding
function toBase64String(inArray: number[]): string;
function fromBase64String(b64Encoded: string): Uint8Array;

// Usage
import { toBase64String, fromBase64String } from "fable-library/String.js";

const data = [72, 101, 108, 108, 111]; // "Hello" in ASCII
const encoded = toBase64String(data);
console.log(encoded); // "SGVsbG8="

const decoded = fromBase64String(encoded);
console.log(Array.from(decoded)); // [72, 101, 108, 108, 111]
console.log(String.fromCharCode(...decoded)); // "Hello"

Printf Functions

F#-style printf formatting system.

// Printf format creation
function printf(input: string): IPrintfFormat;

// Output targets
function toConsole(arg: IPrintfFormat): Function;
function toConsoleError(arg: IPrintfFormat): Function;
function toText(arg: IPrintfFormat): Function;
function toFail(arg: IPrintfFormat): Function;

// Simple formatting
function fsFormat(str: string): Function;
function format(str: string, ...args: any[]): string;

// Usage
import { printf, toConsole, toText, format, fsFormat } from "fable-library/String.js";

// F# style formatting
const formatter = printf("Hello %s, you are %d years old");
const consoleOut = toConsole(formatter);
consoleOut("John", 30); // Prints: "Hello John, you are 30 years old"

const textFormatter = toText(formatter);
const result = textFormatter("Alice", 25); // Returns: "Hello Alice, you are 25 years old"

// Simple formatting
const formatted = format("Value: {0}, Count: {1}", 42, 10);
console.log(formatted); // "Value: 42, Count: 10"

// F# format function
const fsharpFormatter = fsFormat("Processing item %d of %d");
console.log(fsharpFormatter(5, 10)); // "Processing item 5 of 10"

RegExp Module - Regular Expression Utilities

Regular expression creation, matching, and manipulation with .NET Regex compatibility.

Core Functions

// Create regex with options
function create(pattern: string, options?: number): RegExp;

// Escape special characters
function escape(str: string): string;

// Simple matching
function isMatch(str: string, pattern: string, options?: number): boolean;

// Usage
import { create, escape, isMatch } from "fable-library/RegExp.js";

// Create regex patterns
const emailPattern = create("\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b", 1); // Case insensitive

// Escape special characters
const escaped = escape("How much? $5.00 (approx.)");
console.log(escaped); // "How much\\? \\$5\\.00 \\(approx\\.\\)"

// Simple matching
console.log(isMatch("test@example.com", "\\b\\w+@\\w+\\.\\w+\\b")); // true
console.log(isMatch("not-an-email", "\\b\\w+@\\w+\\.\\w+\\b")); // false

Pattern Matching

// Single match
function match(str: string, pattern: string, options?: number): string[];

// Multiple matches
function matches(str: string, pattern: string, options?: number): string[][];

// Usage
import { match, matches } from "fable-library/RegExp.js";

const text = "Call me at 123-456-7890 or 987-654-3210";
const phonePattern = "\\d{3}-\\d{3}-\\d{4}";

// First match only
const firstMatch = match(text, phonePattern);
console.log(firstMatch); // ["123-456-7890"]

// All matches
const allMatches = matches(text, phonePattern);
console.log(allMatches); // [["123-456-7890"], ["987-654-3210"]]

// With capturing groups
const urlText = "Visit https://example.com or http://test.org";
const urlPattern = "(https?)://([\\w.-]+)";

const urlMatches = matches(urlText, urlPattern);
console.log(urlMatches);
// [["https://example.com", "https", "example.com"], 
//  ["http://test.org", "http", "test.org"]]