How to write applicative style code?

[tojoqk]

It seems that Coalton does not provide a way to write Applicative Style code easier, now. Sometimes Applicative is better than Monad. An example is the Validation type. So, I think we need an easy way to write Applicative Style code.

I have considered how to write Applicative Style code. Which method would you prefer?

Method 1. Write Applicative Style code directly

(defpackage #:appliative-style-1
  (:use #:coalton
        #:coalton-prelude))

(in-package #:appliative-style-1)

(named-readtables:in-readtable coalton:coalton)

(coalton-toplevel
  (declare <*> (Applicative :f => :f (:a -> :b) -> :f :a -> :f :b))
  (define <*> (liftA2 id))

  (declare liftA4 (Applicative :f =>
                               (:a -> :b -> :c -> :d -> :e)
                               -> :f :a -> :f :b -> :f :c -> :f :d -> :f :e))
  (define (liftA4 f a1 a2 a3 a4)
    (<*> (<*> (<*> (<*> (pure f) a1) a2) a3) a4)))

In this case, Coalton should provide <*> function.

Method 2. Use pipe and flipped <*>

(defpackage #:appliative-style-2
  (:use #:coalton
        #:coalton-prelude))

(in-package #:appliative-style-2)

(named-readtables:in-readtable coalton:coalton)

(coalton-toplevel
  (declare <*> (Applicative :f => :f :a -> :f (:a -> :b) -> :f :b))
  (define <*> (flip (liftA2 id)))

  (declare liftA4 (Applicative :f =>
                               (:a -> :b -> :c -> :d -> :e)
                               -> :f :a -> :f :b -> :f :c -> :f :d -> :f :e))
  (define (liftA4 f a1 a2 a3 a4)
    (pipe (pure f) (<*> a1) (<*> a2) (<*> a3) (<*> a4))))

In this case, Coalton should provide flipped <*> function.

Method 3. Use macro for binary operations

(left-op <*> (pure f) a1 a2 a3 a4)

In this case, Coalton should provide <*> function and left-op syntax.

Method 4. Use macro for applicative style

(ap-apply f a1 a2 a3 a4)

In this case, Coalton should provide ap-apply syntax.

[tojoqk]

For method 4, (ap-apply (pure f) a1 a2 a3 a4) might be better. This is because in some cases you can only get applicative functors, not functions.