DEV Community: Tareq Hossain

The Art of Beautiful Functions in TypeScript

Tareq Hossain — Wed, 03 Sep 2025 03:03:31 +0000

TypeScript elevates JavaScript with a sophisticated type system that transforms how we design and think about functions. When we write functions in TypeScript, we're not just creating executable code—we're crafting contracts that communicate intent, prevent errors, and guide future development. Beautiful TypeScript functions are those that leverage the type system to create code that is both safe and expressive.

Type-First Function Design

In TypeScript, beautiful function design begins with types. The type signature becomes the function's contract, clearly defining what it accepts, what it returns, and what can go wrong.

Basic function with clear types.

function calculateTax(amount: number, rate: number): number {
    return amount * (rate / 100);
}

Here's an example of more sophisticated typing with object parameters

interface TaxCalculation {
    readonly grossAmount: number;
    readonly taxRate: number;
    readonly region: 'US' | 'EU' | 'BD';
}

function calculateRegionalTax(params: TaxCalculation): number {
    const { grossAmount, taxRate, region } = params;
    const baseAmount = grossAmount * (taxRate / 100);

    const regionalMultiplier = {
        US: 1.0,
        EU: 1.2,
        BD: 1.5  
    }[region];

    return baseAmount * regionalMultiplier;
}

Above code calculates tax based on both the tax rate and the region, making sure different places follow their own rules. It’s good because it keeps the logic simple, reusable, and easy to extend if more regions are added later.

Generic Functions: Flexibility with Safety

Generic functions represent TypeScript's ability to create flexible yet type-safe abstractions. They allow us to write functions that work with multiple types while maintaining full type safety.

// Simple generic function
function identity<T>(value: T): T {
    return value;
}

// More practical example with constraints
interface Identifiable {
    id: string;
}

function findById<T extends Identifiable>(
    items: readonly T[], 
    id: string
): T | undefined {
    return items.find(item => item.id === id);
}

// Advanced generic with multiple type parameters
function mapWithIndex<T, U>(
    array: readonly T[],
    mapper: (item: T, index: number) => U
): U[] {
    return array.map(mapper);
}

// Usage demonstrates type inference
const users = [
    { id: '1', name: 'Alice', age: 30 },
    { id: '2', name: 'Bob', age: 25 }
];

const userNames = mapWithIndex(users, (user, index) => `${index}: ${user.name}`);
// userNames is inferred as string[]

Function Overloads: Precise Type Contracts

TypeScript's function overloads allow us to define multiple type signatures for a single function, providing precise type information for different usage patterns.

// Function overloads for flexible API
function processData(data: string): string;
function processData(data: number): number;
function processData(data: string[]): string[];
function processData(data: string | number | string[]): string | number | string[] {
    if (typeof data === 'string') {
        return data.toUpperCase();
    }

    if (typeof data === 'number') {
        return data * 2;
    }

    return data.map(item => item.toUpperCase());
}

// Each call has the correct return type
const stringResult = processData("hello");     // string
const numberResult = processData(42);          // number
const arrayResult = processData(["a", "b"]);  // string[]

Error Handling with Result Types

Beautiful TypeScript functions make error handling explicit and type-safe using Result types or similar patterns.

// Define a Result type for explicit error handling
type Result<T, E = Error> = {
    success: true;
    data: T;
} | {
    success: false;
    error: E;
};

// Custom error types
class ValidationError extends Error {
    constructor(public field: string, message: string) {
        super(message);
        this.name = 'ValidationError';
    }
}

class NetworkError extends Error {
    constructor(public statusCode: number, message: string) {
        super(message);
        this.name = 'NetworkError';
    }
}

// Function that uses Result type
async function fetchUserProfile(userId: string): Promise<Result<UserProfile, ValidationError | NetworkError>> {
    // Validate input
    if (!userId.trim()) {
        return {
            success: false,
            error: new ValidationError('userId', 'User ID cannot be empty')
        };
    }

    try {
        const response = await fetch(`/api/users/${userId}`);

        if (!response.ok) {
            return {
                success: false,
                error: new NetworkError(response.status, 'Failed to fetch user')
            };
        }

        const profile = await response.json() as UserProfile;

        return {
            success: true,
            data: profile
        };
    } catch (error) {
        return {
            success: false,
            error: new NetworkError(0, 'Network request failed')
        };
    }
}

// Usage with explicit error handling
async function displayUserProfile(userId: string): Promise<void> {
    const result = await fetchUserProfile(userId);

    if (result.success) {
        console.log(`User: ${result.data.name}`);
    } else {
        if (result.error instanceof ValidationError) {
            console.error(`Validation error in ${result.error.field}: ${result.error.message}`);
        } else if (result.error instanceof NetworkError) {
            console.error(`Network error (${result.error.statusCode}): ${result.error.message}`);
        }
    }
}

Higher-Order Functions and Functional Composition

TypeScript excels at typing higher-order functions and functional composition patterns.

// Type-safe function composition
function compose<A, B, C>(
    f: (b: B) => C,
    g: (a: A) => B
): (a: A) => C {
    return (a: A) => f(g(a));
}

// Practical example with pipeline operations
interface User {
    id: string;
    name: string;
    email: string;
    age: number;
}

const validateEmail = (email: string): boolean => 
    /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);

const normalizeEmail = (email: string): string => 
    email.toLowerCase().trim();

const createEmailValidator = compose(validateEmail, normalizeEmail);

// Array processing with strong typing
function processUsers<T extends User>(
    users: readonly T[],
    processors: Array<(user: T) => T>
): T[] {
    return users.map(user => 
        processors.reduce((acc, processor) => processor(acc), user)
    );
}

// Usage
const addFullName = (user: User): User => ({
    ...user,
    fullName: `${user.name} <${user.email}>`
});

const incrementAge = (user: User): User => ({
    ...user,
    age: user.age + 1
});

const processedUsers = processUsers(users, [addFullName, incrementAge]);

Utility Types and Advanced Patterns

TypeScript's utility types enable sophisticated function designs that maintain type safety while providing flexibility.

// Using utility types for function parameters
function updateUser<K extends keyof User>(
    user: User,
    updates: Pick<User, K>
): User {
    return { ...user, ...updates };
}

// Conditional types for flexible APIs
type ApiResponse<T> = T extends string 
    ? { message: T } 
    : { data: T };

function createResponse<T>(payload: T): ApiResponse<T> {
    if (typeof payload === 'string') {
        return { message: payload } as ApiResponse<T>;
    }
    return { data: payload } as ApiResponse<T>;
}

// Template literal types for type-safe string operations
type EventName<T extends string> = `on${Capitalize<T>}`;

function createEventHandler<T extends string>(
    eventName: T,
    handler: (event: any) => void
): Record<EventName<T>, (event: any) => void> {
    const handlerName = `on${eventName.charAt(0).toUpperCase()}${eventName.slice(1)}` as EventName<T>;
    return { [handlerName]: handler } as Record<EventName<T>, (event: any) => void>;
}

const clickHandler = createEventHandler('click', (e) => console.log('Clicked!'));
// Type: { onClick: (event: any) => void }

Async Function Design

Beautiful async functions in TypeScript handle promises and errors gracefully while maintaining clear type contracts.

// Type-safe async operations with proper error handling
interface ApiConfig {
    baseUrl: string;
    timeout: number;
    retries: number;
}

async function withRetry<T>(
    operation: () => Promise<T>,
    maxRetries: number,
    delay: number = 1000
): Promise<T> {
    let lastError: Error;

    for (let attempt = 1; attempt <= maxRetries; attempt++) {
        try {
            return await operation();
        } catch (error) {
            lastError = error instanceof Error ? error : new Error(String(error));

            if (attempt === maxRetries) {
                break;
            }

            await new Promise(resolve => setTimeout(resolve, delay * attempt));
        }
    }

    throw lastError!;
}

// Async function with comprehensive error handling
async function fetchWithConfig<T>(
    endpoint: string,
    config: ApiConfig
): Promise<Result<T, NetworkError | ValidationError>> {
    try {
        const operation = async (): Promise<T> => {
            const controller = new AbortController();
            const timeoutId = setTimeout(() => controller.abort(), config.timeout);

            try {
                const response = await fetch(`${config.baseUrl}${endpoint}`, {
                    signal: controller.signal
                });

                if (!response.ok) {
                    throw new NetworkError(response.status, `HTTP ${response.status}`);
                }

                return await response.json();
            } finally {
                clearTimeout(timeoutId);
            }
        };

        const data = await withRetry(operation, config.retries);

        return { success: true, data };
    } catch (error) {
        if (error instanceof NetworkError) {
            return { success: false, error };
        }

        return {
            success: false,
            error: new NetworkError(0, error instanceof Error ? error.message : 'Unknown error')
        };
    }
}

Why TypeScript Function Design Matters

TypeScript's type system transforms functions from simple executable code into self-documenting contracts. When we design functions with TypeScript's type system in mind, we create code that is not only more robust but also more expressive and maintainable.

The type signatures serve as living documentation that never goes out of sync with the implementation. They catch errors at compile time rather than runtime, reducing bugs and improving developer confidence. They enable powerful IDE features like autocomplete, refactoring, and navigation.

Most importantly, well-typed functions make code more readable and understandable. A developer can look at a function signature and immediately understand what the function expects, what it returns, and what might go wrong—without reading the implementation.

Beautiful TypeScript functions represent the marriage of functional design principles with strong static typing. They demonstrate that type safety and expressiveness are not opposing forces but complementary aspects of great software design. When we write TypeScript functions that fully leverage the type system, we create code that is both safe and elegant—the hallmark of beautiful software.

Conclusion

The journey from writing simple JavaScript functions to crafting beautiful TypeScript functions is transformative. It's not just about adding types to existing code—it's about fundamentally changing how we think about function design, error handling, and API contracts.

Beautiful TypeScript functions are investments in the future. They reduce debugging time, make refactoring safer, enable better tooling, and create self-documenting codebases. When a new developer joins your team, well-typed functions communicate their intent immediately, reducing the learning curve and preventing misunderstandings.

Ultimately, the art of beautiful TypeScript functions lies in the balance between safety and flexibility, between explicit contracts and ergonomic APIs. When you achieve this balance, your functions become more than just code—they become reliable building blocks that enable larger, more complex systems while remaining understandable and maintainable.

That's for today. Let me know your thoughts or questions regarding this article. Thanks

Function Calling with Semantic Kernel

Tareq Hossain — Mon, 27 Jan 2025 16:03:45 +0000

Hi. I'm going to write a bunch of tutorial on ms semantic-kernel and this is the first part. This tutorial will guide you through integrating Ollama with Microsoft Semantic Kernel and how we can use our internal data. We’ll use the llama3.1 model as an example, but you can choose any model that fits your needs.

Prerequisites

Before starting, ensure you have the following:

.NET SDK Installed: Make sure you have .NET 8 or later installed. If not, download it from https://dotnet.microsoft.com/.
Ollama Installed: Download and install Ollama from https://ollama.com/download.
A Model Downloaded: For this tutorial, we’ll use the llama3.1 (8B) model, which you can download from https://ollama.com/library/llama3.1. Alternatively, you can use any model compatible with Ollama.

Project Initialization

1. Create a New .NET Console Project

Run the following command to create a new .NET console project:

dotnet new console -o OllamaKernel

2. Install Microsoft Semantic Kernel Packages

Add the required packages to your project by running the following commands:

dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.SemanticKernel.Connectors.Ollama --version 1.34.0-alpha

Creating the Kernel

We will start by creating a kernel that connects to the llama3.1 model.

Create a new file named OllamaKernel.cs in the root folder.
Update the file with the following code:

using System;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.Ollama;

public class OllamaKernel
{
   public static Kernel GetKernel(string modelId, string endpoint)
   {
        IKernelBuilder builder = Kernel.CreateBuilder();
        builder.AddOllamaChatCompletion(modelId, new Uri(endpoint));
        Kernel kernel = kernelBuilder.Build();
        return kernel;
   }
}

This file contains the logic for connecting your kernel to the llama3.1 model via Ollama.

Adding a Custom Plugin

Now, let’s create a plugin that interacts with the LLM. For simplicity, we’ll use hardcoded data in this example.

Create a new file named CustomPlugin.cs in the root folder.
Update the file with the following code:

using System.ComponentModel;
using Microsoft.SemanticKernel;

namespace OllamaKernel;

public class CustomPlugin
{
    [KernelFunction]
    [Description("Get user city by user name")]
    static string GetUserCity(string name)
    {
        return name switch
        {
            "Tareq" => "Sylhet",
            "Kevin" => "Kualalampur",
            "Beau" => "New York",
            "Santos" => "Mexico",
            "Robert" => "Swansea",
            _ => "Not Defined",
        };
    }
}

The GetUserCity function takes a username as input and returns the corresponding city. If the username is not listed, it will return "Not Defined."

Testing the Integration

Now that we have both the kernel and the plugin, let’s set up the main program to test our application.

Update Program.cs with the following code:

using OllamaKernel;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.Ollama;

#pragma warning disable SKEXP0070

// initialize kernel
Kernel kernel = OllamaKernel.OllamaKernel.GetKernel(modelId: "llama3.1", "http://localhost:11434");

// register our custom plugin to kernel
kernel.Plugins.AddFromType<CustomPlugin>();

// add kernel function arguments
OllamaPromptExecutionSettings settings = new() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(), Temperature = 0 };

while (true)
{
    try
    {
        Console.WriteLine("Ask your question:");
        Console.Write(">>> ");
        string input = Console.ReadLine();
        if (input == "/bye")
        {
            Console.WriteLine("Goodbye!");
            break;
        }
        var result = await kernel.InvokePromptAsync(input, new(settings));
        Console.WriteLine($"Result: {result.ToString()}");
    }
    catch (System.Exception ex)
    {
        Console.WriteLine($"Failed to invoke prompt: {ex.Message}");
    }
}

Notes

The default port for Ollama is 11434. You can change this by setting the OLLAMA_HOST environment variable, e.g., OLLAMA_HOST='http://localhost:{PORT}'.
The modelId is set to llama3.1. Update this if you use a different model.

Running the Application

To test your app:

Open your terminal.
Run the following command:

   dotnet build

Note: You may see warnings due to the prerelease version of the Ollama connector, but these can be ignored for now.

Once the build completes, run the application.

   dotnet run

Here’s output:

In above image, the program correctly identifies Tareq’s city as "Sylhet." Similarly, it outputs "Not Defined" for Sam since Sam is not listed in the GetUserCity function.

You'll find the full source code here Github

Final Thoughts

This tutorial demonstrates the basics of integrating LLM with Microsoft Semantic Kernel with the help of Ollama. With this setup, you can further expand functionality, such as:

Connecting the plugin to external data sources, such as databases or APIs.
Experimenting with different execution settings to fine-tune the model’s responses.
Implementing more advanced kernel functions to address complex use cases.

Feel free to explore the Semantic Kernel documentation to unlock more features and capabilities for your applications. Happy coding!