import {
  Some,
  None,
  Ok,
  Err,
 
  match,
} from 'rust-option'
 
let x = Some(2)
let y = None
let z = Ok(1)
let w = Err('error')
 
// Note: matches are exhaustive
let ret = match(x, [
  [Some(2), theX => 'match and get the 2'],
  [None, () => 'should not match None'],
  [Ok, () => 'should not match Ok'],
  [Err('error'), () => 'should not match Err(\'error\')'],
  // function is not a must
  [Some(2), 'something'],
  // the 'default' match must be function
  (arg) => 'should not match default',
])
// ret is 'match and get the Some(2)'

match(1, [
  [1, () => console.log('match')],
  () => console.log('not match ')
])

match(1, [
  [Number, (x) => console.log(x)],
  () => console.log('not match ')
])

// this will throws 'non-exhaustive patterns' Error
match(x, [
  [None, () => console.log('not match None')],
])

match(x, [
  m => console.log('default match get Some(2) as parameter')
])

let z = Ok(x)
let w = Err('error')
 
match(z, [
  [Ok(Some(2)), () => console.log('match and get Some(2)')],
  [w, () => console.log('not match Err')],
  // the 'default' match
  () => console.log('not match default'),
])

Ok(1).$ === 1  // similar to Ok(1).unwrap() and Ok(1)?
 
try {
  Err('I am Err').$
} catch (err) {
  err.message === 'I am Err'
}
 
Some(1).$ === 1  // similar to Some(1).unwrap() and Some(1)?
 
try {
  None.$
} catch (err) {
  err instanceof NoneError
}

match(x, [
  () => 'x'
])

makeMatch([
  () => 'x'
])(x)

// equal
Some(1).equal(Some(1))
 
// deepEqual
Ok({a: 1}).equal(Ok({a: 1}), true)

const content = await resultify(() => Promise.resolve('content'))()
 
match(content, [
  [Ok, c => c],
  [Err, 'nothing']
])

const content = resultifySync(fs.statSync)('./f')
 
match(content, [
  [Ok, c => c],
  [Err, 'nothing']
])

import {
  Some
} from 'rust-option'
 
let ox = Some({foo: 1})
let oy = Some({foo: 1})
ox.equal(oy)  // false
ox.equal(oy, true)  // true