I am not expanding the range of properties that I am not interested in restricting

Question

I am not expanding the range of properties that I am not interested in restricting

I am working with an interface:

interface I {
  // Question: My main focus is on restricting the input parameters
  fn: (s: string) => any
  val: any
}

The purpose of this interface is to simply ensure that

val exists, without specifying its type
Verify that fn is a function which takes a string, but without specifying the return type

For example, using this interface would look like:

const demo = {
  fn: (s: string) => s.length,
  val: new Date()
}

const example1: I = demo

example1.fn  // (property) I.fn: (s: string) => any
example1.val // (property) I.val: any

demo.fn  // (property) fn: (s: string) => number
demo.val // (property) val: Date

Is there a way to replace any so that both example1 and demo have specific types?

Could it be done with satisfies? What about for those on older versions before 4.9 or when dealing with "legacy" code?

typescript typescript-generics

Answer 1

Answer №1

For developers utilizing typescript version 4.9 or above and leveraging the satisfies operator, the following syntax can be used:

const x = noice satisfies I

If not on typescript >= 4.9, an alternative workaround can be implemented like so:

function enforce<Constraint>() : <T extends Constraint>(t: T) => T {
    return <T>(t: T) => t
}

In this approach, currying is employed to eliminate the need for specifying the second type argument. Initially, the first function is called with a desired constraint, followed by calling the second function which will simply return the original argument. Keep in mind that this method may incur some minor runtime overhead.

const result = enforce<I>()(noice)

Answer 2

For developers utilizing typescript version 4.9 or above and leveraging the satisfies operator, the following syntax can be used:

const x = noice satisfies I

If not on typescript >= 4.9, an alternative workaround can be implemented like so:

function enforce<Constraint>() : <T extends Constraint>(t: T) => T {
    return <T>(t: T) => t
}

In this approach, currying is employed to eliminate the need for specifying the second type argument. Initially, the first function is called with a desired constraint, followed by calling the second function which will simply return the original argument. Keep in mind that this method may incur some minor runtime overhead.

const result = enforce<I>()(noice)

I am not expanding the range of properties that I am not interested in restricting

Answer №1

Similar questions

Using type aliases in Typescript to improve string interpolation

Angular is failing to return the response with the custom headers that I have

Vue is having trouble identifying the src attribute

Utilizing Interface Merging: Determining the Appropriate Instance Type for Field Types

Tips on setting up tsconfig.json for type declarations not found in @types?

In Angular 2 Type Script service, make sure to include the @angular/core module for proper functionality as the 'require' method may not

Is there a more efficient method to optimize this code and eliminate the need for multiple if statements?

Discover the inferred arguments of methods declared on an object in TypeScript

Calculate the date input in Angular 7 by subtracting calendar days

Upon hovering, icons for each project name are displayed when `mouseenter` event is triggered

Exploring the Concept of Template Element Recursion in Angular JS 2

What are the steps to keep Discord bot buttons active even after a restart?

Having trouble locating the 'tsc-watch' module due to the missing 'typescript/bin/tsc' when running the TypeScript compiler

Angular's implementation of nested interface definitions allows for a clear and

Display an array depending on the value in Angular 2 when clicked

Extracting the Hidden Gems in a Nested Object

Creating an Observable from static data in Angular that resembles an HTTP request

typeorm migration:generate - Oops! Could not access the file

Calling a function within another function

Why does the implementation of my interface differ from what is specified in the TypeScript documentation?