Inline value destructuring

[andrecasal]

Hey folks 👋

I'm new to this library and I was wondering how one would destructure a Result's value inline:

	//...
	const { isErr, value: user } = await register({ email, password})
	if (isErr) {
		return json({ fields, fieldErrors: { email: `That email address already exists` } })
	}

	// Everything went ok, create session and redirect user to profile page
	return setUserInSession(user, '/profile')

The register() function returns the following createUser() function:

/** Create new user with email and password */
export const createUser = async ({ email, passwordHash }: { email: string; passwordHash: string }): Promise<Result<SessionUserWithoutPassword, string>> => {
	try {
		return ok(
			await db.user.create({...})
		)
	} catch (e) {
		return err('Email already exists')
	}
}

[chriskrycho]

Hi @andrecasal – just had time to work through notifications and saw this! You can't destructure exactly like you have there because the value field is only available when you've verified that it's an Ok you're dealing with. This kind of scenario is in fact exactly what the .match() method is for, though! Using match, you can get similarly nice-to-work-with code by doing something like this:

    //...
    let result = await register({ email, password});
    return result.match({
      Ok: (user) => setUserInSession(user, '/profile'),
      Err: (_) => json({ fields, fieldErrors: { email: `That email address already exists` } }),
    });

[chriskrycho]

As a bonus tip, you can use make your createUser function a bit nicer by just using a traditional .then():

/** Create new user with email and password */
export const createUser = async ({
  email,
  passwordHash,
}: {
  email: string;
  passwordHash: string;
}): Promise<Result<SessionUserWithoutPassword, string>> =>
  db.user.create({ ... }).then(
    (user) => Result.ok(user),
    (_) => Result.err('Email already exists')
  );

[andrecasal]

Hello @chriskrycho that's very interesting! Then on the caller, I either get a user or an error string, but I'm not sure how to get at them with true-myth in a functional style. Something like this?

const { isErr, value } = await register({user, password})
if(isErr) { // handle error }
// All good, use user in 'value'

[chriskrycho]

Exactly the same way, actually! I wouldn't normally reach for destructuring like that here, not least because the library intentionally does not support it. The type of Result is this (plus a bunch more methods and lots of implementation details):

interface Ok<T, E> {
    isOk: true;
    isErr: false;
    value: T;
}

interface Err<T, E> {
  isOk: false;
  isErr: true;
  error: E;
}

type Result<T, E> = Ok<T, E> | Err<T, E>;

The key thing to notice is that there is no .error property on the base Result type, because it could be an Ok, and Ok does not have an .error property! Likewise, there is no .value property on the Err type. This means that you cannot use destructuring the way you want. This is for a good reason: it means that you never end up with an undefined value in the system—which is the only thing that you could have for the error property when on an Ok type.

Now, you have lots of options! You can .match() on the result returned by register they're just the same, or you could use a conditional and check the .isErr or .isOk properties, or you could import and use the isErr() and isOk() functions, or you could .map() and .mapErr() over the Ok and Err variants respectively, or you could use .mapOrElse() to produce a new Result that is known to be Ok but is still a Result, or any number of other combinations. (Aside: note that most standalone functions in the library have a method versions and vice versa, so you can use whichever is easiest/most useful in any given spot in your code.)

It ultimately depends on what you're trying to do! The point of “functional” here is that you have a building block, the type, and a bunch of functions which can operate on it and produce a new version of the building block type or produce a new type entirely from it, and you can wrap together different functions to produce the results you need.