From b8445b011d9b2a287af0e014998c42525a7fd315 Mon Sep 17 00:00:00 2001
From: JJ
Date: Fri, 29 Dec 2023 16:03:06 -0800
Subject: std: restructure, refactor std.ast

---
 std/default/results.pk | 136 -------------------------------------------------
 1 file changed, 136 deletions(-)
 delete mode 100644 std/default/results.pk

(limited to 'std/default/results.pk')

diff --git a/std/default/results.pk b/std/default/results.pk
deleted file mode 100644
index 8e21234..0000000
--- a/std/default/results.pk
+++ /dev/null
@@ -1,136 +0,0 @@
-## std/results: Result types.
-## This module is imported by default.
-
-use std[options, format]
-
-## The Result type. Represents either success or failure.
-pub type Result[T, E] = union
-  Okay(T)
-  Error(E)
-
-## The Err interface. Useful for dynamically dispatching errors.
-pub type Err = interface
-  str(Self): str
-  dbg(Self): str
-
-## A `Result` type that uses dynamically dispatched errors.
-## The `Error` may be any type implementing `Err`.
-pub type Result[T] = Result[T, ref Err]
-## A `Result` type that only checks for success.
-## Does not contain a value.
-pub type Success[E] = Result[Unit, E]
-
-## Checks if a `Result` type was successful.
-pub func is_ok[T, E](self: Result[T, E]): bool =
-  self of Okay(_)
-## Checks if a `Result` type was not successful.
-pub func is_err[T, E](self: Result[T, E]): bool =
-  self of Error(_)
-
-## Converts from a `Result[T, E]` to an `Option[T]`.
-pub func ok[T, E](self: Result[T, E]): Option[T] =
-  if self of Okay(x):
-    Some(x)
-  else:
-    None()
-## Converts from a `Result[T, E]` to an `Option[E]`.
-pub func err[T, E](self: Result[T, E]): Option[E] =
-  if self of Error(x):
-    Some(x)
-  else:
-    None()
-
-## Applies a function to `T`, if self is `Okay`.
-pub func map[T, E, U](self: Result[T, E], fn: T -> U): Result[U, E] =
-  match self
-  of Okay(x):
-    Okay(fn(x))
-  of Error(e):
-    Error(e)
-## Applies a function to `E`, if self is `Error`.
-pub func map_err[T, E, F](self: Result[T, E], fn: E -> F): Result[T, F] =
-  match self
-  of Error(e):
-    Error(fn(e))
-  of Okay(x):
-    Okay(x)
-
-## Applies a function to `T`, if it exists. Equivalent to `self.map(fn).flatten`.
-pub func flatmap[T, E, U](self: Result[T, E], fn: T -> Result[U, E]): Result[U, E] =
-  match self
-  of Okay(x):
-    fn(x)
-  of Error(e):
-    Error(e)
-## Converts from a `Result[Result[T, E], E]` to a `Result[T, E]`.
-pub func flatten[T, E](self: Result[Result[T, E], E]): Result[T, E] =
-  match self
-  of Okay(Okay(x)):
-    Okay(x)
-  of Okay(Error(e)), Error(e):
-    Error(e)
-
-## Transposes a `Result[Option[T], E]` to an `Option[Result[T, E]]`.
-pub func transpose[T, E](self: Result[Option[T], E]): Option[Result[T, E]] =
-  match self
-  of Okay(Some(x)):
-    Some(Okay(x))
-  of Okay(None()), Error(_):
-    None()
-## Transposes an `Option[Result[T, E]]` to a `Result[Option[T], E]`. Takes a default error.
-pub func transpose[T, E](self: Option[Result[T, E]], error: E): Result[Option[T], E] =
-  match self
-  of Some(Okay(x)):
-    Okay(Some(x))
-  of Some(Error(e)):
-    Error(e)
-  of None():
-    Error(error)
-
-## Returns the inner value or a default.
-pub func get_or[T, E](self: Result[T, E], default: T): T =
-  if self of Okay(x): x
-  else: default
-
-## Directly accesses the inner value. Throws an exception if `Error`.
-pub func ![T, E](self: Result[T, E]): T =
-  match self
-  of Okay(x): x
-  of Error(e): raise e
-## Directly accesses the inner error. Throws an exception of type T if `Okay`.
-pub func get_err[T, E](self: Result[T, E]): E =
-  match self
-  of Error(e): e
-  of Okay(x): raise x
-
-## Indirect access. Propagates `Error`.
-pub macro ?[T, E](self: Result[T, E]) =
-  quote:
-    match `self`
-    of Okay(x): x
-    of Error(e): return Error(e)
-
-## Overloads the `==` operation for use on Results.
-pub func ==[T, E, F](a: Result[T, E], b: Result[T, F]): bool =
-  match (a, b)
-  of (Okay(x), Okay(y)):
-    x == y
-  of _:
-    false
-
-## Overloads the `str()` function for use on Results.
-pub func str[T, E](self: Result[T, E]): str =
-  match self
-  of Some(x):
-    fmt("Okay({})", x.str)
-  of Error(e):
-    fmt("Error({})", e.str)
-
-examples:
-  let x: Error("fuck") = Okay(42)
-  func idk: Result[int, string]
-
-# references:
-# https://doc.rust-lang.org/std/result/enum.Result.html
-# https://github.com/arnetheduck/nim-results
-# https://github.com/codex-storage/questionable
-- 
cgit v1.2.3-70-g09d2