Carp/core/Bool.carp

(system-include "carp_bool.h")

(defmodule Bool
  (register = (Fn [Bool Bool] Bool))
  (implements = Bool.=)
  (register copy (Fn [&Bool] Bool))
  (implements copy Bool.copy)
  (register format (Fn [&String Bool] String))
  (register not (Fn [Bool] Bool))
  (register and (Fn [Bool Bool] Bool))
  (register or (Fn [Bool Bool] Bool))

  (defn zero [] false)
  (implements zero Bool.zero)
)

(defmodule RefBool
  (defn = [a b]
    (Bool.= @a @b))
  (implements = RefBool.=)
  )

(defn not [a] (Bool.not a))
core: namespaced split-up carp headers 2018-01-24 18:08:18 +03:00			`(system-include "carp_bool.h")`
core: split up core.h, installment 1 2018-01-24 17:53:18 +03:00
Added Bool module. Fixed error in test selection.carp 2017-10-11 11:52:18 +03:00			`(defmodule Bool`
testing: added Test module 2017-10-20 18:00:47 +03:00			`(register = (Fn [Bool Bool] Bool))`
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			`(implements = Bool.=)`
core: minor fixes 2017-12-04 20:28:40 +03:00			`(register copy (Fn [&Bool] Bool))`
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			`(implements copy Bool.copy)`
core: made format not leak memory; test: added test for format and fmt 2017-12-30 22:16:31 +03:00			`(register format (Fn [&String Bool] String))`
Preserve includes order in generated output. 2019-10-03 01:23:27 +03:00			`(register not (Fn [Bool] Bool))`
			`(register and (Fn [Bool Bool] Bool))`
			`(register or (Fn [Bool Bool] Bool))`
core: add Bool.zero 2020-06-23 13:26:53 +03:00
			`(defn zero [] false)`
			`(implements zero Bool.zero)`
core: remove interdependencies between modules 2018-02-27 16:49:06 +03:00			`)`
Moved simplified dictionary code to generic struct examples. 2018-01-29 00:54:59 +03:00
			`(defmodule RefBool`
			`(defn = [a b]`
Add some more calls to implement to make tests pass 2020-05-10 20:32:22 +03:00			`(Bool.= @a @b))`
			`(implements = RefBool.=)`
			`)`
Preserve includes order in generated output. 2019-10-03 01:23:27 +03:00
			`(defn not [a] (Bool.not a))`