Clojure JIRA

[ALGOM-10] :when clause in domonad relies on optional m-zero monad operation

Mon, 3 Jun 2013 08:23:15 -0500

In add-monad-step, the :when clause is implemented by this line:

(identical? bform :when)  `(if ~expr ~mexpr ~'m-zero)

which makes sense, except that m-zero is an optional operation for monads.
If :when is used with a monad that does not provide an m-zero operation,
the result (in cases where the condition evaluates to false) is an incorrect monadic value,
and strange, difficult-to-understand errors result.

I don't know that it's possible to make this work reasonably for all monads,
but at the very least the limitation should be documented, and ideally the use of :when
with a monad that does not define m-zero should issue a warning with a recommendation that
{:if :then :else} should be used instead.d

[ALGOM-9] Replace calls to deprecated functions

Sun, 28 Oct 2012 17:23:27 -0500

There are several calls to replicate, which was deprecated in Clojure 1.3. Recommended replacement is repeat, which was added in 1.0.

[ALGOM-8] Cosmetic change in maybe-m

Fri, 12 Oct 2012 08:07:35 -0500

Diff:
;- (if (nil? mv) nil (f mv)))
;+ (when-not (nil? mv) (f mv)))

[ALGOM-7] maybe-m breaks the monad laws.

Fri, 7 Jun 2013 20:51:04 -0500

One of the monad laws is that (m-bind (m-result v) f) should be the same as (f v). However, this is not the case in maybe-m:

user=> (with-monad maybe-m (m-bind (m-result nil) nil?))
nil

user=> (nil? nil)
true

The crux of the problem is that in algo.monad's maybe-m, there is no way to wrap a nil in a Just-like container.

[ALGOM-6] algo.monads README has no artifacts information

Fri, 14 Sep 2012 15:37:12 -0500

algo.monads README has no artifacts information and does not conform to the Contrib README standards in any way. Because clojure-dev is a closed group, I am filing it here.

(originally filed by Michael Klishin in project CLJ, but seems to belong better here)

[ALGOM-5] continuation monad can easily overflow stack

Mon, 10 Sep 2012 12:01:47 -0500

The continuation monad uses tail calls, and because they aren't optimized out it's vulnerable to stack overflows for large computations:

;; there is a function clojure.algo.monads/m-reduce, but it has a
;; wierdly unuseful type.
(defmonadfn fold-m
[f a xs] (reduce (fn [macc x] (m-bind macc #(f % x))) (m-result a) xs))

(defn add [s]
(run-cont
(with-monad cont-m
(call-cc
(fn [k]
(fold-m (fn [a n]
(if (== n 8888) (k 1)
(m-result (+ a n))))
0 s))))))

(add (range 1 10000)) ;; stack overflow

Can be worked around with a trampoline:

(defmonad cont-tramp-m
[m-result m-result-cont
m-bind m-bind-cont])

(defn call-cc-tramp [f]
(fn [c] [(f (fn [v] (fn [_] [c v ::cont]))) c ::cont]))

(defn run-cont-tramp [cont]
(loop [cv (cont identity)]
(if (and (vector? cv)
(= ::cont (nth cv 2)))
(recur ((first cv) (second cv)))
cv)))

(defn add2 [s]
(run-cont-tramp
(with-monad cont-tramp-m
(call-cc-tramp
(fn [k]
(fold-m (fn [a n]
(if (= n 8888)
(k 1)
(m-result (+ a n))))
0 s))))))

(add2 (range 1 1000000)) ;; -> 1

[ALGOM-4] algo.monad state-m fetch-val bug and efficiency issue

Sat, 8 Sep 2012 20:47:32 -0500

;; the bug

(defn fetch-val
"Return a state-monad function that assumes the state to be a map and
returns the value corresponding to the given key. The state is not modified."
[key]
(domonad state-m
[s (fetch-state)]
(key s))) ;; does not work for integer or string keys

;; I propose replacing it with (get s key)

;; the efficiency issue :
;;
;; domonad with monad parameter binds all the monad functions,
;; looking these up in the state-m map on each call
;;
;; solution :

(defn fetch-val
"Return a state-monad function that assumes the state to be a map and
returns the value corresponding to the given key. The state is not modified."
[key]
(fn [s]
[(get s key) s]))

;; - we avoid the monad map lookups
;; - coding style brought up to par with the rest of state-m functions

[ALGOM-3] Bug in writer-monad-protocol for lists

Wed, 18 Apr 2012 13:20:11 -0500

The writer-monad-protocol for lists uses concat in writer-m-combine, the result of which has type LazySeq. However, LazySeq does not have an implementation in writer-monad-protocol (the first example, using vectors, shows expected output):

{{
user=> (use 'clojure.algo.monads)
nil
user=> (domonad (writer-m []) [_ (domonad [_ (write "foo")] nil) _ (write "bar")] 1)
[1 ["foo" "bar"]]
user=> (domonad (writer-m ()) [_ (domonad [_ (write "foo")] nil) _ (write "bar")] 1)
IllegalArgumentException No implementation of method: :writer-m-combine of protocol: #'clojure.algo.monads/writer-monad-
protocol found for class: clojure.lang.LazySeq clojure.core/-cache-protocol-fn (core_deftype.clj:527)
}}

I suggest changing the protocol extension to ISeq as in the attached diff. With that change:

[ALGOM-2] Adding support for both :if-:then-:else and :cond statements on domacro implementations

Tue, 24 Jan 2012 11:15:37 -0600

This patch contains the same features as

http://dev.clojure.org/jira/browse/ALGOM-1

plus a new one, the ability to add :cond statements using the domonad macro.

More info can be found on the commit history of the given patch.

[ALGOM-1] Add conditionals stratements to domonad forms

Tue, 10 Jan 2012 00:28:35 -0600

I implemented a patch that would allow us to do conditionals on domonad macros

Example:

(domonad monad-m
[a (action 1)
:if (= a 3)
:then [
result (action c)
]
:else [
result (action d)
]]
result)

Conditional blocks can be nested.

One gotcha one has to be aware of is: you may use bindings from a conditional branch in the m-result sexp as long as that branch gets called, given that one doesn't know for sure which branch is going to be called, you should set the same bindings on both branches.

The patch code is on: github.com/roman/algo.monads

I didn't do a pull request given that you need to this first.

NOTE: I've added this feature in some other projects I've been working on (parser combinators) and is working perfectly so far, there is tests in the patch but I wanted to give you that safe net as well.