Skip to content

Instantly share code, notes, and snippets.

What would you like to do?
Monads for PLT Racket
(module monad scheme
(require "")
;; i'm too lazy to repeat this pattern for now.
(define-syntax init-public
(syntax-rules ()
((_) (begin))
((_ (m default) ms ...) (begin
(init-field (m default))
(public (internal-m m))
(define (internal-m . rest) (apply (get-field m this) rest))
(init-public ms ...)
((_ m ms ...) (begin
(init-field m)
(public (internal-m m))
(define (internal-m . rest) (apply (get-field m this) rest))
(init-public ms ...)
;; functors
(provide functor-interface functor% fmap)
(define functor-interface (interface () fmap))
(define functor% (class* object% (functor-interface)
(init-public fmap)
(define-curried (fmap f x m) (send m fmap f (x m)))
;; pointed functors
(provide pointed-interface pointed% return)
(define pointed-interface (interface (functor-interface) return))
(define pointed% (class* functor% (pointed-interface)
(init-public return)
(init fmap)
(super-new (fmap fmap))))
(define-curried (return x m) (send m return x))
;; applicative functors and idiom brackets
(provide applicative-interface applicative% ap idiom)
(define applicative-interface (interface (pointed-interface) ap))
(define applicative% (class* pointed% (applicative-interface)
(init-public ap)
(init return
(fmap (lambda (f x) (ap (return f) x))))
(super-new (fmap fmap) (return return))))
(define-curried (ap mf mx m) (send m ap (mf m) (mx m)))
(define-syntax idiom
(syntax-rules ()
((idiom f) (unit f))
((idiom f x) (fmap f x))
((idiom f x y ...) (fold-left ap (fmap f x) y ...))))
;; monads and do sugar
(provide monad-interface monad% bind then when unless do do*)
(define monad-interface (interface (applicative-interface) bind))
(define monad% (class* applicative% (monad-interface)
(init-public bind)
(init return)
(init (fmap (lambda (f mx) (bind (lambda (x) (return (f x))) mx)))
(ap (lambda (mf mx) (bind (lambda (f) (fmap f mx)) mf))))
(init-public (then (lambda (m n) (bind (lambda (_) n) m))))
(super-new (fmap fmap) (ap ap) (return return))))
(define-curried (bind f x m) (send m bind (lambda (a) ((f a) m)) (x m)))
(define-curried (then a b m) (send m then (a m) b m))
(define-curried (when p s m) (if p (s m) (return '() m)))
(define-curried (unless p s m) (if p (return '() m) (s m)))
;; join :: m (m a) -> m a -- before the reader transformation
;; join :: (monad m -> m (monad m -> m a) -> monad m -> m a
;; something closer to let*
(define-syntax do*
(syntax-rules ()
((do* comp-body) comp-body)
((do* ((x0 comp0)) comp-body) (bind (lambda (x0) comp-body) comp0))
((do* ((x0 comp0) (x comp) ...) comp-body)
(bind (lambda (x0) (do* ((x comp) ...) comp-body)) comp0))))
;; a richer, more haskell-like do sugar. todo: pmatch support for destructuring binds with monad-fail?
(define-syntax do
(syntax-rules (let let* letrec letrec* <-)
((do s) s)
((do (x <- s) ss ...) (bind (lambda (x) (do ss ...)) s))
((do (let bs) ss ...) (let bs (do ss ...)))
((do (let* bs) ss ...) (let* bs (do ss ...)))
((do (letrec bs) ss ...) (letrec bs (do ss ...)))
((do (letrec* bs) ss ...) (letrec* bs (do ss ...)))
((do s ss ...) (then s (do ss ...)))))
;; simple mixins
(define-syntax define-mixin
(syntax-rules ()
((_ mixin (interfaces ... ) (ip ...)) (define (mixin %) (class* % (interfaces ...)
(init-public ip ...)
;; functor-plus, alternative, monad-plus
;; unlike haskell plus is variadic, with zero arguments it defines zero.
(provide functor-plus-interface functor-plus-mixin plus guard)
(define functor-plus-interface (interface (functor-interface) plus))
(define-mixin functor-plus-mixin (functor-plus-interface) (plus))
(define zero (plus))
(define (plus . args) (lambda (m) (send/apply m plus (map (lambda (f) (f m)) args))))
(define-curried (guard b m) (if b (return '() m) (zero m)))
;; monad-transformer
(provide monad-trans-interface monad-trans-mixin lift base)
(define monad-trans-interface (interface (monad-interface) lift base))
(define-mixin monad-trans-mixin (monad-trans-interface) (lift base))
(define-curried (lift b m) (send m lift (b (send m base))))
(define-curried (base m) (send m base))
;; state monad
(provide monad-state-interface monad-state-mixin get put gets modify)
(define monad-state-interface (interface (monad-interface) get put))
(define-mixin monad-state-mixin (monad-state-interface) (get put))
(define (get m) (send m get))
(define-curried (put s m) (send m put s))
(define (modify f) (do (x <- get)
(put (f x))))
(define (gets f) (fmap f get))
;; reader monad
(provide monad-reader-interface monad-reader-mixin ask asks)
(define monad-reader-interface (interface (monad-interface) ask))
(define-mixin monad-reader-mixin (monad-reader-interface) (ask))
(define (ask m) (send m ask))
(define (asks f) (fmap f ask))
;; writer monad
(provide monad-writer-interface monad-writer-mixin tell)
(define monad-writer-interface (interface (monad-interface) tell))
(define-mixin monad-writer-mixin (monad-writer-interface) (tell))
(define-curried (tell x m) (send m tell x))
(module curry scheme
(provide curried-lambda define-curried)
(define-syntax curried-lambda
(syntax-rules ()
((_ () body)
(lambda args
(if (null? args)
apply body args)))
((_ (arg) body)
(lambda args
(if (null? args)
(let ((arg (car args))
(rest (cdr args)))
(if (null? rest)
(apply body rest)))))))
((_ (arg args ...) body)
(lambda all-args
(if (null? all-args)
(let ((arg (car all-args))
(rest (cdr all-args)))
(let ((next (curried-lambda (args ...) body)))
(if (null? rest)
(apply next rest))))))))
;; curried defines
(define-syntax define-curried
(syntax-rules ()
((define-curried (name args ...) body)
(define name (curried-lambda (args ...) body)))
((define-curried (name) body)
(define name (curried-lambda () body)))
((define-curried name body)
(define name body)))))
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment