From 01efb4c06187c20e48585a1743c0a1708074aeac Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 24 Apr 2021 15:31:39 -0300 Subject: Add TIL on Clojure auto-currying --- _tils/2021-04-24-clojure-auto-curry.md | 74 ++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 _tils/2021-04-24-clojure-auto-curry.md (limited to '_tils') diff --git a/_tils/2021-04-24-clojure-auto-curry.md b/_tils/2021-04-24-clojure-auto-curry.md new file mode 100644 index 0000000..8a54561 --- /dev/null +++ b/_tils/2021-04-24-clojure-auto-curry.md @@ -0,0 +1,74 @@ +--- + +title: Clojure auto curry + +date: 2021-04-24 + +layout: post + +lang: en + +ref: clojure-auto-curry + +--- + +A simple macro defined by [Loretta He][lorettahe] to create Clojure functions that are curried on all arguments, relying on Clojure's multi-arity support: + +```clojure +(defmacro defcurry + [fname args & body] + (let [partials (map (fn [n] + `(~(subvec args 0 n) (partial ~fname ~@(take n args)))) + (range 1 (count args)))] + `(defn ~fname + (~args ~@body) + ~@partials))) +``` + +A naive `add` definition, alongside its usage and macroexpansion: + +```clojure +user=> (defcurry add + [a b c d e] + (+ 1 2 3 4 5)) +#'user/add + +user=> (add 1) +#object[clojure.core$partial$fn__5857 0x2c708440 "clojure.core$partial$fn__5857@2c708440"] + +user=> (add 1 2 3 4) +#object[clojure.core$partial$fn__5863 0xf4c0e4e "clojure.core$partial$fn__5863@f4c0e4e"] + +user=> ((add 1) 2 3 4 5) +15 + +user=> (((add 1) 2 3) 4 5) +15 + +user=> (use 'clojure.pprint) +nil + +user=> (pprint + (macroexpand + '(defcurry add + [a b c d e] + (+ 1 2 3 4 5)))) +(def + add + (clojure.core/fn + ([a b c d e] (+ 1 2 3 4 5)) + ([a] (clojure.core/partial add a)) + ([a b] (clojure.core/partial add a b)) + ([a b c] (clojure.core/partial add a b c)) + ([a b c d] (clojure.core/partial add a b c d)))) +nil +``` + +This simplistic `defcurry` definition doesn't support optional parameters, multi-arity, `&` rest arguments, docstrings, etc., but it could certainly evolve to do so. + +I like how `defcurry` is so short, and abdicates the responsability of doing the multi-arity logic to Clojure's built-in multi-arity support. +Simple and elegant. + +Same Clojure as before, now with auto-currying via macros. + +[lorettahe]: http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry -- cgit v1.2.3 From 114d4c1148429f72e2e6aa381e0973120ac564ae Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 24 Apr 2021 17:08:21 -0300 Subject: Add TIL on Lisp's :argument-precedence-order --- ...order-parameterization-of-a-generic-function.md | 133 +++++++++++++++++++++ 1 file changed, 133 insertions(+) create mode 100644 _tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md (limited to '_tils') diff --git a/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md b/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md new file mode 100644 index 0000000..67a6799 --- /dev/null +++ b/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md @@ -0,0 +1,133 @@ +--- + +title: Common Lisp argument precedence order parameterization of a generic function + +date: 2021-04-24 + +layout: post + +lang: en + +ref: common-lisp-argument-precedence-order-parameterization-of-a-generic-function + +--- + +When CLOS dispatches a method, it picks the most specific method definition to the argument list: + +```lisp + +* (defgeneric a-fn (x)) +# + +* (defmethod a-fn (x) :default-method) +# + +* (defmethod a-fn ((x number)) :a-number) +# + +* (defmethod a-fn ((x (eql 1))) :number-1) +# + +* (a-fn nil) +:DEFAULT-METHOD + +* (a-fn "1") +:DEFAULT-METHOD + +* (a-fn 0) +:A-NUMBER + +* (a-fn 1) +:NUMBER-1 +``` + +CLOS uses a similar logic when choosing the method from parent classes, when multiple ones are available: + +```lisp +* (defclass class-a () ()) + +# +* (defclass class-b () ()) + +# +* (defgeneric another-fn (obj)) + +# +* (defmethod another-fn ((obj class-a)) :class-a) +; Compiling LAMBDA (.PV-CELL. .NEXT-METHOD-CALL. OBJ): +; Compiling Top-Level Form: + +# +* (defmethod another-fn ((obj class-b)) :class-b) +; Compiling LAMBDA (.PV-CELL. .NEXT-METHOD-CALL. OBJ): +; Compiling Top-Level Form: + +# +``` + +Given the above definitions, when inheriting from `class-a` and `class-b`, the order of inheritance matters: + +```lisp +* (defclass class-a-coming-first (class-a class-b) ()) +# + +* (defclass class-b-coming-first (class-b class-a) ()) +# + +* (another-fn (make-instance 'class-a-coming-first)) +:CLASS-A + +* (another-fn (make-instance 'class-b-coming-first)) +:CLASS-B +``` + +Combining the order of inheritance with generic functions with multiple arguments, CLOS has to make a choice of how to pick a method given two competing definitions, and its default strategy is prioritizing from left to right: + +```lisp +* (defgeneric yet-another-fn (obj1 obj2)) +# + +* (defmethod yet-another-fn ((obj1 class-a) obj2) :first-arg-specialized) +# + +* (defmethod yet-another-fn (obj1 (obj2 class-b)) :second-arg-specialized) +# + +* (yet-another-fn (make-instance 'class-a) (make-instance 'class-b)) +:FIRST-ARG-SPECIALIZED +``` + +CLOS has to make a choice between the first and the second definition of `yet-another-fn`, but its choice is just a heuristic. +What if we want to the choice to be based on the second argument first? + +For that, we use the `:argument-precedence-order` option when declaring a generic function: + +```lisp +* (defgeneric yet-another-fn (obj1 obj2) (:argument-precedence-order obj2 obj1)) +# + +* (yet-another-fn (make-instance 'class-a) (make-instance 'class-b)) +:SECOND-ARG-SPECIALIZED +``` + +I liked that the `:argument-precedence-order` option exists. +We shouldn't have to change the arguments from `(obj1 obj2)` to `(obj2 obj1)` just to make CLOS pick the method that we want. +We can configure its default behaviour if desired, and keep the order of arguments however it best fits the generic function. + +## Comparison with Clojure + +Clojure has an equivalent, when using `defmulti`. + +Since when declaring a multi-method with `defmulti` we must define the dispatch function, Clojure uses it to pick the method definition. +Since the dispatch function is required, there is no need for a default behaviour, such as left-to-right. + +## Conclusion + +Making the argument precedence order configurable for generic functions but not for class definitions makes a lot of sense. + +When declaring a class, we can choose the precedence order, and that is about it. +But when defining a generic function, the order of argumentws is more important to the function semantics, and the argument precedence being left-to-right is just the default behaviour. + +One shouldn't change the order of arguments of a generic function for the sake of tailoring it to the CLOS priority ranking algorithm, but doing it for a class definition is just fine. + +TIL. -- cgit v1.2.3 From b7bc24827c15e802c867eefdc562fab0db1b49af Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 24 Apr 2021 17:50:22 -0300 Subject: Proofread TIL on CLOS --- ...order-parameterization-of-a-generic-function.md | 4 +-- .../_tils/2021-04-24-clojure-auto-curry.po | 42 ++++++++++++++-------- ...order-parameterization-of-a-generic-function.po | 39 +++++++++++++------- .../_tils/2021-04-24-clojure-auto-curry.po | 42 ++++++++++++++-------- ...order-parameterization-of-a-generic-function.po | 39 +++++++++++++------- .../_tils/2021-04-24-clojure-auto-curry.po | 42 ++++++++++++++-------- ...order-parameterization-of-a-generic-function.po | 39 +++++++++++++------- 7 files changed, 164 insertions(+), 83 deletions(-) (limited to '_tils') diff --git a/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md b/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md index 67a6799..eb19b38 100644 --- a/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md +++ b/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md @@ -98,7 +98,7 @@ Combining the order of inheritance with generic functions with multiple argument ``` CLOS has to make a choice between the first and the second definition of `yet-another-fn`, but its choice is just a heuristic. -What if we want to the choice to be based on the second argument first? +What if we want the choice to be based on the second argument, instead of the first? For that, we use the `:argument-precedence-order` option when declaring a generic function: @@ -126,7 +126,7 @@ Since the dispatch function is required, there is no need for a default behaviou Making the argument precedence order configurable for generic functions but not for class definitions makes a lot of sense. When declaring a class, we can choose the precedence order, and that is about it. -But when defining a generic function, the order of argumentws is more important to the function semantics, and the argument precedence being left-to-right is just the default behaviour. +But when defining a generic function, the order of arguments is more important to the function semantics, and the argument precedence being left-to-right is just the default behaviour. One shouldn't change the order of arguments of a generic function for the sake of tailoring it to the CLOS priority ranking algorithm, but doing it for a class definition is just fine. diff --git a/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 67ff1b4..67c4f2e 100644 --- a/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -96,20 +96,6 @@ msgstr "" msgid "My attempt at writing an equivalent for Common Lisp gives me:" msgstr "" -msgid "" -"(defun curry-n (n fn)\n" -" (if (= 0 n)\n" -" (funcall fn)\n" -" (lambda (&rest rest)\n" -" (curry-n (something n) fn))))\n" -"\n" -"(defun add (a b c d e)\n" -" (curry-n\n" -" (length '(a b c d e))\n" -" (lambda (&rest rest)\n" -" (apply #'+ rest))))\n" -msgstr "" - msgid "" "Without built-in multi-arity support, we have to do more work, like tracking" " the number of arguments consumed so far. That is, without dependending on " @@ -125,3 +111,31 @@ msgid "" "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " "arguments, docstrings, etc., but it also could evolve to do so." msgstr "" + +msgid "" +"(defun curry-n (n fn)\n" +" (if (= 0 n)\n" +" (funcall fn)\n" +" (lambda (&rest rest)\n" +" (curry-n (something n) fn))))\n" +"\n" +"(defun add (a b c d e)\n" +" (curry-n\n" +" (length '(a b c d e))\n" +" (lambda (&rest rest)\n" +" (apply #'+ rest))))\n" +msgstr "" + +#~ msgid "" +#~ "(defun curry-n (n fn)\n" +#~ " (if (= 0 n)\n" +#~ " (funcall fn)\n" +#~ " (lambda (&rest rest)\n" +#~ " (curry-n (something n) fn))))\n" +#~ "\n" +#~ "(defun add (a b c d e)\n" +#~ " (curry-n\n" +#~ " (length '(a b c d e))\n" +#~ " (lambda (&rest rest)\n" +#~ " (apply #'+ rest))))\n" +#~ msgstr "" diff --git a/locale/eo/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po b/locale/eo/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po index b773879..4ca9625 100644 --- a/locale/eo/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po +++ b/locale/eo/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po @@ -120,12 +120,6 @@ msgid "" ":FIRST-ARG-SPECIALIZED\n" msgstr "" -msgid "" -"CLOS has to make a choice between the first and the second definition of " -"`yet-another-fn`, but its choice is just a heuristic. What if we want to the" -" choice to be based on the second argument first?" -msgstr "" - msgid "" "For that, we use the `:argument-precedence-order` option when declaring a " "generic function:" @@ -168,13 +162,6 @@ msgid "" "not for class definitions makes a lot of sense." msgstr "" -msgid "" -"When declaring a class, we can choose the precedence order, and that is " -"about it. But when defining a generic function, the order of argumentws is " -"more important to the function semantics, and the argument precedence being " -"left-to-right is just the default behaviour." -msgstr "" - msgid "" "One shouldn't change the order of arguments of a generic function for the " "sake of tailoring it to the CLOS priority ranking algorithm, but doing it " @@ -183,3 +170,29 @@ msgstr "" msgid "TIL." msgstr "" + +msgid "" +"CLOS has to make a choice between the first and the second definition of " +"`yet-another-fn`, but its choice is just a heuristic. What if we want the " +"choice to be based on the second argument, instead of the first?" +msgstr "" + +msgid "" +"When declaring a class, we can choose the precedence order, and that is " +"about it. But when defining a generic function, the order of arguments is " +"more important to the function semantics, and the argument precedence being " +"left-to-right is just the default behaviour." +msgstr "" + +#~ msgid "" +#~ "CLOS has to make a choice between the first and the second definition of " +#~ "`yet-another-fn`, but its choice is just a heuristic. What if we want to the" +#~ " choice to be based on the second argument first?" +#~ msgstr "" + +#~ msgid "" +#~ "When declaring a class, we can choose the precedence order, and that is " +#~ "about it. But when defining a generic function, the order of argumentws is " +#~ "more important to the function semantics, and the argument precedence being " +#~ "left-to-right is just the default behaviour." +#~ msgstr "" diff --git a/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 67ff1b4..67c4f2e 100644 --- a/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -96,20 +96,6 @@ msgstr "" msgid "My attempt at writing an equivalent for Common Lisp gives me:" msgstr "" -msgid "" -"(defun curry-n (n fn)\n" -" (if (= 0 n)\n" -" (funcall fn)\n" -" (lambda (&rest rest)\n" -" (curry-n (something n) fn))))\n" -"\n" -"(defun add (a b c d e)\n" -" (curry-n\n" -" (length '(a b c d e))\n" -" (lambda (&rest rest)\n" -" (apply #'+ rest))))\n" -msgstr "" - msgid "" "Without built-in multi-arity support, we have to do more work, like tracking" " the number of arguments consumed so far. That is, without dependending on " @@ -125,3 +111,31 @@ msgid "" "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " "arguments, docstrings, etc., but it also could evolve to do so." msgstr "" + +msgid "" +"(defun curry-n (n fn)\n" +" (if (= 0 n)\n" +" (funcall fn)\n" +" (lambda (&rest rest)\n" +" (curry-n (something n) fn))))\n" +"\n" +"(defun add (a b c d e)\n" +" (curry-n\n" +" (length '(a b c d e))\n" +" (lambda (&rest rest)\n" +" (apply #'+ rest))))\n" +msgstr "" + +#~ msgid "" +#~ "(defun curry-n (n fn)\n" +#~ " (if (= 0 n)\n" +#~ " (funcall fn)\n" +#~ " (lambda (&rest rest)\n" +#~ " (curry-n (something n) fn))))\n" +#~ "\n" +#~ "(defun add (a b c d e)\n" +#~ " (curry-n\n" +#~ " (length '(a b c d e))\n" +#~ " (lambda (&rest rest)\n" +#~ " (apply #'+ rest))))\n" +#~ msgstr "" diff --git a/locale/fr/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po b/locale/fr/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po index b773879..4ca9625 100644 --- a/locale/fr/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po +++ b/locale/fr/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po @@ -120,12 +120,6 @@ msgid "" ":FIRST-ARG-SPECIALIZED\n" msgstr "" -msgid "" -"CLOS has to make a choice between the first and the second definition of " -"`yet-another-fn`, but its choice is just a heuristic. What if we want to the" -" choice to be based on the second argument first?" -msgstr "" - msgid "" "For that, we use the `:argument-precedence-order` option when declaring a " "generic function:" @@ -168,13 +162,6 @@ msgid "" "not for class definitions makes a lot of sense." msgstr "" -msgid "" -"When declaring a class, we can choose the precedence order, and that is " -"about it. But when defining a generic function, the order of argumentws is " -"more important to the function semantics, and the argument precedence being " -"left-to-right is just the default behaviour." -msgstr "" - msgid "" "One shouldn't change the order of arguments of a generic function for the " "sake of tailoring it to the CLOS priority ranking algorithm, but doing it " @@ -183,3 +170,29 @@ msgstr "" msgid "TIL." msgstr "" + +msgid "" +"CLOS has to make a choice between the first and the second definition of " +"`yet-another-fn`, but its choice is just a heuristic. What if we want the " +"choice to be based on the second argument, instead of the first?" +msgstr "" + +msgid "" +"When declaring a class, we can choose the precedence order, and that is " +"about it. But when defining a generic function, the order of arguments is " +"more important to the function semantics, and the argument precedence being " +"left-to-right is just the default behaviour." +msgstr "" + +#~ msgid "" +#~ "CLOS has to make a choice between the first and the second definition of " +#~ "`yet-another-fn`, but its choice is just a heuristic. What if we want to the" +#~ " choice to be based on the second argument first?" +#~ msgstr "" + +#~ msgid "" +#~ "When declaring a class, we can choose the precedence order, and that is " +#~ "about it. But when defining a generic function, the order of argumentws is " +#~ "more important to the function semantics, and the argument precedence being " +#~ "left-to-right is just the default behaviour." +#~ msgstr "" diff --git a/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 67ff1b4..67c4f2e 100644 --- a/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -96,20 +96,6 @@ msgstr "" msgid "My attempt at writing an equivalent for Common Lisp gives me:" msgstr "" -msgid "" -"(defun curry-n (n fn)\n" -" (if (= 0 n)\n" -" (funcall fn)\n" -" (lambda (&rest rest)\n" -" (curry-n (something n) fn))))\n" -"\n" -"(defun add (a b c d e)\n" -" (curry-n\n" -" (length '(a b c d e))\n" -" (lambda (&rest rest)\n" -" (apply #'+ rest))))\n" -msgstr "" - msgid "" "Without built-in multi-arity support, we have to do more work, like tracking" " the number of arguments consumed so far. That is, without dependending on " @@ -125,3 +111,31 @@ msgid "" "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " "arguments, docstrings, etc., but it also could evolve to do so." msgstr "" + +msgid "" +"(defun curry-n (n fn)\n" +" (if (= 0 n)\n" +" (funcall fn)\n" +" (lambda (&rest rest)\n" +" (curry-n (something n) fn))))\n" +"\n" +"(defun add (a b c d e)\n" +" (curry-n\n" +" (length '(a b c d e))\n" +" (lambda (&rest rest)\n" +" (apply #'+ rest))))\n" +msgstr "" + +#~ msgid "" +#~ "(defun curry-n (n fn)\n" +#~ " (if (= 0 n)\n" +#~ " (funcall fn)\n" +#~ " (lambda (&rest rest)\n" +#~ " (curry-n (something n) fn))))\n" +#~ "\n" +#~ "(defun add (a b c d e)\n" +#~ " (curry-n\n" +#~ " (length '(a b c d e))\n" +#~ " (lambda (&rest rest)\n" +#~ " (apply #'+ rest))))\n" +#~ msgstr "" diff --git a/locale/pt/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po b/locale/pt/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po index b773879..4ca9625 100644 --- a/locale/pt/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po +++ b/locale/pt/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po @@ -120,12 +120,6 @@ msgid "" ":FIRST-ARG-SPECIALIZED\n" msgstr "" -msgid "" -"CLOS has to make a choice between the first and the second definition of " -"`yet-another-fn`, but its choice is just a heuristic. What if we want to the" -" choice to be based on the second argument first?" -msgstr "" - msgid "" "For that, we use the `:argument-precedence-order` option when declaring a " "generic function:" @@ -168,13 +162,6 @@ msgid "" "not for class definitions makes a lot of sense." msgstr "" -msgid "" -"When declaring a class, we can choose the precedence order, and that is " -"about it. But when defining a generic function, the order of argumentws is " -"more important to the function semantics, and the argument precedence being " -"left-to-right is just the default behaviour." -msgstr "" - msgid "" "One shouldn't change the order of arguments of a generic function for the " "sake of tailoring it to the CLOS priority ranking algorithm, but doing it " @@ -183,3 +170,29 @@ msgstr "" msgid "TIL." msgstr "" + +msgid "" +"CLOS has to make a choice between the first and the second definition of " +"`yet-another-fn`, but its choice is just a heuristic. What if we want the " +"choice to be based on the second argument, instead of the first?" +msgstr "" + +msgid "" +"When declaring a class, we can choose the precedence order, and that is " +"about it. But when defining a generic function, the order of arguments is " +"more important to the function semantics, and the argument precedence being " +"left-to-right is just the default behaviour." +msgstr "" + +#~ msgid "" +#~ "CLOS has to make a choice between the first and the second definition of " +#~ "`yet-another-fn`, but its choice is just a heuristic. What if we want to the" +#~ " choice to be based on the second argument first?" +#~ msgstr "" + +#~ msgid "" +#~ "When declaring a class, we can choose the precedence order, and that is " +#~ "about it. But when defining a generic function, the order of argumentws is " +#~ "more important to the function semantics, and the argument precedence being " +#~ "left-to-right is just the default behaviour." +#~ msgstr "" -- cgit v1.2.3 From 3a7a1655a3b65888bbd4e2bb8066bed473443a35 Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 24 Apr 2021 17:52:30 -0300 Subject: Proofread TIL on Clojure auto currying --- _tils/2021-04-24-clojure-auto-curry.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to '_tils') diff --git a/_tils/2021-04-24-clojure-auto-curry.md b/_tils/2021-04-24-clojure-auto-curry.md index 8a54561..98d6c9a 100644 --- a/_tils/2021-04-24-clojure-auto-curry.md +++ b/_tils/2021-04-24-clojure-auto-curry.md @@ -12,7 +12,7 @@ ref: clojure-auto-curry --- -A simple macro defined by [Loretta He][lorettahe] to create Clojure functions that are curried on all arguments, relying on Clojure's multi-arity support: +Here's a simple macro defined by [Loretta He][lorettahe] to create Clojure functions that are curried on all arguments, relying on Clojure's multi-arity support: ```clojure (defmacro defcurry -- cgit v1.2.3 From 75423d429d637a311748adff0599136c70522f12 Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 24 Apr 2021 18:28:27 -0300 Subject: Add references section to TIL on CLOS --- ...browse-a-git-repository-at-a-specific-commit.md | 2 +- ...order-parameterization-of-a-generic-function.md | 4 ++ ...browse-a-git-repository-at-a-specific-commit.po | 9 ++- .../_tils/2021-04-24-clojure-auto-curry.po | 79 ++++++++++++---------- ...order-parameterization-of-a-generic-function.po | 9 +++ ...browse-a-git-repository-at-a-specific-commit.po | 9 ++- .../_tils/2021-04-24-clojure-auto-curry.po | 79 ++++++++++++---------- ...order-parameterization-of-a-generic-function.po | 9 +++ ...browse-a-git-repository-at-a-specific-commit.po | 9 ++- .../_tils/2021-04-24-clojure-auto-curry.po | 79 ++++++++++++---------- ...order-parameterization-of-a-generic-function.po | 9 +++ 11 files changed, 179 insertions(+), 118 deletions(-) (limited to '_tils') diff --git a/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.md b/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.md index 7965d29..d06f0c1 100644 --- a/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.md +++ b/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.md @@ -77,7 +77,7 @@ After any of those checkouts, you have to `git reset .` to reset your current staging area back to what it was before the checkout. -## References: +## References 1. [GIT: Checkout to a specific folder][0] (StackOverflow) diff --git a/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md b/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md index eb19b38..cce0e42 100644 --- a/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md +++ b/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md @@ -131,3 +131,7 @@ But when defining a generic function, the order of arguments is more important t One shouldn't change the order of arguments of a generic function for the sake of tailoring it to the CLOS priority ranking algorithm, but doing it for a class definition is just fine. TIL. + +## References + +1. [Object-Oriented Programming in Common Lisp: A Programmer's Guide to CLOS](https://en.wikipedia.org/wiki/Object-Oriented_Programming_in_Common_Lisp), by Sonja E. Keene diff --git a/locale/eo/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po b/locale/eo/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po index 421e295..6030e0c 100644 --- a/locale/eo/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po +++ b/locale/eo/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po @@ -49,9 +49,6 @@ msgid "" "current staging area back to what it was before the checkout." msgstr "" -msgid "References:" -msgstr "" - msgid "" "[GIT: Checkout to a specific folder](https://stackoverflow.com/a/16493707) " "(StackOverflow)" @@ -107,6 +104,12 @@ msgstr "" msgid "eu_categories: git" msgstr "" +msgid "References" +msgstr "" + +#~ msgid "References:" +#~ msgstr "" + #~ msgid "" #~ "title: Browse a git repository at a specific commit\n" #~ "date: 2020-08-14\n" diff --git a/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 67c4f2e..8e448d0 100644 --- a/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -17,13 +17,6 @@ msgstr "" msgid "ref: clojure-auto-curry" msgstr "" -msgid "" -"A simple macro defined by [Loretta " -"He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " -"create Clojure functions that are curried on all arguments, relying on " -"Clojure's multi-arity support:" -msgstr "" - msgid "" "(defmacro defcurry\n" " [fname args & body]\n" @@ -90,41 +83,55 @@ msgstr "" msgid "Same Clojure as before, now with auto-currying via macros." msgstr "" -msgid "Comparison with Common Lisp" +msgid "" +"Here's a simple macro defined by [Loretta " +"He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " +"create Clojure functions that are curried on all arguments, relying on " +"Clojure's multi-arity support:" msgstr "" -msgid "My attempt at writing an equivalent for Common Lisp gives me:" -msgstr "" +#~ msgid "" +#~ "A simple macro defined by [Loretta " +#~ "He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " +#~ "create Clojure functions that are curried on all arguments, relying on " +#~ "Clojure's multi-arity support:" +#~ msgstr "" -msgid "" -"Without built-in multi-arity support, we have to do more work, like tracking" -" the number of arguments consumed so far. That is, without dependending on " -"any library, sticking to ANSI Common Lisp." -msgstr "" +#~ msgid "Comparison with Common Lisp" +#~ msgstr "" -msgid "" -"This also require `funcall`s, since we return a `lambda` that doesn't live " -"in the function namespace." -msgstr "" +#~ msgid "My attempt at writing an equivalent for Common Lisp gives me:" +#~ msgstr "" -msgid "" -"Like the Clojure one, it doesn't support optional parameters, `&rest` rest " -"arguments, docstrings, etc., but it also could evolve to do so." -msgstr "" +#~ msgid "" +#~ "Without built-in multi-arity support, we have to do more work, like tracking" +#~ " the number of arguments consumed so far. That is, without dependending on " +#~ "any library, sticking to ANSI Common Lisp." +#~ msgstr "" -msgid "" -"(defun curry-n (n fn)\n" -" (if (= 0 n)\n" -" (funcall fn)\n" -" (lambda (&rest rest)\n" -" (curry-n (something n) fn))))\n" -"\n" -"(defun add (a b c d e)\n" -" (curry-n\n" -" (length '(a b c d e))\n" -" (lambda (&rest rest)\n" -" (apply #'+ rest))))\n" -msgstr "" +#~ msgid "" +#~ "This also require `funcall`s, since we return a `lambda` that doesn't live " +#~ "in the function namespace." +#~ msgstr "" + +#~ msgid "" +#~ "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " +#~ "arguments, docstrings, etc., but it also could evolve to do so." +#~ msgstr "" + +#~ msgid "" +#~ "(defun curry-n (n fn)\n" +#~ " (if (= 0 n)\n" +#~ " (funcall fn)\n" +#~ " (lambda (&rest rest)\n" +#~ " (curry-n (something n) fn))))\n" +#~ "\n" +#~ "(defun add (a b c d e)\n" +#~ " (curry-n\n" +#~ " (length '(a b c d e))\n" +#~ " (lambda (&rest rest)\n" +#~ " (apply #'+ rest))))\n" +#~ msgstr "" #~ msgid "" #~ "(defun curry-n (n fn)\n" diff --git a/locale/eo/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po b/locale/eo/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po index 4ca9625..2676e93 100644 --- a/locale/eo/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po +++ b/locale/eo/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po @@ -184,6 +184,15 @@ msgid "" "left-to-right is just the default behaviour." msgstr "" +msgid "References" +msgstr "" + +msgid "" +"[Object-Oriented Programming in Common Lisp: A Programmer's Guide to " +"CLOS](https://en.wikipedia.org/wiki/Object-" +"Oriented_Programming_in_Common_Lisp), by Sonja E. Keene" +msgstr "" + #~ msgid "" #~ "CLOS has to make a choice between the first and the second definition of " #~ "`yet-another-fn`, but its choice is just a heuristic. What if we want to the" diff --git a/locale/fr/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po b/locale/fr/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po index 421e295..6030e0c 100644 --- a/locale/fr/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po +++ b/locale/fr/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po @@ -49,9 +49,6 @@ msgid "" "current staging area back to what it was before the checkout." msgstr "" -msgid "References:" -msgstr "" - msgid "" "[GIT: Checkout to a specific folder](https://stackoverflow.com/a/16493707) " "(StackOverflow)" @@ -107,6 +104,12 @@ msgstr "" msgid "eu_categories: git" msgstr "" +msgid "References" +msgstr "" + +#~ msgid "References:" +#~ msgstr "" + #~ msgid "" #~ "title: Browse a git repository at a specific commit\n" #~ "date: 2020-08-14\n" diff --git a/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 67c4f2e..8e448d0 100644 --- a/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -17,13 +17,6 @@ msgstr "" msgid "ref: clojure-auto-curry" msgstr "" -msgid "" -"A simple macro defined by [Loretta " -"He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " -"create Clojure functions that are curried on all arguments, relying on " -"Clojure's multi-arity support:" -msgstr "" - msgid "" "(defmacro defcurry\n" " [fname args & body]\n" @@ -90,41 +83,55 @@ msgstr "" msgid "Same Clojure as before, now with auto-currying via macros." msgstr "" -msgid "Comparison with Common Lisp" +msgid "" +"Here's a simple macro defined by [Loretta " +"He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " +"create Clojure functions that are curried on all arguments, relying on " +"Clojure's multi-arity support:" msgstr "" -msgid "My attempt at writing an equivalent for Common Lisp gives me:" -msgstr "" +#~ msgid "" +#~ "A simple macro defined by [Loretta " +#~ "He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " +#~ "create Clojure functions that are curried on all arguments, relying on " +#~ "Clojure's multi-arity support:" +#~ msgstr "" -msgid "" -"Without built-in multi-arity support, we have to do more work, like tracking" -" the number of arguments consumed so far. That is, without dependending on " -"any library, sticking to ANSI Common Lisp." -msgstr "" +#~ msgid "Comparison with Common Lisp" +#~ msgstr "" -msgid "" -"This also require `funcall`s, since we return a `lambda` that doesn't live " -"in the function namespace." -msgstr "" +#~ msgid "My attempt at writing an equivalent for Common Lisp gives me:" +#~ msgstr "" -msgid "" -"Like the Clojure one, it doesn't support optional parameters, `&rest` rest " -"arguments, docstrings, etc., but it also could evolve to do so." -msgstr "" +#~ msgid "" +#~ "Without built-in multi-arity support, we have to do more work, like tracking" +#~ " the number of arguments consumed so far. That is, without dependending on " +#~ "any library, sticking to ANSI Common Lisp." +#~ msgstr "" -msgid "" -"(defun curry-n (n fn)\n" -" (if (= 0 n)\n" -" (funcall fn)\n" -" (lambda (&rest rest)\n" -" (curry-n (something n) fn))))\n" -"\n" -"(defun add (a b c d e)\n" -" (curry-n\n" -" (length '(a b c d e))\n" -" (lambda (&rest rest)\n" -" (apply #'+ rest))))\n" -msgstr "" +#~ msgid "" +#~ "This also require `funcall`s, since we return a `lambda` that doesn't live " +#~ "in the function namespace." +#~ msgstr "" + +#~ msgid "" +#~ "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " +#~ "arguments, docstrings, etc., but it also could evolve to do so." +#~ msgstr "" + +#~ msgid "" +#~ "(defun curry-n (n fn)\n" +#~ " (if (= 0 n)\n" +#~ " (funcall fn)\n" +#~ " (lambda (&rest rest)\n" +#~ " (curry-n (something n) fn))))\n" +#~ "\n" +#~ "(defun add (a b c d e)\n" +#~ " (curry-n\n" +#~ " (length '(a b c d e))\n" +#~ " (lambda (&rest rest)\n" +#~ " (apply #'+ rest))))\n" +#~ msgstr "" #~ msgid "" #~ "(defun curry-n (n fn)\n" diff --git a/locale/fr/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po b/locale/fr/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po index 4ca9625..2676e93 100644 --- a/locale/fr/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po +++ b/locale/fr/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po @@ -184,6 +184,15 @@ msgid "" "left-to-right is just the default behaviour." msgstr "" +msgid "References" +msgstr "" + +msgid "" +"[Object-Oriented Programming in Common Lisp: A Programmer's Guide to " +"CLOS](https://en.wikipedia.org/wiki/Object-" +"Oriented_Programming_in_Common_Lisp), by Sonja E. Keene" +msgstr "" + #~ msgid "" #~ "CLOS has to make a choice between the first and the second definition of " #~ "`yet-another-fn`, but its choice is just a heuristic. What if we want to the" diff --git a/locale/pt/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po b/locale/pt/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po index 421e295..6030e0c 100644 --- a/locale/pt/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po +++ b/locale/pt/LC_MESSAGES/_tils/2020-08-14-browse-a-git-repository-at-a-specific-commit.po @@ -49,9 +49,6 @@ msgid "" "current staging area back to what it was before the checkout." msgstr "" -msgid "References:" -msgstr "" - msgid "" "[GIT: Checkout to a specific folder](https://stackoverflow.com/a/16493707) " "(StackOverflow)" @@ -107,6 +104,12 @@ msgstr "" msgid "eu_categories: git" msgstr "" +msgid "References" +msgstr "" + +#~ msgid "References:" +#~ msgstr "" + #~ msgid "" #~ "title: Browse a git repository at a specific commit\n" #~ "date: 2020-08-14\n" diff --git a/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 67c4f2e..8e448d0 100644 --- a/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -17,13 +17,6 @@ msgstr "" msgid "ref: clojure-auto-curry" msgstr "" -msgid "" -"A simple macro defined by [Loretta " -"He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " -"create Clojure functions that are curried on all arguments, relying on " -"Clojure's multi-arity support:" -msgstr "" - msgid "" "(defmacro defcurry\n" " [fname args & body]\n" @@ -90,41 +83,55 @@ msgstr "" msgid "Same Clojure as before, now with auto-currying via macros." msgstr "" -msgid "Comparison with Common Lisp" +msgid "" +"Here's a simple macro defined by [Loretta " +"He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " +"create Clojure functions that are curried on all arguments, relying on " +"Clojure's multi-arity support:" msgstr "" -msgid "My attempt at writing an equivalent for Common Lisp gives me:" -msgstr "" +#~ msgid "" +#~ "A simple macro defined by [Loretta " +#~ "He](http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry) to " +#~ "create Clojure functions that are curried on all arguments, relying on " +#~ "Clojure's multi-arity support:" +#~ msgstr "" -msgid "" -"Without built-in multi-arity support, we have to do more work, like tracking" -" the number of arguments consumed so far. That is, without dependending on " -"any library, sticking to ANSI Common Lisp." -msgstr "" +#~ msgid "Comparison with Common Lisp" +#~ msgstr "" -msgid "" -"This also require `funcall`s, since we return a `lambda` that doesn't live " -"in the function namespace." -msgstr "" +#~ msgid "My attempt at writing an equivalent for Common Lisp gives me:" +#~ msgstr "" -msgid "" -"Like the Clojure one, it doesn't support optional parameters, `&rest` rest " -"arguments, docstrings, etc., but it also could evolve to do so." -msgstr "" +#~ msgid "" +#~ "Without built-in multi-arity support, we have to do more work, like tracking" +#~ " the number of arguments consumed so far. That is, without dependending on " +#~ "any library, sticking to ANSI Common Lisp." +#~ msgstr "" -msgid "" -"(defun curry-n (n fn)\n" -" (if (= 0 n)\n" -" (funcall fn)\n" -" (lambda (&rest rest)\n" -" (curry-n (something n) fn))))\n" -"\n" -"(defun add (a b c d e)\n" -" (curry-n\n" -" (length '(a b c d e))\n" -" (lambda (&rest rest)\n" -" (apply #'+ rest))))\n" -msgstr "" +#~ msgid "" +#~ "This also require `funcall`s, since we return a `lambda` that doesn't live " +#~ "in the function namespace." +#~ msgstr "" + +#~ msgid "" +#~ "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " +#~ "arguments, docstrings, etc., but it also could evolve to do so." +#~ msgstr "" + +#~ msgid "" +#~ "(defun curry-n (n fn)\n" +#~ " (if (= 0 n)\n" +#~ " (funcall fn)\n" +#~ " (lambda (&rest rest)\n" +#~ " (curry-n (something n) fn))))\n" +#~ "\n" +#~ "(defun add (a b c d e)\n" +#~ " (curry-n\n" +#~ " (length '(a b c d e))\n" +#~ " (lambda (&rest rest)\n" +#~ " (apply #'+ rest))))\n" +#~ msgstr "" #~ msgid "" #~ "(defun curry-n (n fn)\n" diff --git a/locale/pt/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po b/locale/pt/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po index 4ca9625..2676e93 100644 --- a/locale/pt/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po +++ b/locale/pt/LC_MESSAGES/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.po @@ -184,6 +184,15 @@ msgid "" "left-to-right is just the default behaviour." msgstr "" +msgid "References" +msgstr "" + +msgid "" +"[Object-Oriented Programming in Common Lisp: A Programmer's Guide to " +"CLOS](https://en.wikipedia.org/wiki/Object-" +"Oriented_Programming_in_Common_Lisp), by Sonja E. Keene" +msgstr "" + #~ msgid "" #~ "CLOS has to make a choice between the first and the second definition of " #~ "`yet-another-fn`, but its choice is just a heuristic. What if we want to the" -- cgit v1.2.3 From 587a8a5724632fb213bd1f3b71011bb64c437215 Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 24 Apr 2021 18:49:39 -0300 Subject: Add TIL on nif macro --- ...04-24-three-way-conditional-for-number-signs.md | 61 ++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 _tils/2021-04-24-three-way-conditional-for-number-signs.md (limited to '_tils') diff --git a/_tils/2021-04-24-three-way-conditional-for-number-signs.md b/_tils/2021-04-24-three-way-conditional-for-number-signs.md new file mode 100644 index 0000000..f8705f5 --- /dev/null +++ b/_tils/2021-04-24-three-way-conditional-for-number-signs.md @@ -0,0 +1,61 @@ +--- + +title: Three-way conditional for number signs + +date: 2021-04-24 + +layout: post + +lang: en + +ref: three-way-conditional-for-number-signs + +--- + +A useful macro from Paul Graham's [On Lisp][on-lisp] book: + +```lisp +(defmacro nif (expr pos zero neg) + (let ((g (gensym))) + `(let ((,g ,expr)) + (cond ((plusp ,g) ,pos) + ((zerop ,g) ,zero) + (t ,neg))))) +``` + +After I looked at this macro, I started seeing opportunities to using it in many places, and yet I didn't see anyonelse using it. + +The latest example I can think of is section 1.3.3 of [Structure and Interpretation of Computer Programs][sicp], which I was reading recently: + +```scheme +(define (search f neg-point pos-point) + (let ((midpoint (average neg-point pos-point))) + (if (close-enough? neg-point post-point) + midpoint + (let ((test-value (f midpoint))) + (cond ((positive? test-value) + (search f neg-point midpoint)) + ((negative? test-value) + (search f midpoint pos-point)) + (else midpoint)))))) +``` + +Not that the book should introduce such macro this early, but I couldn't avoid feeling bothered by not using a `nif` macro, which could even remove the need for the intermediate `test-value` variable: + +```scheme +(define (search f neg-point pos-point) + (let ((midpoint (average neg-point pos-point))) + (if (close-enough? neg-point post-point) + midpoint + (nif (f midpoint) + (search f neg-point midpoint) + (midpoint) + (search f midpoint pos-point))))) +``` + +It also avoids `cond`'s extra clunky parentheses for grouping, which is unnecessary but built-in. + +As a macro, I personally feel it tilts the balance towards expressivenes despite its extra cognitive load toll. + +[on-lisp]: http://www.paulgraham.com/onlisptext.html +[sicp]: https://mitpress.mit.edu/sites/default/files/sicp/index.html -- cgit v1.2.3 From 09c17e9ae4d318c3e43f4465e48b0252178456b2 Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 24 Apr 2021 18:51:40 -0300 Subject: Explicitly order TILs written in the same day --- _tils/2021-04-24-clojure-auto-curry.md | 2 +- ...-argument-precedence-order-parameterization-of-a-generic-function.md | 2 +- _tils/2021-04-24-three-way-conditional-for-number-signs.md | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) (limited to '_tils') diff --git a/_tils/2021-04-24-clojure-auto-curry.md b/_tils/2021-04-24-clojure-auto-curry.md index 98d6c9a..0d50cfa 100644 --- a/_tils/2021-04-24-clojure-auto-curry.md +++ b/_tils/2021-04-24-clojure-auto-curry.md @@ -2,7 +2,7 @@ title: Clojure auto curry -date: 2021-04-24 +date: 2021-04-24 1 layout: post diff --git a/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md b/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md index cce0e42..8051232 100644 --- a/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md +++ b/_tils/2021-04-24-common-lisp-argument-precedence-order-parameterization-of-a-generic-function.md @@ -2,7 +2,7 @@ title: Common Lisp argument precedence order parameterization of a generic function -date: 2021-04-24 +date: 2021-04-24 2 layout: post diff --git a/_tils/2021-04-24-three-way-conditional-for-number-signs.md b/_tils/2021-04-24-three-way-conditional-for-number-signs.md index f8705f5..4a55b61 100644 --- a/_tils/2021-04-24-three-way-conditional-for-number-signs.md +++ b/_tils/2021-04-24-three-way-conditional-for-number-signs.md @@ -2,7 +2,7 @@ title: Three-way conditional for number signs -date: 2021-04-24 +date: 2021-04-24 3 layout: post -- cgit v1.2.3 From 128509ccbf0b280a38636b75ba001808b9ad250f Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Sat, 24 Apr 2021 19:08:45 -0300 Subject: Proofread TIL on nif macro --- ...04-24-three-way-conditional-for-number-signs.md | 4 +-- ...04-24-three-way-conditional-for-number-signs.po | 33 ++++++++++++++-------- ...04-24-three-way-conditional-for-number-signs.po | 33 ++++++++++++++-------- ...04-24-three-way-conditional-for-number-signs.po | 33 ++++++++++++++-------- 4 files changed, 68 insertions(+), 35 deletions(-) (limited to '_tils') diff --git a/_tils/2021-04-24-three-way-conditional-for-number-signs.md b/_tils/2021-04-24-three-way-conditional-for-number-signs.md index 4a55b61..ec62378 100644 --- a/_tils/2021-04-24-three-way-conditional-for-number-signs.md +++ b/_tils/2021-04-24-three-way-conditional-for-number-signs.md @@ -23,7 +23,7 @@ A useful macro from Paul Graham's [On Lisp][on-lisp] book: (t ,neg))))) ``` -After I looked at this macro, I started seeing opportunities to using it in many places, and yet I didn't see anyonelse using it. +After I looked at this macro, I started seeing opportunities to using it in many places, and yet I didn't see anyone else using it. The latest example I can think of is section 1.3.3 of [Structure and Interpretation of Computer Programs][sicp], which I was reading recently: @@ -40,7 +40,7 @@ The latest example I can think of is section 1.3.3 of [Structure and Interpretat (else midpoint)))))) ``` -Not that the book should introduce such macro this early, but I couldn't avoid feeling bothered by not using a `nif` macro, which could even remove the need for the intermediate `test-value` variable: +Not that the book should introduce such macro this early, but I couldn't avoid feeling bothered by not using the `nif` macro, which could even remove the need for the intermediate `test-value` variable: ```scheme (define (search f neg-point pos-point) diff --git a/locale/eo/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po b/locale/eo/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po index 4b98383..925a00b 100644 --- a/locale/eo/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po +++ b/locale/eo/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po @@ -31,11 +31,6 @@ msgid "" " (t ,neg)))))\n" msgstr "" -msgid "" -"After I looked at this macro, I started seeing opportunities to using it in " -"many places, and yet I didn't see anyonelse using it." -msgstr "" - msgid "" "The latest example I can think of is section 1.3.3 of [Structure and " "Interpretation of Computer " @@ -56,12 +51,6 @@ msgid "" " (else midpoint))))))\n" msgstr "" -msgid "" -"Not that the book should introduce such macro this early, but I couldn't " -"avoid feeling bothered by not using a `nif` macro, which could even remove " -"the need for the intermediate `test-value` variable:" -msgstr "" - msgid "" "(define (search f neg-point pos-point)\n" " (let ((midpoint (average neg-point pos-point)))\n" @@ -82,3 +71,25 @@ msgid "" "As a macro, I personally feel it tilts the balance towards expressivenes " "despite its extra cognitive load toll." msgstr "" + +msgid "" +"After I looked at this macro, I started seeing opportunities to using it in " +"many places, and yet I didn't see anyone else using it." +msgstr "" + +msgid "" +"Not that the book should introduce such macro this early, but I couldn't " +"avoid feeling bothered by not using the `nif` macro, which could even remove" +" the need for the intermediate `test-value` variable:" +msgstr "" + +#~ msgid "" +#~ "After I looked at this macro, I started seeing opportunities to using it in " +#~ "many places, and yet I didn't see anyonelse using it." +#~ msgstr "" + +#~ msgid "" +#~ "Not that the book should introduce such macro this early, but I couldn't " +#~ "avoid feeling bothered by not using a `nif` macro, which could even remove " +#~ "the need for the intermediate `test-value` variable:" +#~ msgstr "" diff --git a/locale/fr/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po b/locale/fr/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po index 4b98383..925a00b 100644 --- a/locale/fr/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po +++ b/locale/fr/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po @@ -31,11 +31,6 @@ msgid "" " (t ,neg)))))\n" msgstr "" -msgid "" -"After I looked at this macro, I started seeing opportunities to using it in " -"many places, and yet I didn't see anyonelse using it." -msgstr "" - msgid "" "The latest example I can think of is section 1.3.3 of [Structure and " "Interpretation of Computer " @@ -56,12 +51,6 @@ msgid "" " (else midpoint))))))\n" msgstr "" -msgid "" -"Not that the book should introduce such macro this early, but I couldn't " -"avoid feeling bothered by not using a `nif` macro, which could even remove " -"the need for the intermediate `test-value` variable:" -msgstr "" - msgid "" "(define (search f neg-point pos-point)\n" " (let ((midpoint (average neg-point pos-point)))\n" @@ -82,3 +71,25 @@ msgid "" "As a macro, I personally feel it tilts the balance towards expressivenes " "despite its extra cognitive load toll." msgstr "" + +msgid "" +"After I looked at this macro, I started seeing opportunities to using it in " +"many places, and yet I didn't see anyone else using it." +msgstr "" + +msgid "" +"Not that the book should introduce such macro this early, but I couldn't " +"avoid feeling bothered by not using the `nif` macro, which could even remove" +" the need for the intermediate `test-value` variable:" +msgstr "" + +#~ msgid "" +#~ "After I looked at this macro, I started seeing opportunities to using it in " +#~ "many places, and yet I didn't see anyonelse using it." +#~ msgstr "" + +#~ msgid "" +#~ "Not that the book should introduce such macro this early, but I couldn't " +#~ "avoid feeling bothered by not using a `nif` macro, which could even remove " +#~ "the need for the intermediate `test-value` variable:" +#~ msgstr "" diff --git a/locale/pt/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po b/locale/pt/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po index 4b98383..925a00b 100644 --- a/locale/pt/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po +++ b/locale/pt/LC_MESSAGES/_tils/2021-04-24-three-way-conditional-for-number-signs.po @@ -31,11 +31,6 @@ msgid "" " (t ,neg)))))\n" msgstr "" -msgid "" -"After I looked at this macro, I started seeing opportunities to using it in " -"many places, and yet I didn't see anyonelse using it." -msgstr "" - msgid "" "The latest example I can think of is section 1.3.3 of [Structure and " "Interpretation of Computer " @@ -56,12 +51,6 @@ msgid "" " (else midpoint))))))\n" msgstr "" -msgid "" -"Not that the book should introduce such macro this early, but I couldn't " -"avoid feeling bothered by not using a `nif` macro, which could even remove " -"the need for the intermediate `test-value` variable:" -msgstr "" - msgid "" "(define (search f neg-point pos-point)\n" " (let ((midpoint (average neg-point pos-point)))\n" @@ -82,3 +71,25 @@ msgid "" "As a macro, I personally feel it tilts the balance towards expressivenes " "despite its extra cognitive load toll." msgstr "" + +msgid "" +"After I looked at this macro, I started seeing opportunities to using it in " +"many places, and yet I didn't see anyone else using it." +msgstr "" + +msgid "" +"Not that the book should introduce such macro this early, but I couldn't " +"avoid feeling bothered by not using the `nif` macro, which could even remove" +" the need for the intermediate `test-value` variable:" +msgstr "" + +#~ msgid "" +#~ "After I looked at this macro, I started seeing opportunities to using it in " +#~ "many places, and yet I didn't see anyonelse using it." +#~ msgstr "" + +#~ msgid "" +#~ "Not that the book should introduce such macro this early, but I couldn't " +#~ "avoid feeling bothered by not using a `nif` macro, which could even remove " +#~ "the need for the intermediate `test-value` variable:" +#~ msgstr "" -- cgit v1.2.3 From c86b5f9555d284c254d85c4f4eacb2560d9adfd1 Mon Sep 17 00:00:00 2001 From: EuAndreh Date: Tue, 27 Apr 2021 04:45:16 -0300 Subject: Expand TIL on Clojure auto-curry to include Common Lisp version --- _tils/2021-04-24-clojure-auto-curry.md | 67 ++++++++++- .../_tils/2021-04-24-clojure-auto-curry.po | 123 ++++++++++++++++----- .../_tils/2021-04-24-clojure-auto-curry.po | 123 ++++++++++++++++----- .../_tils/2021-04-24-clojure-auto-curry.po | 123 ++++++++++++++++----- 4 files changed, 352 insertions(+), 84 deletions(-) (limited to '_tils') diff --git a/_tils/2021-04-24-clojure-auto-curry.md b/_tils/2021-04-24-clojure-auto-curry.md index 0d50cfa..c1e277f 100644 --- a/_tils/2021-04-24-clojure-auto-curry.md +++ b/_tils/2021-04-24-clojure-auto-curry.md @@ -4,6 +4,8 @@ title: Clojure auto curry date: 2021-04-24 1 +updated_at: 2021-04-27 + layout: post lang: en @@ -16,11 +18,11 @@ Here's a simple macro defined by [Loretta He][lorettahe] to create Clojure funct ```clojure (defmacro defcurry - [fname args & body] + [name args & body] (let [partials (map (fn [n] - `(~(subvec args 0 n) (partial ~fname ~@(take n args)))) + `(~(subvec args 0 n) (partial ~name ~@(take n args)))) (range 1 (count args)))] - `(defn ~fname + `(defn ~name (~args ~@body) ~@partials))) ``` @@ -72,3 +74,62 @@ Simple and elegant. Same Clojure as before, now with auto-currying via macros. [lorettahe]: http://lorettahe.github.io/clojure/2016/09/22/clojure-auto-curry + +## Comparison with Common Lisp + +My attempt at writing an equivalent for Common Lisp gives me: + +```lisp +(defun partial (fn &rest args) + (lambda (&rest args2) + (apply fn (append args args2)))) + +(defun curry-n (n func) + (cond ((< n 0) (error "Too many arguments")) + ((zerop n) (funcall func)) + (t (lambda (&rest rest) + (curry-n (- n (length rest)) + (apply #'partial func rest)))))) + +(defmacro defcurry (name args &body body) + `(defun ,name (&rest rest) + (let ((func (lambda ,args ,@body))) + (curry-n (- ,(length args) (length rest)) + (apply #'partial func rest))))) +``` + +Without built-in multi-arity support, we have to do more work, like tracking the number of arguments consumed so far. +We also have to write `#'partial` ourselves. +That is, without dependending on any library, sticking to ANSI Common Lisp. + +The usage is pretty similar: + +```lisp +* (defcurry add (a b c d e) + (+ a b c d e)) +ADD + +* (add 1) +# + +* (funcall (add 1) 2 3 4) +# + +* (funcall (add 1) 2 3 4 5) +15 + +* (funcall (funcall (add 1) 2 3) 4 5) +15 + +* (macroexpand-1 + '(defcurry add (a b c d e) + (+ a b c d e))) +(DEFUN ADD (&REST REST) + (LET ((FUNC (LAMBDA (A B C D E) (+ A B C D E)))) + (CURRY-N (- 5 (LENGTH REST)) (APPLY #'PARTIAL FUNC REST)))) +T +``` + +This also require `funcall`s, since we return a `lambda` that doesn't live in the function namespace. + +Like the Clojure one, it doesn't support optional parameters, `&rest` rest arguments, docstrings, etc., but it also could evolve to do so. diff --git a/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 14036ab..ab59a4f 100644 --- a/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/eo/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -14,17 +14,6 @@ msgstr "" msgid "ref: clojure-auto-curry" msgstr "" -msgid "" -"(defmacro defcurry\n" -" [fname args & body]\n" -" (let [partials (map (fn [n]\n" -" `(~(subvec args 0 n) (partial ~fname ~@(take n args))))\n" -" (range 1 (count args)))]\n" -" `(defn ~fname\n" -" (~args ~@body)\n" -" ~@partials)))\n" -msgstr "" - msgid "A naive `add` definition, alongside its usage and macroexpansion:" msgstr "" @@ -90,6 +79,102 @@ msgstr "" msgid "date: 2021-04-24 1" msgstr "" +msgid "" +"(defmacro defcurry\n" +" [name args & body]\n" +" (let [partials (map (fn [n]\n" +" `(~(subvec args 0 n) (partial ~name ~@(take n args))))\n" +" (range 1 (count args)))]\n" +" `(defn ~name\n" +" (~args ~@body)\n" +" ~@partials)))\n" +msgstr "" + +msgid "Comparison with Common Lisp" +msgstr "" + +msgid "My attempt at writing an equivalent for Common Lisp gives me:" +msgstr "" + +msgid "" +"(defun partial (fn &rest args)\n" +" (lambda (&rest args2)\n" +" (apply fn (append args args2))))\n" +"\n" +"(defun curry-n (n func)\n" +" (cond ((< n 0) (error \"Too many arguments\"))\n" +" ((zerop n) (funcall func))\n" +" (t (lambda (&rest rest)\n" +" (curry-n (- n (length rest))\n" +" (apply #'partial func rest))))))\n" +"\n" +"(defmacro defcurry (name args &body body)\n" +" `(defun ,name (&rest rest)\n" +" (let ((func (lambda ,args ,@body)))\n" +" (curry-n (- ,(length args) (length rest))\n" +" (apply #'partial func rest)))))\n" +msgstr "" + +msgid "" +"Without built-in multi-arity support, we have to do more work, like tracking" +" the number of arguments consumed so far. We also have to write `#'partial` " +"ourselves. That is, without dependending on any library, sticking to ANSI " +"Common Lisp." +msgstr "" + +msgid "The usage is pretty similar:" +msgstr "" + +msgid "" +"* (defcurry add (a b c d e)\n" +" (+ a b c d e))\n" +"ADD\n" +"\n" +"* (add 1)\n" +"#\n" +"\n" +"* (funcall (add 1) 2 3 4)\n" +"#\n" +"\n" +"* (funcall (add 1) 2 3 4 5)\n" +"15\n" +"\n" +"* (funcall (funcall (add 1) 2 3) 4 5)\n" +"15\n" +"\n" +"* (macroexpand-1\n" +" '(defcurry add (a b c d e)\n" +" (+ a b c d e)))\n" +"(DEFUN ADD (&REST REST)\n" +" (LET ((FUNC (LAMBDA (A B C D E) (+ A B C D E))))\n" +" (CURRY-N (- 5 (LENGTH REST)) (APPLY #'PARTIAL FUNC REST))))\n" +"T\n" +msgstr "" + +msgid "" +"This also require `funcall`s, since we return a `lambda` that doesn't live " +"in the function namespace." +msgstr "" + +msgid "" +"Like the Clojure one, it doesn't support optional parameters, `&rest` rest " +"arguments, docstrings, etc., but it also could evolve to do so." +msgstr "" + +msgid "updated_at: 2021-04-27" +msgstr "" + +#~ msgid "" +#~ "(defmacro defcurry\n" +#~ " [fname args & body]\n" +#~ " (let [partials (map (fn [n]\n" +#~ " `(~(subvec args 0 n) (partial ~fname ~@(take n args))))\n" +#~ " (range 1 (count args)))]\n" +#~ " `(defn ~fname\n" +#~ " (~args ~@body)\n" +#~ " ~@partials)))\n" +#~ msgstr "" + #~ msgid "date: 2021-04-24" #~ msgstr "" @@ -100,28 +185,12 @@ msgstr "" #~ "Clojure's multi-arity support:" #~ msgstr "" -#~ msgid "Comparison with Common Lisp" -#~ msgstr "" - -#~ msgid "My attempt at writing an equivalent for Common Lisp gives me:" -#~ msgstr "" - #~ msgid "" #~ "Without built-in multi-arity support, we have to do more work, like tracking" #~ " the number of arguments consumed so far. That is, without dependending on " #~ "any library, sticking to ANSI Common Lisp." #~ msgstr "" -#~ msgid "" -#~ "This also require `funcall`s, since we return a `lambda` that doesn't live " -#~ "in the function namespace." -#~ msgstr "" - -#~ msgid "" -#~ "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " -#~ "arguments, docstrings, etc., but it also could evolve to do so." -#~ msgstr "" - #~ msgid "" #~ "(defun curry-n (n fn)\n" #~ " (if (= 0 n)\n" diff --git a/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 14036ab..ab59a4f 100644 --- a/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/fr/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -14,17 +14,6 @@ msgstr "" msgid "ref: clojure-auto-curry" msgstr "" -msgid "" -"(defmacro defcurry\n" -" [fname args & body]\n" -" (let [partials (map (fn [n]\n" -" `(~(subvec args 0 n) (partial ~fname ~@(take n args))))\n" -" (range 1 (count args)))]\n" -" `(defn ~fname\n" -" (~args ~@body)\n" -" ~@partials)))\n" -msgstr "" - msgid "A naive `add` definition, alongside its usage and macroexpansion:" msgstr "" @@ -90,6 +79,102 @@ msgstr "" msgid "date: 2021-04-24 1" msgstr "" +msgid "" +"(defmacro defcurry\n" +" [name args & body]\n" +" (let [partials (map (fn [n]\n" +" `(~(subvec args 0 n) (partial ~name ~@(take n args))))\n" +" (range 1 (count args)))]\n" +" `(defn ~name\n" +" (~args ~@body)\n" +" ~@partials)))\n" +msgstr "" + +msgid "Comparison with Common Lisp" +msgstr "" + +msgid "My attempt at writing an equivalent for Common Lisp gives me:" +msgstr "" + +msgid "" +"(defun partial (fn &rest args)\n" +" (lambda (&rest args2)\n" +" (apply fn (append args args2))))\n" +"\n" +"(defun curry-n (n func)\n" +" (cond ((< n 0) (error \"Too many arguments\"))\n" +" ((zerop n) (funcall func))\n" +" (t (lambda (&rest rest)\n" +" (curry-n (- n (length rest))\n" +" (apply #'partial func rest))))))\n" +"\n" +"(defmacro defcurry (name args &body body)\n" +" `(defun ,name (&rest rest)\n" +" (let ((func (lambda ,args ,@body)))\n" +" (curry-n (- ,(length args) (length rest))\n" +" (apply #'partial func rest)))))\n" +msgstr "" + +msgid "" +"Without built-in multi-arity support, we have to do more work, like tracking" +" the number of arguments consumed so far. We also have to write `#'partial` " +"ourselves. That is, without dependending on any library, sticking to ANSI " +"Common Lisp." +msgstr "" + +msgid "The usage is pretty similar:" +msgstr "" + +msgid "" +"* (defcurry add (a b c d e)\n" +" (+ a b c d e))\n" +"ADD\n" +"\n" +"* (add 1)\n" +"#\n" +"\n" +"* (funcall (add 1) 2 3 4)\n" +"#\n" +"\n" +"* (funcall (add 1) 2 3 4 5)\n" +"15\n" +"\n" +"* (funcall (funcall (add 1) 2 3) 4 5)\n" +"15\n" +"\n" +"* (macroexpand-1\n" +" '(defcurry add (a b c d e)\n" +" (+ a b c d e)))\n" +"(DEFUN ADD (&REST REST)\n" +" (LET ((FUNC (LAMBDA (A B C D E) (+ A B C D E))))\n" +" (CURRY-N (- 5 (LENGTH REST)) (APPLY #'PARTIAL FUNC REST))))\n" +"T\n" +msgstr "" + +msgid "" +"This also require `funcall`s, since we return a `lambda` that doesn't live " +"in the function namespace." +msgstr "" + +msgid "" +"Like the Clojure one, it doesn't support optional parameters, `&rest` rest " +"arguments, docstrings, etc., but it also could evolve to do so." +msgstr "" + +msgid "updated_at: 2021-04-27" +msgstr "" + +#~ msgid "" +#~ "(defmacro defcurry\n" +#~ " [fname args & body]\n" +#~ " (let [partials (map (fn [n]\n" +#~ " `(~(subvec args 0 n) (partial ~fname ~@(take n args))))\n" +#~ " (range 1 (count args)))]\n" +#~ " `(defn ~fname\n" +#~ " (~args ~@body)\n" +#~ " ~@partials)))\n" +#~ msgstr "" + #~ msgid "date: 2021-04-24" #~ msgstr "" @@ -100,28 +185,12 @@ msgstr "" #~ "Clojure's multi-arity support:" #~ msgstr "" -#~ msgid "Comparison with Common Lisp" -#~ msgstr "" - -#~ msgid "My attempt at writing an equivalent for Common Lisp gives me:" -#~ msgstr "" - #~ msgid "" #~ "Without built-in multi-arity support, we have to do more work, like tracking" #~ " the number of arguments consumed so far. That is, without dependending on " #~ "any library, sticking to ANSI Common Lisp." #~ msgstr "" -#~ msgid "" -#~ "This also require `funcall`s, since we return a `lambda` that doesn't live " -#~ "in the function namespace." -#~ msgstr "" - -#~ msgid "" -#~ "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " -#~ "arguments, docstrings, etc., but it also could evolve to do so." -#~ msgstr "" - #~ msgid "" #~ "(defun curry-n (n fn)\n" #~ " (if (= 0 n)\n" diff --git a/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po b/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po index 14036ab..ab59a4f 100644 --- a/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po +++ b/locale/pt/LC_MESSAGES/_tils/2021-04-24-clojure-auto-curry.po @@ -14,17 +14,6 @@ msgstr "" msgid "ref: clojure-auto-curry" msgstr "" -msgid "" -"(defmacro defcurry\n" -" [fname args & body]\n" -" (let [partials (map (fn [n]\n" -" `(~(subvec args 0 n) (partial ~fname ~@(take n args))))\n" -" (range 1 (count args)))]\n" -" `(defn ~fname\n" -" (~args ~@body)\n" -" ~@partials)))\n" -msgstr "" - msgid "A naive `add` definition, alongside its usage and macroexpansion:" msgstr "" @@ -90,6 +79,102 @@ msgstr "" msgid "date: 2021-04-24 1" msgstr "" +msgid "" +"(defmacro defcurry\n" +" [name args & body]\n" +" (let [partials (map (fn [n]\n" +" `(~(subvec args 0 n) (partial ~name ~@(take n args))))\n" +" (range 1 (count args)))]\n" +" `(defn ~name\n" +" (~args ~@body)\n" +" ~@partials)))\n" +msgstr "" + +msgid "Comparison with Common Lisp" +msgstr "" + +msgid "My attempt at writing an equivalent for Common Lisp gives me:" +msgstr "" + +msgid "" +"(defun partial (fn &rest args)\n" +" (lambda (&rest args2)\n" +" (apply fn (append args args2))))\n" +"\n" +"(defun curry-n (n func)\n" +" (cond ((< n 0) (error \"Too many arguments\"))\n" +" ((zerop n) (funcall func))\n" +" (t (lambda (&rest rest)\n" +" (curry-n (- n (length rest))\n" +" (apply #'partial func rest))))))\n" +"\n" +"(defmacro defcurry (name args &body body)\n" +" `(defun ,name (&rest rest)\n" +" (let ((func (lambda ,args ,@body)))\n" +" (curry-n (- ,(length args) (length rest))\n" +" (apply #'partial func rest)))))\n" +msgstr "" + +msgid "" +"Without built-in multi-arity support, we have to do more work, like tracking" +" the number of arguments consumed so far. We also have to write `#'partial` " +"ourselves. That is, without dependending on any library, sticking to ANSI " +"Common Lisp." +msgstr "" + +msgid "The usage is pretty similar:" +msgstr "" + +msgid "" +"* (defcurry add (a b c d e)\n" +" (+ a b c d e))\n" +"ADD\n" +"\n" +"* (add 1)\n" +"#\n" +"\n" +"* (funcall (add 1) 2 3 4)\n" +"#\n" +"\n" +"* (funcall (add 1) 2 3 4 5)\n" +"15\n" +"\n" +"* (funcall (funcall (add 1) 2 3) 4 5)\n" +"15\n" +"\n" +"* (macroexpand-1\n" +" '(defcurry add (a b c d e)\n" +" (+ a b c d e)))\n" +"(DEFUN ADD (&REST REST)\n" +" (LET ((FUNC (LAMBDA (A B C D E) (+ A B C D E))))\n" +" (CURRY-N (- 5 (LENGTH REST)) (APPLY #'PARTIAL FUNC REST))))\n" +"T\n" +msgstr "" + +msgid "" +"This also require `funcall`s, since we return a `lambda` that doesn't live " +"in the function namespace." +msgstr "" + +msgid "" +"Like the Clojure one, it doesn't support optional parameters, `&rest` rest " +"arguments, docstrings, etc., but it also could evolve to do so." +msgstr "" + +msgid "updated_at: 2021-04-27" +msgstr "" + +#~ msgid "" +#~ "(defmacro defcurry\n" +#~ " [fname args & body]\n" +#~ " (let [partials (map (fn [n]\n" +#~ " `(~(subvec args 0 n) (partial ~fname ~@(take n args))))\n" +#~ " (range 1 (count args)))]\n" +#~ " `(defn ~fname\n" +#~ " (~args ~@body)\n" +#~ " ~@partials)))\n" +#~ msgstr "" + #~ msgid "date: 2021-04-24" #~ msgstr "" @@ -100,28 +185,12 @@ msgstr "" #~ "Clojure's multi-arity support:" #~ msgstr "" -#~ msgid "Comparison with Common Lisp" -#~ msgstr "" - -#~ msgid "My attempt at writing an equivalent for Common Lisp gives me:" -#~ msgstr "" - #~ msgid "" #~ "Without built-in multi-arity support, we have to do more work, like tracking" #~ " the number of arguments consumed so far. That is, without dependending on " #~ "any library, sticking to ANSI Common Lisp." #~ msgstr "" -#~ msgid "" -#~ "This also require `funcall`s, since we return a `lambda` that doesn't live " -#~ "in the function namespace." -#~ msgstr "" - -#~ msgid "" -#~ "Like the Clojure one, it doesn't support optional parameters, `&rest` rest " -#~ "arguments, docstrings, etc., but it also could evolve to do so." -#~ msgstr "" - #~ msgid "" #~ "(defun curry-n (n fn)\n" #~ " (if (= 0 n)\n" -- cgit v1.2.3