Result.isOk

class Result<T, E> {
  isOk(): this is Ok<T, E>
}

import { ok, err } from 'neverthrow'

const success = ok(42)
const failure = err('error')

if (success.isOk()) {
  console.log('Success!')
  // TypeScript knows this is Ok<number, string>
  const value: number = success.value
}

if (failure.isOk()) {
  // This block won't execute
  console.log('This won\'t print')
}

function processResult(result: Result<User, Error>) {
  if (result.isOk()) {
    // TypeScript narrows the type to Ok<User, Error>
    const user = result.value  // Type: User
    console.log(user.name)
  } else {
    // TypeScript narrows the type to Err<User, Error>
    const error = result.error  // Type: Error
    console.error(error.message)
  }
}

function getUserName(result: Result<User, string>): string {
  if (!result.isOk()) {
    return 'Anonymous'
  }
  
  // TypeScript knows result is Ok here
  return result.value.name
}

const results: Result<number, string>[] = [
  ok(1),
  err('error'),
  ok(2),
  ok(3)
]

const successes = results.filter(r => r.isOk())
// successes has Ok results only

const values = successes.map(r => r.value)
// values is [1, 2, 3]

const result: Result<string, number> = ok('hello')

// Before isOk() check
result.value  // ❌ TypeScript error: Property 'value' doesn't exist on Result

if (result.isOk()) {
  // After isOk() check
  result.value  // ✅ TypeScript knows this is safe
}

// Using isOk - imperative style
if (result.isOk()) {
  console.log(result.value)
} else {
  console.error(result.error)
}

// Using match - functional style
result.match(
  value => console.log(value),
  error => console.error(error)
)

// Using isOk with conditional logic
const value = result.isOk() ? result.value : defaultValue

// Using unwrapOr - more concise
const value = result.unwrapOr(defaultValue)