Carp/core/Collection.carp

(definterface unsafe-nth (Fn [(Ref (a b) c) Int] &b))
(implements unsafe-nth Array.unsafe-nth)
(implements unsafe-nth StaticArray.unsafe-nth)
(definterface length (Fn [(Ref (a b))] Int))
(implements unsafe-nth Array.length)
(implements unsafe-nth StaticArray.length)

(defmodule Collections
  (defn empty? [a] 
    (= 0 (length a)))
  (defn first [a] 
    (if (empty? a)
        (Maybe.Nothing)
        (Maybe.Just @(unsafe-nth a 0))))
)
Add an implements primitive, update core This change adds a new primitive Implements which changes interface implementations from being implicit to being explicit. Going forward, users will have to declare (implements <interface> <implementation>) to explicitly add a function to an interface. This provides two benefits: - Prevents unwitting name clashes. Previously, if one defined a function that happened to have the same name as an interface, it was automatically assumed the function implemented that interface when this is not always the intention, especially in large programs. - Name flexibility. One can now implement an interface with a function that has a different name than the interface, which allows for greater flexibility. I've updated core to make the necessary calls to the new primitive. Since str and copy are derived automatically for types, we treat these functions as a special case and auto-implement the interfaces. 2020-05-09 19:59:47 +03:00			`(definterface unsafe-nth (Fn [(Ref (a b) c) Int] &b))`
Add some more calls to implement to make tests pass 2020-05-10 20:32:22 +03:00			`(implements unsafe-nth Array.unsafe-nth)`
			`(implements unsafe-nth StaticArray.unsafe-nth)`
Add an implements primitive, update core This change adds a new primitive Implements which changes interface implementations from being implicit to being explicit. Going forward, users will have to declare (implements <interface> <implementation>) to explicitly add a function to an interface. This provides two benefits: - Prevents unwitting name clashes. Previously, if one defined a function that happened to have the same name as an interface, it was automatically assumed the function implemented that interface when this is not always the intention, especially in large programs. - Name flexibility. One can now implement an interface with a function that has a different name than the interface, which allows for greater flexibility. I've updated core to make the necessary calls to the new primitive. Since str and copy are derived automatically for types, we treat these functions as a special case and auto-implement the interfaces. 2020-05-09 19:59:47 +03:00			`(definterface length (Fn [(Ref (a b))] Int))`
Add some more calls to implement to make tests pass 2020-05-10 20:32:22 +03:00			`(implements unsafe-nth Array.length)`
			`(implements unsafe-nth StaticArray.length)`
Add an implements primitive, update core This change adds a new primitive Implements which changes interface implementations from being implicit to being explicit. Going forward, users will have to declare (implements <interface> <implementation>) to explicitly add a function to an interface. This provides two benefits: - Prevents unwitting name clashes. Previously, if one defined a function that happened to have the same name as an interface, it was automatically assumed the function implemented that interface when this is not always the intention, especially in large programs. - Name flexibility. One can now implement an interface with a function that has a different name than the interface, which allows for greater flexibility. I've updated core to make the necessary calls to the new primitive. Since str and copy are derived automatically for types, we treat these functions as a special case and auto-implement the interfaces. 2020-05-09 19:59:47 +03:00
			`(defmodule Collections`
			`(defn empty? [a]`
			`(= 0 (length a)))`
			`(defn first [a]`
			`(if (empty? a)`
			`(Maybe.Nothing)`
			`(Maybe.Just @(unsafe-nth a 0))))`
			`)`