流程优化之在JavaScript里写Rust match

const Main = () => {
	const condition = xxx; // 判断条件
	const Component = condition === '1' ? ComponentA
		: condition === '2' ? ComponentB
		: ComponentC

	return (
		<div>
			<Component/>
		</div>
	)
}

const componentMapper = {
	"1": ComponentA,
	"2": ComponentB,
}
const Main = () => {
	const condition = xxx; // 判断条件	
	const component = componentMapper[condition] || ComponentC
	return (
		<div>
			<Component/>
		</div>
	)
}

fn main() {
    let number = 13;
    // TODO ^ Try different values for `number`

    println!("Tell me about {}", number);
    match number {
        // Match a single value
        1 => println!("One!"),
        // Match several values
        2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
        // TODO ^ Try adding 13 to the list of prime values
        // Match an inclusive range
        13..=19 => println!("A teen"),
        // Handle the rest of cases
        _ => println!("Ain't special"),
        // TODO ^ Try commenting out this catch-all arm
    }

    let boolean = true;
    // Match is an expression too
    let binary = match boolean {
        // The arms of a match must cover all the possible values
        false => 0,
        true => 1,
        // TODO ^ Try commenting out one of these arms
    };

    println!("{} -> {}", boolean, binary);
}

const Main = () => {
	const condition = xxx; // 判断条件	
	const component = match(condition, {
		"1": ComponentA,
		"2": ComponentB,
		_: ComponentC
	})
	return (
		<div>
			<Component/>
		</div>
	)
}

match(condition, {
	"1": ComponentA,
	"2": ComponentB,
	_: ComponentC
})

// match(target, matchers)

var a = {
  1: 'hello',
  2: 'world'
}
Object.keys(a) // ['1', '2']

match(condition, [
	["1", ComponentA],
	["2", ComponentB],
	[_, ComponentC],
])

// match(target, matchers)

type Matcher<T, R> = [identifier: T, matcherFn: () => R]

type Matchers<T, R> = Matcher<T, R>[]

export const match = <T = any, R = any>(
  target: T,
  matchers: Matchers<T, R>,
) => R

export const _ = Symbol("PLACEHOLDER");

export const _ = Symbol("PLACEHOLDER");

type Matcher<T, R> = [identifier: T, matcherFn: () => R];

type FallbackMatcher<R> = [identifier: typeof _, matcherFn: () => R];

type Matchers<T, R> = (Matcher<T, R> | FallbackMatcher<R>)[];

export const match = <T = any, R = any>(
  target: T,
  matchers: Matchers<T, R>,
) => R;

/**
 * partition an Array into two.
 *
 * returns a Tuple which contain the desired elements and the rests
 *
 * @param arr the original array
 * @param partitionFn a function that pick the desired elements
 * @returns
 */
export const partition = <T>(
  arr: Array<T>,
  partitionFn: (element: T) => boolean,
): [Array<T>, Array<T>] => {
  const length = arr.length
  const target: Array<T> = []
  const rest: Array<T> = []

  for (let i = 0; i < length; i++) {
    const curr = arr[i]

    if (Boolean(partitionFn(curr))) {
      target.push(curr)
    } else {
      rest.push(curr)
    }
  }

  return [target, rest]
}

export const match = <T = any, R = any>(
  target: T,
  matchers: Matchers<T, R>,
) => {
  const [fallback, rest] = partition(matchers, (matcher) => {
    const [identifier] = matcher
    return identifier === _
  }) as [[] | [FallbackMatcher<R>], Matcher<T, R>[]]

	//.....
}

export const match = <T = any, R = any>(
  target: T,
  matchers: Matchers<T, R>,
) => {
  const [fallback, rest] = partition(matchers, (matcher) => {
    const [identifier] = matcher
    return identifier === _
  }) as [[] | [FallbackMatcher<R>], Matcher<T, R>[]]

  if (fallback.length < 1) {
    throw new Error("[match] should contain at least one fallback matcher")

	// .....

}

export const match = <T = any, R = any>(
  target: T,
  matchers: Matchers<T, R>,
) => {
  // .....

  let matcherFound = false
  const length = rest.length
  let result = undefined

  for (let i = 0; i < length; i++) {
    const curr = rest[i]
    const [identifier, fn] = curr
    if (identifier === target) {
      matcherFound = true
      result = fn()
      break
    }
  }

  if (matcherFound) {
    return result
  }

	// .....
}

export const match = <T = any, R = any>(
  target: T,
  matchers: Matchers<T, R>,
) => {
	// ....

  if (fallback.length !== 0) {
    const [, fallbackFn] = fallback[0]
    return fallbackFn()
  }
}

match number {
    // Match a single value
    1 => println!("One!"),
    // Match several values
    2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
    // TODO ^ Try adding 13 to the list of prime values
    // Match an inclusive range
    13..=19 => println!("A teen"),
    // Handle the rest of cases
    _ => println!("Ain't special"),
    // TODO ^ Try commenting out this catch-all arm
}