Implementing Trait-Like Behavior with Intersection Types in TypeScript

TypeScript doesn't have explicit "traits" like Rust or Go. However, we can achieve similar functionality using intersection types and type guards. This challenge will guide you in creating a system that allows you to define reusable "trait-like" behaviors and apply them to different types, ensuring they adhere to a specific contract. This is a powerful technique for enforcing consistency and code reuse across your project.

Problem Description

You need to implement a system that mimics trait-like behavior in TypeScript. Specifically, you'll define a set of "traits" (represented as type definitions) that specify a set of methods and properties. Then, you'll create several types that "implement" these traits by intersecting them with the trait types. Finally, you'll write a function that uses type guards to safely access methods defined in the traits, ensuring that the input object actually implements the expected trait.

What needs to be achieved:

Define a Speakable trait that requires a speak() method returning a string.
Define a Flyable trait that requires a fly() method returning a string.
Create a Bird type that implements both Speakable and Flyable.
Create a Car type that implements Speakable but not Flyable.
Write a function makeItSpeakAndFly(obj: any): string | undefined that takes an arbitrary object and attempts to call both speak() and fly() on it. The function should use type guards to ensure that the object actually implements the necessary traits before attempting to call the methods. If the object implements both traits, return the concatenated result of speak() and fly(). If it only implements Speakable, return the result of speak(). If it implements neither, return undefined.

Key Requirements:

Use intersection types to define the traits and implement them on your types.
Use type guards (e.g., isSpeakable, isFlyable) to safely access the trait methods.
Handle cases where an object might only implement one trait or neither.
The function should be robust and avoid runtime errors if the object doesn't have the expected methods.

Expected Behavior:

makeItSpeakAndFly({ speak: () => "Hello", fly: () => "Flying!" }) should return "Hello Flying!"
makeItSpeakAndFly({ speak: () => "Hello" }) should return "Hello"
makeItSpeakAndFly({ wheels: 4 }) should return undefined

Edge Cases to Consider:

Objects that have properties with the same names as the trait methods but are not actually functions.
Objects that have methods with the same names but different signatures than those defined in the traits.
Null or undefined input to makeItSpeakAndFly. (While not explicitly required, handling this gracefully is good practice).

Examples

Example 1:

Input: { speak: () => "Woof", fly: () => "Soaring!" }
Output: "Woof Soaring!"
Explanation: The object implements both Speakable and Flyable traits, so both methods are called and concatenated.

Example 2:

Input: { speak: () => "Meow" }
Output: "Meow"
Explanation: The object only implements the Speakable trait, so only the speak() method is called.

Example 3:

Input: { wheels: 4 }
Output: undefined
Explanation: The object does not implement either trait, so the function returns undefined.

Constraints

The speak() method must return a string.
The fly() method must return a string.
The makeItSpeakAndFly function must not throw errors at runtime if the input object does not implement the expected traits.
The solution must be written in valid TypeScript.

Notes

Think about how to create type guards that accurately check if an object implements a specific trait. in operator can be helpful.
Intersection types are key to defining the "trait" contracts.
Consider using a more generic approach if you want to support a larger number of traits. However, for this exercise, focusing on the Speakable and Flyable traits is sufficient.
The goal is to demonstrate the concept of trait-like behavior using TypeScript's type system, not to create a fully-fledged trait system.