Get rid of free-floating atoms. Everything has a type now!

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

@@ -2,15 +2,12 @@ from Standard.Base import all
 
 from Standard.Base.Error.Common import dataflow_error_handler
 
-# The type that subsumes all types.
-type Any
-
-    ## Any is the universal top-type, with all other types being subsumed by it.
+## 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
+   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
 
@@ -78,19 +75,19 @@ type Any
     == self that = if Meta.is_same_object self that then True else
         self_meta = Meta.meta self
         that_meta = Meta.meta that
-        case Cons self_meta that_meta of
-            Cons (Meta.Atom _) (Meta.Atom _) ->
+        case Pair_Data self_meta that_meta of
+            Pair_Data (Meta.Atom_Data _) (Meta.Atom_Data _) ->
                 c_1 = self_meta.constructor
                 c_2 = that_meta.constructor
                 if Meta.is_same_object c_1 c_2 . not then False else
                     f_1 = self_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 _) -> self_meta.payload == that_meta.payload
-            Cons (Meta.Polyglot o_1) (Meta.Polyglot o_2) ->
+            Pair_Data (Meta.Error_Data _) (Meta.Error_Data _) -> self_meta.payload == that_meta.payload
+            Pair_Data (Meta.Polyglot_Data o_1) (Meta.Polyglot_Data o_2) ->
                 langs_match = (self_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 _) ->
+            Pair_Data (Meta.Unresolved_Symbol_Data _) (Meta.Unresolved_Symbol_Data _) ->
                 (self_meta.name == that_meta.name) && (self_meta.scope == that_meta.scope)
             ## Constructor comparison is covered by the identity equality.
                Primitive objects should define their own equality.

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

@@ -1,12 +1,8 @@
 import Standard.Base.Data.Vector
 
-## Utilities for working with primitive arrays.
+## The type of primitive mutable arrays.
+@Builtin_Type
 type Array
-
-    ## The type of primitive mutable arrays.
-    @Builtin_Type
-    type Array
-
     ## Gets the element at index in the array this.
 
        Arguments:
@@ -68,7 +64,7 @@ type Array
              [1, 2, 3, 4].to_array.to_default_visualization_data
     to_default_visualization_data : Text
     to_default_visualization_data self =
-        Vector.Vector self . to_default_visualization_data
+        Vector.Vector_Data self . to_default_visualization_data
 
 ## Creates an array with length 0.
 

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

@@ -1,12 +1,11 @@
-## Booleans.
-type Boolean
-
-    ## A type with only two possible values.
+## A type with only two possible values.
 
-       The boolean type represents the two truth values of boolean logic. It is
-       primarily used for control-flow.
-    @Builtin_Type
-    type Boolean
+   The boolean type represents the two truth values of boolean logic. It is
+   primarily used for control-flow.
+@Builtin_Type
+type Boolean
+    True
+    False
 
     ## Compares two booleans for equality.
 
@@ -106,11 +105,3 @@ type Boolean
              if (27 % 3) == 0 then IO.println "Fizz"
     if_then : Any -> Any | Nothing
     if_then self ~on_true = @Builtin_Method "Boolean.if_then"
-
-## The constructor for the value True.
-@Builtin_Type
-type True
-
-## The constructor for the value False.
-@Builtin_Type
-type False

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

@@ -8,16 +8,16 @@ type Index_Sub_Range
 
        Selects no items if `count` is less than or equal to 0.
        Selects all items  if `count` is greater than the length of the input.
-    type First (count : Integer = 1)
+    First (count : Integer = 1)
 
     ## Select the last `count` characters.
 
        Selects no items if `count` is less than or equal to 0.
        Selects all items  if `count` is greater than the length of the input.
-    type Last (count : Integer = 1)
+    Last (count : Integer = 1)
 
     ## Select elements from the start while the predicate returns `True`.
-    type While (predicate : (Any -> Boolean))
+    While (predicate : (Any -> Boolean))
 
     ## Selects specific indexes (starting from 0) either as an `Integer` or a
        `Range`.
@@ -29,21 +29,21 @@ type Index_Sub_Range
        Only ranges with positive step and positive indices are supported.
        Individual integer indices can be negative which allows for indexing
        from the end of the collection.
-    type By_Index (indexes : (Integer | Range | Vector (Integer | Range)) = [0])
+    By_Index (indexes : (Integer | Range | Vector (Integer | Range)) = [0])
 
     ## Gets a random sample of entries, without repetitions.
 
        If `count` is greater than the length of the input, a random permutation
        of all elements from the input is selected.
-    type Sample (count:Integer) (seed:Integer=Random.get_default_seed)
+    Sample (count:Integer) (seed:Integer=Random.get_default_seed)
 
     ## Gets every Nth entry.
 
        Arguments:
        - step: The step between consecutive entries that are included.
        - first: The first entry to include. If it is outside of bounds of the
          input, an error is raised.
-    type Every (step:Integer) (first:Integer=0)
+    Every (step:Integer) (first:Integer=0)
 
 ## PRIVATE
    Resolves a vector of ranges or indices into a vector of ranges that fit
@@ -55,15 +55,15 @@ resolve_ranges ranges length =
     trim descriptor = case descriptor of
         Integer ->
             actual_index = if descriptor < 0 then length + descriptor else descriptor
-            if (actual_index < 0) || (actual_index >= length) then Panic.throw (Index_Out_Of_Bounds_Error descriptor length) else
+            if (actual_index < 0) || (actual_index >= length) then Panic.throw (Index_Out_Of_Bounds_Error_Data descriptor length) else
                 actual_index
-        Range start end step ->
-            if step <= 0 then Panic.throw (Illegal_Argument_Error "Range step must be positive.") else
-                if (start < 0) || (end < 0) then Panic.throw (Illegal_Argument_Error "Range start and end must not be negative.") else
-                    if start >= length then Panic.throw (Index_Out_Of_Bounds_Error start length) else
+        Range_Data start end step ->
+            if step <= 0 then Panic.throw (Illegal_Argument_Error_Data "Range step must be positive.") else
+                if (start < 0) || (end < 0) then Panic.throw (Illegal_Argument_Error_Data "Range start and end must not be negative.") else
+                    if start >= length then Panic.throw (Index_Out_Of_Bounds_Error_Data start length) else
                         actual_end = Math.min end length
-                        if actual_end < start then Range start start step else
-                            Range start actual_end step
+                        if actual_end < start then Range_Data start start step else
+                            Range_Data start actual_end step
     ranges.map trim
 
 ## PRIVATE
@@ -73,11 +73,11 @@ resolve_ranges ranges length =
    single-element ranges.
 normalize_ranges descriptors =
     normalize descriptor = case descriptor of
-        Integer -> [Range descriptor descriptor+1]
-        Range _ _ _ ->
+        Integer -> [Range_Data descriptor descriptor+1]
+        Range_Data _ _ _ ->
             if descriptor.step == 1 then [descriptor] else
                 descriptor.to_vector.map ix->
-                    Range ix ix+1
+                    Range_Data ix ix+1
     descriptors.flat_map normalize
 
 ## PRIVATE
@@ -96,9 +96,9 @@ normalize_ranges descriptors =
 invert_range_selection : Vector Range -> Integer -> Boolean -> Vector Range
 invert_range_selection ranges length needs_sorting =
     sorted = if needs_sorting then sort_and_merge_ranges ranges else ranges
-    ranges_with_sentinels = [Range 0 0] + sorted + [Range length length]
+    ranges_with_sentinels = [Range_Data 0 0] + sorted + [Range_Data length length]
     ranges_with_sentinels.zip ranges_with_sentinels.tail prev-> next->
-        Range prev.end next.start
+        Range_Data prev.end next.start
 
 ## PRIVATE
    Returns a new sorted list of ranges where intersecting ranges have been
@@ -113,7 +113,7 @@ sort_and_merge_ranges ranges =
         sorted.tail.each range->
             current = current_ref.get
             case range.start <= current.end of
-                True -> current_ref.put (Range current.start (Math.max current.end range.end))
+                True -> current_ref.put (Range_Data current.start (Math.max current.end range.end))
                 False ->
                     builder.append current
                     current_ref.put range
@@ -147,16 +147,16 @@ sort_and_merge_ranges ranges =
    - range: The `Index_Sub_Range` to take from the collection.
 take_helper : Integer -> (Integer -> Any) -> (Integer -> Integer -> Any) -> (Vector (Integer | Range) -> Vector Any) -> Index_Sub_Range -> Any
 take_helper length at single_slice slice_ranges index_sub_range = case index_sub_range of
-    Range _ _ _ -> take_helper length at single_slice slice_ranges (By_Index index_sub_range)
+    Range_Data _ _ _ -> take_helper length at single_slice slice_ranges (By_Index index_sub_range)
     First count -> single_slice 0 (Math.min length count)
     Last count -> single_slice length-count length
     While predicate ->
         end = 0.up_to length . find i-> (predicate (at i)).not
         true_end = if end.is_nothing then length else end
         single_slice 0 true_end
-    By_Index one_or_many_descriptors -> Panic.recover [Index_Out_Of_Bounds_Error, Illegal_Argument_Error] <|
+    By_Index one_or_many_descriptors -> Panic.recover [Index_Out_Of_Bounds_Error_Data, Illegal_Argument_Error_Data] <|
         indices = case one_or_many_descriptors of
-            Vector.Vector _ -> one_or_many_descriptors
+            Vector.Vector_Data _ -> one_or_many_descriptors
             _ -> [one_or_many_descriptors]
         trimmed = resolve_ranges indices length
         slice_ranges trimmed
@@ -165,9 +165,9 @@ take_helper length at single_slice slice_ranges index_sub_range = case index_sub
         indices_to_take = Random.random_indices length count rng
         take_helper length at single_slice slice_ranges (By_Index indices_to_take)
     Every step start ->
-        if step <= 0 then Error.throw (Illegal_Argument_Error "Step within Every must be positive.") else
+        if step <= 0 then Error.throw (Illegal_Argument_Error_Data "Step within Every must be positive.") else
             if start >= length then single_slice 0 0 else
-                range = Range start length step
+                range = Range_Data start length step
                 take_helper length at single_slice slice_ranges (By_Index range)
 
 ## PRIVATE
@@ -196,16 +196,16 @@ take_helper length at single_slice slice_ranges index_sub_range = case index_sub
    - range: The `Index_Sub_Range` to drop from the collection.
 drop_helper : Integer -> (Integer -> Any) -> (Integer -> Integer -> Any) -> (Vector (Integer | Range) -> Vector Any) -> Index_Sub_Range -> Any
 drop_helper length at single_slice slice_ranges index_sub_range = case index_sub_range of
-    Range _ _ _ -> drop_helper length at single_slice slice_ranges (By_Index index_sub_range)
+    Range_Data _ _ _ -> drop_helper length at single_slice slice_ranges (By_Index index_sub_range)
     First count -> single_slice count length
     Last count -> single_slice 0 length-count
     While predicate ->
         end = 0.up_to length . find i-> (predicate (at i)).not
         true_end = if end.is_nothing then length else end
         single_slice true_end length
-    By_Index one_or_many_descriptors -> Panic.recover [Index_Out_Of_Bounds_Error, Illegal_Argument_Error] <|
+    By_Index one_or_many_descriptors -> Panic.recover [Index_Out_Of_Bounds_Error_Data, Illegal_Argument_Error_Data] <|
         indices = case one_or_many_descriptors of
-            Vector.Vector _ -> one_or_many_descriptors
+            Vector.Vector_Data _ -> one_or_many_descriptors
             _ -> [one_or_many_descriptors]
         trimmed = resolve_ranges indices length
         normalized = normalize_ranges trimmed
@@ -216,7 +216,7 @@ drop_helper length at single_slice slice_ranges index_sub_range = case index_sub
         indices_to_drop = Random.random_indices length count rng
         drop_helper length at single_slice slice_ranges (By_Index indices_to_drop)
     Every step start ->
-        if step <= 0 then Error.throw (Illegal_Argument_Error "Step within Every must be positive.") else
+        if step <= 0 then Error.throw (Illegal_Argument_Error_Data "Step within Every must be positive.") else
             if start >= length then single_slice 0 length else
-                range = Range start length step
+                range = Range_Data start length step
                 drop_helper length at single_slice slice_ranges (By_Index range)

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

@@ -13,7 +13,7 @@ export Standard.Base.Data.Interval.Bound
 
          example_exclusive = Interval.exclusive 0.1 0.5
 exclusive : Number -> Number -> Interval
-exclusive start end = Interval (Bound.Exclusive start) (Bound.Exclusive end)
+exclusive start end = Interval_Data (Bound.Exclusive start) (Bound.Exclusive end)
 
 ## Creates an interval that excludes its lower bound.
 
@@ -24,7 +24,7 @@ exclusive start end = Interval (Bound.Exclusive start) (Bound.Exclusive end)
 
          example_start_exclusive = Interval.start_exclusive 1 5
 start_exclusive : Number -> Number -> Interval
-start_exclusive start end = Interval (Bound.Exclusive start) (Bound.Inclusive end)
+start_exclusive start end = Interval_Data (Bound.Exclusive start) (Bound.Inclusive end)
 
 ## Creates an interval that excludes its upper bound.
 
@@ -35,7 +35,7 @@ start_exclusive start end = Interval (Bound.Exclusive start) (Bound.Inclusive en
 
          example_end_exclusive = Interval.end_exclusive 1 5
 end_exclusive : Number -> Number -> Interval
-end_exclusive start end = Interval (Bound.Inclusive start) (Bound.Exclusive end)
+end_exclusive start end = Interval_Data (Bound.Inclusive start) (Bound.Exclusive end)
 
 ## Creates an interval that includes both of its bounds.
 
@@ -46,7 +46,7 @@ end_exclusive start end = Interval (Bound.Inclusive start) (Bound.Exclusive end)
 
          example_inclusive = Interval.inclusive 0 0
 inclusive : Number -> Number -> Interval
-inclusive start end = Interval (Bound.Inclusive start) (Bound.Inclusive end)
+inclusive start end = Interval_Data (Bound.Inclusive start) (Bound.Inclusive end)
 
 ## A type representing an interval over real numbers.
 type Interval
@@ -58,7 +58,7 @@ type Interval
        Arguments:
        - start: The start of the interval.
        - end: The end of the interval.
-    type Interval (start : Number) (end : Number)
+    Interval_Data (start : Bound.Bound) (end : Bound.Bound)
 
     ## Checks if the interval contains `that`.
 

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

@@ -16,7 +16,7 @@ type Bound
              import Standard.Base.Data.Interval.Bound
 
              example_bound_inclusive = Bound.Inclusive 2
-    type Inclusive n
+    Inclusive n
 
     ## A bound that excludes the value `n`.
 
@@ -29,4 +29,4 @@ type Bound
              import Standard.Base.Data.Interval.Bound
 
              example_bound_exclusive = Bound.Exclusive 2.
-    type Exclusive n
+    Exclusive n