Move Builtin Types and Methods to stdlib

app/gui/view/graph-editor/src/builtin/visualization/native/inc/error_preprocessor.enso

@@ -1,7 +1,7 @@
 x ->
-    result = Builtins.Ref.new '{ message: ""}'
+    result = Ref.new '{ message: ""}'
     x.catch err->
         message = err.to_display_text
-        Builtins.Ref.put result ('{ "kind": "Dataflow", "message": ' + message.to_json.to_text + '}')
-    Builtins.Ref.get result
+        Ref.put result ('{ "kind": "Dataflow", "message": ' + message.to_json.to_text + '}')
+    Ref.get result
 

distribution/lib/Standard/Base/0.0.0-dev/src/Data/Any.enso

@@ -0,0 +1,373 @@
+from Standard.Base import all
+
+# The type that subsumes all types.
+type Any
+
+    ## Any is the universal top-type, with all other types being subsumed by it.
+
+       If a value of type Any is expected in a given location, _any value_ can
+       be used in that position.
+    @Builtin_Type
+    type Any
+
+    ## PRIVATE
+
+       Executes the provided handler on a dataflow error, or executes as
+       identity on a non-error value.
+
+       Arguments:
+       - handler: The function to call on this if it is an error value.
+    catch_primitive : (Error -> Any) -> Any
+    catch_primitive handler = @Builtin_Method "Any.catch"
+
+    ## Generic conversion of an arbitrary Enso value to a corresponding textual
+       representation.
+
+       > Example
+         Getting a textual representation of the number 7.
+
+             7.to_text
+    to_text : Text
+    to_text = @Builtin_Method "Any.to_text"
+
+    ## ALIAS Equality
+
+       Checks if `this` is equal to `that`.
+
+       Arguments:
+       - that: The object to compare `this` with.
+
+       Two values are considered to be equal in Enso when they obey the following
+       recursive properties:
+       - At each level, they have the same structure.
+       - The value of each field in `this` is equal (by this definition) to the
+         corresponding field in `that`.
+
+       ! Implementing Your Own Equality
+         Equality in Enso is defined to allow comparison of any two values
+         (universal equality), no matter if they are not directly comparable. When
+         implementing equality for your own types, keep in mind that it needs to
+         work with any Enso value as the `that` argument.
+
+       ? Generic Equality and Performance
+         While the generic equality provided here will work for _all_ values in
+         Enso, its performance may often be suboptimal. Many types can implement
+         their own equality operations that will be more efficient than these.
+
+       > Example
+         Checking if the variable `a` is equal to `147`.
+
+             from Standard.Base import all
+
+             example_equality =
+                 a = 7 * 21
+                 a == 147
+    == : Any -> Boolean
+    == that = if Meta.is_same_object this that then True else
+        this_meta = Meta.meta this
+        that_meta = Meta.meta that
+        case Cons this_meta that_meta of
+            Cons (Meta.Atom _) (Meta.Atom _) ->
+                c_1 = this_meta.constructor
+                c_2 = that_meta.constructor
+                if Meta.is_same_object c_1 c_2 . not then False else
+                    f_1 = this_meta.fields
+                    f_2 = that_meta.fields
+                    0.up_to f_1.length . all i-> (f_1.at i) == (f_2.at i)
+            Cons (Meta.Error _) (Meta.Error _) -> this_meta.payload == that_meta.payload
+            Cons (Meta.Polyglot o_1) (Meta.Polyglot o_2) ->
+                langs_match = (this_meta.get_language == Meta.Java) && (that_meta.get_language == Meta.Java)
+                if langs_match.not then False else o_1.equals o_2
+            Cons (Meta.Unresolved_Symbol _) (Meta.Unresolved_Symbol _) ->
+                (this_meta.name == that_meta.name) && (this_meta.scope == that_meta.scope)
+            ## Constructor comparison is covered by the identity equality.
+               Primitive objects should define their own equality.
+               Therefore, there are no more cases to handle in this method.
+            _ -> False
+
+    ## ALIAS Inequality
+
+       Checks if `this` is not equal to `that`.
+
+       Arguments:
+       - that: The object to compare `this` against.
+
+       ! Implementing Your Own Inequality
+         We recommend that you do not implement your own inequality, instead relying
+         on the default definition given here. If you do, please ensure that you
+         satisfy universal equality, as described in the documentation for `Any.==`.
+
+       > Example
+         Checking if the variable `a` is not equal to `147`.
+
+             from Standard.Base import all
+
+             example_inequality =
+                 a = 7 * 21
+                 a != 147
+    != : Any -> Boolean
+    != that = (this == that).not
+
+    ## ALIAS Greater Than
+
+       Checks if `this` is greater than `that`.
+
+       Arguments:
+       - that: The value to compare `this` against.
+
+       To have `>` defined, a type must define `compare_to`, returning an Ordering.
+
+       ! Implementing Greater Than
+         Many types can admit a definition of greater than that is more efficient
+         than the generic one given here. When implementing this for your own types
+         please ensure that it is semantically equivalent to using `.compare_to`.
+
+       > Example
+         Checking if the variable `a` is greater than `147`.
+
+             from Standard.Base import all
+
+             example_greater =
+                 a = 7 * 28
+                 a > 147
+    > : Any -> Boolean
+    > that = this.compare_to that == Ordering.Greater
+
+    ## ALIAS Greater Than or Equal
+
+       Checks if `this` is greater than or equal to `that`.
+
+       Arguments:
+       - that: The value to compare `this` against.
+
+       To have `>=` defined, a type must define both `>` and `==`.
+
+       ! Implementing Greater Than or Equal
+         While it is often possible to implement a more efficient version of this
+         operation for complex types, care must be taken to ensure that your
+         implementation is semantically equivalent to the disjunction of the
+         greater than and equal to operations.
+
+       > Example
+         Checking if the variable `a` is greater than or equal to `147`.
+
+             from Standard.Base import all
+
+             example_greater_eq =
+                 a = 6 * 21
+                 a >= 147
+    >= : Any -> Boolean
+    >= that = (this > that) || (this == that)
+
+    ## ALIAS Less Than
+
+       Checks if `this` is less than `that`.
+
+       Arguments:
+       - that: The value to compare `this` against.
+
+       To have `<` defined, a type must define `compare_to`, returning an Ordering.
+
+       ! Implementing Less Than
+         Many types can admit a definition of less than that is more efficient than
+         the generic one given here. When implementing this for your own types
+         please ensure that it is semantically equivalent to using `.compare_to`.
+
+       > Example
+         Checking if the variable `a` is less than `147`.
+
+             from Standard.Base import all
+
+             example_less =
+                 a = 7 * 21
+                 a < 147
+    < : Any -> Boolean
+    < that = this.compare_to that == Ordering.Less
+
+    ## ALIAS Less Than or Equal
+
+       Checks if `this` is less than or equal to `that`.
+
+       Arguments:
+       - that: The value to compare `this` against.
+
+       To have `<=` defined, a type must define both `<` and `==`.
+
+       ! Implementing Less Than or Equal
+         While it is often possible to implement a more efficient version of this
+         operation for complex types, care must be taken to ensure that your
+         implementation is semantically equivalent to the disjunction of the
+         less than than and equal to operations.
+
+       > Example
+         Checking if the variable `a` is less than or equal to `147`.
+
+             from Standard.Base import all
+
+             example_less_eq =
+                 a = 7 * 21
+                 a < 147
+    <= : Any -> Boolean
+    <= that = (this < that) || (this == that)
+
+    ## Checks if the type is an instance of `Nothing`.
+
+       Nothing in Enso is used as a universal value to indicate the lack of presence
+       of a value. This function is primarily useful in the IDE.
+
+       > Example
+         Checking if the value 1 is nothing.
+
+             1.is_nothing
+    is_nothing : Boolean
+    is_nothing = case this of
+        Nothing -> True
+        _ -> False
+
+    ## Executes the provided handler on an error, or returns a non-error value
+       unchanged.
+
+       Arguments:
+       - handler: The function to call on this if it is an error value. By default
+         this is identity.
+
+       > Example
+         Catching an erroneous value and getting the length of its message.
+
+             from Standard.Base import all
+
+             example_catch =
+                 error = Error.throw "My message"
+                 error.catch (err -> err.length)
+    catch : (Error -> Any) -> Any
+    catch (handler = x->x) = this.catch_primitive handler
+
+    ## Transforms an error.
+
+       Arguments:
+       - f: The function used to transform the error.
+
+       If `this` is a non-error value it is returned unchanged. However, if `this`
+       is an error, the error is transformed using the provided function.
+
+       > Example
+         Transforming an error value to provide more information.
+
+             from Standard.Base import all
+             from Standard.Examples import Example_Error_Type
+
+             example_map_error =
+                my_map = Map.empty
+                error = my_map.get "x"
+                error.map_error (_ -> Example_Error_Type "x is missing")
+    map_error : (Error -> Error) -> Any
+    map_error _ = this
+
+    ## Checks if `this` is an error.
+
+       > Example
+         Checking if the provided value is an error.
+
+             1.is_error
+    is_error : Boolean
+    is_error = False
+
+    ## Applies the provided function to `this` unless `this` is `Nothing`, which is
+       returned unchanged.
+
+       Arguments:
+       - f: The function to apply to `this` if `this` is not `Nothing`.
+
+       > Example
+         Applying a function over a value 10.
+
+             10.map_nothing *2
+    map_nothing : (a -> b) -> b | Nothing
+    map_nothing f = case this of
+        Nothing -> Nothing
+        a -> f a
+
+    ## Applies the function `this` to the provided argument.
+
+       Arguments:
+       - argument: The argument to apply `this` to.
+
+       ? Piping Blocks to Functions
+         This construction is particularly useful for passing a block as an argument
+         to a function. This means that you can compute more sophisticated values
+         in-line, as shown in the example below.
+
+       > Example
+         Applying a function to a block.
+
+             (x -> x + 1) <|
+                y = 1 ^ 3
+                3 + y
+    <| : Any -> Any
+    <| ~argument = this argument
+
+    ## Applies the function on the right hand side to the argument on the left.
+
+       Arguments
+       - function: The function to apply to `this`.
+
+       ? `|>` or `.`?
+         The eagle-eyed reader will notice that the operator dot (`.`) is very
+         similar to the operator `|>`. In Enso, with the variable precedence of
+         operators, this makes perfect sense. In general, we recommend using `.`.
+         However, there are some contexts where variable precedence might be unclear
+         or confusing, or where the function being applied is not a method. In these
+         contexts we recommend using `|>`.
+
+       > Example
+         Applying multiple functions in a pipeline to compute a number and transform
+         it to text.
+
+             1 |> (* 2) |> (/ 100) |> .to_text
+    |> : (Any -> Any) -> Any
+    |> ~function = function this
+
+    ## Composes two functions together, for `f << g` creating the function
+       composition `f ∘ g` (equivalent to `x -> f (g x)`).
+
+       Arguments:
+       - that: The function to compose with `this`.
+
+       > Example
+         Multiply by 2 and then add 1 as a function applied to 2.
+
+             (+1 << *2) 2
+    << : (Any -> Any) -> (Any -> Any) -> Any -> Any
+    << ~that = x -> this (that x)
+
+    ## Composes two functions together in the forward direction, for `f >> g`
+       creating the function composition `g ∘ f` (equivalent to `x -> g (f (x))`).
+
+       Arguments:
+       - that: The function to compose with `this`.
+
+       > Example
+         Add one and then multiply by two as a function applied to 2.
+
+             (+1 >> *2) 2
+    >> : (Any -> Any) -> (Any -> Any) -> Any -> Any
+    >> ~that = x -> that (this x)
+
+    ## UNSTABLE
+       ADVANCED
+
+       Returns a Text used to display this value in the IDE.
+
+       The particular representation is left unspecified and subject to change in
+       the future. The current implementation uses JSON serialization as the
+       default.
+
+       Types defining their own versions of this method should ensure that the
+       result is reasonably small and that the operation is quick to compute.
+
+       > Example
+         Converting the number `2` into visualization data.
+
+             2.to_default_visualization_data
+    to_default_visualization_data : Text
+    to_default_visualization_data = this.to_json.to_text