moar

(ns moar.example
    (:require [moar.core :refer :all]
              [moar.protocols :refer :all]
              [moar.monads.sequence :as sequence]
              [moar.monads.continuation :as continuation]
              [moar.monads.state :as state]
              [moar.monads.maybe :as maybe :refer [just nothing]]))

(wrap maybe/monad :tobias)
;;=> #<Just@74de792d: :tobias>

(bind (just 2) #(wrap maybe/monad (inc %)))
;;=> #<Just@1e8c0586: 3>

@(just :x)
;;=> :x

(>>= (wrap maybe/monad 2)
     (fn [x] (just (inc x)))
     (fn [x] nothing)
     (fn [x] (just (inc x))))
;;=> #<Nothing moar.monads.maybe.Nothing@72ca7ea3>

(fmap inc (just 2))
;;=> #<Just@590d3235: 3>

(= (just 2) (just 2))
;;=> true

(= (just 2) (just 3))
;;=> false

;; Monad transformers!

;; Continuation + State!
(let [monad   (continuation/monad-t state/monad)
      run     continuation/run
      return  (partial wrap monad)
      callcc  (partial continuation/callcc monad)
      modify  (comp (partial lift monad)
                    (partial state/modify state/monad))
      pull    (comp (partial lift monad)
                    (partial state/pull state/monad))

      my-loop (>> (callcc (fn [cont]
                           (modify assoc :next
                                   (partial cont nil))))
                 (modify update-in [:count] inc)
                 (mlet [n    (pull :count)
                        next (pull :next)]
                       (modify update-in [:log] conj n)
                       (if (< n 5)
                         (next)
                         (>> (modify dissoc :next)
                             (return :done)))))]
  ((run my-loop) {:count 0 :log []}))
;;=> #moar.monads.state.Pair{:state {:count 5, :log [1 2 3 4 5]}, :result :done}