├── README.md ├── .gitignore ├── elm-package.json ├── lib └── Monad │ ├── Writer.elm │ ├── Reader.elm │ └── State.elm └── LICENSE /README.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | elm-stuff/ 2 | app.js 3 | -------------------------------------------------------------------------------- /elm-package.json: -------------------------------------------------------------------------------- 1 | { 2 | "summary": "Useful Monads for elm.", 3 | "source-directories": [ 4 | "lib" 5 | ], 6 | "repository": "https://github.com/JustusAdam/elm-monad.git", 7 | "dependencies": { 8 | "elm-lang/core": "3.0.0 <= v < 4.0.0" 9 | }, 10 | "exposed-modules": [ 11 | "Monad.State", 12 | "Monad.Reader" 13 | ], 14 | "version": "1.0.0", 15 | "elm-version": "0.15.0 <= v < 0.16.0", 16 | "license": "MIT" 17 | } 18 | -------------------------------------------------------------------------------- /lib/Monad/Writer.elm: -------------------------------------------------------------------------------- 1 | module Monad.Writer where 2 | 3 | 4 | import Monad.State as S 5 | 6 | 7 | type alias Writer w a = S.State [w] a 8 | 9 | 10 | runWriter : Writer w a -> ([w], a) 11 | runWriter = S.runState [] 12 | 13 | 14 | write : w -> Writer w () 15 | write w s = (w::s, ()) 16 | 17 | 18 | andThen : Writer w a -> (a -> Writer w b) -> Writer w b 19 | andThen = S.andThen 20 | 21 | 22 | thenDo : Writer w a -> Writer w b -> Writer w b 23 | thenDo = S.thenDo 24 | 25 | 26 | map : (a -> b) -> Writer w a -> Writer w b 27 | map = S.map 28 | 29 | 30 | return : a -> Writer w a 31 | return = S.return 32 | 33 | 34 | ap : Writer w (a -> b) -> Writer w a -> Writer w b 35 | ap = S.ap 36 | -------------------------------------------------------------------------------- /lib/Monad/Reader.elm: -------------------------------------------------------------------------------- 1 | module Monad.Reader where 2 | 3 | 4 | import Monad.State as S 5 | 6 | 7 | type alias Reader env a = S.State env a 8 | 9 | 10 | runReader : env -> Reader env a -> a 11 | runReader env r = S.execState 12 | 13 | 14 | andThen : Reader env a -> (a -> Reader env b) -> Reader env b 15 | andThen = S.andThen 16 | 17 | 18 | thenDo : Reader env a -> Reader env b -> Reader env b 19 | thenTo = S.thenDo 20 | 21 | 22 | return : a -> Reader env a 23 | return = S.return 24 | 25 | 26 | ask : Reader env env 27 | ask = S.get 28 | 29 | 30 | reader : (env -> a) -> Reader env a 31 | reader f = S.map f ask 32 | 33 | 34 | local : (env -> env) -> Reader env a -> Reader env a 35 | local f r = 36 | ask `andThen` \old -> 37 | S.modify f 38 | `S.thenDo` r 39 | `andThen` \res -> 40 | S.put old `S.thenDo` return res 41 | 42 | 43 | map : (a -> b) -> Reader env a -> Reader env b 44 | map = S.map 45 | 46 | 47 | ap : Reader env (a -> b) -> Reader env a -> Reader env b 48 | ap = S.ap 49 | -------------------------------------------------------------------------------- /lib/Monad/State.elm: -------------------------------------------------------------------------------- 1 | module Monad.State where 2 | 3 | 4 | type alias State s v = s -> (v, s) 5 | 6 | 7 | runState : s -> State s a -> (a, s) 8 | runState initial s = s initial 9 | 10 | 11 | execState : s -> State s a -> a 12 | execState = snd << runState 13 | 14 | 15 | evalState : s -> State s a -> s 16 | evalState = fst << runState 17 | 18 | 19 | return : a -> State s a 20 | return = (,) 21 | 22 | 23 | andThen : State s v -> (v -> State s v') -> State s v' 24 | andThen st f v = 25 | let 26 | (v', s') = st v 27 | in 28 | f v' s' 29 | 30 | 31 | thenDo : State s v -> State s v' -> State s v' 32 | thenDo s s2 = s `andThen` \_ -> s2 33 | 34 | 35 | get : State s s 36 | get s = (s, s) 37 | 38 | 39 | put : s -> State s () 40 | put s _ = ((), s) 41 | 42 | 43 | modify : (s -> s) -> State s () 44 | modify f s = ((), f s) 45 | 46 | 47 | map : (a -> b) -> State s a -> State s b 48 | map f s = s `andThen` (return << f) 49 | 50 | 51 | ap : State s (a -> b) -> State s a -> State s b 52 | ap sf a = st `andThen` \f -> State.map f a 53 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2016 Justus Adam 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included 12 | in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 17 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 18 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 19 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 20 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | --------------------------------------------------------------------------------